1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004
3 Free Software Foundation, Inc.
5 Originally developed by Eric Youngdale <eric@andante.jic.com>
6 Modifications by Nick Clifton <nickc@redhat.com>
8 This file is part of GNU Binutils.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place - Suite 330, 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. */
45 #include <sys/types.h>
51 /* Define BFD64 here, even if our default architecture is 32 bit ELF
52 as this will allow us to read in and parse 64bit and 32bit ELF files.
53 Only do this if we believe that the compiler can support a 64 bit
54 data type. For now we only rely on GCC being able to do this. */
60 #include "elf/common.h"
61 #include "elf/external.h"
62 #include "elf/internal.h"
63 #include "elf/dwarf2.h"
65 /* The following headers use the elf/reloc-macros.h file to
66 automatically generate relocation recognition functions
67 such as elf_mips_reloc_type() */
69 #define RELOC_MACROS_GEN_FUNC
71 #include "elf/alpha.h"
91 #include "elf/m68hc11.h"
92 #include "elf/mcore.h"
95 #include "elf/mn10200.h"
96 #include "elf/mn10300.h"
97 #include "elf/msp430.h"
101 #include "elf/ppc64.h"
102 #include "elf/s390.h"
104 #include "elf/sparc.h"
105 #include "elf/v850.h"
107 #include "elf/x86-64.h"
108 #include "elf/xstormy16.h"
110 #include "elf/iq2000.h"
111 #include "elf/xtensa.h"
117 #include "libiberty.h"
119 char *program_name = "readelf";
120 long archive_file_offset;
121 unsigned long archive_file_size;
122 unsigned long dynamic_addr;
123 bfd_size_type dynamic_size;
124 unsigned int dynamic_nent;
125 char *dynamic_strings;
127 unsigned long string_table_length;
128 unsigned long num_dynamic_syms;
129 Elf_Internal_Sym *dynamic_symbols;
130 Elf_Internal_Syminfo *dynamic_syminfo;
131 unsigned long dynamic_syminfo_offset;
132 unsigned int dynamic_syminfo_nent;
133 char program_interpreter[64];
134 bfd_vma dynamic_info[DT_JMPREL + 1];
135 bfd_vma version_info[16];
136 Elf_Internal_Ehdr elf_header;
137 Elf_Internal_Shdr *section_headers;
138 Elf_Internal_Phdr *program_headers;
139 Elf_Internal_Dyn *dynamic_section;
140 Elf_Internal_Shdr *symtab_shndx_hdr;
146 int do_section_groups;
149 int do_using_dynamic;
157 int do_debug_abbrevs;
159 int do_debug_pubnames;
160 int do_debug_aranges;
162 int do_debug_frames_interp;
163 int do_debug_macinfo;
172 struct group_list *next;
173 unsigned int section_index;
178 struct group_list *root;
179 unsigned int group_index;
182 struct group *section_groups;
183 size_t group_count = 0;
185 struct group **section_headers_groups;
187 /* A dynamic array of flags indicating which sections require dumping. */
188 char *dump_sects = NULL;
189 unsigned int num_dump_sects = 0;
191 #define HEX_DUMP (1 << 0)
192 #define DISASS_DUMP (1 << 1)
193 #define DEBUG_DUMP (1 << 2)
195 /* How to rpint a vma value. */
196 typedef enum print_mode
208 static bfd_vma (*byte_get) (unsigned char *, int);
209 static void (*byte_put) (unsigned char *, bfd_vma, int);
213 #define SECTION_NAME(X) ((X) == NULL ? "<none>" : \
214 ((X)->sh_name >= string_table_length \
215 ? "<corrupt>" : string_table + (X)->sh_name))
217 /* Given st_shndx I, map to section_headers index. */
218 #define SECTION_HEADER_INDEX(I) \
219 ((I) < SHN_LORESERVE \
221 : ((I) <= SHN_HIRESERVE \
223 : (I) - (SHN_HIRESERVE + 1 - SHN_LORESERVE)))
225 /* Reverse of the above. */
226 #define SECTION_HEADER_NUM(N) \
227 ((N) < SHN_LORESERVE \
229 : (N) + (SHN_HIRESERVE + 1 - SHN_LORESERVE))
231 #define SECTION_HEADER(I) (section_headers + SECTION_HEADER_INDEX (I))
233 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
235 #define BYTE_GET(field) byte_get (field, sizeof (field))
237 /* If we can support a 64 bit data type then BFD64 should be defined
238 and sizeof (bfd_vma) == 8. In this case when translating from an
239 external 8 byte field to an internal field, we can assume that the
240 internal field is also 8 bytes wide and so we can extract all the data.
241 If, however, BFD64 is not defined, then we must assume that the
242 internal data structure only has 4 byte wide fields that are the
243 equivalent of the 8 byte wide external counterparts, and so we must
244 truncate the data. */
246 #define BYTE_GET8(field) byte_get (field, -8)
248 #define BYTE_GET8(field) byte_get (field, 8)
251 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
253 #define GET_ELF_SYMBOLS(file, section) \
254 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
255 : get_64bit_elf_symbols (file, section))
259 error (const char *message, ...)
263 va_start (args, message);
264 fprintf (stderr, _("%s: Error: "), program_name);
265 vfprintf (stderr, message, args);
270 warn (const char *message, ...)
274 va_start (args, message);
275 fprintf (stderr, _("%s: Warning: "), program_name);
276 vfprintf (stderr, message, args);
281 get_data (void *var, FILE *file, long offset, size_t size, const char *reason)
288 if (fseek (file, archive_file_offset + offset, SEEK_SET))
290 error (_("Unable to seek to 0x%x for %s\n"),
291 archive_file_offset + offset, reason);
298 mvar = malloc (size);
302 error (_("Out of memory allocating 0x%x bytes for %s\n"),
308 if (fread (mvar, size, 1, file) != 1)
310 error (_("Unable to read in 0x%x bytes of %s\n"), size, reason);
320 byte_get_little_endian (unsigned char *field, int size)
328 return ((unsigned int) (field[0]))
329 | (((unsigned int) (field[1])) << 8);
333 /* We want to extract data from an 8 byte wide field and
334 place it into a 4 byte wide field. Since this is a little
335 endian source we can just use the 4 byte extraction code. */
339 return ((unsigned long) (field[0]))
340 | (((unsigned long) (field[1])) << 8)
341 | (((unsigned long) (field[2])) << 16)
342 | (((unsigned long) (field[3])) << 24);
347 /* This is a special case, generated by the BYTE_GET8 macro.
348 It means that we are loading an 8 byte value from a field
349 in an external structure into an 8 byte value in a field
350 in an internal structure. */
351 return ((bfd_vma) (field[0]))
352 | (((bfd_vma) (field[1])) << 8)
353 | (((bfd_vma) (field[2])) << 16)
354 | (((bfd_vma) (field[3])) << 24)
355 | (((bfd_vma) (field[4])) << 32)
356 | (((bfd_vma) (field[5])) << 40)
357 | (((bfd_vma) (field[6])) << 48)
358 | (((bfd_vma) (field[7])) << 56);
361 error (_("Unhandled data length: %d\n"), size);
367 byte_get_signed (unsigned char *field, int size)
369 bfd_vma x = byte_get (field, size);
374 return (x ^ 0x80) - 0x80;
376 return (x ^ 0x8000) - 0x8000;
378 return (x ^ 0x80000000) - 0x80000000;
388 byte_put_little_endian (unsigned char *field, bfd_vma value, int size)
393 field[7] = (((value >> 24) >> 24) >> 8) & 0xff;
394 field[6] = ((value >> 24) >> 24) & 0xff;
395 field[5] = ((value >> 24) >> 16) & 0xff;
396 field[4] = ((value >> 24) >> 8) & 0xff;
399 field[3] = (value >> 24) & 0xff;
400 field[2] = (value >> 16) & 0xff;
403 field[1] = (value >> 8) & 0xff;
406 field[0] = value & 0xff;
410 error (_("Unhandled data length: %d\n"), size);
415 /* Print a VMA value. */
417 print_vma (bfd_vma vma, print_mode mode)
429 printf ("%8.8lx", (unsigned long) vma);
435 printf ("%5ld", (long) vma);
443 printf ("%lx", (unsigned long) vma);
447 printf ("%ld", (unsigned long) vma);
451 printf ("%lu", (unsigned long) vma);
473 #if BFD_HOST_64BIT_LONG
476 if (_bfd_int64_high (vma))
477 printf ("%lx%8.8lx", _bfd_int64_high (vma), _bfd_int64_low (vma));
479 printf ("%lx", _bfd_int64_low (vma));
484 #if BFD_HOST_64BIT_LONG
487 if (_bfd_int64_high (vma))
489 printf ("++%ld", _bfd_int64_low (vma));
491 printf ("%ld", _bfd_int64_low (vma));
496 #if BFD_HOST_64BIT_LONG
498 printf ("%5ld", vma);
500 printf ("%#lx", vma);
502 if (_bfd_int64_high (vma))
504 printf ("++%ld", _bfd_int64_low (vma));
505 else if (vma <= 99999)
506 printf ("%5ld", _bfd_int64_low (vma));
508 printf ("%#lx", _bfd_int64_low (vma));
513 #if BFD_HOST_64BIT_LONG
516 if (_bfd_int64_high (vma))
518 printf ("++%lu", _bfd_int64_low (vma));
520 printf ("%lu", _bfd_int64_low (vma));
528 /* Display a symbol on stdout. If do_wide is not true then
529 format the symbol to be at most WIDTH characters,
530 truncating as necessary. If WIDTH is negative then
531 format the string to be exactly - WIDTH characters,
532 truncating or padding as necessary. */
535 print_symbol (int width, const char *symbol)
538 printf ("%s", symbol);
540 printf ("%-*.*s", width, width, symbol);
542 printf ("%-.*s", width, symbol);
546 byte_get_big_endian (unsigned char *field, int size)
554 return ((unsigned int) (field[1])) | (((int) (field[0])) << 8);
557 return ((unsigned long) (field[3]))
558 | (((unsigned long) (field[2])) << 8)
559 | (((unsigned long) (field[1])) << 16)
560 | (((unsigned long) (field[0])) << 24);
564 /* Although we are extracing data from an 8 byte wide field, we
565 are returning only 4 bytes of data. */
566 return ((unsigned long) (field[7]))
567 | (((unsigned long) (field[6])) << 8)
568 | (((unsigned long) (field[5])) << 16)
569 | (((unsigned long) (field[4])) << 24);
573 /* This is a special case, generated by the BYTE_GET8 macro.
574 It means that we are loading an 8 byte value from a field
575 in an external structure into an 8 byte value in a field
576 in an internal structure. */
577 return ((bfd_vma) (field[7]))
578 | (((bfd_vma) (field[6])) << 8)
579 | (((bfd_vma) (field[5])) << 16)
580 | (((bfd_vma) (field[4])) << 24)
581 | (((bfd_vma) (field[3])) << 32)
582 | (((bfd_vma) (field[2])) << 40)
583 | (((bfd_vma) (field[1])) << 48)
584 | (((bfd_vma) (field[0])) << 56);
588 error (_("Unhandled data length: %d\n"), size);
594 byte_put_big_endian (unsigned char *field, bfd_vma value, int size)
599 field[7] = value & 0xff;
600 field[6] = (value >> 8) & 0xff;
601 field[5] = (value >> 16) & 0xff;
602 field[4] = (value >> 24) & 0xff;
607 field[3] = value & 0xff;
608 field[2] = (value >> 8) & 0xff;
612 field[1] = value & 0xff;
616 field[0] = value & 0xff;
620 error (_("Unhandled data length: %d\n"), size);
625 /* Guess the relocation size commonly used by the specific machines. */
628 guess_is_rela (unsigned long e_machine)
632 /* Targets that use REL relocations. */
647 /* Targets that use RELA relocations. */
662 case EM_CYGNUS_MN10200:
664 case EM_CYGNUS_MN10300:
711 warn (_("Don't know about relocations on this machine architecture\n"));
717 slurp_rela_relocs (FILE *file,
718 unsigned long rel_offset,
719 unsigned long rel_size,
720 Elf_Internal_Rela **relasp,
721 unsigned long *nrelasp)
723 Elf_Internal_Rela *relas;
724 unsigned long nrelas;
729 Elf32_External_Rela *erelas;
731 erelas = get_data (NULL, file, rel_offset, rel_size, _("relocs"));
735 nrelas = rel_size / sizeof (Elf32_External_Rela);
737 relas = malloc (nrelas * sizeof (Elf_Internal_Rela));
741 error(_("out of memory parsing relocs"));
745 for (i = 0; i < nrelas; i++)
747 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
748 relas[i].r_info = BYTE_GET (erelas[i].r_info);
749 relas[i].r_addend = BYTE_GET (erelas[i].r_addend);
756 Elf64_External_Rela *erelas;
758 erelas = get_data (NULL, file, rel_offset, rel_size, _("relocs"));
762 nrelas = rel_size / sizeof (Elf64_External_Rela);
764 relas = malloc (nrelas * sizeof (Elf_Internal_Rela));
768 error(_("out of memory parsing relocs"));
772 for (i = 0; i < nrelas; i++)
774 relas[i].r_offset = BYTE_GET8 (erelas[i].r_offset);
775 relas[i].r_info = BYTE_GET8 (erelas[i].r_info);
776 relas[i].r_addend = BYTE_GET8 (erelas[i].r_addend);
787 slurp_rel_relocs (FILE *file,
788 unsigned long rel_offset,
789 unsigned long rel_size,
790 Elf_Internal_Rela **relsp,
791 unsigned long *nrelsp)
793 Elf_Internal_Rela *rels;
799 Elf32_External_Rel *erels;
801 erels = get_data (NULL, file, rel_offset, rel_size, _("relocs"));
805 nrels = rel_size / sizeof (Elf32_External_Rel);
807 rels = malloc (nrels * sizeof (Elf_Internal_Rela));
811 error(_("out of memory parsing relocs"));
815 for (i = 0; i < nrels; i++)
817 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
818 rels[i].r_info = BYTE_GET (erels[i].r_info);
819 rels[i].r_addend = 0;
826 Elf64_External_Rel *erels;
828 erels = get_data (NULL, file, rel_offset, rel_size, _("relocs"));
832 nrels = rel_size / sizeof (Elf64_External_Rel);
834 rels = malloc (nrels * sizeof (Elf_Internal_Rela));
838 error(_("out of memory parsing relocs"));
842 for (i = 0; i < nrels; i++)
844 rels[i].r_offset = BYTE_GET8 (erels[i].r_offset);
845 rels[i].r_info = BYTE_GET8 (erels[i].r_info);
846 rels[i].r_addend = 0;
856 /* Display the contents of the relocation data found at the specified
860 dump_relocations (FILE *file,
861 unsigned long rel_offset,
862 unsigned long rel_size,
863 Elf_Internal_Sym *symtab,
869 Elf_Internal_Rela *rels;
872 if (is_rela == UNKNOWN)
873 is_rela = guess_is_rela (elf_header.e_machine);
877 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
882 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
891 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
893 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
898 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
900 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
908 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
910 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
915 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
917 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
921 for (i = 0; i < rel_size; i++)
924 const char *rtype2 = NULL;
925 const char *rtype3 = NULL;
928 bfd_vma symtab_index;
933 offset = rels[i].r_offset;
934 info = rels[i].r_info;
938 type = ELF32_R_TYPE (info);
939 symtab_index = ELF32_R_SYM (info);
943 /* The #ifdef BFD64 below is to prevent a compile time warning.
944 We know that if we do not have a 64 bit data type that we
945 will never execute this code anyway. */
947 if (elf_header.e_machine == EM_MIPS)
949 /* In little-endian objects, r_info isn't really a 64-bit
950 little-endian value: it has a 32-bit little-endian
951 symbol index followed by four individual byte fields.
952 Reorder INFO accordingly. */
953 if (elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
954 info = (((info & 0xffffffff) << 32)
955 | ((info >> 56) & 0xff)
956 | ((info >> 40) & 0xff00)
957 | ((info >> 24) & 0xff0000)
958 | ((info >> 8) & 0xff000000));
959 type = ELF64_MIPS_R_TYPE (info);
960 type2 = ELF64_MIPS_R_TYPE2 (info);
961 type3 = ELF64_MIPS_R_TYPE3 (info);
963 else if (elf_header.e_machine == EM_SPARCV9)
964 type = ELF64_R_TYPE_ID (info);
966 type = ELF64_R_TYPE (info);
968 symtab_index = ELF64_R_SYM (info);
974 #ifdef _bfd_int64_low
975 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset), _bfd_int64_low (info));
977 printf ("%8.8lx %8.8lx ", offset, info);
982 #ifdef _bfd_int64_low
984 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
985 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
986 _bfd_int64_high (offset),
987 _bfd_int64_low (offset),
988 _bfd_int64_high (info),
989 _bfd_int64_low (info));
992 ? "%16.16lx %16.16lx "
993 : "%12.12lx %12.12lx ",
998 switch (elf_header.e_machine)
1005 case EM_CYGNUS_M32R:
1006 rtype = elf_m32r_reloc_type (type);
1011 rtype = elf_i386_reloc_type (type);
1016 rtype = elf_m68hc11_reloc_type (type);
1020 rtype = elf_m68k_reloc_type (type);
1024 rtype = elf_i960_reloc_type (type);
1029 rtype = elf_avr_reloc_type (type);
1032 case EM_OLD_SPARCV9:
1033 case EM_SPARC32PLUS:
1036 rtype = elf_sparc_reloc_type (type);
1040 case EM_CYGNUS_V850:
1041 rtype = v850_reloc_type (type);
1045 case EM_CYGNUS_D10V:
1046 rtype = elf_d10v_reloc_type (type);
1050 case EM_CYGNUS_D30V:
1051 rtype = elf_d30v_reloc_type (type);
1055 rtype = elf_dlx_reloc_type (type);
1059 rtype = elf_sh_reloc_type (type);
1063 case EM_CYGNUS_MN10300:
1064 rtype = elf_mn10300_reloc_type (type);
1068 case EM_CYGNUS_MN10200:
1069 rtype = elf_mn10200_reloc_type (type);
1073 case EM_CYGNUS_FR30:
1074 rtype = elf_fr30_reloc_type (type);
1078 rtype = elf_frv_reloc_type (type);
1082 rtype = elf_mcore_reloc_type (type);
1086 rtype = elf_mmix_reloc_type (type);
1091 rtype = elf_msp430_reloc_type (type);
1095 rtype = elf_ppc_reloc_type (type);
1099 rtype = elf_ppc64_reloc_type (type);
1103 case EM_MIPS_RS3_LE:
1104 rtype = elf_mips_reloc_type (type);
1107 rtype2 = elf_mips_reloc_type (type2);
1108 rtype3 = elf_mips_reloc_type (type3);
1113 rtype = elf_alpha_reloc_type (type);
1117 rtype = elf_arm_reloc_type (type);
1121 rtype = elf_arc_reloc_type (type);
1125 rtype = elf_hppa_reloc_type (type);
1131 rtype = elf_h8_reloc_type (type);
1136 rtype = elf_or32_reloc_type (type);
1141 rtype = elf_pj_reloc_type (type);
1144 rtype = elf_ia64_reloc_type (type);
1148 rtype = elf_cris_reloc_type (type);
1152 rtype = elf_i860_reloc_type (type);
1156 rtype = elf_x86_64_reloc_type (type);
1160 rtype = i370_reloc_type (type);
1165 rtype = elf_s390_reloc_type (type);
1169 rtype = elf_xstormy16_reloc_type (type);
1173 rtype = elf_crx_reloc_type (type);
1177 rtype = elf_vax_reloc_type (type);
1182 rtype = elf_ip2k_reloc_type (type);
1186 rtype = elf_iq2000_reloc_type (type);
1191 rtype = elf_xtensa_reloc_type (type);
1196 #ifdef _bfd_int64_low
1197 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type));
1199 printf (_("unrecognized: %-7lx"), type);
1202 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1206 if (symtab == NULL || symtab_index >= nsyms)
1207 printf (" bad symbol index: %08lx", (unsigned long) symtab_index);
1210 Elf_Internal_Sym *psym;
1212 psym = symtab + symtab_index;
1215 print_vma (psym->st_value, LONG_HEX);
1216 printf (is_32bit_elf ? " " : " ");
1218 if (psym->st_name == 0)
1220 const char *sec_name = "<null>";
1223 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1225 bfd_vma sec_index = (bfd_vma) -1;
1227 if (psym->st_shndx < SHN_LORESERVE)
1228 sec_index = psym->st_shndx;
1229 else if (psym->st_shndx > SHN_HIRESERVE)
1230 sec_index = psym->st_shndx - (SHN_HIRESERVE + 1
1233 if (sec_index != (bfd_vma) -1)
1234 sec_name = SECTION_NAME (section_headers + sec_index);
1235 else if (psym->st_shndx == SHN_ABS)
1237 else if (psym->st_shndx == SHN_COMMON)
1238 sec_name = "COMMON";
1239 else if (elf_header.e_machine == EM_IA_64
1240 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1241 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1242 sec_name = "ANSI_COM";
1245 sprintf (name_buf, "<section 0x%x>",
1246 (unsigned int) psym->st_shndx);
1247 sec_name = name_buf;
1250 print_symbol (22, sec_name);
1252 else if (strtab == NULL)
1253 printf (_("<string table index %3ld>"), psym->st_name);
1255 print_symbol (22, strtab + psym->st_name);
1258 printf (" + %lx", (unsigned long) rels[i].r_addend);
1263 printf ("%*c", is_32bit_elf ? (do_wide ? 34 : 28) : (do_wide ? 26 : 20), ' ');
1264 print_vma (rels[i].r_addend, LONG_HEX);
1267 if (elf_header.e_machine == EM_SPARCV9
1268 && !strcmp (rtype, "R_SPARC_OLO10"))
1269 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info));
1273 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1275 printf (" Type2: ");
1278 #ifdef _bfd_int64_low
1279 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2));
1281 printf (_("unrecognized: %-7lx"), type2);
1284 printf ("%-17.17s", rtype2);
1286 printf("\n Type3: ");
1289 #ifdef _bfd_int64_low
1290 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3));
1292 printf (_("unrecognized: %-7lx"), type3);
1295 printf ("%-17.17s", rtype3);
1307 get_mips_dynamic_type (unsigned long type)
1311 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1312 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1313 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1314 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1315 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1316 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1317 case DT_MIPS_MSYM: return "MIPS_MSYM";
1318 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1319 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1320 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1321 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1322 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1323 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1324 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1325 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1326 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1327 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1328 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1329 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1330 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1331 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1332 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1333 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1334 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1335 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1336 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1337 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1338 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1339 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1340 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1341 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1342 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1343 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1344 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1345 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1346 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1347 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1348 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1349 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1350 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1351 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1352 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1353 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1360 get_sparc64_dynamic_type (unsigned long type)
1364 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1371 get_ppc64_dynamic_type (unsigned long type)
1375 case DT_PPC64_GLINK: return "PPC64_GLINK";
1376 case DT_PPC64_OPD: return "PPC64_OPD";
1377 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1384 get_parisc_dynamic_type (unsigned long type)
1388 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1389 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1390 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1391 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1392 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1393 case DT_HP_PREINIT: return "HP_PREINIT";
1394 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1395 case DT_HP_NEEDED: return "HP_NEEDED";
1396 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1397 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1398 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1399 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1400 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1407 get_ia64_dynamic_type (unsigned long type)
1411 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1418 get_dynamic_type (unsigned long type)
1420 static char buff[32];
1424 case DT_NULL: return "NULL";
1425 case DT_NEEDED: return "NEEDED";
1426 case DT_PLTRELSZ: return "PLTRELSZ";
1427 case DT_PLTGOT: return "PLTGOT";
1428 case DT_HASH: return "HASH";
1429 case DT_STRTAB: return "STRTAB";
1430 case DT_SYMTAB: return "SYMTAB";
1431 case DT_RELA: return "RELA";
1432 case DT_RELASZ: return "RELASZ";
1433 case DT_RELAENT: return "RELAENT";
1434 case DT_STRSZ: return "STRSZ";
1435 case DT_SYMENT: return "SYMENT";
1436 case DT_INIT: return "INIT";
1437 case DT_FINI: return "FINI";
1438 case DT_SONAME: return "SONAME";
1439 case DT_RPATH: return "RPATH";
1440 case DT_SYMBOLIC: return "SYMBOLIC";
1441 case DT_REL: return "REL";
1442 case DT_RELSZ: return "RELSZ";
1443 case DT_RELENT: return "RELENT";
1444 case DT_PLTREL: return "PLTREL";
1445 case DT_DEBUG: return "DEBUG";
1446 case DT_TEXTREL: return "TEXTREL";
1447 case DT_JMPREL: return "JMPREL";
1448 case DT_BIND_NOW: return "BIND_NOW";
1449 case DT_INIT_ARRAY: return "INIT_ARRAY";
1450 case DT_FINI_ARRAY: return "FINI_ARRAY";
1451 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1452 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1453 case DT_RUNPATH: return "RUNPATH";
1454 case DT_FLAGS: return "FLAGS";
1456 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1457 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1459 case DT_CHECKSUM: return "CHECKSUM";
1460 case DT_PLTPADSZ: return "PLTPADSZ";
1461 case DT_MOVEENT: return "MOVEENT";
1462 case DT_MOVESZ: return "MOVESZ";
1463 case DT_FEATURE: return "FEATURE";
1464 case DT_POSFLAG_1: return "POSFLAG_1";
1465 case DT_SYMINSZ: return "SYMINSZ";
1466 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
1468 case DT_ADDRRNGLO: return "ADDRRNGLO";
1469 case DT_CONFIG: return "CONFIG";
1470 case DT_DEPAUDIT: return "DEPAUDIT";
1471 case DT_AUDIT: return "AUDIT";
1472 case DT_PLTPAD: return "PLTPAD";
1473 case DT_MOVETAB: return "MOVETAB";
1474 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
1476 case DT_VERSYM: return "VERSYM";
1478 case DT_RELACOUNT: return "RELACOUNT";
1479 case DT_RELCOUNT: return "RELCOUNT";
1480 case DT_FLAGS_1: return "FLAGS_1";
1481 case DT_VERDEF: return "VERDEF";
1482 case DT_VERDEFNUM: return "VERDEFNUM";
1483 case DT_VERNEED: return "VERNEED";
1484 case DT_VERNEEDNUM: return "VERNEEDNUM";
1486 case DT_AUXILIARY: return "AUXILIARY";
1487 case DT_USED: return "USED";
1488 case DT_FILTER: return "FILTER";
1490 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1491 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1492 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1493 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1494 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1497 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1501 switch (elf_header.e_machine)
1504 case EM_MIPS_RS3_LE:
1505 result = get_mips_dynamic_type (type);
1508 result = get_sparc64_dynamic_type (type);
1511 result = get_ppc64_dynamic_type (type);
1514 result = get_ia64_dynamic_type (type);
1524 sprintf (buff, _("Processor Specific: %lx"), type);
1526 else if ((type >= DT_LOOS) && (type <= DT_HIOS))
1530 switch (elf_header.e_machine)
1533 result = get_parisc_dynamic_type (type);
1543 sprintf (buff, _("Operating System specific: %lx"), type);
1546 sprintf (buff, _("<unknown>: %lx"), type);
1553 get_file_type (unsigned e_type)
1555 static char buff[32];
1559 case ET_NONE: return _("NONE (None)");
1560 case ET_REL: return _("REL (Relocatable file)");
1561 case ET_EXEC: return _("EXEC (Executable file)");
1562 case ET_DYN: return _("DYN (Shared object file)");
1563 case ET_CORE: return _("CORE (Core file)");
1566 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1567 sprintf (buff, _("Processor Specific: (%x)"), e_type);
1568 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1569 sprintf (buff, _("OS Specific: (%x)"), e_type);
1571 sprintf (buff, _("<unknown>: %x"), e_type);
1577 get_machine_name (unsigned e_machine)
1579 static char buff[64]; /* XXX */
1583 case EM_NONE: return _("None");
1584 case EM_M32: return "WE32100";
1585 case EM_SPARC: return "Sparc";
1586 case EM_386: return "Intel 80386";
1587 case EM_68K: return "MC68000";
1588 case EM_88K: return "MC88000";
1589 case EM_486: return "Intel 80486";
1590 case EM_860: return "Intel 80860";
1591 case EM_MIPS: return "MIPS R3000";
1592 case EM_S370: return "IBM System/370";
1593 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
1594 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
1595 case EM_PARISC: return "HPPA";
1596 case EM_PPC_OLD: return "Power PC (old)";
1597 case EM_SPARC32PLUS: return "Sparc v8+" ;
1598 case EM_960: return "Intel 90860";
1599 case EM_PPC: return "PowerPC";
1600 case EM_PPC64: return "PowerPC64";
1601 case EM_V800: return "NEC V800";
1602 case EM_FR20: return "Fujitsu FR20";
1603 case EM_RH32: return "TRW RH32";
1604 case EM_MCORE: return "MCORE";
1605 case EM_ARM: return "ARM";
1606 case EM_OLD_ALPHA: return "Digital Alpha (old)";
1607 case EM_SH: return "Renesas / SuperH SH";
1608 case EM_SPARCV9: return "Sparc v9";
1609 case EM_TRICORE: return "Siemens Tricore";
1610 case EM_ARC: return "ARC";
1611 case EM_H8_300: return "Renesas H8/300";
1612 case EM_H8_300H: return "Renesas H8/300H";
1613 case EM_H8S: return "Renesas H8S";
1614 case EM_H8_500: return "Renesas H8/500";
1615 case EM_IA_64: return "Intel IA-64";
1616 case EM_MIPS_X: return "Stanford MIPS-X";
1617 case EM_COLDFIRE: return "Motorola Coldfire";
1618 case EM_68HC12: return "Motorola M68HC12";
1619 case EM_ALPHA: return "Alpha";
1620 case EM_CYGNUS_D10V:
1621 case EM_D10V: return "d10v";
1622 case EM_CYGNUS_D30V:
1623 case EM_D30V: return "d30v";
1624 case EM_CYGNUS_M32R:
1625 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
1626 case EM_CYGNUS_V850:
1627 case EM_V850: return "NEC v850";
1628 case EM_CYGNUS_MN10300:
1629 case EM_MN10300: return "mn10300";
1630 case EM_CYGNUS_MN10200:
1631 case EM_MN10200: return "mn10200";
1632 case EM_CYGNUS_FR30:
1633 case EM_FR30: return "Fujitsu FR30";
1634 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
1636 case EM_PJ: return "picoJava";
1637 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1638 case EM_PCP: return "Siemens PCP";
1639 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1640 case EM_NDR1: return "Denso NDR1 microprocesspr";
1641 case EM_STARCORE: return "Motorola Star*Core processor";
1642 case EM_ME16: return "Toyota ME16 processor";
1643 case EM_ST100: return "STMicroelectronics ST100 processor";
1644 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
1645 case EM_FX66: return "Siemens FX66 microcontroller";
1646 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1647 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1648 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
1649 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1650 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1651 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1652 case EM_SVX: return "Silicon Graphics SVx";
1653 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1654 case EM_VAX: return "Digital VAX";
1656 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1657 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
1658 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
1659 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
1660 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
1661 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
1662 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
1663 case EM_PRISM: return "Vitesse Prism";
1664 case EM_X86_64: return "Advanced Micro Devices X86-64";
1666 case EM_S390: return "IBM S/390";
1667 case EM_XSTORMY16: return "Sanyo Xstormy16 CPU core";
1669 case EM_OR32: return "OpenRISC";
1670 case EM_CRX: return "National Semiconductor CRX microprocessor";
1671 case EM_DLX: return "OpenDLX";
1673 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
1674 case EM_IQ2000: return "Vitesse IQ2000";
1676 case EM_XTENSA: return "Tensilica Xtensa Processor";
1678 sprintf (buff, _("<unknown>: %x"), e_machine);
1684 decode_ARM_machine_flags (unsigned e_flags, char buf[])
1689 eabi = EF_ARM_EABI_VERSION (e_flags);
1690 e_flags &= ~ EF_ARM_EABIMASK;
1692 /* Handle "generic" ARM flags. */
1693 if (e_flags & EF_ARM_RELEXEC)
1695 strcat (buf, ", relocatable executable");
1696 e_flags &= ~ EF_ARM_RELEXEC;
1699 if (e_flags & EF_ARM_HASENTRY)
1701 strcat (buf, ", has entry point");
1702 e_flags &= ~ EF_ARM_HASENTRY;
1705 /* Now handle EABI specific flags. */
1709 strcat (buf, ", <unrecognized EABI>");
1714 case EF_ARM_EABI_VER1:
1715 strcat (buf, ", Version1 EABI");
1720 /* Process flags one bit at a time. */
1721 flag = e_flags & - e_flags;
1726 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
1727 strcat (buf, ", sorted symbol tables");
1737 case EF_ARM_EABI_VER2:
1738 strcat (buf, ", Version2 EABI");
1743 /* Process flags one bit at a time. */
1744 flag = e_flags & - e_flags;
1749 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
1750 strcat (buf, ", sorted symbol tables");
1753 case EF_ARM_DYNSYMSUSESEGIDX:
1754 strcat (buf, ", dynamic symbols use segment index");
1757 case EF_ARM_MAPSYMSFIRST:
1758 strcat (buf, ", mapping symbols precede others");
1768 case EF_ARM_EABI_VER3:
1769 strcat (buf, ", Version3 EABI");
1772 case EF_ARM_EABI_VER4:
1773 strcat (buf, ", Version4 EABI");
1778 /* Process flags one bit at a time. */
1779 flag = e_flags & - e_flags;
1785 strcat (buf, ", BE8");
1789 strcat (buf, ", LE8");
1799 case EF_ARM_EABI_UNKNOWN:
1800 strcat (buf, ", GNU EABI");
1805 /* Process flags one bit at a time. */
1806 flag = e_flags & - e_flags;
1811 case EF_ARM_INTERWORK:
1812 strcat (buf, ", interworking enabled");
1815 case EF_ARM_APCS_26:
1816 strcat (buf, ", uses APCS/26");
1819 case EF_ARM_APCS_FLOAT:
1820 strcat (buf, ", uses APCS/float");
1824 strcat (buf, ", position independent");
1828 strcat (buf, ", 8 bit structure alignment");
1831 case EF_ARM_NEW_ABI:
1832 strcat (buf, ", uses new ABI");
1835 case EF_ARM_OLD_ABI:
1836 strcat (buf, ", uses old ABI");
1839 case EF_ARM_SOFT_FLOAT:
1840 strcat (buf, ", software FP");
1843 case EF_ARM_VFP_FLOAT:
1844 strcat (buf, ", VFP");
1847 case EF_ARM_MAVERICK_FLOAT:
1848 strcat (buf, ", Maverick FP");
1859 strcat (buf,", <unknown>");
1863 get_machine_flags (unsigned e_flags, unsigned e_machine)
1865 static char buf[1024];
1877 decode_ARM_machine_flags (e_flags, buf);
1881 switch (e_flags & EF_FRV_CPU_MASK)
1883 case EF_FRV_CPU_GENERIC:
1887 strcat (buf, ", fr???");
1890 case EF_FRV_CPU_FR300:
1891 strcat (buf, ", fr300");
1894 case EF_FRV_CPU_FR400:
1895 strcat (buf, ", fr400");
1897 case EF_FRV_CPU_FR405:
1898 strcat (buf, ", fr405");
1901 case EF_FRV_CPU_FR450:
1902 strcat (buf, ", fr450");
1905 case EF_FRV_CPU_FR500:
1906 strcat (buf, ", fr500");
1908 case EF_FRV_CPU_FR550:
1909 strcat (buf, ", fr550");
1912 case EF_FRV_CPU_SIMPLE:
1913 strcat (buf, ", simple");
1915 case EF_FRV_CPU_TOMCAT:
1916 strcat (buf, ", tomcat");
1922 if (e_flags & EF_CPU32)
1923 strcat (buf, ", cpu32");
1924 if (e_flags & EF_M68000)
1925 strcat (buf, ", m68000");
1929 if (e_flags & EF_PPC_EMB)
1930 strcat (buf, ", emb");
1932 if (e_flags & EF_PPC_RELOCATABLE)
1933 strcat (buf, ", relocatable");
1935 if (e_flags & EF_PPC_RELOCATABLE_LIB)
1936 strcat (buf, ", relocatable-lib");
1940 case EM_CYGNUS_V850:
1941 switch (e_flags & EF_V850_ARCH)
1944 strcat (buf, ", v850e1");
1947 strcat (buf, ", v850e");
1950 strcat (buf, ", v850");
1953 strcat (buf, ", unknown v850 architecture variant");
1959 case EM_CYGNUS_M32R:
1960 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
1961 strcat (buf, ", m32r");
1966 case EM_MIPS_RS3_LE:
1967 if (e_flags & EF_MIPS_NOREORDER)
1968 strcat (buf, ", noreorder");
1970 if (e_flags & EF_MIPS_PIC)
1971 strcat (buf, ", pic");
1973 if (e_flags & EF_MIPS_CPIC)
1974 strcat (buf, ", cpic");
1976 if (e_flags & EF_MIPS_UCODE)
1977 strcat (buf, ", ugen_reserved");
1979 if (e_flags & EF_MIPS_ABI2)
1980 strcat (buf, ", abi2");
1982 if (e_flags & EF_MIPS_OPTIONS_FIRST)
1983 strcat (buf, ", odk first");
1985 if (e_flags & EF_MIPS_32BITMODE)
1986 strcat (buf, ", 32bitmode");
1988 switch ((e_flags & EF_MIPS_MACH))
1990 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
1991 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
1992 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
1993 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
1994 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
1995 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
1996 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
1997 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
1998 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
2000 /* We simply ignore the field in this case to avoid confusion:
2001 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2004 default: strcat (buf, ", unknown CPU"); break;
2007 switch ((e_flags & EF_MIPS_ABI))
2009 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2010 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2011 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2012 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2014 /* We simply ignore the field in this case to avoid confusion:
2015 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2016 This means it is likely to be an o32 file, but not for
2019 default: strcat (buf, ", unknown ABI"); break;
2022 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2023 strcat (buf, ", mdmx");
2025 if (e_flags & EF_MIPS_ARCH_ASE_M16)
2026 strcat (buf, ", mips16");
2028 switch ((e_flags & EF_MIPS_ARCH))
2030 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2031 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2032 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2033 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2034 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2035 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
2036 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
2037 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
2038 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2039 default: strcat (buf, ", unknown ISA"); break;
2045 switch ((e_flags & EF_SH_MACH_MASK))
2047 case EF_SH1: strcat (buf, ", sh1"); break;
2048 case EF_SH2: strcat (buf, ", sh2"); break;
2049 case EF_SH3: strcat (buf, ", sh3"); break;
2050 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2051 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2052 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2053 case EF_SH3E: strcat (buf, ", sh3e"); break;
2054 case EF_SH4: strcat (buf, ", sh4"); break;
2055 case EF_SH5: strcat (buf, ", sh5"); break;
2056 case EF_SH2E: strcat (buf, ", sh2e"); break;
2057 case EF_SH4A: strcat (buf, ", sh4a"); break;
2058 case EF_SH2A: strcat (buf, ", sh2a"); break;
2059 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2060 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
2061 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
2062 default: strcat (buf, ", unknown ISA"); break;
2068 if (e_flags & EF_SPARC_32PLUS)
2069 strcat (buf, ", v8+");
2071 if (e_flags & EF_SPARC_SUN_US1)
2072 strcat (buf, ", ultrasparcI");
2074 if (e_flags & EF_SPARC_SUN_US3)
2075 strcat (buf, ", ultrasparcIII");
2077 if (e_flags & EF_SPARC_HAL_R1)
2078 strcat (buf, ", halr1");
2080 if (e_flags & EF_SPARC_LEDATA)
2081 strcat (buf, ", ledata");
2083 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2084 strcat (buf, ", tso");
2086 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2087 strcat (buf, ", pso");
2089 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2090 strcat (buf, ", rmo");
2094 switch (e_flags & EF_PARISC_ARCH)
2096 case EFA_PARISC_1_0:
2097 strcpy (buf, ", PA-RISC 1.0");
2099 case EFA_PARISC_1_1:
2100 strcpy (buf, ", PA-RISC 1.1");
2102 case EFA_PARISC_2_0:
2103 strcpy (buf, ", PA-RISC 2.0");
2108 if (e_flags & EF_PARISC_TRAPNIL)
2109 strcat (buf, ", trapnil");
2110 if (e_flags & EF_PARISC_EXT)
2111 strcat (buf, ", ext");
2112 if (e_flags & EF_PARISC_LSB)
2113 strcat (buf, ", lsb");
2114 if (e_flags & EF_PARISC_WIDE)
2115 strcat (buf, ", wide");
2116 if (e_flags & EF_PARISC_NO_KABP)
2117 strcat (buf, ", no kabp");
2118 if (e_flags & EF_PARISC_LAZYSWAP)
2119 strcat (buf, ", lazyswap");
2124 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2125 strcat (buf, ", new calling convention");
2127 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2128 strcat (buf, ", gnu calling convention");
2132 if ((e_flags & EF_IA_64_ABI64))
2133 strcat (buf, ", 64-bit");
2135 strcat (buf, ", 32-bit");
2136 if ((e_flags & EF_IA_64_REDUCEDFP))
2137 strcat (buf, ", reduced fp model");
2138 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2139 strcat (buf, ", no function descriptors, constant gp");
2140 else if ((e_flags & EF_IA_64_CONS_GP))
2141 strcat (buf, ", constant gp");
2142 if ((e_flags & EF_IA_64_ABSOLUTE))
2143 strcat (buf, ", absolute");
2147 if ((e_flags & EF_VAX_NONPIC))
2148 strcat (buf, ", non-PIC");
2149 if ((e_flags & EF_VAX_DFLOAT))
2150 strcat (buf, ", D-Float");
2151 if ((e_flags & EF_VAX_GFLOAT))
2152 strcat (buf, ", G-Float");
2161 get_osabi_name (unsigned int osabi)
2163 static char buff[32];
2167 case ELFOSABI_NONE: return "UNIX - System V";
2168 case ELFOSABI_HPUX: return "UNIX - HP-UX";
2169 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
2170 case ELFOSABI_LINUX: return "UNIX - Linux";
2171 case ELFOSABI_HURD: return "GNU/Hurd";
2172 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
2173 case ELFOSABI_AIX: return "UNIX - AIX";
2174 case ELFOSABI_IRIX: return "UNIX - IRIX";
2175 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
2176 case ELFOSABI_TRU64: return "UNIX - TRU64";
2177 case ELFOSABI_MODESTO: return "Novell - Modesto";
2178 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
2179 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
2180 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
2181 case ELFOSABI_AROS: return "Amiga Research OS";
2182 case ELFOSABI_STANDALONE: return _("Standalone App");
2183 case ELFOSABI_ARM: return "ARM";
2185 sprintf (buff, _("<unknown: %x>"), osabi);
2191 get_mips_segment_type (unsigned long type)
2195 case PT_MIPS_REGINFO:
2197 case PT_MIPS_RTPROC:
2199 case PT_MIPS_OPTIONS:
2209 get_parisc_segment_type (unsigned long type)
2213 case PT_HP_TLS: return "HP_TLS";
2214 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
2215 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
2216 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
2217 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
2218 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
2219 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
2220 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
2221 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
2222 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
2223 case PT_HP_PARALLEL: return "HP_PARALLEL";
2224 case PT_HP_FASTBIND: return "HP_FASTBIND";
2225 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
2226 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
2235 get_ia64_segment_type (unsigned long type)
2239 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
2240 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
2241 case PT_HP_TLS: return "HP_TLS";
2242 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
2243 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
2244 case PT_IA_64_HP_STACK: return "HP_STACK";
2253 get_segment_type (unsigned long p_type)
2255 static char buff[32];
2259 case PT_NULL: return "NULL";
2260 case PT_LOAD: return "LOAD";
2261 case PT_DYNAMIC: return "DYNAMIC";
2262 case PT_INTERP: return "INTERP";
2263 case PT_NOTE: return "NOTE";
2264 case PT_SHLIB: return "SHLIB";
2265 case PT_PHDR: return "PHDR";
2266 case PT_TLS: return "TLS";
2268 case PT_GNU_EH_FRAME:
2269 return "GNU_EH_FRAME";
2270 case PT_GNU_STACK: return "GNU_STACK";
2271 case PT_GNU_RELRO: return "GNU_RELRO";
2274 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
2278 switch (elf_header.e_machine)
2281 case EM_MIPS_RS3_LE:
2282 result = get_mips_segment_type (p_type);
2285 result = get_parisc_segment_type (p_type);
2288 result = get_ia64_segment_type (p_type);
2298 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
2300 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
2304 switch (elf_header.e_machine)
2307 result = get_parisc_segment_type (p_type);
2310 result = get_ia64_segment_type (p_type);
2320 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
2323 sprintf (buff, _("<unknown>: %lx"), p_type);
2330 get_mips_section_type_name (unsigned int sh_type)
2334 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
2335 case SHT_MIPS_MSYM: return "MIPS_MSYM";
2336 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
2337 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
2338 case SHT_MIPS_UCODE: return "MIPS_UCODE";
2339 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
2340 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
2341 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
2342 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
2343 case SHT_MIPS_RELD: return "MIPS_RELD";
2344 case SHT_MIPS_IFACE: return "MIPS_IFACE";
2345 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
2346 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
2347 case SHT_MIPS_SHDR: return "MIPS_SHDR";
2348 case SHT_MIPS_FDESC: return "MIPS_FDESC";
2349 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
2350 case SHT_MIPS_DENSE: return "MIPS_DENSE";
2351 case SHT_MIPS_PDESC: return "MIPS_PDESC";
2352 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
2353 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
2354 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
2355 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
2356 case SHT_MIPS_LINE: return "MIPS_LINE";
2357 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
2358 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
2359 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
2360 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
2361 case SHT_MIPS_DWARF: return "MIPS_DWARF";
2362 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
2363 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
2364 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
2365 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
2366 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
2367 case SHT_MIPS_XLATE: return "MIPS_XLATE";
2368 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
2369 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
2370 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
2371 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
2372 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
2380 get_parisc_section_type_name (unsigned int sh_type)
2384 case SHT_PARISC_EXT: return "PARISC_EXT";
2385 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
2386 case SHT_PARISC_DOC: return "PARISC_DOC";
2394 get_ia64_section_type_name (unsigned int sh_type)
2396 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2397 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
2398 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
2402 case SHT_IA_64_EXT: return "IA_64_EXT";
2403 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
2404 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
2412 get_x86_64_section_type_name (unsigned int sh_type)
2416 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
2424 get_arm_section_type_name (unsigned int sh_type)
2437 get_section_type_name (unsigned int sh_type)
2439 static char buff[32];
2443 case SHT_NULL: return "NULL";
2444 case SHT_PROGBITS: return "PROGBITS";
2445 case SHT_SYMTAB: return "SYMTAB";
2446 case SHT_STRTAB: return "STRTAB";
2447 case SHT_RELA: return "RELA";
2448 case SHT_HASH: return "HASH";
2449 case SHT_DYNAMIC: return "DYNAMIC";
2450 case SHT_NOTE: return "NOTE";
2451 case SHT_NOBITS: return "NOBITS";
2452 case SHT_REL: return "REL";
2453 case SHT_SHLIB: return "SHLIB";
2454 case SHT_DYNSYM: return "DYNSYM";
2455 case SHT_INIT_ARRAY: return "INIT_ARRAY";
2456 case SHT_FINI_ARRAY: return "FINI_ARRAY";
2457 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2458 case SHT_GROUP: return "GROUP";
2459 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
2460 case SHT_GNU_verdef: return "VERDEF";
2461 case SHT_GNU_verneed: return "VERNEED";
2462 case SHT_GNU_versym: return "VERSYM";
2463 case 0x6ffffff0: return "VERSYM";
2464 case 0x6ffffffc: return "VERDEF";
2465 case 0x7ffffffd: return "AUXILIARY";
2466 case 0x7fffffff: return "FILTER";
2467 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
2470 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
2474 switch (elf_header.e_machine)
2477 case EM_MIPS_RS3_LE:
2478 result = get_mips_section_type_name (sh_type);
2481 result = get_parisc_section_type_name (sh_type);
2484 result = get_ia64_section_type_name (sh_type);
2487 result = get_x86_64_section_type_name (sh_type);
2490 result = get_arm_section_type_name (sh_type);
2500 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
2502 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
2503 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
2504 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
2505 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
2507 sprintf (buff, _("<unknown>: %x"), sh_type);
2513 #define OPTION_DEBUG_DUMP 512
2515 struct option options[] =
2517 {"all", no_argument, 0, 'a'},
2518 {"file-header", no_argument, 0, 'h'},
2519 {"program-headers", no_argument, 0, 'l'},
2520 {"headers", no_argument, 0, 'e'},
2521 {"histogram", no_argument, 0, 'I'},
2522 {"segments", no_argument, 0, 'l'},
2523 {"sections", no_argument, 0, 'S'},
2524 {"section-headers", no_argument, 0, 'S'},
2525 {"section-groups", no_argument, 0, 'g'},
2526 {"symbols", no_argument, 0, 's'},
2527 {"syms", no_argument, 0, 's'},
2528 {"relocs", no_argument, 0, 'r'},
2529 {"notes", no_argument, 0, 'n'},
2530 {"dynamic", no_argument, 0, 'd'},
2531 {"arch-specific", no_argument, 0, 'A'},
2532 {"version-info", no_argument, 0, 'V'},
2533 {"use-dynamic", no_argument, 0, 'D'},
2534 {"hex-dump", required_argument, 0, 'x'},
2535 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
2536 {"unwind", no_argument, 0, 'u'},
2537 #ifdef SUPPORT_DISASSEMBLY
2538 {"instruction-dump", required_argument, 0, 'i'},
2541 {"version", no_argument, 0, 'v'},
2542 {"wide", no_argument, 0, 'W'},
2543 {"help", no_argument, 0, 'H'},
2544 {0, no_argument, 0, 0}
2550 fprintf (stdout, _("Usage: readelf <option(s)> elf-file(s)\n"));
2551 fprintf (stdout, _(" Display information about the contents of ELF format files\n"));
2552 fprintf (stdout, _(" Options are:\n\
2553 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2554 -h --file-header Display the ELF file header\n\
2555 -l --program-headers Display the program headers\n\
2556 --segments An alias for --program-headers\n\
2557 -S --section-headers Display the sections' header\n\
2558 --sections An alias for --section-headers\n\
2559 -g --section-groups Display the section groups\n\
2560 -e --headers Equivalent to: -h -l -S\n\
2561 -s --syms Display the symbol table\n\
2562 --symbols An alias for --syms\n\
2563 -n --notes Display the core notes (if present)\n\
2564 -r --relocs Display the relocations (if present)\n\
2565 -u --unwind Display the unwind info (if present)\n\
2566 -d --dynamic Display the dynamic section (if present)\n\
2567 -V --version-info Display the version sections (if present)\n\
2568 -A --arch-specific Display architecture specific information (if any).\n\
2569 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2570 -x --hex-dump=<number> Dump the contents of section <number>\n\
2571 -w[liaprmfFso] or\n\
2572 --debug-dump[=line,=info,=abbrev,=pubnames,=ranges,=macro,=frames,=str,=loc]\n\
2573 Display the contents of DWARF2 debug sections\n"));
2574 #ifdef SUPPORT_DISASSEMBLY
2575 fprintf (stdout, _("\
2576 -i --instruction-dump=<number>\n\
2577 Disassemble the contents of section <number>\n"));
2579 fprintf (stdout, _("\
2580 -I --histogram Display histogram of bucket list lengths\n\
2581 -W --wide Allow output width to exceed 80 characters\n\
2582 -H --help Display this information\n\
2583 -v --version Display the version number of readelf\n"));
2584 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
2590 request_dump (unsigned int section, int type)
2592 if (section >= num_dump_sects)
2594 char *new_dump_sects;
2596 new_dump_sects = calloc (section + 1, 1);
2598 if (new_dump_sects == NULL)
2599 error (_("Out of memory allocating dump request table."));
2602 /* Copy current flag settings. */
2603 memcpy (new_dump_sects, dump_sects, num_dump_sects);
2607 dump_sects = new_dump_sects;
2608 num_dump_sects = section + 1;
2613 dump_sects[section] |= type;
2619 parse_args (int argc, char **argv)
2626 while ((c = getopt_long
2627 (argc, argv, "ersuahnldSDAIgw::x:i:vVWH", options, NULL)) != EOF)
2648 do_section_groups++;
2656 do_section_groups++;
2698 section = strtoul (optarg, & cp, 0);
2699 if (! *cp && section >= 0)
2701 request_dump (section, HEX_DUMP);
2711 unsigned int index = 0;
2715 while (optarg[index])
2716 switch (optarg[index++])
2725 do_debug_abbrevs = 1;
2735 do_debug_pubnames = 1;
2740 do_debug_aranges = 1;
2744 do_debug_frames_interp = 1;
2746 do_debug_frames = 1;
2751 do_debug_macinfo = 1;
2765 warn (_("Unrecognized debug option '%s'\n"), optarg);
2770 case OPTION_DEBUG_DUMP:
2776 static const char *debug_dump_opt[]
2777 = { "line", "info", "abbrev", "pubnames", "ranges",
2778 "macro", "frames", "frames-interp", "str", "loc", NULL };
2787 for (index = 0; debug_dump_opt[index]; index++)
2789 size_t len = strlen (debug_dump_opt[index]);
2791 if (strncmp (p, debug_dump_opt[index], len) == 0
2792 && (p[len] == ',' || p[len] == '\0'))
2801 do_debug_abbrevs = 1;
2812 do_debug_pubnames = 1;
2816 do_debug_aranges = 1;
2821 do_debug_frames_interp = 1;
2822 do_debug_frames = 1;
2826 do_debug_macinfo = 1;
2839 if (debug_dump_opt[index] == NULL)
2841 warn (_("Unrecognized debug option '%s'\n"), p);
2842 p = strchr (p, ',');
2852 #ifdef SUPPORT_DISASSEMBLY
2855 section = strtoul (optarg, & cp, 0);
2856 if (! *cp && section >= 0)
2858 request_dump (section, DISASS_DUMP);
2864 print_version (program_name);
2874 /* xgettext:c-format */
2875 error (_("Invalid option '-%c'\n"), c);
2882 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
2883 && !do_segments && !do_header && !do_dump && !do_version
2884 && !do_histogram && !do_debugging && !do_arch && !do_notes
2885 && !do_section_groups)
2889 warn (_("Nothing to do.\n"));
2895 get_elf_class (unsigned int elf_class)
2897 static char buff[32];
2901 case ELFCLASSNONE: return _("none");
2902 case ELFCLASS32: return "ELF32";
2903 case ELFCLASS64: return "ELF64";
2905 sprintf (buff, _("<unknown: %x>"), elf_class);
2911 get_data_encoding (unsigned int encoding)
2913 static char buff[32];
2917 case ELFDATANONE: return _("none");
2918 case ELFDATA2LSB: return _("2's complement, little endian");
2919 case ELFDATA2MSB: return _("2's complement, big endian");
2921 sprintf (buff, _("<unknown: %x>"), encoding);
2926 /* Decode the data held in 'elf_header'. */
2929 process_file_header (void)
2931 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
2932 || elf_header.e_ident[EI_MAG1] != ELFMAG1
2933 || elf_header.e_ident[EI_MAG2] != ELFMAG2
2934 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
2937 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2945 printf (_("ELF Header:\n"));
2946 printf (_(" Magic: "));
2947 for (i = 0; i < EI_NIDENT; i++)
2948 printf ("%2.2x ", elf_header.e_ident[i]);
2950 printf (_(" Class: %s\n"),
2951 get_elf_class (elf_header.e_ident[EI_CLASS]));
2952 printf (_(" Data: %s\n"),
2953 get_data_encoding (elf_header.e_ident[EI_DATA]));
2954 printf (_(" Version: %d %s\n"),
2955 elf_header.e_ident[EI_VERSION],
2956 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
2958 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2961 printf (_(" OS/ABI: %s\n"),
2962 get_osabi_name (elf_header.e_ident[EI_OSABI]));
2963 printf (_(" ABI Version: %d\n"),
2964 elf_header.e_ident[EI_ABIVERSION]);
2965 printf (_(" Type: %s\n"),
2966 get_file_type (elf_header.e_type));
2967 printf (_(" Machine: %s\n"),
2968 get_machine_name (elf_header.e_machine));
2969 printf (_(" Version: 0x%lx\n"),
2970 (unsigned long) elf_header.e_version);
2972 printf (_(" Entry point address: "));
2973 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2974 printf (_("\n Start of program headers: "));
2975 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
2976 printf (_(" (bytes into file)\n Start of section headers: "));
2977 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
2978 printf (_(" (bytes into file)\n"));
2980 printf (_(" Flags: 0x%lx%s\n"),
2981 (unsigned long) elf_header.e_flags,
2982 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
2983 printf (_(" Size of this header: %ld (bytes)\n"),
2984 (long) elf_header.e_ehsize);
2985 printf (_(" Size of program headers: %ld (bytes)\n"),
2986 (long) elf_header.e_phentsize);
2987 printf (_(" Number of program headers: %ld\n"),
2988 (long) elf_header.e_phnum);
2989 printf (_(" Size of section headers: %ld (bytes)\n"),
2990 (long) elf_header.e_shentsize);
2991 printf (_(" Number of section headers: %ld"),
2992 (long) elf_header.e_shnum);
2993 if (section_headers != NULL && elf_header.e_shnum == 0)
2994 printf (" (%ld)", (long) section_headers[0].sh_size);
2995 putc ('\n', stdout);
2996 printf (_(" Section header string table index: %ld"),
2997 (long) elf_header.e_shstrndx);
2998 if (section_headers != NULL && elf_header.e_shstrndx == SHN_XINDEX)
2999 printf (" (%ld)", (long) section_headers[0].sh_link);
3000 putc ('\n', stdout);
3003 if (section_headers != NULL)
3005 if (elf_header.e_shnum == 0)
3006 elf_header.e_shnum = section_headers[0].sh_size;
3007 if (elf_header.e_shstrndx == SHN_XINDEX)
3008 elf_header.e_shstrndx = section_headers[0].sh_link;
3009 free (section_headers);
3010 section_headers = NULL;
3018 get_32bit_program_headers (FILE *file, Elf_Internal_Phdr *program_headers)
3020 Elf32_External_Phdr *phdrs;
3021 Elf32_External_Phdr *external;
3022 Elf_Internal_Phdr *internal;
3025 phdrs = get_data (NULL, file, elf_header.e_phoff,
3026 elf_header.e_phentsize * elf_header.e_phnum,
3027 _("program headers"));
3031 for (i = 0, internal = program_headers, external = phdrs;
3032 i < elf_header.e_phnum;
3033 i++, internal++, external++)
3035 internal->p_type = BYTE_GET (external->p_type);
3036 internal->p_offset = BYTE_GET (external->p_offset);
3037 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3038 internal->p_paddr = BYTE_GET (external->p_paddr);
3039 internal->p_filesz = BYTE_GET (external->p_filesz);
3040 internal->p_memsz = BYTE_GET (external->p_memsz);
3041 internal->p_flags = BYTE_GET (external->p_flags);
3042 internal->p_align = BYTE_GET (external->p_align);
3051 get_64bit_program_headers (FILE *file, Elf_Internal_Phdr *program_headers)
3053 Elf64_External_Phdr *phdrs;
3054 Elf64_External_Phdr *external;
3055 Elf_Internal_Phdr *internal;
3058 phdrs = get_data (NULL, file, elf_header.e_phoff,
3059 elf_header.e_phentsize * elf_header.e_phnum,
3060 _("program headers"));
3064 for (i = 0, internal = program_headers, external = phdrs;
3065 i < elf_header.e_phnum;
3066 i++, internal++, external++)
3068 internal->p_type = BYTE_GET (external->p_type);
3069 internal->p_flags = BYTE_GET (external->p_flags);
3070 internal->p_offset = BYTE_GET8 (external->p_offset);
3071 internal->p_vaddr = BYTE_GET8 (external->p_vaddr);
3072 internal->p_paddr = BYTE_GET8 (external->p_paddr);
3073 internal->p_filesz = BYTE_GET8 (external->p_filesz);
3074 internal->p_memsz = BYTE_GET8 (external->p_memsz);
3075 internal->p_align = BYTE_GET8 (external->p_align);
3083 /* Returns 1 if the program headers were read into `program_headers'. */
3086 get_program_headers (FILE *file)
3088 Elf_Internal_Phdr *phdrs;
3090 /* Check cache of prior read. */
3091 if (program_headers != NULL)
3094 phdrs = malloc (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
3098 error (_("Out of memory\n"));
3103 ? get_32bit_program_headers (file, phdrs)
3104 : get_64bit_program_headers (file, phdrs))
3106 program_headers = phdrs;
3114 /* Returns 1 if the program headers were loaded. */
3117 process_program_headers (FILE *file)
3119 Elf_Internal_Phdr *segment;
3122 if (elf_header.e_phnum == 0)
3125 printf (_("\nThere are no program headers in this file.\n"));
3129 if (do_segments && !do_header)
3131 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
3132 printf (_("Entry point "));
3133 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3134 printf (_("\nThere are %d program headers, starting at offset "),
3135 elf_header.e_phnum);
3136 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3140 if (! get_program_headers (file))
3145 if (elf_header.e_phnum > 1)
3146 printf (_("\nProgram Headers:\n"));
3148 printf (_("\nProgram Headers:\n"));
3152 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3155 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3159 (_(" Type Offset VirtAddr PhysAddr\n"));
3161 (_(" FileSiz MemSiz Flags Align\n"));
3168 for (i = 0, segment = program_headers;
3169 i < elf_header.e_phnum;
3174 printf (" %-14.14s ", get_segment_type (segment->p_type));
3178 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3179 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
3180 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
3181 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
3182 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
3184 (segment->p_flags & PF_R ? 'R' : ' '),
3185 (segment->p_flags & PF_W ? 'W' : ' '),
3186 (segment->p_flags & PF_X ? 'E' : ' '));
3187 printf ("%#lx", (unsigned long) segment->p_align);
3191 if ((unsigned long) segment->p_offset == segment->p_offset)
3192 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3195 print_vma (segment->p_offset, FULL_HEX);
3199 print_vma (segment->p_vaddr, FULL_HEX);
3201 print_vma (segment->p_paddr, FULL_HEX);
3204 if ((unsigned long) segment->p_filesz == segment->p_filesz)
3205 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
3208 print_vma (segment->p_filesz, FULL_HEX);
3212 if ((unsigned long) segment->p_memsz == segment->p_memsz)
3213 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
3216 print_vma (segment->p_offset, FULL_HEX);
3220 (segment->p_flags & PF_R ? 'R' : ' '),
3221 (segment->p_flags & PF_W ? 'W' : ' '),
3222 (segment->p_flags & PF_X ? 'E' : ' '));
3224 if ((unsigned long) segment->p_align == segment->p_align)
3225 printf ("%#lx", (unsigned long) segment->p_align);
3228 print_vma (segment->p_align, PREFIX_HEX);
3233 print_vma (segment->p_offset, FULL_HEX);
3235 print_vma (segment->p_vaddr, FULL_HEX);
3237 print_vma (segment->p_paddr, FULL_HEX);
3239 print_vma (segment->p_filesz, FULL_HEX);
3241 print_vma (segment->p_memsz, FULL_HEX);
3243 (segment->p_flags & PF_R ? 'R' : ' '),
3244 (segment->p_flags & PF_W ? 'W' : ' '),
3245 (segment->p_flags & PF_X ? 'E' : ' '));
3246 print_vma (segment->p_align, HEX);
3250 switch (segment->p_type)
3254 error (_("more than one dynamic segment\n"));
3256 /* Try to locate the .dynamic section. If there is
3257 a section header table, we can easily locate it. */
3258 if (section_headers != NULL)
3260 Elf_Internal_Shdr *sec;
3263 for (j = 0, sec = section_headers;
3264 j < elf_header.e_shnum;
3266 if (strcmp (SECTION_NAME (sec), ".dynamic") == 0)
3269 if (j == elf_header.e_shnum || sec->sh_size == 0)
3271 error (_("no .dynamic section in the dynamic segment"));
3275 dynamic_addr = sec->sh_offset;
3276 dynamic_size = sec->sh_size;
3278 if (dynamic_addr < segment->p_offset
3279 || dynamic_addr > segment->p_offset + segment->p_filesz)
3280 warn (_("the .dynamic section is not contained within the dynamic segment"));
3281 else if (dynamic_addr > segment->p_offset)
3282 warn (_("the .dynamic section is not the first section in the dynamic segment."));
3286 /* Otherwise, we can only assume that the .dynamic
3287 section is the first section in the DYNAMIC segment. */
3288 dynamic_addr = segment->p_offset;
3289 dynamic_size = segment->p_filesz;
3294 if (fseek (file, archive_file_offset + (long) segment->p_offset,
3296 error (_("Unable to find program interpreter name\n"));
3299 program_interpreter[0] = 0;
3300 fscanf (file, "%63s", program_interpreter);
3303 printf (_("\n [Requesting program interpreter: %s]"),
3304 program_interpreter);
3310 putc ('\n', stdout);
3313 if (do_segments && section_headers != NULL)
3315 printf (_("\n Section to Segment mapping:\n"));
3316 printf (_(" Segment Sections...\n"));
3318 assert (string_table != NULL);
3320 for (i = 0; i < elf_header.e_phnum; i++)
3323 Elf_Internal_Shdr *section;
3325 segment = program_headers + i;
3326 section = section_headers;
3328 printf (" %2.2d ", i);
3330 for (j = 1; j < elf_header.e_shnum; j++, section++)
3332 if (section->sh_size > 0
3333 /* Compare allocated sections by VMA, unallocated
3334 sections by file offset. */
3335 && (section->sh_flags & SHF_ALLOC
3336 ? (section->sh_addr >= segment->p_vaddr
3337 && section->sh_addr + section->sh_size
3338 <= segment->p_vaddr + segment->p_memsz)
3339 : ((bfd_vma) section->sh_offset >= segment->p_offset
3340 && (section->sh_offset + section->sh_size
3341 <= segment->p_offset + segment->p_filesz)))
3342 /* .tbss is special. It doesn't contribute memory space
3343 to normal segments. */
3344 && (!((section->sh_flags & SHF_TLS) != 0
3345 && section->sh_type == SHT_NOBITS)
3346 || segment->p_type == PT_TLS))
3347 printf ("%s ", SECTION_NAME (section));
3358 /* Find the file offset corresponding to VMA by using the program headers. */
3361 offset_from_vma (FILE *file, bfd_vma vma, bfd_size_type size)
3363 Elf_Internal_Phdr *seg;
3365 if (! get_program_headers (file))
3367 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3371 for (seg = program_headers;
3372 seg < program_headers + elf_header.e_phnum;
3375 if (seg->p_type != PT_LOAD)
3378 if (vma >= (seg->p_vaddr & -seg->p_align)
3379 && vma + size <= seg->p_vaddr + seg->p_filesz)
3380 return vma - seg->p_vaddr + seg->p_offset;
3383 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3390 get_32bit_section_headers (FILE *file, unsigned int num)
3392 Elf32_External_Shdr *shdrs;
3393 Elf_Internal_Shdr *internal;
3396 shdrs = get_data (NULL, file, elf_header.e_shoff,
3397 elf_header.e_shentsize * num, _("section headers"));
3401 section_headers = malloc (num * sizeof (Elf_Internal_Shdr));
3403 if (section_headers == NULL)
3405 error (_("Out of memory\n"));
3409 for (i = 0, internal = section_headers;
3413 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
3414 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
3415 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
3416 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
3417 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
3418 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
3419 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
3420 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
3421 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3422 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
3431 get_64bit_section_headers (FILE *file, unsigned int num)
3433 Elf64_External_Shdr *shdrs;
3434 Elf_Internal_Shdr *internal;
3437 shdrs = get_data (NULL, file, elf_header.e_shoff,
3438 elf_header.e_shentsize * num, _("section headers"));
3442 section_headers = malloc (num * sizeof (Elf_Internal_Shdr));
3444 if (section_headers == NULL)
3446 error (_("Out of memory\n"));
3450 for (i = 0, internal = section_headers;
3454 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
3455 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
3456 internal->sh_flags = BYTE_GET8 (shdrs[i].sh_flags);
3457 internal->sh_addr = BYTE_GET8 (shdrs[i].sh_addr);
3458 internal->sh_size = BYTE_GET8 (shdrs[i].sh_size);
3459 internal->sh_entsize = BYTE_GET8 (shdrs[i].sh_entsize);
3460 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
3461 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
3462 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
3463 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3471 static Elf_Internal_Sym *
3472 get_32bit_elf_symbols (FILE *file, Elf_Internal_Shdr *section)
3474 unsigned long number;
3475 Elf32_External_Sym *esyms;
3476 Elf_External_Sym_Shndx *shndx;
3477 Elf_Internal_Sym *isyms;
3478 Elf_Internal_Sym *psym;
3481 esyms = get_data (NULL, file, section->sh_offset, section->sh_size,
3487 if (symtab_shndx_hdr != NULL
3488 && (symtab_shndx_hdr->sh_link
3489 == (unsigned long) SECTION_HEADER_NUM (section - section_headers)))
3491 shndx = get_data (NULL, file, symtab_shndx_hdr->sh_offset,
3492 symtab_shndx_hdr->sh_size, _("symtab shndx"));
3500 number = section->sh_size / section->sh_entsize;
3501 isyms = malloc (number * sizeof (Elf_Internal_Sym));
3505 error (_("Out of memory\n"));
3512 for (j = 0, psym = isyms;
3516 psym->st_name = BYTE_GET (esyms[j].st_name);
3517 psym->st_value = BYTE_GET (esyms[j].st_value);
3518 psym->st_size = BYTE_GET (esyms[j].st_size);
3519 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
3520 if (psym->st_shndx == SHN_XINDEX && shndx != NULL)
3522 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
3523 psym->st_info = BYTE_GET (esyms[j].st_info);
3524 psym->st_other = BYTE_GET (esyms[j].st_other);
3534 static Elf_Internal_Sym *
3535 get_64bit_elf_symbols (FILE *file, Elf_Internal_Shdr *section)
3537 unsigned long number;
3538 Elf64_External_Sym *esyms;
3539 Elf_External_Sym_Shndx *shndx;
3540 Elf_Internal_Sym *isyms;
3541 Elf_Internal_Sym *psym;
3544 esyms = get_data (NULL, file, section->sh_offset, section->sh_size,
3550 if (symtab_shndx_hdr != NULL
3551 && (symtab_shndx_hdr->sh_link
3552 == (unsigned long) SECTION_HEADER_NUM (section - section_headers)))
3554 shndx = get_data (NULL, file, symtab_shndx_hdr->sh_offset,
3555 symtab_shndx_hdr->sh_size, _("symtab shndx"));
3563 number = section->sh_size / section->sh_entsize;
3564 isyms = malloc (number * sizeof (Elf_Internal_Sym));
3568 error (_("Out of memory\n"));
3575 for (j = 0, psym = isyms;
3579 psym->st_name = BYTE_GET (esyms[j].st_name);
3580 psym->st_info = BYTE_GET (esyms[j].st_info);
3581 psym->st_other = BYTE_GET (esyms[j].st_other);
3582 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
3583 if (psym->st_shndx == SHN_XINDEX && shndx != NULL)
3585 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
3586 psym->st_value = BYTE_GET8 (esyms[j].st_value);
3587 psym->st_size = BYTE_GET8 (esyms[j].st_size);
3598 get_elf_section_flags (bfd_vma sh_flags)
3600 static char buff[32];
3608 flag = sh_flags & - sh_flags;
3613 case SHF_WRITE: strcat (buff, "W"); break;
3614 case SHF_ALLOC: strcat (buff, "A"); break;
3615 case SHF_EXECINSTR: strcat (buff, "X"); break;
3616 case SHF_MERGE: strcat (buff, "M"); break;
3617 case SHF_STRINGS: strcat (buff, "S"); break;
3618 case SHF_INFO_LINK: strcat (buff, "I"); break;
3619 case SHF_LINK_ORDER: strcat (buff, "L"); break;
3620 case SHF_OS_NONCONFORMING: strcat (buff, "O"); break;
3621 case SHF_GROUP: strcat (buff, "G"); break;
3622 case SHF_TLS: strcat (buff, "T"); break;
3625 if (flag & SHF_MASKOS)
3628 sh_flags &= ~ SHF_MASKOS;
3630 else if (flag & SHF_MASKPROC)
3633 sh_flags &= ~ SHF_MASKPROC;
3645 process_section_headers (FILE *file)
3647 Elf_Internal_Shdr *section;
3650 section_headers = NULL;
3652 if (elf_header.e_shnum == 0)
3655 printf (_("\nThere are no sections in this file.\n"));
3660 if (do_sections && !do_header)
3661 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3662 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
3666 if (! get_32bit_section_headers (file, elf_header.e_shnum))
3669 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
3672 /* Read in the string table, so that we have names to display. */
3673 section = SECTION_HEADER (elf_header.e_shstrndx);
3675 if (section->sh_size != 0)
3677 string_table = get_data (NULL, file, section->sh_offset,
3678 section->sh_size, _("string table"));
3680 if (string_table == NULL)
3683 string_table_length = section->sh_size;
3686 /* Scan the sections for the dynamic symbol table
3687 and dynamic string table and debug sections. */
3688 dynamic_symbols = NULL;
3689 dynamic_strings = NULL;
3690 dynamic_syminfo = NULL;
3691 symtab_shndx_hdr = NULL;
3693 for (i = 0, section = section_headers;
3694 i < elf_header.e_shnum;
3697 char *name = SECTION_NAME (section);
3699 if (section->sh_type == SHT_DYNSYM)
3701 if (dynamic_symbols != NULL)
3703 error (_("File contains multiple dynamic symbol tables\n"));
3707 num_dynamic_syms = section->sh_size / section->sh_entsize;
3708 dynamic_symbols = GET_ELF_SYMBOLS (file, section);
3710 else if (section->sh_type == SHT_STRTAB
3711 && strcmp (name, ".dynstr") == 0)
3713 if (dynamic_strings != NULL)
3715 error (_("File contains multiple dynamic string tables\n"));
3719 dynamic_strings = get_data (NULL, file, section->sh_offset,
3720 section->sh_size, _("dynamic strings"));
3722 else if (section->sh_type == SHT_SYMTAB_SHNDX)
3724 if (symtab_shndx_hdr != NULL)
3726 error (_("File contains multiple symtab shndx tables\n"));
3729 symtab_shndx_hdr = section;
3731 else if ((do_debugging || do_debug_info || do_debug_abbrevs
3732 || do_debug_lines || do_debug_pubnames || do_debug_aranges
3733 || do_debug_frames || do_debug_macinfo || do_debug_str
3735 && strncmp (name, ".debug_", 7) == 0)
3740 || (do_debug_info && (strcmp (name, "info") == 0))
3741 || (do_debug_abbrevs && (strcmp (name, "abbrev") == 0))
3742 || (do_debug_lines && (strcmp (name, "line") == 0))
3743 || (do_debug_pubnames && (strcmp (name, "pubnames") == 0))
3744 || (do_debug_aranges && (strcmp (name, "aranges") == 0))
3745 || (do_debug_frames && (strcmp (name, "frame") == 0))
3746 || (do_debug_macinfo && (strcmp (name, "macinfo") == 0))
3747 || (do_debug_str && (strcmp (name, "str") == 0))
3748 || (do_debug_loc && (strcmp (name, "loc") == 0))
3750 request_dump (i, DEBUG_DUMP);
3752 /* linkonce section to be combined with .debug_info at link time. */
3753 else if ((do_debugging || do_debug_info)
3754 && strncmp (name, ".gnu.linkonce.wi.", 17) == 0)
3755 request_dump (i, DEBUG_DUMP);
3756 else if (do_debug_frames && strcmp (name, ".eh_frame") == 0)
3757 request_dump (i, DEBUG_DUMP);
3763 if (elf_header.e_shnum > 1)
3764 printf (_("\nSection Headers:\n"));
3766 printf (_("\nSection Header:\n"));
3770 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
3773 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
3776 printf (_(" [Nr] Name Type Address Offset\n"));
3777 printf (_(" Size EntSize Flags Link Info Align\n"));
3780 for (i = 0, section = section_headers;
3781 i < elf_header.e_shnum;
3784 printf (" [%2u] %-17.17s %-15.15s ",
3785 SECTION_HEADER_NUM (i),
3786 SECTION_NAME (section),
3787 get_section_type_name (section->sh_type));
3791 print_vma (section->sh_addr, LONG_HEX);
3793 printf ( " %6.6lx %6.6lx %2.2lx",
3794 (unsigned long) section->sh_offset,
3795 (unsigned long) section->sh_size,
3796 (unsigned long) section->sh_entsize);
3798 printf (" %3s ", get_elf_section_flags (section->sh_flags));
3800 printf ("%2ld %3lu %2ld\n",
3801 (unsigned long) section->sh_link,
3802 (unsigned long) section->sh_info,
3803 (unsigned long) section->sh_addralign);
3807 print_vma (section->sh_addr, LONG_HEX);
3809 if ((long) section->sh_offset == section->sh_offset)
3810 printf (" %6.6lx", (unsigned long) section->sh_offset);
3814 print_vma (section->sh_offset, LONG_HEX);
3817 if ((unsigned long) section->sh_size == section->sh_size)
3818 printf (" %6.6lx", (unsigned long) section->sh_size);
3822 print_vma (section->sh_size, LONG_HEX);
3825 if ((unsigned long) section->sh_entsize == section->sh_entsize)
3826 printf (" %2.2lx", (unsigned long) section->sh_entsize);
3830 print_vma (section->sh_entsize, LONG_HEX);
3833 printf (" %3s ", get_elf_section_flags (section->sh_flags));
3835 printf ("%2ld %3lu ",
3836 (unsigned long) section->sh_link,
3837 (unsigned long) section->sh_info);
3839 if ((unsigned long) section->sh_addralign == section->sh_addralign)
3840 printf ("%2ld\n", (unsigned long) section->sh_addralign);
3843 print_vma (section->sh_addralign, DEC);
3850 print_vma (section->sh_addr, LONG_HEX);
3851 if ((long) section->sh_offset == section->sh_offset)
3852 printf (" %8.8lx", (unsigned long) section->sh_offset);
3856 print_vma (section->sh_offset, LONG_HEX);
3859 print_vma (section->sh_size, LONG_HEX);
3861 print_vma (section->sh_entsize, LONG_HEX);
3863 printf (" %3s ", get_elf_section_flags (section->sh_flags));
3865 printf (" %2ld %3lu %ld\n",
3866 (unsigned long) section->sh_link,
3867 (unsigned long) section->sh_info,
3868 (unsigned long) section->sh_addralign);
3872 printf (_("Key to Flags:\n\
3873 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
3874 I (info), L (link order), G (group), x (unknown)\n\
3875 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3881 get_group_flags (unsigned int flags)
3883 static char buff[32];
3890 sprintf (buff, _("[<unknown>: 0x%x]"), flags);
3897 process_section_groups (FILE *file)
3899 Elf_Internal_Shdr *section;
3901 struct group *group;
3903 if (elf_header.e_shnum == 0)
3905 if (do_section_groups)
3906 printf (_("\nThere are no section groups in this file.\n"));
3911 if (section_headers == NULL)
3913 error (_("Section headers are not available!\n"));
3917 section_headers_groups = calloc (elf_header.e_shnum,
3918 sizeof (struct group *));
3920 if (section_headers_groups == NULL)
3922 error (_("Out of memory\n"));
3926 /* Scan the sections for the group section. */
3927 for (i = 0, section = section_headers;
3928 i < elf_header.e_shnum;
3930 if (section->sh_type == SHT_GROUP)
3933 section_groups = calloc (group_count, sizeof (struct group));
3935 if (section_groups == NULL)
3937 error (_("Out of memory\n"));
3941 for (i = 0, section = section_headers, group = section_groups;
3942 i < elf_header.e_shnum;
3945 if (section->sh_type == SHT_GROUP)
3947 char *name = SECTION_NAME (section);
3948 char *group_name, *strtab, *start, *indices;
3949 unsigned int entry, j, size;
3950 Elf_Internal_Sym *sym;
3951 Elf_Internal_Shdr *symtab_sec, *strtab_sec, *sec;
3952 Elf_Internal_Sym *symtab;
3954 /* Get the symbol table. */
3955 symtab_sec = SECTION_HEADER (section->sh_link);
3956 if (symtab_sec->sh_type != SHT_SYMTAB)
3958 error (_("Bad sh_link in group section `%s'\n"), name);
3961 symtab = GET_ELF_SYMBOLS (file, symtab_sec);
3963 sym = symtab + section->sh_info;
3965 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
3967 bfd_vma sec_index = SECTION_HEADER_INDEX (sym->st_shndx);
3970 error (_("Bad sh_info in group section `%s'\n"), name);
3974 group_name = SECTION_NAME (section_headers + sec_index);
3979 /* Get the string table. */
3980 strtab_sec = SECTION_HEADER (symtab_sec->sh_link);
3981 strtab = get_data (NULL, file, strtab_sec->sh_offset,
3982 strtab_sec->sh_size,
3985 group_name = strtab + sym->st_name;
3988 start = get_data (NULL, file, section->sh_offset,
3989 section->sh_size, _("section data"));
3992 size = (section->sh_size / section->sh_entsize) - 1;
3993 entry = byte_get (indices, 4);
3996 if (do_section_groups)
3998 printf ("\n%s group section `%s' [%s] contains %u sections:\n",
3999 get_group_flags (entry), name, group_name, size);
4001 printf (_(" [Index] Name\n"));
4004 group->group_index = i;
4006 for (j = 0; j < size; j++)
4008 struct group_list *g;
4010 entry = byte_get (indices, 4);
4013 if (section_headers_groups [SECTION_HEADER_INDEX (entry)]
4016 error (_("section [%5u] already in group section [%5u]\n"),
4017 entry, section_headers_groups [SECTION_HEADER_INDEX (entry)]->group_index);
4021 section_headers_groups [SECTION_HEADER_INDEX (entry)]
4024 if (do_section_groups)
4026 sec = SECTION_HEADER (entry);
4027 printf (" [%5u] %s\n",
4028 entry, SECTION_NAME (sec));
4031 g = xmalloc (sizeof (struct group_list));
4032 g->section_index = entry;
4033 g->next = group->root;
4055 } dynamic_relocations [] =
4057 { "REL", DT_REL, DT_RELSZ, FALSE },
4058 { "RELA", DT_RELA, DT_RELASZ, TRUE },
4059 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
4062 /* Process the reloc section. */
4064 process_relocs (FILE *file)
4066 unsigned long rel_size;
4067 unsigned long rel_offset;
4073 if (do_using_dynamic)
4077 int has_dynamic_reloc;
4080 has_dynamic_reloc = 0;
4082 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
4084 is_rela = dynamic_relocations [i].rela;
4085 name = dynamic_relocations [i].name;
4086 rel_size = dynamic_info [dynamic_relocations [i].size];
4087 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
4089 has_dynamic_reloc |= rel_size;
4091 if (is_rela == UNKNOWN)
4093 if (dynamic_relocations [i].reloc == DT_JMPREL)
4094 switch (dynamic_info[DT_PLTREL])
4108 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4109 name, rel_offset, rel_size);
4111 dump_relocations (file,
4112 offset_from_vma (file, rel_offset, rel_size),
4114 dynamic_symbols, num_dynamic_syms,
4115 dynamic_strings, is_rela);
4119 if (! has_dynamic_reloc)
4120 printf (_("\nThere are no dynamic relocations in this file.\n"));
4124 Elf_Internal_Shdr *section;
4128 for (i = 0, section = section_headers;
4129 i < elf_header.e_shnum;
4132 if ( section->sh_type != SHT_RELA
4133 && section->sh_type != SHT_REL)
4136 rel_offset = section->sh_offset;
4137 rel_size = section->sh_size;
4141 Elf_Internal_Shdr *strsec;
4142 Elf_Internal_Sym *symtab;
4145 unsigned long nsyms;
4147 printf (_("\nRelocation section "));
4149 if (string_table == NULL)
4150 printf ("%d", section->sh_name);
4152 printf (_("'%s'"), SECTION_NAME (section));
4154 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4155 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
4160 if (section->sh_link)
4162 Elf_Internal_Shdr *symsec;
4164 symsec = SECTION_HEADER (section->sh_link);
4165 nsyms = symsec->sh_size / symsec->sh_entsize;
4166 symtab = GET_ELF_SYMBOLS (file, symsec);
4171 strsec = SECTION_HEADER (symsec->sh_link);
4173 strtab = get_data (NULL, file, strsec->sh_offset,
4174 strsec->sh_size, _("string table"));
4176 is_rela = section->sh_type == SHT_RELA;
4178 dump_relocations (file, rel_offset, rel_size,
4179 symtab, nsyms, strtab, is_rela);
4191 printf (_("\nThere are no relocations in this file.\n"));
4197 #include "unwind-ia64.h"
4199 /* An absolute address consists of a section and an offset. If the
4200 section is NULL, the offset itself is the address, otherwise, the
4201 address equals to LOAD_ADDRESS(section) + offset. */
4205 unsigned short section;
4211 struct unw_table_entry
4213 struct absaddr start;
4215 struct absaddr info;
4217 *table; /* Unwind table. */
4218 unsigned long table_len; /* Length of unwind table. */
4219 unsigned char *info; /* Unwind info. */
4220 unsigned long info_size; /* Size of unwind info. */
4221 bfd_vma info_addr; /* starting address of unwind info. */
4222 bfd_vma seg_base; /* Starting address of segment. */
4223 Elf_Internal_Sym *symtab; /* The symbol table. */
4224 unsigned long nsyms; /* Number of symbols. */
4225 char *strtab; /* The string table. */
4226 unsigned long strtab_size; /* Size of string table. */
4230 find_symbol_for_address (struct unw_aux_info *aux,
4231 struct absaddr addr,
4232 const char **symname,
4235 bfd_vma dist = 0x100000;
4236 Elf_Internal_Sym *sym, *best = NULL;
4239 for (i = 0, sym = aux->symtab; i < aux->nsyms; ++i, ++sym)
4241 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
4242 && sym->st_name != 0
4243 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
4244 && addr.offset >= sym->st_value
4245 && addr.offset - sym->st_value < dist)
4248 dist = addr.offset - sym->st_value;
4255 *symname = (best->st_name >= aux->strtab_size
4256 ? "<corrupt>" : aux->strtab + best->st_name);
4261 *offset = addr.offset;
4265 dump_ia64_unwind (struct unw_aux_info *aux)
4268 struct unw_table_entry *tp;
4271 addr_size = is_32bit_elf ? 4 : 8;
4273 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
4277 const unsigned char *dp;
4278 const unsigned char *head;
4279 const char *procname;
4281 find_symbol_for_address (aux, tp->start, &procname, &offset);
4283 fputs ("\n<", stdout);
4287 fputs (procname, stdout);
4290 printf ("+%lx", (unsigned long) offset);
4293 fputs (">: [", stdout);
4294 print_vma (tp->start.offset, PREFIX_HEX);
4295 fputc ('-', stdout);
4296 print_vma (tp->end.offset, PREFIX_HEX);
4297 printf ("], info at +0x%lx\n",
4298 (unsigned long) (tp->info.offset - aux->seg_base));
4300 head = aux->info + (tp->info.offset - aux->info_addr);
4301 stamp = BYTE_GET8 ((unsigned char *) head);
4303 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4304 (unsigned) UNW_VER (stamp),
4305 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
4306 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
4307 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
4308 (unsigned long) (addr_size * UNW_LENGTH (stamp)));
4310 if (UNW_VER (stamp) != 1)
4312 printf ("\tUnknown version.\n");
4317 for (dp = head + 8; dp < head + 8 + addr_size * UNW_LENGTH (stamp);)
4318 dp = unw_decode (dp, in_body, & in_body);
4323 slurp_ia64_unwind_table (FILE *file,
4324 struct unw_aux_info *aux,
4325 Elf_Internal_Shdr *sec)
4327 unsigned long size, addr_size, nrelas, i;
4328 Elf_Internal_Phdr *seg;
4329 struct unw_table_entry *tep;
4330 Elf_Internal_Shdr *relsec;
4331 Elf_Internal_Rela *rela, *rp;
4332 unsigned char *table, *tp;
4333 Elf_Internal_Sym *sym;
4334 const char *relname;
4336 addr_size = is_32bit_elf ? 4 : 8;
4338 /* First, find the starting address of the segment that includes
4341 if (elf_header.e_phnum)
4343 if (! get_program_headers (file))
4346 for (seg = program_headers;
4347 seg < program_headers + elf_header.e_phnum;
4350 if (seg->p_type != PT_LOAD)
4353 if (sec->sh_addr >= seg->p_vaddr
4354 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
4356 aux->seg_base = seg->p_vaddr;
4362 /* Second, build the unwind table from the contents of the unwind section: */
4363 size = sec->sh_size;
4364 table = get_data (NULL, file, sec->sh_offset, size, _("unwind table"));
4368 tep = aux->table = xmalloc (size / (3 * addr_size) * sizeof (aux->table[0]));
4369 for (tp = table; tp < table + size; tp += 3 * addr_size, ++tep)
4371 tep->start.section = SHN_UNDEF;
4372 tep->end.section = SHN_UNDEF;
4373 tep->info.section = SHN_UNDEF;
4376 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
4377 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
4378 tep->info.offset = byte_get ((unsigned char *) tp + 8, 4);
4382 tep->start.offset = BYTE_GET8 ((unsigned char *) tp + 0);
4383 tep->end.offset = BYTE_GET8 ((unsigned char *) tp + 8);
4384 tep->info.offset = BYTE_GET8 ((unsigned char *) tp + 16);
4386 tep->start.offset += aux->seg_base;
4387 tep->end.offset += aux->seg_base;
4388 tep->info.offset += aux->seg_base;
4392 /* Third, apply any relocations to the unwind table: */
4394 for (relsec = section_headers;
4395 relsec < section_headers + elf_header.e_shnum;
4398 if (relsec->sh_type != SHT_RELA
4399 || SECTION_HEADER (relsec->sh_info) != sec)
4402 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
4406 for (rp = rela; rp < rela + nrelas; ++rp)
4410 relname = elf_ia64_reloc_type (ELF32_R_TYPE (rp->r_info));
4411 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
4413 if (ELF32_ST_TYPE (sym->st_info) != STT_SECTION)
4415 warn (_("Skipping unexpected symbol type %u\n"),
4416 ELF32_ST_TYPE (sym->st_info));
4422 relname = elf_ia64_reloc_type (ELF64_R_TYPE (rp->r_info));
4423 sym = aux->symtab + ELF64_R_SYM (rp->r_info);
4425 if (ELF64_ST_TYPE (sym->st_info) != STT_SECTION)
4427 warn (_("Skipping unexpected symbol type %u\n"),
4428 ELF64_ST_TYPE (sym->st_info));
4433 if (strncmp (relname, "R_IA64_SEGREL", 13) != 0)
4435 warn (_("Skipping unexpected relocation type %s\n"), relname);
4439 i = rp->r_offset / (3 * addr_size);
4441 switch (rp->r_offset/addr_size % 3)
4444 aux->table[i].start.section = sym->st_shndx;
4445 aux->table[i].start.offset += rp->r_addend;
4448 aux->table[i].end.section = sym->st_shndx;
4449 aux->table[i].end.offset += rp->r_addend;
4452 aux->table[i].info.section = sym->st_shndx;
4453 aux->table[i].info.offset += rp->r_addend;
4463 aux->table_len = size / (3 * addr_size);
4468 process_unwind (FILE *file)
4470 Elf_Internal_Shdr *sec, *unwsec = NULL, *strsec;
4471 unsigned long i, addr_size, unwcount = 0, unwstart = 0;
4472 struct unw_aux_info aux;
4477 if (elf_header.e_machine != EM_IA_64)
4479 printf (_("\nThere are no unwind sections in this file.\n"));
4483 memset (& aux, 0, sizeof (aux));
4485 addr_size = is_32bit_elf ? 4 : 8;
4487 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
4489 if (sec->sh_type == SHT_SYMTAB)
4491 aux.nsyms = sec->sh_size / sec->sh_entsize;
4492 aux.symtab = GET_ELF_SYMBOLS (file, sec);
4494 strsec = SECTION_HEADER (sec->sh_link);
4495 aux.strtab_size = strsec->sh_size;
4496 aux.strtab = get_data (NULL, file, strsec->sh_offset,
4497 aux.strtab_size, _("string table"));
4499 else if (sec->sh_type == SHT_IA_64_UNWIND)
4504 printf (_("\nThere are no unwind sections in this file.\n"));
4506 while (unwcount-- > 0)
4511 for (i = unwstart, sec = section_headers + unwstart;
4512 i < elf_header.e_shnum; ++i, ++sec)
4513 if (sec->sh_type == SHT_IA_64_UNWIND)
4520 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
4522 if ((unwsec->sh_flags & SHF_GROUP) != 0)
4524 /* We need to find which section group it is in. */
4525 struct group_list *g = section_headers_groups [i]->root;
4527 for (; g != NULL; g = g->next)
4529 sec = SECTION_HEADER (g->section_index);
4530 if (strcmp (SECTION_NAME (sec),
4531 ELF_STRING_ia64_unwind_info) == 0)
4536 i = elf_header.e_shnum;
4538 else if (strncmp (SECTION_NAME (unwsec),
4539 ELF_STRING_ia64_unwind_once, len) == 0)
4541 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO */
4542 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
4543 suffix = SECTION_NAME (unwsec) + len;
4544 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
4546 if (strncmp (SECTION_NAME (sec),
4547 ELF_STRING_ia64_unwind_info_once, len2) == 0
4548 && strcmp (SECTION_NAME (sec) + len2, suffix) == 0)
4553 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
4554 .IA_64.unwind or BAR -> .IA_64.unwind_info */
4555 len = sizeof (ELF_STRING_ia64_unwind) - 1;
4556 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
4558 if (strncmp (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind,
4560 suffix = SECTION_NAME (unwsec) + len;
4561 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
4563 if (strncmp (SECTION_NAME (sec),
4564 ELF_STRING_ia64_unwind_info, len2) == 0
4565 && strcmp (SECTION_NAME (sec) + len2, suffix) == 0)
4569 if (i == elf_header.e_shnum)
4571 printf (_("\nCould not find unwind info section for "));
4573 if (string_table == NULL)
4574 printf ("%d", unwsec->sh_name);
4576 printf (_("'%s'"), SECTION_NAME (unwsec));
4580 aux.info_size = sec->sh_size;
4581 aux.info_addr = sec->sh_addr;
4582 aux.info = get_data (NULL, file, sec->sh_offset, aux.info_size,
4585 printf (_("\nUnwind section "));
4587 if (string_table == NULL)
4588 printf ("%d", unwsec->sh_name);
4590 printf (_("'%s'"), SECTION_NAME (unwsec));
4592 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4593 (unsigned long) unwsec->sh_offset,
4594 (unsigned long) (unwsec->sh_size / (3 * addr_size)));
4596 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
4598 if (aux.table_len > 0)
4599 dump_ia64_unwind (& aux);
4602 free ((char *) aux.table);
4604 free ((char *) aux.info);
4613 free ((char *) aux.strtab);
4619 dynamic_section_mips_val (Elf_Internal_Dyn *entry)
4621 switch (entry->d_tag)
4624 if (entry->d_un.d_val == 0)
4628 static const char * opts[] =
4630 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
4631 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
4632 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
4633 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
4638 for (cnt = 0; cnt < NUM_ELEM (opts); ++cnt)
4639 if (entry->d_un.d_val & (1 << cnt))
4641 printf ("%s%s", first ? "" : " ", opts[cnt]);
4648 case DT_MIPS_IVERSION:
4649 if (dynamic_strings != NULL)
4650 printf ("Interface Version: %s\n",
4651 dynamic_strings + entry->d_un.d_val);
4653 printf ("%ld\n", (long) entry->d_un.d_ptr);
4656 case DT_MIPS_TIME_STAMP:
4661 time_t time = entry->d_un.d_val;
4662 tmp = gmtime (&time);
4663 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
4664 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
4665 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4666 printf ("Time Stamp: %s\n", timebuf);
4670 case DT_MIPS_RLD_VERSION:
4671 case DT_MIPS_LOCAL_GOTNO:
4672 case DT_MIPS_CONFLICTNO:
4673 case DT_MIPS_LIBLISTNO:
4674 case DT_MIPS_SYMTABNO:
4675 case DT_MIPS_UNREFEXTNO:
4676 case DT_MIPS_HIPAGENO:
4677 case DT_MIPS_DELTA_CLASS_NO:
4678 case DT_MIPS_DELTA_INSTANCE_NO:
4679 case DT_MIPS_DELTA_RELOC_NO:
4680 case DT_MIPS_DELTA_SYM_NO:
4681 case DT_MIPS_DELTA_CLASSSYM_NO:
4682 case DT_MIPS_COMPACT_SIZE:
4683 printf ("%ld\n", (long) entry->d_un.d_ptr);
4687 printf ("%#lx\n", (long) entry->d_un.d_ptr);
4693 dynamic_section_parisc_val (Elf_Internal_Dyn *entry)
4695 switch (entry->d_tag)
4697 case DT_HP_DLD_FLAGS:
4706 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
4707 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
4708 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
4709 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
4710 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
4711 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
4712 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
4713 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
4714 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
4715 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
4716 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" }
4720 bfd_vma val = entry->d_un.d_val;
4722 for (cnt = 0; cnt < sizeof (flags) / sizeof (flags[0]); ++cnt)
4723 if (val & flags[cnt].bit)
4727 fputs (flags[cnt].str, stdout);
4729 val ^= flags[cnt].bit;
4732 if (val != 0 || first)
4736 print_vma (val, HEX);
4742 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
4749 dynamic_section_ia64_val (Elf_Internal_Dyn *entry)
4751 switch (entry->d_tag)
4753 case DT_IA_64_PLT_RESERVE:
4754 /* First 3 slots reserved. */
4755 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
4757 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
4761 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
4768 get_32bit_dynamic_section (FILE *file)
4770 Elf32_External_Dyn *edyn, *ext;
4771 Elf_Internal_Dyn *entry;
4773 edyn = get_data (NULL, file, dynamic_addr, dynamic_size,
4774 _("dynamic section"));
4778 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
4779 might not have the luxury of section headers. Look for the DT_NULL
4780 terminator to determine the number of entries. */
4781 for (ext = edyn, dynamic_nent = 0;
4782 (char *) ext < (char *) edyn + dynamic_size;
4786 if (BYTE_GET (ext->d_tag) == DT_NULL)
4790 dynamic_section = malloc (dynamic_nent * sizeof (*entry));
4791 if (dynamic_section == NULL)
4793 error (_("Out of memory\n"));
4798 for (ext = edyn, entry = dynamic_section;
4799 entry < dynamic_section + dynamic_nent;
4802 entry->d_tag = BYTE_GET (ext->d_tag);
4803 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
4812 get_64bit_dynamic_section (FILE *file)
4814 Elf64_External_Dyn *edyn, *ext;
4815 Elf_Internal_Dyn *entry;
4817 edyn = get_data (NULL, file, dynamic_addr, dynamic_size,
4818 _("dynamic section"));
4822 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
4823 might not have the luxury of section headers. Look for the DT_NULL
4824 terminator to determine the number of entries. */
4825 for (ext = edyn, dynamic_nent = 0;
4826 (char *) ext < (char *) edyn + dynamic_size;
4830 if (BYTE_GET8 (ext->d_tag) == DT_NULL)
4834 dynamic_section = malloc (dynamic_nent * sizeof (*entry));
4835 if (dynamic_section == NULL)
4837 error (_("Out of memory\n"));
4842 for (ext = edyn, entry = dynamic_section;
4843 entry < dynamic_section + dynamic_nent;
4846 entry->d_tag = BYTE_GET8 (ext->d_tag);
4847 entry->d_un.d_val = BYTE_GET8 (ext->d_un.d_val);
4856 get_dynamic_flags (bfd_vma flags)
4858 static char buff[128];
4866 flag = flags & - flags;
4874 case DF_ORIGIN: strcpy (p, "ORIGIN"); break;
4875 case DF_SYMBOLIC: strcpy (p, "SYMBOLIC"); break;
4876 case DF_TEXTREL: strcpy (p, "TEXTREL"); break;
4877 case DF_BIND_NOW: strcpy (p, "BIND_NOW"); break;
4878 case DF_STATIC_TLS: strcpy (p, "STATIC_TLS"); break;
4879 default: strcpy (p, "unknown"); break;
4882 p = strchr (p, '\0');
4887 /* Parse and display the contents of the dynamic section. */
4890 process_dynamic_section (FILE *file)
4892 Elf_Internal_Dyn *entry;
4894 if (dynamic_size == 0)
4897 printf (_("\nThere is no dynamic section in this file.\n"));
4904 if (! get_32bit_dynamic_section (file))
4907 else if (! get_64bit_dynamic_section (file))
4910 /* Find the appropriate symbol table. */
4911 if (dynamic_symbols == NULL)
4913 for (entry = dynamic_section;
4914 entry < dynamic_section + dynamic_nent;
4917 Elf_Internal_Shdr section;
4919 if (entry->d_tag != DT_SYMTAB)
4922 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
4924 /* Since we do not know how big the symbol table is,
4925 we default to reading in the entire file (!) and
4926 processing that. This is overkill, I know, but it
4928 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
4930 if (archive_file_offset != 0)
4931 section.sh_size = archive_file_size - section.sh_offset;
4934 if (fseek (file, 0, SEEK_END))
4935 error (_("Unable to seek to end of file!"));
4937 section.sh_size = ftell (file) - section.sh_offset;
4941 section.sh_entsize = sizeof (Elf32_External_Sym);
4943 section.sh_entsize = sizeof (Elf64_External_Sym);
4945 num_dynamic_syms = section.sh_size / section.sh_entsize;
4946 if (num_dynamic_syms < 1)
4948 error (_("Unable to determine the number of symbols to load\n"));
4952 dynamic_symbols = GET_ELF_SYMBOLS (file, §ion);
4956 /* Similarly find a string table. */
4957 if (dynamic_strings == NULL)
4959 for (entry = dynamic_section;
4960 entry < dynamic_section + dynamic_nent;
4963 unsigned long offset;
4966 if (entry->d_tag != DT_STRTAB)
4969 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
4971 /* Since we do not know how big the string table is,
4972 we default to reading in the entire file (!) and
4973 processing that. This is overkill, I know, but it
4976 offset = offset_from_vma (file, entry->d_un.d_val, 0);
4978 if (archive_file_offset != 0)
4979 str_tab_len = archive_file_size - offset;
4982 if (fseek (file, 0, SEEK_END))
4983 error (_("Unable to seek to end of file\n"));
4984 str_tab_len = ftell (file) - offset;
4987 if (str_tab_len < 1)
4990 (_("Unable to determine the length of the dynamic string table\n"));
4994 dynamic_strings = get_data (NULL, file, offset, str_tab_len,
4995 _("dynamic string table"));
5000 /* And find the syminfo section if available. */
5001 if (dynamic_syminfo == NULL)
5003 unsigned long syminsz = 0;
5005 for (entry = dynamic_section;
5006 entry < dynamic_section + dynamic_nent;
5009 if (entry->d_tag == DT_SYMINENT)
5011 /* Note: these braces are necessary to avoid a syntax
5012 error from the SunOS4 C compiler. */
5013 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
5015 else if (entry->d_tag == DT_SYMINSZ)
5016 syminsz = entry->d_un.d_val;
5017 else if (entry->d_tag == DT_SYMINFO)
5018 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
5022 if (dynamic_syminfo_offset != 0 && syminsz != 0)
5024 Elf_External_Syminfo *extsyminfo, *extsym;
5025 Elf_Internal_Syminfo *syminfo;
5027 /* There is a syminfo section. Read the data. */
5028 extsyminfo = get_data (NULL, file, dynamic_syminfo_offset, syminsz,
5029 _("symbol information"));
5033 dynamic_syminfo = malloc (syminsz);
5034 if (dynamic_syminfo == NULL)
5036 error (_("Out of memory\n"));
5040 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
5041 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
5042 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
5043 ++syminfo, ++extsym)
5045 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
5046 syminfo->si_flags = BYTE_GET (extsym->si_flags);
5053 if (do_dynamic && dynamic_addr)
5054 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
5055 dynamic_addr, dynamic_nent);
5057 printf (_(" Tag Type Name/Value\n"));
5059 for (entry = dynamic_section;
5060 entry < dynamic_section + dynamic_nent;
5068 print_vma (entry->d_tag, FULL_HEX);
5069 dtype = get_dynamic_type (entry->d_tag);
5070 printf (" (%s)%*s", dtype,
5071 ((is_32bit_elf ? 27 : 19)
5072 - (int) strlen (dtype)),
5076 switch (entry->d_tag)
5080 puts (get_dynamic_flags (entry->d_un.d_val));
5090 switch (entry->d_tag)
5093 printf (_("Auxiliary library"));
5097 printf (_("Filter library"));
5101 printf (_("Configuration file"));
5105 printf (_("Dependency audit library"));
5109 printf (_("Audit library"));
5113 if (dynamic_strings)
5114 printf (": [%s]\n", dynamic_strings + entry->d_un.d_val);
5118 print_vma (entry->d_un.d_val, PREFIX_HEX);
5127 printf (_("Flags:"));
5129 if (entry->d_un.d_val == 0)
5130 printf (_(" None\n"));
5133 unsigned long int val = entry->d_un.d_val;
5135 if (val & DTF_1_PARINIT)
5137 printf (" PARINIT");
5138 val ^= DTF_1_PARINIT;
5140 if (val & DTF_1_CONFEXP)
5142 printf (" CONFEXP");
5143 val ^= DTF_1_CONFEXP;
5146 printf (" %lx", val);
5155 printf (_("Flags:"));
5157 if (entry->d_un.d_val == 0)
5158 printf (_(" None\n"));
5161 unsigned long int val = entry->d_un.d_val;
5163 if (val & DF_P1_LAZYLOAD)
5165 printf (" LAZYLOAD");
5166 val ^= DF_P1_LAZYLOAD;
5168 if (val & DF_P1_GROUPPERM)
5170 printf (" GROUPPERM");
5171 val ^= DF_P1_GROUPPERM;
5174 printf (" %lx", val);
5183 printf (_("Flags:"));
5184 if (entry->d_un.d_val == 0)
5185 printf (_(" None\n"));
5188 unsigned long int val = entry->d_un.d_val;
5195 if (val & DF_1_GLOBAL)
5200 if (val & DF_1_GROUP)
5205 if (val & DF_1_NODELETE)
5207 printf (" NODELETE");
5208 val ^= DF_1_NODELETE;
5210 if (val & DF_1_LOADFLTR)
5212 printf (" LOADFLTR");
5213 val ^= DF_1_LOADFLTR;
5215 if (val & DF_1_INITFIRST)
5217 printf (" INITFIRST");
5218 val ^= DF_1_INITFIRST;
5220 if (val & DF_1_NOOPEN)
5225 if (val & DF_1_ORIGIN)
5230 if (val & DF_1_DIRECT)
5235 if (val & DF_1_TRANS)
5240 if (val & DF_1_INTERPOSE)
5242 printf (" INTERPOSE");
5243 val ^= DF_1_INTERPOSE;
5245 if (val & DF_1_NODEFLIB)
5247 printf (" NODEFLIB");
5248 val ^= DF_1_NODEFLIB;
5250 if (val & DF_1_NODUMP)
5255 if (val & DF_1_CONLFAT)
5257 printf (" CONLFAT");
5258 val ^= DF_1_CONLFAT;
5261 printf (" %lx", val);
5268 dynamic_info[entry->d_tag] = entry->d_un.d_val;
5270 puts (get_dynamic_type (entry->d_un.d_val));
5290 dynamic_info[entry->d_tag] = entry->d_un.d_val;
5296 if (dynamic_strings == NULL)
5299 name = dynamic_strings + entry->d_un.d_val;
5303 switch (entry->d_tag)
5306 printf (_("Shared library: [%s]"), name);
5308 if (strcmp (name, program_interpreter) == 0)
5309 printf (_(" program interpreter"));
5313 printf (_("Library soname: [%s]"), name);
5317 printf (_("Library rpath: [%s]"), name);
5321 printf (_("Library runpath: [%s]"), name);
5325 print_vma (entry->d_un.d_val, PREFIX_HEX);
5330 print_vma (entry->d_un.d_val, PREFIX_HEX);
5343 dynamic_info[entry->d_tag] = entry->d_un.d_val;
5347 case DT_INIT_ARRAYSZ:
5348 case DT_FINI_ARRAYSZ:
5349 case DT_GNU_CONFLICTSZ:
5350 case DT_GNU_LIBLISTSZ:
5353 print_vma (entry->d_un.d_val, UNSIGNED);
5354 printf (" (bytes)\n");
5364 print_vma (entry->d_un.d_val, UNSIGNED);
5377 if (dynamic_strings != NULL && entry->d_tag == DT_USED)
5381 name = dynamic_strings + entry->d_un.d_val;
5385 printf (_("Not needed object: [%s]\n"), name);
5390 print_vma (entry->d_un.d_val, PREFIX_HEX);
5396 /* The value of this entry is ignored. */
5401 case DT_GNU_PRELINKED:
5405 time_t time = entry->d_un.d_val;
5407 tmp = gmtime (&time);
5408 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
5409 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
5410 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
5416 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
5417 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
5422 switch (elf_header.e_machine)
5425 case EM_MIPS_RS3_LE:
5426 dynamic_section_mips_val (entry);
5429 dynamic_section_parisc_val (entry);
5432 dynamic_section_ia64_val (entry);
5435 print_vma (entry->d_un.d_val, PREFIX_HEX);
5447 get_ver_flags (unsigned int flags)
5449 static char buff[32];
5456 if (flags & VER_FLG_BASE)
5457 strcat (buff, "BASE ");
5459 if (flags & VER_FLG_WEAK)
5461 if (flags & VER_FLG_BASE)
5462 strcat (buff, "| ");
5464 strcat (buff, "WEAK ");
5467 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK))
5468 strcat (buff, "| <unknown>");
5473 /* Display the contents of the version sections. */
5475 process_version_sections (FILE *file)
5477 Elf_Internal_Shdr *section;
5484 for (i = 0, section = section_headers;
5485 i < elf_header.e_shnum;
5488 switch (section->sh_type)
5490 case SHT_GNU_verdef:
5492 Elf_External_Verdef *edefs;
5499 (_("\nVersion definition section '%s' contains %ld entries:\n"),
5500 SECTION_NAME (section), section->sh_info);
5502 printf (_(" Addr: 0x"));
5503 printf_vma (section->sh_addr);
5504 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5505 (unsigned long) section->sh_offset, section->sh_link,
5506 SECTION_NAME (SECTION_HEADER (section->sh_link)));
5508 edefs = get_data (NULL, file, section->sh_offset, section->sh_size,
5509 _("version definition section"));
5513 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
5516 Elf_External_Verdef *edef;
5517 Elf_Internal_Verdef ent;
5518 Elf_External_Verdaux *eaux;
5519 Elf_Internal_Verdaux aux;
5523 vstart = ((char *) edefs) + idx;
5525 edef = (Elf_External_Verdef *) vstart;
5527 ent.vd_version = BYTE_GET (edef->vd_version);
5528 ent.vd_flags = BYTE_GET (edef->vd_flags);
5529 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
5530 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
5531 ent.vd_hash = BYTE_GET (edef->vd_hash);
5532 ent.vd_aux = BYTE_GET (edef->vd_aux);
5533 ent.vd_next = BYTE_GET (edef->vd_next);
5535 printf (_(" %#06x: Rev: %d Flags: %s"),
5536 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
5538 printf (_(" Index: %d Cnt: %d "),
5539 ent.vd_ndx, ent.vd_cnt);
5541 vstart += ent.vd_aux;
5543 eaux = (Elf_External_Verdaux *) vstart;
5545 aux.vda_name = BYTE_GET (eaux->vda_name);
5546 aux.vda_next = BYTE_GET (eaux->vda_next);
5548 if (dynamic_strings)
5549 printf (_("Name: %s\n"), dynamic_strings + aux.vda_name);
5551 printf (_("Name index: %ld\n"), aux.vda_name);
5553 isum = idx + ent.vd_aux;
5555 for (j = 1; j < ent.vd_cnt; j++)
5557 isum += aux.vda_next;
5558 vstart += aux.vda_next;
5560 eaux = (Elf_External_Verdaux *) vstart;
5562 aux.vda_name = BYTE_GET (eaux->vda_name);
5563 aux.vda_next = BYTE_GET (eaux->vda_next);
5565 if (dynamic_strings)
5566 printf (_(" %#06x: Parent %d: %s\n"),
5567 isum, j, dynamic_strings + aux.vda_name);
5569 printf (_(" %#06x: Parent %d, name index: %ld\n"),
5570 isum, j, aux.vda_name);
5580 case SHT_GNU_verneed:
5582 Elf_External_Verneed *eneed;
5588 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
5589 SECTION_NAME (section), section->sh_info);
5591 printf (_(" Addr: 0x"));
5592 printf_vma (section->sh_addr);
5593 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
5594 (unsigned long) section->sh_offset, section->sh_link,
5595 SECTION_NAME (SECTION_HEADER (section->sh_link)));
5597 eneed = get_data (NULL, file, section->sh_offset, section->sh_size,
5598 _("version need section"));
5602 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
5604 Elf_External_Verneed *entry;
5605 Elf_Internal_Verneed ent;
5610 vstart = ((char *) eneed) + idx;
5612 entry = (Elf_External_Verneed *) vstart;
5614 ent.vn_version = BYTE_GET (entry->vn_version);
5615 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
5616 ent.vn_file = BYTE_GET (entry->vn_file);
5617 ent.vn_aux = BYTE_GET (entry->vn_aux);
5618 ent.vn_next = BYTE_GET (entry->vn_next);
5620 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
5622 if (dynamic_strings)
5623 printf (_(" File: %s"), dynamic_strings + ent.vn_file);
5625 printf (_(" File: %lx"), ent.vn_file);
5627 printf (_(" Cnt: %d\n"), ent.vn_cnt);
5629 vstart += ent.vn_aux;
5631 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
5633 Elf_External_Vernaux *eaux;
5634 Elf_Internal_Vernaux aux;
5636 eaux = (Elf_External_Vernaux *) vstart;
5638 aux.vna_hash = BYTE_GET (eaux->vna_hash);
5639 aux.vna_flags = BYTE_GET (eaux->vna_flags);
5640 aux.vna_other = BYTE_GET (eaux->vna_other);
5641 aux.vna_name = BYTE_GET (eaux->vna_name);
5642 aux.vna_next = BYTE_GET (eaux->vna_next);
5644 if (dynamic_strings)
5645 printf (_(" %#06x: Name: %s"),
5646 isum, dynamic_strings + aux.vna_name);
5648 printf (_(" %#06x: Name index: %lx"),
5649 isum, aux.vna_name);
5651 printf (_(" Flags: %s Version: %d\n"),
5652 get_ver_flags (aux.vna_flags), aux.vna_other);
5654 isum += aux.vna_next;
5655 vstart += aux.vna_next;
5665 case SHT_GNU_versym:
5667 Elf_Internal_Shdr *link_section;
5670 unsigned char *edata;
5671 unsigned short *data;
5673 Elf_Internal_Sym *symbols;
5674 Elf_Internal_Shdr *string_sec;
5677 link_section = SECTION_HEADER (section->sh_link);
5678 total = section->sh_size / section->sh_entsize;
5682 symbols = GET_ELF_SYMBOLS (file, link_section);
5684 string_sec = SECTION_HEADER (link_section->sh_link);
5686 strtab = get_data (NULL, file, string_sec->sh_offset,
5687 string_sec->sh_size, _("version string table"));
5691 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
5692 SECTION_NAME (section), total);
5694 printf (_(" Addr: "));
5695 printf_vma (section->sh_addr);
5696 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5697 (unsigned long) section->sh_offset, section->sh_link,
5698 SECTION_NAME (link_section));
5700 off = offset_from_vma (file,
5701 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
5702 total * sizeof (short));
5703 edata = get_data (NULL, file, off, total * sizeof (short),
5704 _("version symbol data"));
5711 data = malloc (total * sizeof (short));
5713 for (cnt = total; cnt --;)
5714 data[cnt] = byte_get (edata + cnt * sizeof (short),
5719 for (cnt = 0; cnt < total; cnt += 4)
5722 int check_def, check_need;
5725 printf (" %03x:", cnt);
5727 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
5728 switch (data[cnt + j])
5731 fputs (_(" 0 (*local*) "), stdout);
5735 fputs (_(" 1 (*global*) "), stdout);
5739 nn = printf ("%4x%c", data[cnt + j] & 0x7fff,
5740 data[cnt + j] & 0x8000 ? 'h' : ' ');
5744 if (SECTION_HEADER (symbols[cnt + j].st_shndx)->sh_type
5747 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
5754 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
5756 Elf_Internal_Verneed ivn;
5757 unsigned long offset;
5759 offset = offset_from_vma
5760 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
5761 sizeof (Elf_External_Verneed));
5765 Elf_Internal_Vernaux ivna;
5766 Elf_External_Verneed evn;
5767 Elf_External_Vernaux evna;
5768 unsigned long a_off;
5770 get_data (&evn, file, offset, sizeof (evn),
5773 ivn.vn_aux = BYTE_GET (evn.vn_aux);
5774 ivn.vn_next = BYTE_GET (evn.vn_next);
5776 a_off = offset + ivn.vn_aux;
5780 get_data (&evna, file, a_off, sizeof (evna),
5781 _("version need aux (2)"));
5783 ivna.vna_next = BYTE_GET (evna.vna_next);
5784 ivna.vna_other = BYTE_GET (evna.vna_other);
5786 a_off += ivna.vna_next;
5788 while (ivna.vna_other != data[cnt + j]
5789 && ivna.vna_next != 0);
5791 if (ivna.vna_other == data[cnt + j])
5793 ivna.vna_name = BYTE_GET (evna.vna_name);
5795 name = strtab + ivna.vna_name;
5796 nn += printf ("(%s%-*s",
5798 12 - (int) strlen (name),
5804 offset += ivn.vn_next;
5806 while (ivn.vn_next);
5809 if (check_def && data[cnt + j] != 0x8001
5810 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
5812 Elf_Internal_Verdef ivd;
5813 Elf_External_Verdef evd;
5814 unsigned long offset;
5816 offset = offset_from_vma
5817 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
5822 get_data (&evd, file, offset, sizeof (evd),
5825 ivd.vd_next = BYTE_GET (evd.vd_next);
5826 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
5828 offset += ivd.vd_next;
5830 while (ivd.vd_ndx != (data[cnt + j] & 0x7fff)
5831 && ivd.vd_next != 0);
5833 if (ivd.vd_ndx == (data[cnt + j] & 0x7fff))
5835 Elf_External_Verdaux evda;
5836 Elf_Internal_Verdaux ivda;
5838 ivd.vd_aux = BYTE_GET (evd.vd_aux);
5840 get_data (&evda, file,
5841 offset - ivd.vd_next + ivd.vd_aux,
5842 sizeof (evda), _("version def aux"));
5844 ivda.vda_name = BYTE_GET (evda.vda_name);
5846 name = strtab + ivda.vda_name;
5847 nn += printf ("(%s%-*s",
5849 12 - (int) strlen (name),
5855 printf ("%*c", 18 - nn, ' ');
5873 printf (_("\nNo version information found in this file.\n"));
5879 get_symbol_binding (unsigned int binding)
5881 static char buff[32];
5885 case STB_LOCAL: return "LOCAL";
5886 case STB_GLOBAL: return "GLOBAL";
5887 case STB_WEAK: return "WEAK";
5889 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
5890 sprintf (buff, _("<processor specific>: %d"), binding);
5891 else if (binding >= STB_LOOS && binding <= STB_HIOS)
5892 sprintf (buff, _("<OS specific>: %d"), binding);
5894 sprintf (buff, _("<unknown>: %d"), binding);
5900 get_symbol_type (unsigned int type)
5902 static char buff[32];
5906 case STT_NOTYPE: return "NOTYPE";
5907 case STT_OBJECT: return "OBJECT";
5908 case STT_FUNC: return "FUNC";
5909 case STT_SECTION: return "SECTION";
5910 case STT_FILE: return "FILE";
5911 case STT_COMMON: return "COMMON";
5912 case STT_TLS: return "TLS";
5914 if (type >= STT_LOPROC && type <= STT_HIPROC)
5916 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
5917 return "THUMB_FUNC";
5919 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
5922 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
5923 return "PARISC_MILLI";
5925 sprintf (buff, _("<processor specific>: %d"), type);
5927 else if (type >= STT_LOOS && type <= STT_HIOS)
5929 if (elf_header.e_machine == EM_PARISC)
5931 if (type == STT_HP_OPAQUE)
5933 if (type == STT_HP_STUB)
5937 sprintf (buff, _("<OS specific>: %d"), type);
5940 sprintf (buff, _("<unknown>: %d"), type);
5946 get_symbol_visibility (unsigned int visibility)
5950 case STV_DEFAULT: return "DEFAULT";
5951 case STV_INTERNAL: return "INTERNAL";
5952 case STV_HIDDEN: return "HIDDEN";
5953 case STV_PROTECTED: return "PROTECTED";
5959 get_symbol_index_type (unsigned int type)
5961 static char buff[32];
5965 case SHN_UNDEF: return "UND";
5966 case SHN_ABS: return "ABS";
5967 case SHN_COMMON: return "COM";
5969 if (type == SHN_IA_64_ANSI_COMMON
5970 && elf_header.e_machine == EM_IA_64
5971 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
5973 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
5974 sprintf (buff, "PRC[0x%04x]", type);
5975 else if (type >= SHN_LOOS && type <= SHN_HIOS)
5976 sprintf (buff, "OS [0x%04x]", type);
5977 else if (type >= SHN_LORESERVE && type <= SHN_HIRESERVE)
5978 sprintf (buff, "RSV[0x%04x]", type);
5980 sprintf (buff, "%3d", type);
5988 get_dynamic_data (FILE *file, unsigned int number)
5990 unsigned char *e_data;
5993 e_data = malloc (number * 4);
5997 error (_("Out of memory\n"));
6001 if (fread (e_data, 4, number, file) != number)
6003 error (_("Unable to read in dynamic data\n"));
6007 i_data = malloc (number * sizeof (*i_data));
6011 error (_("Out of memory\n"));
6017 i_data[number] = byte_get (e_data + number * 4, 4);
6024 /* Dump the symbol table. */
6026 process_symbol_table (FILE *file)
6028 Elf_Internal_Shdr *section;
6029 unsigned char nb[4];
6030 unsigned char nc[4];
6033 int *buckets = NULL;
6036 if (! do_syms && !do_histogram)
6039 if (dynamic_info[DT_HASH] && ((do_using_dynamic && dynamic_strings != NULL)
6043 (archive_file_offset
6044 + offset_from_vma (file, dynamic_info[DT_HASH],
6045 sizeof nb + sizeof nc)),
6048 error (_("Unable to seek to start of dynamic information"));
6052 if (fread (nb, sizeof (nb), 1, file) != 1)
6054 error (_("Failed to read in number of buckets\n"));
6058 if (fread (nc, sizeof (nc), 1, file) != 1)
6060 error (_("Failed to read in number of chains\n"));
6064 nbuckets = byte_get (nb, 4);
6065 nchains = byte_get (nc, 4);
6067 buckets = get_dynamic_data (file, nbuckets);
6068 chains = get_dynamic_data (file, nchains);
6070 if (buckets == NULL || chains == NULL)
6075 && dynamic_info[DT_HASH] && do_using_dynamic && dynamic_strings != NULL)
6080 printf (_("\nSymbol table for image:\n"));
6082 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6084 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6086 for (hn = 0; hn < nbuckets; hn++)
6091 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
6093 Elf_Internal_Sym *psym;
6095 psym = dynamic_symbols + si;
6097 printf (" %3d %3d: ", si, hn);
6098 print_vma (psym->st_value, LONG_HEX);
6100 print_vma (psym->st_size, DEC_5);
6102 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
6103 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
6104 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6105 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
6106 print_symbol (25, dynamic_strings + psym->st_name);
6111 else if (do_syms && !do_using_dynamic)
6115 for (i = 0, section = section_headers;
6116 i < elf_header.e_shnum;
6121 Elf_Internal_Sym *symtab;
6122 Elf_Internal_Sym *psym;
6125 if ( section->sh_type != SHT_SYMTAB
6126 && section->sh_type != SHT_DYNSYM)
6129 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
6130 SECTION_NAME (section),
6131 (unsigned long) (section->sh_size / section->sh_entsize));
6133 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6135 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6137 symtab = GET_ELF_SYMBOLS (file, section);
6141 if (section->sh_link == elf_header.e_shstrndx)
6142 strtab = string_table;
6145 Elf_Internal_Shdr *string_sec;
6147 string_sec = SECTION_HEADER (section->sh_link);
6149 strtab = get_data (NULL, file, string_sec->sh_offset,
6150 string_sec->sh_size, _("string table"));
6153 for (si = 0, psym = symtab;
6154 si < section->sh_size / section->sh_entsize;
6157 printf ("%6d: ", si);
6158 print_vma (psym->st_value, LONG_HEX);
6160 print_vma (psym->st_size, DEC_5);
6161 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
6162 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
6163 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6164 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
6165 print_symbol (25, strtab + psym->st_name);
6167 if (section->sh_type == SHT_DYNSYM &&
6168 version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
6170 unsigned char data[2];
6171 unsigned short vers_data;
6172 unsigned long offset;
6176 offset = offset_from_vma
6177 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
6178 sizeof data + si * sizeof (vers_data));
6180 get_data (&data, file, offset + si * sizeof (vers_data),
6181 sizeof (data), _("version data"));
6183 vers_data = byte_get (data, 2);
6185 is_nobits = (SECTION_HEADER (psym->st_shndx)->sh_type
6188 check_def = (psym->st_shndx != SHN_UNDEF);
6190 if ((vers_data & 0x8000) || vers_data > 1)
6192 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
6193 && (is_nobits || ! check_def))
6195 Elf_External_Verneed evn;
6196 Elf_Internal_Verneed ivn;
6197 Elf_Internal_Vernaux ivna;
6199 /* We must test both. */
6200 offset = offset_from_vma
6201 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
6206 unsigned long vna_off;
6208 get_data (&evn, file, offset, sizeof (evn),
6211 ivn.vn_aux = BYTE_GET (evn.vn_aux);
6212 ivn.vn_next = BYTE_GET (evn.vn_next);
6214 vna_off = offset + ivn.vn_aux;
6218 Elf_External_Vernaux evna;
6220 get_data (&evna, file, vna_off,
6222 _("version need aux (3)"));
6224 ivna.vna_other = BYTE_GET (evna.vna_other);
6225 ivna.vna_next = BYTE_GET (evna.vna_next);
6226 ivna.vna_name = BYTE_GET (evna.vna_name);
6228 vna_off += ivna.vna_next;
6230 while (ivna.vna_other != vers_data
6231 && ivna.vna_next != 0);
6233 if (ivna.vna_other == vers_data)
6236 offset += ivn.vn_next;
6238 while (ivn.vn_next != 0);
6240 if (ivna.vna_other == vers_data)
6243 strtab + ivna.vna_name, ivna.vna_other);
6246 else if (! is_nobits)
6247 error (_("bad dynamic symbol"));
6254 if (vers_data != 0x8001
6255 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
6257 Elf_Internal_Verdef ivd;
6258 Elf_Internal_Verdaux ivda;
6259 Elf_External_Verdaux evda;
6260 unsigned long offset;
6262 offset = offset_from_vma
6264 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
6265 sizeof (Elf_External_Verdef));
6269 Elf_External_Verdef evd;
6271 get_data (&evd, file, offset, sizeof (evd),
6274 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
6275 ivd.vd_aux = BYTE_GET (evd.vd_aux);
6276 ivd.vd_next = BYTE_GET (evd.vd_next);
6278 offset += ivd.vd_next;
6280 while (ivd.vd_ndx != (vers_data & 0x7fff)
6281 && ivd.vd_next != 0);
6283 offset -= ivd.vd_next;
6284 offset += ivd.vd_aux;
6286 get_data (&evda, file, offset, sizeof (evda),
6287 _("version def aux"));
6289 ivda.vda_name = BYTE_GET (evda.vda_name);
6291 if (psym->st_name != ivda.vda_name)
6292 printf ((vers_data & 0x8000)
6294 strtab + ivda.vda_name);
6304 if (strtab != string_table)
6310 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
6312 if (do_histogram && buckets != NULL)
6319 int nzero_counts = 0;
6322 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
6324 printf (_(" Length Number %% of total Coverage\n"));
6326 lengths = calloc (nbuckets, sizeof (int));
6327 if (lengths == NULL)
6329 error (_("Out of memory"));
6332 for (hn = 0; hn < nbuckets; ++hn)
6337 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
6340 if (maxlength < ++lengths[hn])
6345 counts = calloc (maxlength + 1, sizeof (int));
6348 error (_("Out of memory"));
6352 for (hn = 0; hn < nbuckets; ++hn)
6353 ++counts[lengths[hn]];
6357 printf (" 0 %-10d (%5.1f%%)\n",
6358 counts[0], (counts[0] * 100.0) / nbuckets);
6359 for (si = 1; si <= maxlength; ++si)
6361 nzero_counts += counts[si] * si;
6362 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
6363 si, counts[si], (counts[si] * 100.0) / nbuckets,
6364 (nzero_counts * 100.0) / nsyms);
6372 if (buckets != NULL)
6382 process_syminfo (FILE *file ATTRIBUTE_UNUSED)
6386 if (dynamic_syminfo == NULL
6388 /* No syminfo, this is ok. */
6391 /* There better should be a dynamic symbol section. */
6392 if (dynamic_symbols == NULL || dynamic_strings == NULL)
6396 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
6397 dynamic_syminfo_offset, dynamic_syminfo_nent);
6399 printf (_(" Num: Name BoundTo Flags\n"));
6400 for (i = 0; i < dynamic_syminfo_nent; ++i)
6402 unsigned short int flags = dynamic_syminfo[i].si_flags;
6404 printf ("%4d: ", i);
6405 print_symbol (30, dynamic_strings + dynamic_symbols[i].st_name);
6408 switch (dynamic_syminfo[i].si_boundto)
6410 case SYMINFO_BT_SELF:
6411 fputs ("SELF ", stdout);
6413 case SYMINFO_BT_PARENT:
6414 fputs ("PARENT ", stdout);
6417 if (dynamic_syminfo[i].si_boundto > 0
6418 && dynamic_syminfo[i].si_boundto < dynamic_nent)
6423 [dynamic_syminfo[i].si_boundto].d_un.d_val));
6427 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
6431 if (flags & SYMINFO_FLG_DIRECT)
6433 if (flags & SYMINFO_FLG_PASSTHRU)
6434 printf (" PASSTHRU");
6435 if (flags & SYMINFO_FLG_COPY)
6437 if (flags & SYMINFO_FLG_LAZYLOAD)
6438 printf (" LAZYLOAD");
6446 #ifdef SUPPORT_DISASSEMBLY
6448 disassemble_section (Elf_Internal_Shdr *section, FILE *file)
6450 printf (_("\nAssembly dump of section %s\n"),
6451 SECTION_NAME (section));
6453 /* XXX -- to be done --- XXX */
6460 dump_section (Elf_Internal_Shdr *section, FILE *file)
6462 bfd_size_type bytes;
6464 unsigned char *data;
6465 unsigned char *start;
6467 bytes = section->sh_size;
6469 if (bytes == 0 || section->sh_type == SHT_NOBITS)
6471 printf (_("\nSection '%s' has no data to dump.\n"),
6472 SECTION_NAME (section));
6476 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
6478 addr = section->sh_addr;
6480 start = get_data (NULL, file, section->sh_offset, bytes, _("section data"));
6492 lbytes = (bytes > 16 ? 16 : bytes);
6494 printf (" 0x%8.8lx ", (unsigned long) addr);
6496 switch (elf_header.e_ident[EI_DATA])
6500 for (j = 15; j >= 0; j --)
6503 printf ("%2.2x", data[j]);
6513 for (j = 0; j < 16; j++)
6516 printf ("%2.2x", data[j]);
6526 for (j = 0; j < lbytes; j++)
6529 if (k >= ' ' && k < 0x7f)
6548 static unsigned long int
6549 read_leb128 (unsigned char *data, int *length_return, int sign)
6551 unsigned long int result = 0;
6552 unsigned int num_read = 0;
6561 result |= (byte & 0x7f) << shift;
6566 while (byte & 0x80);
6568 if (length_return != NULL)
6569 *length_return = num_read;
6571 if (sign && (shift < 32) && (byte & 0x40))
6572 result |= -1 << shift;
6577 typedef struct State_Machine_Registers
6579 unsigned long address;
6582 unsigned int column;
6586 /* This variable hold the number of the last entry seen
6587 in the File Table. */
6588 unsigned int last_file_entry;
6591 static SMR state_machine_regs;
6594 reset_state_machine (int is_stmt)
6596 state_machine_regs.address = 0;
6597 state_machine_regs.file = 1;
6598 state_machine_regs.line = 1;
6599 state_machine_regs.column = 0;
6600 state_machine_regs.is_stmt = is_stmt;
6601 state_machine_regs.basic_block = 0;
6602 state_machine_regs.end_sequence = 0;
6603 state_machine_regs.last_file_entry = 0;
6606 /* Handled an extend line op. Returns true if this is the end
6609 process_extended_line_op (unsigned char *data, int is_stmt, int pointer_size)
6611 unsigned char op_code;
6614 unsigned char *name;
6617 len = read_leb128 (data, & bytes_read, 0);
6622 warn (_("badly formed extended line op encountered!\n"));
6629 printf (_(" Extended opcode %d: "), op_code);
6633 case DW_LNE_end_sequence:
6634 printf (_("End of Sequence\n\n"));
6635 reset_state_machine (is_stmt);
6638 case DW_LNE_set_address:
6639 adr = byte_get (data, pointer_size);
6640 printf (_("set Address to 0x%lx\n"), adr);
6641 state_machine_regs.address = adr;
6644 case DW_LNE_define_file:
6645 printf (_(" define new File Table entry\n"));
6646 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6648 printf (_(" %d\t"), ++state_machine_regs.last_file_entry);
6650 data += strlen ((char *) data) + 1;
6651 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6653 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6655 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6656 printf (_("%s\n\n"), name);
6660 printf (_("UNKNOWN: length %d\n"), len - bytes_read);
6667 /* Finds section NAME inside FILE and returns a
6668 pointer to it, or NULL upon failure. */
6670 static Elf_Internal_Shdr *
6671 find_section (const char * name)
6673 Elf_Internal_Shdr *sec;
6676 for (i = elf_header.e_shnum, sec = section_headers + i - 1;
6678 if (strcmp (SECTION_NAME (sec), name) == 0)
6681 if (i && sec && sec->sh_size != 0)
6687 /* Size of pointers in the .debug_line section. This information is not
6688 really present in that section. It's obtained before dumping the debug
6689 sections by doing some pre-scan of the .debug_info section. */
6690 static unsigned int * debug_line_pointer_sizes = NULL;
6691 static unsigned int num_debug_line_pointer_sizes = 0;
6693 /* Locate and scan the .debug_info section in the file and record the pointer
6694 sizes for the compilation units in it. Usually an executable will have
6695 just one pointer size, but this is not guaranteed, and so we try not to
6696 make any assumptions. Returns zero upon failure, or the number of
6697 compilation units upon success. */
6700 get_debug_line_pointer_sizes (FILE * file)
6702 Elf_Internal_Shdr * section;
6703 unsigned char * start;
6704 unsigned char * end;
6705 unsigned char * begin;
6706 unsigned long length;
6707 unsigned int num_units;
6710 section = find_section (".debug_info");
6711 if (section == NULL)
6714 length = section->sh_size;
6715 start = get_data (NULL, file, section->sh_offset, section->sh_size,
6716 _("extracting pointer sizes from .debug_info section"));
6720 end = start + section->sh_size;
6721 /* First scan the section to get the number of comp units. */
6722 for (begin = start, num_units = 0; begin < end; num_units++)
6724 /* Read the first 4 bytes. For a 32-bit DWARF section, this will
6725 be the length. For a 64-bit DWARF section, it'll be the escape
6726 code 0xffffffff followed by an 8 byte length. */
6727 length = byte_get (begin, 4);
6729 if (length == 0xffffffff)
6731 length = byte_get (begin + 4, 8);
6732 begin += length + 12;
6735 begin += length + 4;
6740 error (_("No comp units in .debug_info section ?"));
6745 /* Then allocate an array to hold the pointer sizes. */
6746 debug_line_pointer_sizes = malloc (num_units * sizeof * debug_line_pointer_sizes);
6747 if (debug_line_pointer_sizes == NULL)
6749 error (_("Not enough memory for a pointer size array of %u entries"),
6755 /* Populate the array. */
6756 for (begin = start, unit = 0; begin < end; unit++)
6758 length = byte_get (begin, 4);
6759 if (length == 0xffffffff)
6761 /* For 64-bit DWARF, the 1-byte address_size field is 22 bytes
6762 from the start of the section. This is computed as follows:
6764 unit_length: 12 bytes
6766 debug_abbrev_offset: 8 bytes
6767 -----------------------------
6770 debug_line_pointer_sizes [unit] = byte_get (begin + 22, 1);
6771 length = byte_get (begin + 4, 8);
6772 begin += length + 12;
6776 /* For 32-bit DWARF, the 1-byte address_size field is 10 bytes from
6777 the start of the section:
6779 unit_length: 4 bytes
6781 debug_abbrev_offset: 4 bytes
6782 -----------------------------
6785 debug_line_pointer_sizes [unit] = byte_get (begin + 10, 1);
6786 begin += length + 4;
6791 num_debug_line_pointer_sizes = num_units;
6796 display_debug_lines (Elf_Internal_Shdr *section,
6797 unsigned char *start, FILE *file)
6799 unsigned char *hdrptr;
6800 DWARF2_Internal_LineInfo info;
6801 unsigned char *standard_opcodes;
6802 unsigned char *data = start;
6803 unsigned char *end = start + section->sh_size;
6804 unsigned char *end_of_sequence;
6807 int initial_length_size;
6808 unsigned int comp_unit = 0;
6810 printf (_("\nDump of debug contents of section %s:\n\n"),
6811 SECTION_NAME (section));
6813 if (num_debug_line_pointer_sizes == 0)
6814 get_debug_line_pointer_sizes (file);
6818 unsigned int pointer_size;
6822 /* Check the length of the block. */
6823 info.li_length = byte_get (hdrptr, 4);
6826 if (info.li_length == 0xffffffff)
6828 /* This section is 64-bit DWARF 3. */
6829 info.li_length = byte_get (hdrptr, 8);
6832 initial_length_size = 12;
6837 initial_length_size = 4;
6840 if (info.li_length + initial_length_size > section->sh_size)
6843 (_("The line info appears to be corrupt - the section is too small\n"));
6847 /* Check its version number. */
6848 info.li_version = byte_get (hdrptr, 2);
6850 if (info.li_version != 2 && info.li_version != 3)
6852 warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
6856 info.li_prologue_length = byte_get (hdrptr, offset_size);
6857 hdrptr += offset_size;
6858 info.li_min_insn_length = byte_get (hdrptr, 1);
6860 info.li_default_is_stmt = byte_get (hdrptr, 1);
6862 info.li_line_base = byte_get (hdrptr, 1);
6864 info.li_line_range = byte_get (hdrptr, 1);
6866 info.li_opcode_base = byte_get (hdrptr, 1);
6869 /* Sign extend the line base field. */
6870 info.li_line_base <<= 24;
6871 info.li_line_base >>= 24;
6873 /* Get the pointer size from the comp unit associated
6874 with this block of line number information. */
6875 if (comp_unit >= num_debug_line_pointer_sizes)
6877 error (_("Not enough comp units for .debug_lines section\n"));
6882 pointer_size = debug_line_pointer_sizes [comp_unit];
6886 printf (_(" Length: %ld\n"), info.li_length);
6887 printf (_(" DWARF Version: %d\n"), info.li_version);
6888 printf (_(" Prologue Length: %d\n"), info.li_prologue_length);
6889 printf (_(" Minimum Instruction Length: %d\n"), info.li_min_insn_length);
6890 printf (_(" Initial value of 'is_stmt': %d\n"), info.li_default_is_stmt);
6891 printf (_(" Line Base: %d\n"), info.li_line_base);
6892 printf (_(" Line Range: %d\n"), info.li_line_range);
6893 printf (_(" Opcode Base: %d\n"), info.li_opcode_base);
6894 printf (_(" (Pointer size: %u)\n"), pointer_size);
6896 end_of_sequence = data + info.li_length + initial_length_size;
6898 reset_state_machine (info.li_default_is_stmt);
6900 /* Display the contents of the Opcodes table. */
6901 standard_opcodes = hdrptr;
6903 printf (_("\n Opcodes:\n"));
6905 for (i = 1; i < info.li_opcode_base; i++)
6906 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
6908 /* Display the contents of the Directory table. */
6909 data = standard_opcodes + info.li_opcode_base - 1;
6912 printf (_("\n The Directory Table is empty.\n"));
6915 printf (_("\n The Directory Table:\n"));
6919 printf (_(" %s\n"), data);
6921 data += strlen ((char *) data) + 1;
6925 /* Skip the NUL at the end of the table. */
6928 /* Display the contents of the File Name table. */
6930 printf (_("\n The File Name Table is empty.\n"));
6933 printf (_("\n The File Name Table:\n"));
6934 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6938 unsigned char *name;
6941 printf (_(" %d\t"), ++state_machine_regs.last_file_entry);
6944 data += strlen ((char *) data) + 1;
6946 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6948 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6950 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6952 printf (_("%s\n"), name);
6956 /* Skip the NUL at the end of the table. */
6959 /* Now display the statements. */
6960 printf (_("\n Line Number Statements:\n"));
6963 while (data < end_of_sequence)
6965 unsigned char op_code;
6971 if (op_code >= info.li_opcode_base)
6973 op_code -= info.li_opcode_base;
6974 adv = (op_code / info.li_line_range) * info.li_min_insn_length;
6975 state_machine_regs.address += adv;
6976 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
6977 op_code, adv, state_machine_regs.address);
6978 adv = (op_code % info.li_line_range) + info.li_line_base;
6979 state_machine_regs.line += adv;
6980 printf (_(" and Line by %d to %d\n"),
6981 adv, state_machine_regs.line);
6983 else switch (op_code)
6985 case DW_LNS_extended_op:
6986 data += process_extended_line_op (data, info.li_default_is_stmt,
6991 printf (_(" Copy\n"));
6994 case DW_LNS_advance_pc:
6995 adv = info.li_min_insn_length * read_leb128 (data, & bytes_read, 0);
6997 state_machine_regs.address += adv;
6998 printf (_(" Advance PC by %d to %lx\n"), adv,
6999 state_machine_regs.address);
7002 case DW_LNS_advance_line:
7003 adv = read_leb128 (data, & bytes_read, 1);
7005 state_machine_regs.line += adv;
7006 printf (_(" Advance Line by %d to %d\n"), adv,
7007 state_machine_regs.line);
7010 case DW_LNS_set_file:
7011 adv = read_leb128 (data, & bytes_read, 0);
7013 printf (_(" Set File Name to entry %d in the File Name Table\n"),
7015 state_machine_regs.file = adv;
7018 case DW_LNS_set_column:
7019 adv = read_leb128 (data, & bytes_read, 0);
7021 printf (_(" Set column to %d\n"), adv);
7022 state_machine_regs.column = adv;
7025 case DW_LNS_negate_stmt:
7026 adv = state_machine_regs.is_stmt;
7028 printf (_(" Set is_stmt to %d\n"), adv);
7029 state_machine_regs.is_stmt = adv;
7032 case DW_LNS_set_basic_block:
7033 printf (_(" Set basic block\n"));
7034 state_machine_regs.basic_block = 1;
7037 case DW_LNS_const_add_pc:
7038 adv = (((255 - info.li_opcode_base) / info.li_line_range)
7039 * info.li_min_insn_length);
7040 state_machine_regs.address += adv;
7041 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv,
7042 state_machine_regs.address);
7045 case DW_LNS_fixed_advance_pc:
7046 adv = byte_get (data, 2);
7048 state_machine_regs.address += adv;
7049 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
7050 adv, state_machine_regs.address);
7053 case DW_LNS_set_prologue_end:
7054 printf (_(" Set prologue_end to true\n"));
7057 case DW_LNS_set_epilogue_begin:
7058 printf (_(" Set epilogue_begin to true\n"));
7061 case DW_LNS_set_isa:
7062 adv = read_leb128 (data, & bytes_read, 0);
7064 printf (_(" Set ISA to %d\n"), adv);
7068 printf (_(" Unknown opcode %d with operands: "), op_code);
7071 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
7073 printf ("0x%lx%s", read_leb128 (data, &bytes_read, 0),
7074 i == 1 ? "" : ", ");
7089 display_debug_pubnames (Elf_Internal_Shdr *section,
7090 unsigned char *start,
7091 FILE *file ATTRIBUTE_UNUSED)
7093 DWARF2_Internal_PubNames pubnames;
7096 end = start + section->sh_size;
7098 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
7102 unsigned char *data;
7103 unsigned long offset;
7104 int offset_size, initial_length_size;
7108 pubnames.pn_length = byte_get (data, 4);
7110 if (pubnames.pn_length == 0xffffffff)
7112 pubnames.pn_length = byte_get (data, 8);
7115 initial_length_size = 12;
7120 initial_length_size = 4;
7123 pubnames.pn_version = byte_get (data, 2);
7125 pubnames.pn_offset = byte_get (data, offset_size);
7126 data += offset_size;
7127 pubnames.pn_size = byte_get (data, offset_size);
7128 data += offset_size;
7130 start += pubnames.pn_length + initial_length_size;
7132 if (pubnames.pn_version != 2 && pubnames.pn_version != 3)
7134 static int warned = 0;
7138 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
7145 printf (_(" Length: %ld\n"),
7146 pubnames.pn_length);
7147 printf (_(" Version: %d\n"),
7148 pubnames.pn_version);
7149 printf (_(" Offset into .debug_info section: %ld\n"),
7150 pubnames.pn_offset);
7151 printf (_(" Size of area in .debug_info section: %ld\n"),
7154 printf (_("\n Offset\tName\n"));
7158 offset = byte_get (data, offset_size);
7162 data += offset_size;
7163 printf (" %-6ld\t\t%s\n", offset, data);
7164 data += strlen ((char *) data) + 1;
7167 while (offset != 0);
7175 get_TAG_name (unsigned long tag)
7179 case DW_TAG_padding: return "DW_TAG_padding";
7180 case DW_TAG_array_type: return "DW_TAG_array_type";
7181 case DW_TAG_class_type: return "DW_TAG_class_type";
7182 case DW_TAG_entry_point: return "DW_TAG_entry_point";
7183 case DW_TAG_enumeration_type: return "DW_TAG_enumeration_type";
7184 case DW_TAG_formal_parameter: return "DW_TAG_formal_parameter";
7185 case DW_TAG_imported_declaration: return "DW_TAG_imported_declaration";
7186 case DW_TAG_label: return "DW_TAG_label";
7187 case DW_TAG_lexical_block: return "DW_TAG_lexical_block";
7188 case DW_TAG_member: return "DW_TAG_member";
7189 case DW_TAG_pointer_type: return "DW_TAG_pointer_type";
7190 case DW_TAG_reference_type: return "DW_TAG_reference_type";
7191 case DW_TAG_compile_unit: return "DW_TAG_compile_unit";
7192 case DW_TAG_string_type: return "DW_TAG_string_type";
7193 case DW_TAG_structure_type: return "DW_TAG_structure_type";
7194 case DW_TAG_subroutine_type: return "DW_TAG_subroutine_type";
7195 case DW_TAG_typedef: return "DW_TAG_typedef";
7196 case DW_TAG_union_type: return "DW_TAG_union_type";
7197 case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters";
7198 case DW_TAG_variant: return "DW_TAG_variant";
7199 case DW_TAG_common_block: return "DW_TAG_common_block";
7200 case DW_TAG_common_inclusion: return "DW_TAG_common_inclusion";
7201 case DW_TAG_inheritance: return "DW_TAG_inheritance";
7202 case DW_TAG_inlined_subroutine: return "DW_TAG_inlined_subroutine";
7203 case DW_TAG_module: return "DW_TAG_module";
7204 case DW_TAG_ptr_to_member_type: return "DW_TAG_ptr_to_member_type";
7205 case DW_TAG_set_type: return "DW_TAG_set_type";
7206 case DW_TAG_subrange_type: return "DW_TAG_subrange_type";
7207 case DW_TAG_with_stmt: return "DW_TAG_with_stmt";
7208 case DW_TAG_access_declaration: return "DW_TAG_access_declaration";
7209 case DW_TAG_base_type: return "DW_TAG_base_type";
7210 case DW_TAG_catch_block: return "DW_TAG_catch_block";
7211 case DW_TAG_const_type: return "DW_TAG_const_type";
7212 case DW_TAG_constant: return "DW_TAG_constant";
7213 case DW_TAG_enumerator: return "DW_TAG_enumerator";
7214 case DW_TAG_file_type: return "DW_TAG_file_type";
7215 case DW_TAG_friend: return "DW_TAG_friend";
7216 case DW_TAG_namelist: return "DW_TAG_namelist";
7217 case DW_TAG_namelist_item: return "DW_TAG_namelist_item";
7218 case DW_TAG_packed_type: return "DW_TAG_packed_type";
7219 case DW_TAG_subprogram: return "DW_TAG_subprogram";
7220 case DW_TAG_template_type_param: return "DW_TAG_template_type_param";
7221 case DW_TAG_template_value_param: return "DW_TAG_template_value_param";
7222 case DW_TAG_thrown_type: return "DW_TAG_thrown_type";
7223 case DW_TAG_try_block: return "DW_TAG_try_block";
7224 case DW_TAG_variant_part: return "DW_TAG_variant_part";
7225 case DW_TAG_variable: return "DW_TAG_variable";
7226 case DW_TAG_volatile_type: return "DW_TAG_volatile_type";
7227 case DW_TAG_MIPS_loop: return "DW_TAG_MIPS_loop";
7228 case DW_TAG_format_label: return "DW_TAG_format_label";
7229 case DW_TAG_function_template: return "DW_TAG_function_template";
7230 case DW_TAG_class_template: return "DW_TAG_class_template";
7231 /* DWARF 2.1 values. */
7232 case DW_TAG_dwarf_procedure: return "DW_TAG_dwarf_procedure";
7233 case DW_TAG_restrict_type: return "DW_TAG_restrict_type";
7234 case DW_TAG_interface_type: return "DW_TAG_interface_type";
7235 case DW_TAG_namespace: return "DW_TAG_namespace";
7236 case DW_TAG_imported_module: return "DW_TAG_imported_module";
7237 case DW_TAG_unspecified_type: return "DW_TAG_unspecified_type";
7238 case DW_TAG_partial_unit: return "DW_TAG_partial_unit";
7239 case DW_TAG_imported_unit: return "DW_TAG_imported_unit";
7241 case DW_TAG_upc_shared_type: return "DW_TAG_upc_shared_type";
7242 case DW_TAG_upc_strict_type: return "DW_TAG_upc_strict_type";
7243 case DW_TAG_upc_relaxed_type: return "DW_TAG_upc_relaxed_type";
7246 static char buffer[100];
7248 sprintf (buffer, _("Unknown TAG value: %lx"), tag);
7255 get_AT_name (unsigned long attribute)
7259 case DW_AT_sibling: return "DW_AT_sibling";
7260 case DW_AT_location: return "DW_AT_location";
7261 case DW_AT_name: return "DW_AT_name";
7262 case DW_AT_ordering: return "DW_AT_ordering";
7263 case DW_AT_subscr_data: return "DW_AT_subscr_data";
7264 case DW_AT_byte_size: return "DW_AT_byte_size";
7265 case DW_AT_bit_offset: return "DW_AT_bit_offset";
7266 case DW_AT_bit_size: return "DW_AT_bit_size";
7267 case DW_AT_element_list: return "DW_AT_element_list";
7268 case DW_AT_stmt_list: return "DW_AT_stmt_list";
7269 case DW_AT_low_pc: return "DW_AT_low_pc";
7270 case DW_AT_high_pc: return "DW_AT_high_pc";
7271 case DW_AT_language: return "DW_AT_language";
7272 case DW_AT_member: return "DW_AT_member";
7273 case DW_AT_discr: return "DW_AT_discr";
7274 case DW_AT_discr_value: return "DW_AT_discr_value";
7275 case DW_AT_visibility: return "DW_AT_visibility";
7276 case DW_AT_import: return "DW_AT_import";
7277 case DW_AT_string_length: return "DW_AT_string_length";
7278 case DW_AT_common_reference: return "DW_AT_common_reference";
7279 case DW_AT_comp_dir: return "DW_AT_comp_dir";
7280 case DW_AT_const_value: return "DW_AT_const_value";
7281 case DW_AT_containing_type: return "DW_AT_containing_type";
7282 case DW_AT_default_value: return "DW_AT_default_value";
7283 case DW_AT_inline: return "DW_AT_inline";
7284 case DW_AT_is_optional: return "DW_AT_is_optional";
7285 case DW_AT_lower_bound: return "DW_AT_lower_bound";
7286 case DW_AT_producer: return "DW_AT_producer";
7287 case DW_AT_prototyped: return "DW_AT_prototyped";
7288 case DW_AT_return_addr: return "DW_AT_return_addr";
7289 case DW_AT_start_scope: return "DW_AT_start_scope";
7290 case DW_AT_stride_size: return "DW_AT_stride_size";
7291 case DW_AT_upper_bound: return "DW_AT_upper_bound";
7292 case DW_AT_abstract_origin: return "DW_AT_abstract_origin";
7293 case DW_AT_accessibility: return "DW_AT_accessibility";
7294 case DW_AT_address_class: return "DW_AT_address_class";
7295 case DW_AT_artificial: return "DW_AT_artificial";
7296 case DW_AT_base_types: return "DW_AT_base_types";
7297 case DW_AT_calling_convention: return "DW_AT_calling_convention";
7298 case DW_AT_count: return "DW_AT_count";
7299 case DW_AT_data_member_location: return "DW_AT_data_member_location";
7300 case DW_AT_decl_column: return "DW_AT_decl_column";
7301 case DW_AT_decl_file: return "DW_AT_decl_file";
7302 case DW_AT_decl_line: return "DW_AT_decl_line";
7303 case DW_AT_declaration: return "DW_AT_declaration";
7304 case DW_AT_discr_list: return "DW_AT_discr_list";
7305 case DW_AT_encoding: return "DW_AT_encoding";
7306 case DW_AT_external: return "DW_AT_external";
7307 case DW_AT_frame_base: return "DW_AT_frame_base";
7308 case DW_AT_friend: return "DW_AT_friend";
7309 case DW_AT_identifier_case: return "DW_AT_identifier_case";
7310 case DW_AT_macro_info: return "DW_AT_macro_info";
7311 case DW_AT_namelist_items: return "DW_AT_namelist_items";
7312 case DW_AT_priority: return "DW_AT_priority";
7313 case DW_AT_segment: return "DW_AT_segment";
7314 case DW_AT_specification: return "DW_AT_specification";
7315 case DW_AT_static_link: return "DW_AT_static_link";
7316 case DW_AT_type: return "DW_AT_type";
7317 case DW_AT_use_location: return "DW_AT_use_location";
7318 case DW_AT_variable_parameter: return "DW_AT_variable_parameter";
7319 case DW_AT_virtuality: return "DW_AT_virtuality";
7320 case DW_AT_vtable_elem_location: return "DW_AT_vtable_elem_location";
7321 /* DWARF 2.1 values. */
7322 case DW_AT_allocated: return "DW_AT_allocated";
7323 case DW_AT_associated: return "DW_AT_associated";
7324 case DW_AT_data_location: return "DW_AT_data_location";
7325 case DW_AT_stride: return "DW_AT_stride";
7326 case DW_AT_entry_pc: return "DW_AT_entry_pc";
7327 case DW_AT_use_UTF8: return "DW_AT_use_UTF8";
7328 case DW_AT_extension: return "DW_AT_extension";
7329 case DW_AT_ranges: return "DW_AT_ranges";
7330 case DW_AT_trampoline: return "DW_AT_trampoline";
7331 case DW_AT_call_column: return "DW_AT_call_column";
7332 case DW_AT_call_file: return "DW_AT_call_file";
7333 case DW_AT_call_line: return "DW_AT_call_line";
7334 /* SGI/MIPS extensions. */
7335 case DW_AT_MIPS_fde: return "DW_AT_MIPS_fde";
7336 case DW_AT_MIPS_loop_begin: return "DW_AT_MIPS_loop_begin";
7337 case DW_AT_MIPS_tail_loop_begin: return "DW_AT_MIPS_tail_loop_begin";
7338 case DW_AT_MIPS_epilog_begin: return "DW_AT_MIPS_epilog_begin";
7339 case DW_AT_MIPS_loop_unroll_factor: return "DW_AT_MIPS_loop_unroll_factor";
7340 case DW_AT_MIPS_software_pipeline_depth:
7341 return "DW_AT_MIPS_software_pipeline_depth";
7342 case DW_AT_MIPS_linkage_name: return "DW_AT_MIPS_linkage_name";
7343 case DW_AT_MIPS_stride: return "DW_AT_MIPS_stride";
7344 case DW_AT_MIPS_abstract_name: return "DW_AT_MIPS_abstract_name";
7345 case DW_AT_MIPS_clone_origin: return "DW_AT_MIPS_clone_origin";
7346 case DW_AT_MIPS_has_inlines: return "DW_AT_MIPS_has_inlines";
7347 /* GNU extensions. */
7348 case DW_AT_sf_names: return "DW_AT_sf_names";
7349 case DW_AT_src_info: return "DW_AT_src_info";
7350 case DW_AT_mac_info: return "DW_AT_mac_info";
7351 case DW_AT_src_coords: return "DW_AT_src_coords";
7352 case DW_AT_body_begin: return "DW_AT_body_begin";
7353 case DW_AT_body_end: return "DW_AT_body_end";
7354 case DW_AT_GNU_vector: return "DW_AT_GNU_vector";
7355 /* UPC extension. */
7356 case DW_AT_upc_threads_scaled: return "DW_AT_upc_threads_scaled";
7359 static char buffer[100];
7361 sprintf (buffer, _("Unknown AT value: %lx"), attribute);
7368 get_FORM_name (unsigned long form)
7372 case DW_FORM_addr: return "DW_FORM_addr";
7373 case DW_FORM_block2: return "DW_FORM_block2";
7374 case DW_FORM_block4: return "DW_FORM_block4";
7375 case DW_FORM_data2: return "DW_FORM_data2";
7376 case DW_FORM_data4: return "DW_FORM_data4";
7377 case DW_FORM_data8: return "DW_FORM_data8";
7378 case DW_FORM_string: return "DW_FORM_string";
7379 case DW_FORM_block: return "DW_FORM_block";
7380 case DW_FORM_block1: return "DW_FORM_block1";
7381 case DW_FORM_data1: return "DW_FORM_data1";
7382 case DW_FORM_flag: return "DW_FORM_flag";
7383 case DW_FORM_sdata: return "DW_FORM_sdata";
7384 case DW_FORM_strp: return "DW_FORM_strp";
7385 case DW_FORM_udata: return "DW_FORM_udata";
7386 case DW_FORM_ref_addr: return "DW_FORM_ref_addr";
7387 case DW_FORM_ref1: return "DW_FORM_ref1";
7388 case DW_FORM_ref2: return "DW_FORM_ref2";
7389 case DW_FORM_ref4: return "DW_FORM_ref4";
7390 case DW_FORM_ref8: return "DW_FORM_ref8";
7391 case DW_FORM_ref_udata: return "DW_FORM_ref_udata";
7392 case DW_FORM_indirect: return "DW_FORM_indirect";
7395 static char buffer[100];
7397 sprintf (buffer, _("Unknown FORM value: %lx"), form);
7403 /* FIXME: There are better and more efficient ways to handle
7404 these structures. For now though, I just want something that
7405 is simple to implement. */
7406 typedef struct abbrev_attr
7408 unsigned long attribute;
7410 struct abbrev_attr *next;
7414 typedef struct abbrev_entry
7416 unsigned long entry;
7419 struct abbrev_attr *first_attr;
7420 struct abbrev_attr *last_attr;
7421 struct abbrev_entry *next;
7425 static abbrev_entry *first_abbrev = NULL;
7426 static abbrev_entry *last_abbrev = NULL;
7431 abbrev_entry *abbrev;
7433 for (abbrev = first_abbrev; abbrev;)
7435 abbrev_entry *next = abbrev->next;
7438 for (attr = abbrev->first_attr; attr;)
7440 abbrev_attr *next = attr->next;
7450 last_abbrev = first_abbrev = NULL;
7454 add_abbrev (unsigned long number, unsigned long tag, int children)
7456 abbrev_entry *entry;
7458 entry = malloc (sizeof (*entry));
7464 entry->entry = number;
7466 entry->children = children;
7467 entry->first_attr = NULL;
7468 entry->last_attr = NULL;
7471 if (first_abbrev == NULL)
7472 first_abbrev = entry;
7474 last_abbrev->next = entry;
7476 last_abbrev = entry;
7480 add_abbrev_attr (unsigned long attribute, unsigned long form)
7484 attr = malloc (sizeof (*attr));
7490 attr->attribute = attribute;
7494 if (last_abbrev->first_attr == NULL)
7495 last_abbrev->first_attr = attr;
7497 last_abbrev->last_attr->next = attr;
7499 last_abbrev->last_attr = attr;
7502 /* Processes the (partial) contents of a .debug_abbrev section.
7503 Returns NULL if the end of the section was encountered.
7504 Returns the address after the last byte read if the end of
7505 an abbreviation set was found. */
7507 static unsigned char *
7508 process_abbrev_section (unsigned char *start, unsigned char *end)
7510 if (first_abbrev != NULL)
7516 unsigned long entry;
7518 unsigned long attribute;
7521 entry = read_leb128 (start, & bytes_read, 0);
7522 start += bytes_read;
7524 /* A single zero is supposed to end the section according
7525 to the standard. If there's more, then signal that to
7528 return start == end ? NULL : start;
7530 tag = read_leb128 (start, & bytes_read, 0);
7531 start += bytes_read;
7533 children = *start++;
7535 add_abbrev (entry, tag, children);
7541 attribute = read_leb128 (start, & bytes_read, 0);
7542 start += bytes_read;
7544 form = read_leb128 (start, & bytes_read, 0);
7545 start += bytes_read;
7548 add_abbrev_attr (attribute, form);
7550 while (attribute != 0);
7558 display_debug_macinfo (Elf_Internal_Shdr *section,
7559 unsigned char *start,
7560 FILE *file ATTRIBUTE_UNUSED)
7562 unsigned char *end = start + section->sh_size;
7563 unsigned char *curr = start;
7564 unsigned int bytes_read;
7565 enum dwarf_macinfo_record_type op;
7567 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
7571 unsigned int lineno;
7579 case DW_MACINFO_start_file:
7581 unsigned int filenum;
7583 lineno = read_leb128 (curr, & bytes_read, 0);
7585 filenum = read_leb128 (curr, & bytes_read, 0);
7588 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"), lineno, filenum);
7592 case DW_MACINFO_end_file:
7593 printf (_(" DW_MACINFO_end_file\n"));
7596 case DW_MACINFO_define:
7597 lineno = read_leb128 (curr, & bytes_read, 0);
7600 curr += strlen (string) + 1;
7601 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"), lineno, string);
7604 case DW_MACINFO_undef:
7605 lineno = read_leb128 (curr, & bytes_read, 0);
7608 curr += strlen (string) + 1;
7609 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"), lineno, string);
7612 case DW_MACINFO_vendor_ext:
7614 unsigned int constant;
7616 constant = read_leb128 (curr, & bytes_read, 0);
7619 curr += strlen (string) + 1;
7620 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"), constant, string);
7631 display_debug_abbrev (Elf_Internal_Shdr *section,
7632 unsigned char *start,
7633 FILE *file ATTRIBUTE_UNUSED)
7635 abbrev_entry *entry;
7636 unsigned char *end = start + section->sh_size;
7638 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
7642 start = process_abbrev_section (start, end);
7644 if (first_abbrev == NULL)
7647 printf (_(" Number TAG\n"));
7649 for (entry = first_abbrev; entry; entry = entry->next)
7653 printf (_(" %ld %s [%s]\n"),
7655 get_TAG_name (entry->tag),
7656 entry->children ? _("has children") : _("no children"));
7658 for (attr = entry->first_attr; attr; attr = attr->next)
7660 printf (_(" %-18s %s\n"),
7661 get_AT_name (attr->attribute),
7662 get_FORM_name (attr->form));
7676 static unsigned char *
7677 display_block (unsigned char *data, unsigned long length)
7679 printf (_(" %lu byte block: "), length);
7682 printf ("%lx ", (unsigned long) byte_get (data++, 1));
7688 decode_location_expression (unsigned char * data,
7689 unsigned int pointer_size,
7690 unsigned long length)
7694 unsigned long uvalue;
7695 unsigned char *end = data + length;
7704 printf ("DW_OP_addr: %lx",
7705 (unsigned long) byte_get (data, pointer_size));
7706 data += pointer_size;
7709 printf ("DW_OP_deref");
7712 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data++, 1));
7715 printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data++, 1));
7718 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2));
7722 printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data, 2));
7726 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
7730 printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data, 4));
7734 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
7735 (unsigned long) byte_get (data + 4, 4));
7739 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
7740 (long) byte_get (data + 4, 4));
7744 printf ("DW_OP_constu: %lu", read_leb128 (data, &bytes_read, 0));
7748 printf ("DW_OP_consts: %ld", read_leb128 (data, &bytes_read, 1));
7752 printf ("DW_OP_dup");
7755 printf ("DW_OP_drop");
7758 printf ("DW_OP_over");
7761 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data++, 1));
7764 printf ("DW_OP_swap");
7767 printf ("DW_OP_rot");
7770 printf ("DW_OP_xderef");
7773 printf ("DW_OP_abs");
7776 printf ("DW_OP_and");
7779 printf ("DW_OP_div");
7782 printf ("DW_OP_minus");
7785 printf ("DW_OP_mod");
7788 printf ("DW_OP_mul");
7791 printf ("DW_OP_neg");
7794 printf ("DW_OP_not");
7797 printf ("DW_OP_or");
7800 printf ("DW_OP_plus");
7802 case DW_OP_plus_uconst:
7803 printf ("DW_OP_plus_uconst: %lu",
7804 read_leb128 (data, &bytes_read, 0));
7808 printf ("DW_OP_shl");
7811 printf ("DW_OP_shr");
7814 printf ("DW_OP_shra");
7817 printf ("DW_OP_xor");
7820 printf ("DW_OP_bra: %ld", (long) byte_get_signed (data, 2));
7824 printf ("DW_OP_eq");
7827 printf ("DW_OP_ge");
7830 printf ("DW_OP_gt");
7833 printf ("DW_OP_le");
7836 printf ("DW_OP_lt");
7839 printf ("DW_OP_ne");
7842 printf ("DW_OP_skip: %ld", (long) byte_get_signed (data, 2));
7878 printf ("DW_OP_lit%d", op - DW_OP_lit0);
7913 printf ("DW_OP_reg%d", op - DW_OP_reg0);
7948 printf ("DW_OP_breg%d: %ld", op - DW_OP_breg0,
7949 read_leb128 (data, &bytes_read, 1));
7954 printf ("DW_OP_regx: %lu", read_leb128 (data, &bytes_read, 0));
7958 printf ("DW_OP_fbreg: %ld", read_leb128 (data, &bytes_read, 1));
7962 uvalue = read_leb128 (data, &bytes_read, 0);
7964 printf ("DW_OP_bregx: %lu %ld", uvalue,
7965 read_leb128 (data, &bytes_read, 1));
7969 printf ("DW_OP_piece: %lu", read_leb128 (data, &bytes_read, 0));
7972 case DW_OP_deref_size:
7973 printf ("DW_OP_deref_size: %ld", (long) byte_get (data++, 1));
7975 case DW_OP_xderef_size:
7976 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data++, 1));
7979 printf ("DW_OP_nop");
7982 /* DWARF 3 extensions. */
7983 case DW_OP_push_object_address:
7984 printf ("DW_OP_push_object_address");
7987 printf ("DW_OP_call2: <%lx>", (long) byte_get (data, 2));
7991 printf ("DW_OP_call4: <%lx>", (long) byte_get (data, 4));
7994 case DW_OP_call_ref:
7995 printf ("DW_OP_call_ref");
7998 /* GNU extensions. */
7999 case DW_OP_GNU_push_tls_address:
8000 printf ("DW_OP_GNU_push_tls_address");
8004 if (op >= DW_OP_lo_user
8005 && op <= DW_OP_hi_user)
8006 printf (_("(User defined location op)"));
8008 printf (_("(Unknown location op)"));
8009 /* No way to tell where the next op is, so just bail. */
8013 /* Separate the ops. */
8019 static const char *debug_loc_contents;
8020 static bfd_vma debug_loc_size;
8023 load_debug_loc (FILE *file)
8025 Elf_Internal_Shdr *sec;
8027 /* If it is already loaded, do nothing. */
8028 if (debug_loc_contents != NULL)
8031 /* Locate the .debug_loc section. */
8032 sec = find_section (".debug_loc");
8036 debug_loc_size = sec->sh_size;
8038 debug_loc_contents = get_data (NULL, file, sec->sh_offset, sec->sh_size,
8039 _("debug_loc section data"));
8043 free_debug_loc (void)
8045 if (debug_loc_contents == NULL)
8048 free ((char *) debug_loc_contents);
8049 debug_loc_contents = NULL;
8055 display_debug_loc (Elf_Internal_Shdr *section,
8056 unsigned char *start, FILE *file)
8058 unsigned char *section_end;
8059 unsigned long bytes;
8060 unsigned char *section_begin = start;
8062 unsigned int comp_unit = 0;
8064 addr = section->sh_addr;
8065 bytes = section->sh_size;
8066 section_end = start + bytes;
8070 printf (_("\nThe .debug_loc section is empty.\n"));
8074 if (num_debug_line_pointer_sizes == 0)
8075 get_debug_line_pointer_sizes (file);
8077 printf (_("Contents of the .debug_loc section:\n\n"));
8078 printf (_("\n Offset Begin End Expression\n"));
8080 while (start < section_end)
8082 unsigned long begin;
8084 unsigned short length;
8085 unsigned long offset;
8086 unsigned int pointer_size;
8088 offset = start - section_begin;
8090 /* Get the pointer size from the comp unit associated
8091 with this block of location information. */
8092 if (comp_unit >= num_debug_line_pointer_sizes)
8094 error (_("Not enough comp units for .debug_loc section\n"));
8099 pointer_size = debug_line_pointer_sizes [comp_unit];
8105 begin = byte_get (start, pointer_size);
8106 start += pointer_size;
8107 end = byte_get (start, pointer_size);
8108 start += pointer_size;
8110 if (begin == 0 && end == 0)
8113 /* For now, skip any base address specifiers. */
8114 if (begin == 0xffffffff)
8120 length = byte_get (start, 2);
8123 printf (" %8.8lx %8.8lx %8.8lx (", offset, begin, end);
8124 decode_location_expression (start, pointer_size, length);
8134 static const char *debug_str_contents;
8135 static bfd_vma debug_str_size;
8138 load_debug_str (FILE *file)
8140 Elf_Internal_Shdr *sec;
8142 /* If it is already loaded, do nothing. */
8143 if (debug_str_contents != NULL)
8146 /* Locate the .debug_str section. */
8147 sec = find_section (".debug_str");
8151 debug_str_size = sec->sh_size;
8153 debug_str_contents = get_data (NULL, file, sec->sh_offset, sec->sh_size,
8154 _("debug_str section data"));
8158 free_debug_str (void)
8160 if (debug_str_contents == NULL)
8163 free ((char *) debug_str_contents);
8164 debug_str_contents = NULL;
8169 fetch_indirect_string (unsigned long offset)
8171 if (debug_str_contents == NULL)
8172 return _("<no .debug_str section>");
8174 if (offset > debug_str_size)
8175 return _("<offset is too big>");
8177 return debug_str_contents + offset;
8181 display_debug_str (Elf_Internal_Shdr *section,
8182 unsigned char *start,
8183 FILE *file ATTRIBUTE_UNUSED)
8185 unsigned long bytes;
8188 addr = section->sh_addr;
8189 bytes = section->sh_size;
8193 printf (_("\nThe .debug_str section is empty.\n"));
8197 printf (_("Contents of the .debug_str section:\n\n"));
8205 lbytes = (bytes > 16 ? 16 : bytes);
8207 printf (" 0x%8.8lx ", (unsigned long) addr);
8209 for (j = 0; j < 16; j++)
8212 printf ("%2.2x", start[j]);
8220 for (j = 0; j < lbytes; j++)
8223 if (k >= ' ' && k < 0x80)
8239 static unsigned char *
8240 read_and_display_attr_value (unsigned long attribute,
8242 unsigned char *data,
8243 unsigned long cu_offset,
8244 unsigned long pointer_size,
8245 unsigned long offset_size,
8248 unsigned long uvalue = 0;
8249 unsigned char *block_start = NULL;
8257 case DW_FORM_ref_addr:
8258 if (dwarf_version == 2)
8260 uvalue = byte_get (data, pointer_size);
8261 data += pointer_size;
8263 else if (dwarf_version == 3)
8265 uvalue = byte_get (data, offset_size);
8266 data += offset_size;
8270 error (_("Internal error: DWARF version is not 2 or 3.\n"));
8275 uvalue = byte_get (data, pointer_size);
8276 data += pointer_size;
8280 uvalue = byte_get (data, offset_size);
8281 data += offset_size;
8287 uvalue = byte_get (data++, 1);
8292 uvalue = byte_get (data, 2);
8298 uvalue = byte_get (data, 4);
8303 uvalue = read_leb128 (data, & bytes_read, 1);
8307 case DW_FORM_ref_udata:
8309 uvalue = read_leb128 (data, & bytes_read, 0);
8313 case DW_FORM_indirect:
8314 form = read_leb128 (data, & bytes_read, 0);
8316 printf (" %s", get_FORM_name (form));
8317 return read_and_display_attr_value (attribute, form, data, cu_offset,
8318 pointer_size, offset_size,
8324 case DW_FORM_ref_addr:
8325 printf (" <#%lx>", uvalue);
8331 case DW_FORM_ref_udata:
8332 printf (" <%lx>", uvalue + cu_offset);
8336 printf (" %#lx", uvalue);
8345 printf (" %ld", uvalue);
8350 uvalue = byte_get (data, 4);
8351 printf (" %lx", uvalue);
8352 printf (" %lx", (unsigned long) byte_get (data + 4, 4));
8356 case DW_FORM_string:
8357 printf (" %s", data);
8358 data += strlen ((char *) data) + 1;
8362 uvalue = read_leb128 (data, & bytes_read, 0);
8363 block_start = data + bytes_read;
8364 data = display_block (block_start, uvalue);
8367 case DW_FORM_block1:
8368 uvalue = byte_get (data, 1);
8369 block_start = data + 1;
8370 data = display_block (block_start, uvalue);
8373 case DW_FORM_block2:
8374 uvalue = byte_get (data, 2);
8375 block_start = data + 2;
8376 data = display_block (block_start, uvalue);
8379 case DW_FORM_block4:
8380 uvalue = byte_get (data, 4);
8381 block_start = data + 4;
8382 data = display_block (block_start, uvalue);
8386 printf (_(" (indirect string, offset: 0x%lx): %s"),
8387 uvalue, fetch_indirect_string (uvalue));
8390 case DW_FORM_indirect:
8391 /* Handled above. */
8395 warn (_("Unrecognized form: %d\n"), form);
8399 /* For some attributes we can display further information. */
8408 case DW_INL_not_inlined:
8409 printf (_("(not inlined)"));
8411 case DW_INL_inlined:
8412 printf (_("(inlined)"));
8414 case DW_INL_declared_not_inlined:
8415 printf (_("(declared as inline but ignored)"));
8417 case DW_INL_declared_inlined:
8418 printf (_("(declared as inline and inlined)"));
8421 printf (_(" (Unknown inline attribute value: %lx)"), uvalue);
8426 case DW_AT_language:
8429 case DW_LANG_C: printf ("(non-ANSI C)"); break;
8430 case DW_LANG_C89: printf ("(ANSI C)"); break;
8431 case DW_LANG_C_plus_plus: printf ("(C++)"); break;
8432 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break;
8433 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break;
8434 case DW_LANG_Modula2: printf ("(Modula 2)"); break;
8435 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break;
8436 case DW_LANG_Ada83: printf ("(Ada)"); break;
8437 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break;
8438 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break;
8439 /* DWARF 2.1 values. */
8440 case DW_LANG_C99: printf ("(ANSI C99)"); break;
8441 case DW_LANG_Ada95: printf ("(ADA 95)"); break;
8442 case DW_LANG_Fortran95: printf ("(Fortran 95)"); break;
8443 /* MIPS extension. */
8444 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
8445 /* UPC extension. */
8446 case DW_LANG_Upc: printf ("(Unified Parallel C)"); break;
8448 printf ("(Unknown: %lx)", uvalue);
8453 case DW_AT_encoding:
8456 case DW_ATE_void: printf ("(void)"); break;
8457 case DW_ATE_address: printf ("(machine address)"); break;
8458 case DW_ATE_boolean: printf ("(boolean)"); break;
8459 case DW_ATE_complex_float: printf ("(complex float)"); break;
8460 case DW_ATE_float: printf ("(float)"); break;
8461 case DW_ATE_signed: printf ("(signed)"); break;
8462 case DW_ATE_signed_char: printf ("(signed char)"); break;
8463 case DW_ATE_unsigned: printf ("(unsigned)"); break;
8464 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
8465 /* DWARF 2.1 value. */
8466 case DW_ATE_imaginary_float: printf ("(imaginary float)"); break;
8468 if (uvalue >= DW_ATE_lo_user
8469 && uvalue <= DW_ATE_hi_user)
8470 printf ("(user defined type)");
8472 printf ("(unknown type)");
8477 case DW_AT_accessibility:
8480 case DW_ACCESS_public: printf ("(public)"); break;
8481 case DW_ACCESS_protected: printf ("(protected)"); break;
8482 case DW_ACCESS_private: printf ("(private)"); break;
8484 printf ("(unknown accessibility)");
8489 case DW_AT_visibility:
8492 case DW_VIS_local: printf ("(local)"); break;
8493 case DW_VIS_exported: printf ("(exported)"); break;
8494 case DW_VIS_qualified: printf ("(qualified)"); break;
8495 default: printf ("(unknown visibility)"); break;
8499 case DW_AT_virtuality:
8502 case DW_VIRTUALITY_none: printf ("(none)"); break;
8503 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
8504 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
8505 default: printf ("(unknown virtuality)"); break;
8509 case DW_AT_identifier_case:
8512 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
8513 case DW_ID_up_case: printf ("(up_case)"); break;
8514 case DW_ID_down_case: printf ("(down_case)"); break;
8515 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
8516 default: printf ("(unknown case)"); break;
8520 case DW_AT_calling_convention:
8523 case DW_CC_normal: printf ("(normal)"); break;
8524 case DW_CC_program: printf ("(program)"); break;
8525 case DW_CC_nocall: printf ("(nocall)"); break;
8527 if (uvalue >= DW_CC_lo_user
8528 && uvalue <= DW_CC_hi_user)
8529 printf ("(user defined)");
8531 printf ("(unknown convention)");
8535 case DW_AT_ordering:
8538 case -1: printf ("(undefined)"); break;
8539 case 0: printf ("(row major)"); break;
8540 case 1: printf ("(column major)"); break;
8544 case DW_AT_frame_base:
8545 case DW_AT_location:
8546 case DW_AT_data_member_location:
8547 case DW_AT_vtable_elem_location:
8548 case DW_AT_allocated:
8549 case DW_AT_associated:
8550 case DW_AT_data_location:
8552 case DW_AT_upper_bound:
8553 case DW_AT_lower_bound:
8557 decode_location_expression (block_start, pointer_size, uvalue);
8560 else if (form == DW_FORM_data4 || form == DW_FORM_data8)
8563 printf ("location list");
8575 static unsigned char *
8576 read_and_display_attr (unsigned long attribute,
8578 unsigned char *data,
8579 unsigned long cu_offset,
8580 unsigned long pointer_size,
8581 unsigned long offset_size,
8584 printf (" %-18s:", get_AT_name (attribute));
8585 data = read_and_display_attr_value (attribute, form, data, cu_offset,
8586 pointer_size, offset_size, dwarf_version);
8591 /* Apply addends of RELA relocations. */
8594 debug_apply_rela_addends (FILE *file,
8595 Elf_Internal_Shdr *section,
8597 unsigned char *sec_data,
8598 unsigned char *start,
8601 Elf_Internal_Shdr *relsec;
8603 if (end - start < reloc_size)
8606 for (relsec = section_headers;
8607 relsec < section_headers + elf_header.e_shnum;
8610 unsigned long nrelas;
8611 Elf_Internal_Rela *rela, *rp;
8612 Elf_Internal_Shdr *symsec;
8613 Elf_Internal_Sym *symtab;
8614 Elf_Internal_Sym *sym;
8616 if (relsec->sh_type != SHT_RELA
8617 || SECTION_HEADER (relsec->sh_info) != section
8618 || relsec->sh_size == 0)
8621 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
8625 symsec = SECTION_HEADER (relsec->sh_link);
8626 symtab = GET_ELF_SYMBOLS (file, symsec);
8628 for (rp = rela; rp < rela + nrelas; ++rp)
8632 if (rp->r_offset >= (bfd_vma) (start - sec_data)
8633 && rp->r_offset < (bfd_vma) (end - sec_data) - reloc_size)
8634 loc = sec_data + rp->r_offset;
8640 sym = symtab + ELF32_R_SYM (rp->r_info);
8642 if (ELF32_R_SYM (rp->r_info) != 0
8643 && ELF32_ST_TYPE (sym->st_info) != STT_SECTION)
8645 warn (_("Skipping unexpected symbol type %u\n"),
8646 ELF32_ST_TYPE (sym->st_info));
8652 sym = symtab + ELF64_R_SYM (rp->r_info);
8654 if (ELF64_R_SYM (rp->r_info) != 0
8655 && ELF64_ST_TYPE (sym->st_info) != STT_SECTION)
8657 warn (_("Skipping unexpected symbol type %u\n"),
8658 ELF64_ST_TYPE (sym->st_info));
8663 byte_put (loc, rp->r_addend, reloc_size);
8674 display_debug_info (Elf_Internal_Shdr *section,
8675 unsigned char *start,
8678 unsigned char *end = start + section->sh_size;
8679 unsigned char *section_begin = start;
8681 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
8683 load_debug_str (file);
8684 load_debug_loc (file);
8688 DWARF2_Internal_CompUnit compunit;
8689 unsigned char *hdrptr;
8690 unsigned char *cu_abbrev_offset_ptr;
8691 unsigned char *tags;
8693 unsigned long cu_offset;
8695 int initial_length_size;
8699 compunit.cu_length = byte_get (hdrptr, 4);
8702 if (compunit.cu_length == 0xffffffff)
8704 compunit.cu_length = byte_get (hdrptr, 8);
8707 initial_length_size = 12;
8712 initial_length_size = 4;
8715 compunit.cu_version = byte_get (hdrptr, 2);
8718 cu_offset = start - section_begin;
8719 start += compunit.cu_length + initial_length_size;
8721 if (elf_header.e_type == ET_REL
8722 && !debug_apply_rela_addends (file, section, offset_size,
8723 section_begin, hdrptr, start))
8726 cu_abbrev_offset_ptr = hdrptr;
8727 compunit.cu_abbrev_offset = byte_get (hdrptr, offset_size);
8728 hdrptr += offset_size;
8730 compunit.cu_pointer_size = byte_get (hdrptr, 1);
8735 printf (_(" Compilation Unit @ %lx:\n"), cu_offset);
8736 printf (_(" Length: %ld\n"), compunit.cu_length);
8737 printf (_(" Version: %d\n"), compunit.cu_version);
8738 printf (_(" Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
8739 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
8741 if (compunit.cu_version != 2 && compunit.cu_version != 3)
8743 warn (_("Only version 2 and 3 DWARF debug information is currently supported.\n"));
8749 /* Read in the abbrevs used by this compilation unit. */
8751 Elf_Internal_Shdr *sec;
8752 unsigned char *begin;
8754 /* Locate the .debug_abbrev section and process it. */
8755 sec = find_section (".debug_abbrev");
8758 warn (_("Unable to locate .debug_abbrev section!\n"));
8762 begin = get_data (NULL, file, sec->sh_offset, sec->sh_size,
8763 _("debug_abbrev section data"));
8767 process_abbrev_section (begin + compunit.cu_abbrev_offset,
8768 begin + sec->sh_size);
8774 while (tags < start)
8777 unsigned long abbrev_number;
8778 abbrev_entry *entry;
8781 abbrev_number = read_leb128 (tags, & bytes_read, 0);
8784 /* A null DIE marks the end of a list of children. */
8785 if (abbrev_number == 0)
8791 /* Scan through the abbreviation list until we reach the
8793 for (entry = first_abbrev;
8794 entry && entry->entry != abbrev_number;
8795 entry = entry->next)
8800 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
8805 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
8807 (unsigned long) (tags - section_begin - bytes_read),
8809 get_TAG_name (entry->tag));
8811 for (attr = entry->first_attr; attr; attr = attr->next)
8812 tags = read_and_display_attr (attr->attribute,
8815 compunit.cu_pointer_size,
8817 compunit.cu_version);
8819 if (entry->children)
8833 display_debug_aranges (Elf_Internal_Shdr *section,
8834 unsigned char *start,
8835 FILE *file ATTRIBUTE_UNUSED)
8837 unsigned char *end = start + section->sh_size;
8839 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
8843 unsigned char *hdrptr;
8844 DWARF2_Internal_ARange arange;
8845 unsigned char *ranges;
8846 unsigned long length;
8847 unsigned long address;
8850 int initial_length_size;
8854 arange.ar_length = byte_get (hdrptr, 4);
8857 if (arange.ar_length == 0xffffffff)
8859 arange.ar_length = byte_get (hdrptr, 8);
8862 initial_length_size = 12;
8867 initial_length_size = 4;
8870 arange.ar_version = byte_get (hdrptr, 2);
8873 arange.ar_info_offset = byte_get (hdrptr, offset_size);
8874 hdrptr += offset_size;
8876 arange.ar_pointer_size = byte_get (hdrptr, 1);
8879 arange.ar_segment_size = byte_get (hdrptr, 1);
8882 if (arange.ar_version != 2 && arange.ar_version != 3)
8884 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
8888 printf (_(" Length: %ld\n"), arange.ar_length);
8889 printf (_(" Version: %d\n"), arange.ar_version);
8890 printf (_(" Offset into .debug_info: %lx\n"), arange.ar_info_offset);
8891 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
8892 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
8894 printf (_("\n Address Length\n"));
8898 /* Must pad to an alignment boundary that is twice the pointer size. */
8899 excess = (hdrptr - start) % (2 * arange.ar_pointer_size);
8901 ranges += (2 * arange.ar_pointer_size) - excess;
8905 address = byte_get (ranges, arange.ar_pointer_size);
8907 ranges += arange.ar_pointer_size;
8909 length = byte_get (ranges, arange.ar_pointer_size);
8911 ranges += arange.ar_pointer_size;
8913 /* A pair of zeros marks the end of the list. */
8914 if (address == 0 && length == 0)
8917 printf (" %8.8lx %lu\n", address, length);
8920 start += arange.ar_length + initial_length_size;
8928 typedef struct Frame_Chunk
8930 struct Frame_Chunk *next;
8931 unsigned char *chunk_start;
8933 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
8934 short int *col_type;
8937 unsigned int code_factor;
8939 unsigned long pc_begin;
8940 unsigned long pc_range;
8944 unsigned char fde_encoding;
8945 unsigned char cfa_exp;
8949 /* A marker for a col_type that means this column was never referenced
8950 in the frame info. */
8951 #define DW_CFA_unreferenced (-1)
8954 frame_need_space (Frame_Chunk *fc, int reg)
8956 int prev = fc->ncols;
8958 if (reg < fc->ncols)
8961 fc->ncols = reg + 1;
8962 fc->col_type = xrealloc (fc->col_type, fc->ncols * sizeof (short int));
8963 fc->col_offset = xrealloc (fc->col_offset, fc->ncols * sizeof (int));
8965 while (prev < fc->ncols)
8967 fc->col_type[prev] = DW_CFA_unreferenced;
8968 fc->col_offset[prev] = 0;
8974 frame_display_row (Frame_Chunk *fc, int *need_col_headers, int *max_regs)
8979 if (*max_regs < fc->ncols)
8980 *max_regs = fc->ncols;
8982 if (*need_col_headers)
8984 *need_col_headers = 0;
8986 printf (" LOC CFA ");
8988 for (r = 0; r < *max_regs; r++)
8989 if (fc->col_type[r] != DW_CFA_unreferenced)
8994 printf ("r%-4d", r);
9000 printf ("%08lx ", fc->pc_begin);
9002 strcpy (tmp, "exp");
9004 sprintf (tmp, "r%d%+d", fc->cfa_reg, fc->cfa_offset);
9005 printf ("%-8s ", tmp);
9007 for (r = 0; r < fc->ncols; r++)
9009 if (fc->col_type[r] != DW_CFA_unreferenced)
9011 switch (fc->col_type[r])
9013 case DW_CFA_undefined:
9016 case DW_CFA_same_value:
9020 sprintf (tmp, "c%+d", fc->col_offset[r]);
9022 case DW_CFA_register:
9023 sprintf (tmp, "r%d", fc->col_offset[r]);
9025 case DW_CFA_expression:
9026 strcpy (tmp, "exp");
9029 strcpy (tmp, "n/a");
9032 printf ("%-5s", tmp);
9039 size_of_encoded_value (int encoding)
9041 switch (encoding & 0x7)
9044 case 0: return is_32bit_elf ? 4 : 8;
9052 get_encoded_value (unsigned char *data, int encoding)
9054 int size = size_of_encoded_value (encoding);
9055 if (encoding & DW_EH_PE_signed)
9056 return byte_get_signed (data, size);
9058 return byte_get (data, size);
9061 #define GET(N) byte_get (start, N); start += N
9062 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
9063 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
9066 display_debug_frames (Elf_Internal_Shdr *section,
9067 unsigned char *start,
9068 FILE *file ATTRIBUTE_UNUSED)
9070 unsigned char *end = start + section->sh_size;
9071 unsigned char *section_start = start;
9072 Frame_Chunk *chunks = 0;
9073 Frame_Chunk *remembered_state = 0;
9075 int is_eh = (strcmp (SECTION_NAME (section), ".eh_frame") == 0);
9078 int addr_size = is_32bit_elf ? 4 : 8;
9080 printf (_("The section %s contains:\n"), SECTION_NAME (section));
9084 unsigned char *saved_start;
9085 unsigned char *block_end;
9086 unsigned long length;
9087 unsigned long cie_id;
9090 int need_col_headers = 1;
9091 unsigned char *augmentation_data = NULL;
9092 unsigned long augmentation_data_len = 0;
9093 int encoded_ptr_size = addr_size;
9095 int initial_length_size;
9097 saved_start = start;
9098 length = byte_get (start, 4); start += 4;
9102 printf ("\n%08lx ZERO terminator\n\n",
9103 (unsigned long)(saved_start - section_start));
9107 if (length == 0xffffffff)
9109 length = byte_get (start, 8);
9112 initial_length_size = 12;
9117 initial_length_size = 4;
9120 block_end = saved_start + length + initial_length_size;
9121 cie_id = byte_get (start, offset_size); start += offset_size;
9123 if (elf_header.e_type == ET_REL
9124 && !debug_apply_rela_addends (file, section, offset_size,
9125 section_start, start, block_end))
9128 if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
9132 fc = xmalloc (sizeof (Frame_Chunk));
9133 memset (fc, 0, sizeof (Frame_Chunk));
9137 fc->chunk_start = saved_start;
9139 fc->col_type = xmalloc (sizeof (short int));
9140 fc->col_offset = xmalloc (sizeof (int));
9141 frame_need_space (fc, max_regs-1);
9145 fc->augmentation = start;
9146 start = strchr (start, '\0') + 1;
9148 if (fc->augmentation[0] == 'z')
9150 fc->code_factor = LEB ();
9151 fc->data_factor = SLEB ();
9160 augmentation_data_len = LEB ();
9161 augmentation_data = start;
9162 start += augmentation_data_len;
9164 else if (strcmp (fc->augmentation, "eh") == 0)
9167 fc->code_factor = LEB ();
9168 fc->data_factor = SLEB ();
9180 fc->code_factor = LEB ();
9181 fc->data_factor = SLEB ();
9193 if (do_debug_frames_interp)
9194 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
9195 (unsigned long)(saved_start - section_start), length, cie_id,
9196 fc->augmentation, fc->code_factor, fc->data_factor,
9200 printf ("\n%08lx %08lx %08lx CIE\n",
9201 (unsigned long)(saved_start - section_start), length, cie_id);
9202 printf (" Version: %d\n", version);
9203 printf (" Augmentation: \"%s\"\n", fc->augmentation);
9204 printf (" Code alignment factor: %u\n", fc->code_factor);
9205 printf (" Data alignment factor: %d\n", fc->data_factor);
9206 printf (" Return address column: %d\n", fc->ra);
9208 if (augmentation_data_len)
9211 printf (" Augmentation data: ");
9212 for (i = 0; i < augmentation_data_len; ++i)
9213 printf (" %02x", augmentation_data[i]);
9219 if (augmentation_data_len)
9221 unsigned char *p, *q;
9222 p = fc->augmentation + 1;
9223 q = augmentation_data;
9230 q += 1 + size_of_encoded_value (*q);
9232 fc->fde_encoding = *q++;
9238 if (fc->fde_encoding)
9239 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
9242 frame_need_space (fc, fc->ra);
9246 unsigned char *look_for;
9247 static Frame_Chunk fde_fc;
9250 memset (fc, 0, sizeof (Frame_Chunk));
9252 look_for = is_eh ? start - 4 - cie_id : section_start + cie_id;
9254 for (cie = chunks; cie ; cie = cie->next)
9255 if (cie->chunk_start == look_for)
9260 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
9261 cie_id, saved_start);
9264 fc->col_type = xmalloc (sizeof (short int));
9265 fc->col_offset = xmalloc (sizeof (int));
9266 frame_need_space (fc, max_regs - 1);
9268 fc->augmentation = "";
9269 fc->fde_encoding = 0;
9273 fc->ncols = cie->ncols;
9274 fc->col_type = xmalloc (fc->ncols * sizeof (short int));
9275 fc->col_offset = xmalloc (fc->ncols * sizeof (int));
9276 memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
9277 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
9278 fc->augmentation = cie->augmentation;
9279 fc->code_factor = cie->code_factor;
9280 fc->data_factor = cie->data_factor;
9281 fc->cfa_reg = cie->cfa_reg;
9282 fc->cfa_offset = cie->cfa_offset;
9284 frame_need_space (fc, max_regs-1);
9285 fc->fde_encoding = cie->fde_encoding;
9288 if (fc->fde_encoding)
9289 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
9291 fc->pc_begin = get_encoded_value (start, fc->fde_encoding);
9292 if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel
9293 /* Don't adjust for ET_REL since there's invariably a pcrel
9294 reloc here, which we haven't applied. */
9295 && elf_header.e_type != ET_REL)
9296 fc->pc_begin += section->sh_addr + (start - section_start);
9297 start += encoded_ptr_size;
9298 fc->pc_range = byte_get (start, encoded_ptr_size);
9299 start += encoded_ptr_size;
9301 if (cie->augmentation[0] == 'z')
9303 augmentation_data_len = LEB ();
9304 augmentation_data = start;
9305 start += augmentation_data_len;
9308 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
9309 (unsigned long)(saved_start - section_start), length, cie_id,
9310 (unsigned long)(cie->chunk_start - section_start),
9311 fc->pc_begin, fc->pc_begin + fc->pc_range);
9312 if (! do_debug_frames_interp && augmentation_data_len)
9315 printf (" Augmentation data: ");
9316 for (i = 0; i < augmentation_data_len; ++i)
9317 printf (" %02x", augmentation_data[i]);
9323 /* At this point, fc is the current chunk, cie (if any) is set, and we're
9324 about to interpret instructions for the chunk. */
9325 /* ??? At present we need to do this always, since this sizes the
9326 fc->col_type and fc->col_offset arrays, which we write into always.
9327 We should probably split the interpreted and non-interpreted bits
9328 into two different routines, since there's so much that doesn't
9329 really overlap between them. */
9330 if (1 || do_debug_frames_interp)
9332 /* Start by making a pass over the chunk, allocating storage
9333 and taking note of what registers are used. */
9334 unsigned char *tmp = start;
9336 while (start < block_end)
9339 unsigned long reg, tmp;
9346 /* Warning: if you add any more cases to this switch, be
9347 sure to add them to the corresponding switch below. */
9350 case DW_CFA_advance_loc:
9354 frame_need_space (fc, opa);
9355 fc->col_type[opa] = DW_CFA_undefined;
9357 case DW_CFA_restore:
9358 frame_need_space (fc, opa);
9359 fc->col_type[opa] = DW_CFA_undefined;
9361 case DW_CFA_set_loc:
9362 start += encoded_ptr_size;
9364 case DW_CFA_advance_loc1:
9367 case DW_CFA_advance_loc2:
9370 case DW_CFA_advance_loc4:
9373 case DW_CFA_offset_extended:
9374 reg = LEB (); LEB ();
9375 frame_need_space (fc, reg);
9376 fc->col_type[reg] = DW_CFA_undefined;
9378 case DW_CFA_restore_extended:
9380 frame_need_space (fc, reg);
9381 fc->col_type[reg] = DW_CFA_undefined;
9383 case DW_CFA_undefined:
9385 frame_need_space (fc, reg);
9386 fc->col_type[reg] = DW_CFA_undefined;
9388 case DW_CFA_same_value:
9390 frame_need_space (fc, reg);
9391 fc->col_type[reg] = DW_CFA_undefined;
9393 case DW_CFA_register:
9394 reg = LEB (); LEB ();
9395 frame_need_space (fc, reg);
9396 fc->col_type[reg] = DW_CFA_undefined;
9398 case DW_CFA_def_cfa:
9401 case DW_CFA_def_cfa_register:
9404 case DW_CFA_def_cfa_offset:
9407 case DW_CFA_def_cfa_expression:
9411 case DW_CFA_expression:
9415 frame_need_space (fc, reg);
9416 fc->col_type[reg] = DW_CFA_undefined;
9418 case DW_CFA_offset_extended_sf:
9419 reg = LEB (); SLEB ();
9420 frame_need_space (fc, reg);
9421 fc->col_type[reg] = DW_CFA_undefined;
9423 case DW_CFA_def_cfa_sf:
9426 case DW_CFA_def_cfa_offset_sf:
9429 case DW_CFA_MIPS_advance_loc8:
9432 case DW_CFA_GNU_args_size:
9435 case DW_CFA_GNU_negative_offset_extended:
9436 reg = LEB (); LEB ();
9437 frame_need_space (fc, reg);
9438 fc->col_type[reg] = DW_CFA_undefined;
9447 /* Now we know what registers are used, make a second pass over
9448 the chunk, this time actually printing out the info. */
9450 while (start < block_end)
9453 unsigned long ul, reg, roffs;
9462 /* Warning: if you add any more cases to this switch, be
9463 sure to add them to the corresponding switch above. */
9466 case DW_CFA_advance_loc:
9467 if (do_debug_frames_interp)
9468 frame_display_row (fc, &need_col_headers, &max_regs);
9470 printf (" DW_CFA_advance_loc: %d to %08lx\n",
9471 opa * fc->code_factor,
9472 fc->pc_begin + opa * fc->code_factor);
9473 fc->pc_begin += opa * fc->code_factor;
9478 if (! do_debug_frames_interp)
9479 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
9480 opa, roffs * fc->data_factor);
9481 fc->col_type[opa] = DW_CFA_offset;
9482 fc->col_offset[opa] = roffs * fc->data_factor;
9485 case DW_CFA_restore:
9486 if (! do_debug_frames_interp)
9487 printf (" DW_CFA_restore: r%d\n", opa);
9488 fc->col_type[opa] = cie->col_type[opa];
9489 fc->col_offset[opa] = cie->col_offset[opa];
9492 case DW_CFA_set_loc:
9493 vma = get_encoded_value (start, fc->fde_encoding);
9494 if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel
9495 && elf_header.e_type != ET_REL)
9496 vma += section->sh_addr + (start - section_start);
9497 start += encoded_ptr_size;
9498 if (do_debug_frames_interp)
9499 frame_display_row (fc, &need_col_headers, &max_regs);
9501 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma);
9505 case DW_CFA_advance_loc1:
9506 ofs = byte_get (start, 1); start += 1;
9507 if (do_debug_frames_interp)
9508 frame_display_row (fc, &need_col_headers, &max_regs);
9510 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
9511 ofs * fc->code_factor,
9512 fc->pc_begin + ofs * fc->code_factor);
9513 fc->pc_begin += ofs * fc->code_factor;
9516 case DW_CFA_advance_loc2:
9517 ofs = byte_get (start, 2); start += 2;
9518 if (do_debug_frames_interp)
9519 frame_display_row (fc, &need_col_headers, &max_regs);
9521 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
9522 ofs * fc->code_factor,
9523 fc->pc_begin + ofs * fc->code_factor);
9524 fc->pc_begin += ofs * fc->code_factor;
9527 case DW_CFA_advance_loc4:
9528 ofs = byte_get (start, 4); start += 4;
9529 if (do_debug_frames_interp)
9530 frame_display_row (fc, &need_col_headers, &max_regs);
9532 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
9533 ofs * fc->code_factor,
9534 fc->pc_begin + ofs * fc->code_factor);
9535 fc->pc_begin += ofs * fc->code_factor;
9538 case DW_CFA_offset_extended:
9541 if (! do_debug_frames_interp)
9542 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
9543 reg, roffs * fc->data_factor);
9544 fc->col_type[reg] = DW_CFA_offset;
9545 fc->col_offset[reg] = roffs * fc->data_factor;
9548 case DW_CFA_restore_extended:
9550 if (! do_debug_frames_interp)
9551 printf (" DW_CFA_restore_extended: r%ld\n", reg);
9552 fc->col_type[reg] = cie->col_type[reg];
9553 fc->col_offset[reg] = cie->col_offset[reg];
9556 case DW_CFA_undefined:
9558 if (! do_debug_frames_interp)
9559 printf (" DW_CFA_undefined: r%ld\n", reg);
9560 fc->col_type[reg] = DW_CFA_undefined;
9561 fc->col_offset[reg] = 0;
9564 case DW_CFA_same_value:
9566 if (! do_debug_frames_interp)
9567 printf (" DW_CFA_same_value: r%ld\n", reg);
9568 fc->col_type[reg] = DW_CFA_same_value;
9569 fc->col_offset[reg] = 0;
9572 case DW_CFA_register:
9575 if (! do_debug_frames_interp)
9576 printf (" DW_CFA_register: r%ld in r%ld\n", reg, roffs);
9577 fc->col_type[reg] = DW_CFA_register;
9578 fc->col_offset[reg] = roffs;
9581 case DW_CFA_remember_state:
9582 if (! do_debug_frames_interp)
9583 printf (" DW_CFA_remember_state\n");
9584 rs = xmalloc (sizeof (Frame_Chunk));
9585 rs->ncols = fc->ncols;
9586 rs->col_type = xmalloc (rs->ncols * sizeof (short int));
9587 rs->col_offset = xmalloc (rs->ncols * sizeof (int));
9588 memcpy (rs->col_type, fc->col_type, rs->ncols);
9589 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
9590 rs->next = remembered_state;
9591 remembered_state = rs;
9594 case DW_CFA_restore_state:
9595 if (! do_debug_frames_interp)
9596 printf (" DW_CFA_restore_state\n");
9597 rs = remembered_state;
9600 remembered_state = rs->next;
9601 frame_need_space (fc, rs->ncols-1);
9602 memcpy (fc->col_type, rs->col_type, rs->ncols);
9603 memcpy (fc->col_offset, rs->col_offset,
9604 rs->ncols * sizeof (int));
9605 free (rs->col_type);
9606 free (rs->col_offset);
9609 else if (do_debug_frames_interp)
9610 printf ("Mismatched DW_CFA_restore_state\n");
9613 case DW_CFA_def_cfa:
9614 fc->cfa_reg = LEB ();
9615 fc->cfa_offset = LEB ();
9617 if (! do_debug_frames_interp)
9618 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
9619 fc->cfa_reg, fc->cfa_offset);
9622 case DW_CFA_def_cfa_register:
9623 fc->cfa_reg = LEB ();
9625 if (! do_debug_frames_interp)
9626 printf (" DW_CFA_def_cfa_reg: r%d\n", fc->cfa_reg);
9629 case DW_CFA_def_cfa_offset:
9630 fc->cfa_offset = LEB ();
9631 if (! do_debug_frames_interp)
9632 printf (" DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
9636 if (! do_debug_frames_interp)
9637 printf (" DW_CFA_nop\n");
9640 case DW_CFA_def_cfa_expression:
9642 if (! do_debug_frames_interp)
9644 printf (" DW_CFA_def_cfa_expression (");
9645 decode_location_expression (start, addr_size, ul);
9652 case DW_CFA_expression:
9655 if (! do_debug_frames_interp)
9657 printf (" DW_CFA_expression: r%ld (", reg);
9658 decode_location_expression (start, addr_size, ul);
9661 fc->col_type[reg] = DW_CFA_expression;
9665 case DW_CFA_offset_extended_sf:
9668 frame_need_space (fc, reg);
9669 if (! do_debug_frames_interp)
9670 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
9671 reg, l * fc->data_factor);
9672 fc->col_type[reg] = DW_CFA_offset;
9673 fc->col_offset[reg] = l * fc->data_factor;
9676 case DW_CFA_def_cfa_sf:
9677 fc->cfa_reg = LEB ();
9678 fc->cfa_offset = SLEB ();
9680 if (! do_debug_frames_interp)
9681 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
9682 fc->cfa_reg, fc->cfa_offset);
9685 case DW_CFA_def_cfa_offset_sf:
9686 fc->cfa_offset = SLEB ();
9687 if (! do_debug_frames_interp)
9688 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc->cfa_offset);
9691 case DW_CFA_MIPS_advance_loc8:
9692 ofs = byte_get (start, 8); start += 8;
9693 if (do_debug_frames_interp)
9694 frame_display_row (fc, &need_col_headers, &max_regs);
9696 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
9697 ofs * fc->code_factor,
9698 fc->pc_begin + ofs * fc->code_factor);
9699 fc->pc_begin += ofs * fc->code_factor;
9702 case DW_CFA_GNU_window_save:
9703 if (! do_debug_frames_interp)
9704 printf (" DW_CFA_GNU_window_save\n");
9707 case DW_CFA_GNU_args_size:
9709 if (! do_debug_frames_interp)
9710 printf (" DW_CFA_GNU_args_size: %ld\n", ul);
9713 case DW_CFA_GNU_negative_offset_extended:
9716 frame_need_space (fc, reg);
9717 if (! do_debug_frames_interp)
9718 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
9719 reg, l * fc->data_factor);
9720 fc->col_type[reg] = DW_CFA_offset;
9721 fc->col_offset[reg] = l * fc->data_factor;
9725 fprintf (stderr, "unsupported or unknown DW_CFA_%d\n", op);
9730 if (do_debug_frames_interp)
9731 frame_display_row (fc, &need_col_headers, &max_regs);
9746 display_debug_not_supported (Elf_Internal_Shdr *section,
9747 unsigned char *start ATTRIBUTE_UNUSED,
9748 FILE *file ATTRIBUTE_UNUSED)
9750 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
9751 SECTION_NAME (section));
9756 /* A structure containing the name of a debug section
9757 and a pointer to a function that can decode it. */
9760 const char *const name;
9761 int (*display) (Elf_Internal_Shdr *, unsigned char *, FILE *);
9765 { ".debug_abbrev", display_debug_abbrev },
9766 { ".debug_aranges", display_debug_aranges },
9767 { ".debug_frame", display_debug_frames },
9768 { ".debug_info", display_debug_info },
9769 { ".debug_line", display_debug_lines },
9770 { ".debug_pubnames", display_debug_pubnames },
9771 { ".eh_frame", display_debug_frames },
9772 { ".debug_macinfo", display_debug_macinfo },
9773 { ".debug_str", display_debug_str },
9774 { ".debug_loc", display_debug_loc },
9775 { ".debug_pubtypes", display_debug_pubnames },
9776 { ".debug_ranges", display_debug_not_supported },
9777 { ".debug_static_func", display_debug_not_supported },
9778 { ".debug_static_vars", display_debug_not_supported },
9779 { ".debug_types", display_debug_not_supported },
9780 { ".debug_weaknames", display_debug_not_supported }
9784 display_debug_section (Elf_Internal_Shdr *section, FILE *file)
9786 char *name = SECTION_NAME (section);
9787 bfd_size_type length;
9788 unsigned char *start;
9791 length = section->sh_size;
9794 printf (_("\nSection '%s' has no debugging data.\n"), name);
9798 start = get_data (NULL, file, section->sh_offset, length,
9799 _("debug section data"));
9803 /* See if we know how to display the contents of this section. */
9804 if (strncmp (name, ".gnu.linkonce.wi.", 17) == 0)
9805 name = ".debug_info";
9807 for (i = NUM_ELEM (debug_displays); i--;)
9808 if (strcmp (debug_displays[i].name, name) == 0)
9810 debug_displays[i].display (section, start, file);
9815 printf (_("Unrecognized debug section: %s\n"), name);
9819 /* If we loaded in the abbrev section at some point,
9820 we must release it here. */
9827 process_section_contents (FILE *file)
9829 Elf_Internal_Shdr *section;
9835 for (i = 0, section = section_headers;
9836 i < elf_header.e_shnum && i < num_dump_sects;
9839 #ifdef SUPPORT_DISASSEMBLY
9840 if (dump_sects[i] & DISASS_DUMP)
9841 disassemble_section (section, file);
9843 if (dump_sects[i] & HEX_DUMP)
9844 dump_section (section, file);
9846 if (dump_sects[i] & DEBUG_DUMP)
9847 display_debug_section (section, file);
9850 if (i < num_dump_sects)
9851 warn (_("Some sections were not dumped because they do not exist!\n"));
9857 process_mips_fpe_exception (int mask)
9862 if (mask & OEX_FPU_INEX)
9863 fputs ("INEX", stdout), first = 0;
9864 if (mask & OEX_FPU_UFLO)
9865 printf ("%sUFLO", first ? "" : "|"), first = 0;
9866 if (mask & OEX_FPU_OFLO)
9867 printf ("%sOFLO", first ? "" : "|"), first = 0;
9868 if (mask & OEX_FPU_DIV0)
9869 printf ("%sDIV0", first ? "" : "|"), first = 0;
9870 if (mask & OEX_FPU_INVAL)
9871 printf ("%sINVAL", first ? "" : "|");
9874 fputs ("0", stdout);
9878 process_mips_specific (FILE *file)
9880 Elf_Internal_Dyn *entry;
9881 size_t liblist_offset = 0;
9882 size_t liblistno = 0;
9883 size_t conflictsno = 0;
9884 size_t options_offset = 0;
9885 size_t conflicts_offset = 0;
9887 /* We have a lot of special sections. Thanks SGI! */
9888 if (dynamic_section == NULL)
9889 /* No information available. */
9892 for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
9893 switch (entry->d_tag)
9895 case DT_MIPS_LIBLIST:
9897 = offset_from_vma (file, entry->d_un.d_val,
9898 liblistno * sizeof (Elf32_External_Lib));
9900 case DT_MIPS_LIBLISTNO:
9901 liblistno = entry->d_un.d_val;
9903 case DT_MIPS_OPTIONS:
9904 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
9906 case DT_MIPS_CONFLICT:
9908 = offset_from_vma (file, entry->d_un.d_val,
9909 conflictsno * sizeof (Elf32_External_Conflict));
9911 case DT_MIPS_CONFLICTNO:
9912 conflictsno = entry->d_un.d_val;
9918 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
9920 Elf32_External_Lib *elib;
9923 elib = get_data (NULL, file, liblist_offset,
9924 liblistno * sizeof (Elf32_External_Lib),
9928 printf ("\nSection '.liblist' contains %lu entries:\n",
9929 (unsigned long) liblistno);
9930 fputs (" Library Time Stamp Checksum Version Flags\n",
9933 for (cnt = 0; cnt < liblistno; ++cnt)
9940 liblist.l_name = BYTE_GET (elib[cnt].l_name);
9941 time = BYTE_GET (elib[cnt].l_time_stamp);
9942 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
9943 liblist.l_version = BYTE_GET (elib[cnt].l_version);
9944 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
9946 tmp = gmtime (&time);
9947 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
9948 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9949 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9951 printf ("%3lu: ", (unsigned long) cnt);
9952 print_symbol (20, dynamic_strings + liblist.l_name);
9953 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
9956 if (liblist.l_flags == 0)
9967 { " EXACT_MATCH", LL_EXACT_MATCH },
9968 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
9969 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
9970 { " EXPORTS", LL_EXPORTS },
9971 { " DELAY_LOAD", LL_DELAY_LOAD },
9972 { " DELTA", LL_DELTA }
9974 int flags = liblist.l_flags;
9978 fcnt < sizeof (l_flags_vals) / sizeof (l_flags_vals[0]);
9980 if ((flags & l_flags_vals[fcnt].bit) != 0)
9982 fputs (l_flags_vals[fcnt].name, stdout);
9983 flags ^= l_flags_vals[fcnt].bit;
9986 printf (" %#x", (unsigned int) flags);
9996 if (options_offset != 0)
9998 Elf_External_Options *eopt;
9999 Elf_Internal_Shdr *sect = section_headers;
10000 Elf_Internal_Options *iopt;
10001 Elf_Internal_Options *option;
10005 /* Find the section header so that we get the size. */
10006 while (sect->sh_type != SHT_MIPS_OPTIONS)
10009 eopt = get_data (NULL, file, options_offset, sect->sh_size,
10013 iopt = malloc ((sect->sh_size / sizeof (eopt)) * sizeof (*iopt));
10016 error (_("Out of memory"));
10023 while (offset < sect->sh_size)
10025 Elf_External_Options *eoption;
10027 eoption = (Elf_External_Options *) ((char *) eopt + offset);
10029 option->kind = BYTE_GET (eoption->kind);
10030 option->size = BYTE_GET (eoption->size);
10031 option->section = BYTE_GET (eoption->section);
10032 option->info = BYTE_GET (eoption->info);
10034 offset += option->size;
10040 printf (_("\nSection '%s' contains %d entries:\n"),
10041 SECTION_NAME (sect), cnt);
10049 switch (option->kind)
10052 /* This shouldn't happen. */
10053 printf (" NULL %d %lx", option->section, option->info);
10056 printf (" REGINFO ");
10057 if (elf_header.e_machine == EM_MIPS)
10060 Elf32_External_RegInfo *ereg;
10061 Elf32_RegInfo reginfo;
10063 ereg = (Elf32_External_RegInfo *) (option + 1);
10064 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
10065 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
10066 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
10067 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
10068 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
10069 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
10071 printf ("GPR %08lx GP 0x%lx\n",
10072 reginfo.ri_gprmask,
10073 (unsigned long) reginfo.ri_gp_value);
10074 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
10075 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
10076 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
10081 Elf64_External_RegInfo *ereg;
10082 Elf64_Internal_RegInfo reginfo;
10084 ereg = (Elf64_External_RegInfo *) (option + 1);
10085 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
10086 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
10087 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
10088 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
10089 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
10090 reginfo.ri_gp_value = BYTE_GET8 (ereg->ri_gp_value);
10092 printf ("GPR %08lx GP 0x",
10093 reginfo.ri_gprmask);
10094 printf_vma (reginfo.ri_gp_value);
10097 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
10098 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
10099 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
10103 case ODK_EXCEPTIONS:
10104 fputs (" EXCEPTIONS fpe_min(", stdout);
10105 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
10106 fputs (") fpe_max(", stdout);
10107 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
10108 fputs (")", stdout);
10110 if (option->info & OEX_PAGE0)
10111 fputs (" PAGE0", stdout);
10112 if (option->info & OEX_SMM)
10113 fputs (" SMM", stdout);
10114 if (option->info & OEX_FPDBUG)
10115 fputs (" FPDBUG", stdout);
10116 if (option->info & OEX_DISMISS)
10117 fputs (" DISMISS", stdout);
10120 fputs (" PAD ", stdout);
10121 if (option->info & OPAD_PREFIX)
10122 fputs (" PREFIX", stdout);
10123 if (option->info & OPAD_POSTFIX)
10124 fputs (" POSTFIX", stdout);
10125 if (option->info & OPAD_SYMBOL)
10126 fputs (" SYMBOL", stdout);
10129 fputs (" HWPATCH ", stdout);
10130 if (option->info & OHW_R4KEOP)
10131 fputs (" R4KEOP", stdout);
10132 if (option->info & OHW_R8KPFETCH)
10133 fputs (" R8KPFETCH", stdout);
10134 if (option->info & OHW_R5KEOP)
10135 fputs (" R5KEOP", stdout);
10136 if (option->info & OHW_R5KCVTL)
10137 fputs (" R5KCVTL", stdout);
10140 fputs (" FILL ", stdout);
10141 /* XXX Print content of info word? */
10144 fputs (" TAGS ", stdout);
10145 /* XXX Print content of info word? */
10148 fputs (" HWAND ", stdout);
10149 if (option->info & OHWA0_R4KEOP_CHECKED)
10150 fputs (" R4KEOP_CHECKED", stdout);
10151 if (option->info & OHWA0_R4KEOP_CLEAN)
10152 fputs (" R4KEOP_CLEAN", stdout);
10155 fputs (" HWOR ", stdout);
10156 if (option->info & OHWA0_R4KEOP_CHECKED)
10157 fputs (" R4KEOP_CHECKED", stdout);
10158 if (option->info & OHWA0_R4KEOP_CLEAN)
10159 fputs (" R4KEOP_CLEAN", stdout);
10162 printf (" GP_GROUP %#06lx self-contained %#06lx",
10163 option->info & OGP_GROUP,
10164 (option->info & OGP_SELF) >> 16);
10167 printf (" IDENT %#06lx self-contained %#06lx",
10168 option->info & OGP_GROUP,
10169 (option->info & OGP_SELF) >> 16);
10172 /* This shouldn't happen. */
10173 printf (" %3d ??? %d %lx",
10174 option->kind, option->section, option->info);
10178 len = sizeof (*eopt);
10179 while (len < option->size)
10180 if (((char *) option)[len] >= ' '
10181 && ((char *) option)[len] < 0x7f)
10182 printf ("%c", ((char *) option)[len++]);
10184 printf ("\\%03o", ((char *) option)[len++]);
10186 fputs ("\n", stdout);
10194 if (conflicts_offset != 0 && conflictsno != 0)
10196 Elf32_Conflict *iconf;
10199 if (dynamic_symbols == NULL)
10201 error (_("conflict list found without a dynamic symbol table"));
10205 iconf = malloc (conflictsno * sizeof (*iconf));
10208 error (_("Out of memory"));
10214 Elf32_External_Conflict *econf32;
10216 econf32 = get_data (NULL, file, conflicts_offset,
10217 conflictsno * sizeof (*econf32), _("conflict"));
10221 for (cnt = 0; cnt < conflictsno; ++cnt)
10222 iconf[cnt] = BYTE_GET (econf32[cnt]);
10228 Elf64_External_Conflict *econf64;
10230 econf64 = get_data (NULL, file, conflicts_offset,
10231 conflictsno * sizeof (*econf64), _("conflict"));
10235 for (cnt = 0; cnt < conflictsno; ++cnt)
10236 iconf[cnt] = BYTE_GET (econf64[cnt]);
10241 printf (_("\nSection '.conflict' contains %lu entries:\n"),
10242 (unsigned long) conflictsno);
10243 puts (_(" Num: Index Value Name"));
10245 for (cnt = 0; cnt < conflictsno; ++cnt)
10247 Elf_Internal_Sym *psym = & dynamic_symbols[iconf[cnt]];
10249 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
10250 print_vma (psym->st_value, FULL_HEX);
10252 print_symbol (25, dynamic_strings + psym->st_name);
10263 process_gnu_liblist (FILE *file)
10265 Elf_Internal_Shdr *section, *string_sec;
10266 Elf32_External_Lib *elib;
10274 for (i = 0, section = section_headers;
10275 i < elf_header.e_shnum;
10278 switch (section->sh_type)
10280 case SHT_GNU_LIBLIST:
10281 elib = get_data (NULL, file, section->sh_offset, section->sh_size,
10286 string_sec = SECTION_HEADER (section->sh_link);
10288 strtab = get_data (NULL, file, string_sec->sh_offset,
10289 string_sec->sh_size, _("liblist string table"));
10292 || section->sh_entsize != sizeof (Elf32_External_Lib))
10298 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
10299 SECTION_NAME (section),
10300 (long) (section->sh_size / sizeof (Elf32_External_Lib)));
10302 puts (" Library Time Stamp Checksum Version Flags");
10304 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
10312 liblist.l_name = BYTE_GET (elib[cnt].l_name);
10313 time = BYTE_GET (elib[cnt].l_time_stamp);
10314 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
10315 liblist.l_version = BYTE_GET (elib[cnt].l_version);
10316 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
10318 tmp = gmtime (&time);
10319 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
10320 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10321 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10323 printf ("%3lu: ", (unsigned long) cnt);
10325 printf ("%-20s", strtab + liblist.l_name);
10327 printf ("%-20.20s", strtab + liblist.l_name);
10328 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
10329 liblist.l_version, liblist.l_flags);
10339 static const char *
10340 get_note_type (unsigned e_type)
10342 static char buff[64];
10346 case NT_AUXV: return _("NT_AUXV (auxiliary vector)");
10347 case NT_PRSTATUS: return _("NT_PRSTATUS (prstatus structure)");
10348 case NT_FPREGSET: return _("NT_FPREGSET (floating point registers)");
10349 case NT_PRPSINFO: return _("NT_PRPSINFO (prpsinfo structure)");
10350 case NT_TASKSTRUCT: return _("NT_TASKSTRUCT (task structure)");
10351 case NT_PRXFPREG: return _("NT_PRXFPREG (user_xfpregs structure)");
10352 case NT_PSTATUS: return _("NT_PSTATUS (pstatus structure)");
10353 case NT_FPREGS: return _("NT_FPREGS (floating point registers)");
10354 case NT_PSINFO: return _("NT_PSINFO (psinfo structure)");
10355 case NT_LWPSTATUS: return _("NT_LWPSTATUS (lwpstatus_t structure)");
10356 case NT_LWPSINFO: return _("NT_LWPSINFO (lwpsinfo_t structure)");
10357 case NT_WIN32PSTATUS: return _("NT_WIN32PSTATUS (win32_pstatus structure)");
10359 sprintf (buff, _("Unknown note type: (0x%08x)"), e_type);
10364 static const char *
10365 get_netbsd_elfcore_note_type (unsigned e_type)
10367 static char buff[64];
10369 if (e_type == NT_NETBSDCORE_PROCINFO)
10371 /* NetBSD core "procinfo" structure. */
10372 return _("NetBSD procinfo structure");
10375 /* As of Jan 2002 there are no other machine-independent notes
10376 defined for NetBSD core files. If the note type is less
10377 than the start of the machine-dependent note types, we don't
10380 if (e_type < NT_NETBSDCORE_FIRSTMACH)
10382 sprintf (buff, _("Unknown note type: (0x%08x)"), e_type);
10386 switch (elf_header.e_machine)
10388 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
10389 and PT_GETFPREGS == mach+2. */
10394 case EM_SPARC32PLUS:
10398 case NT_NETBSDCORE_FIRSTMACH+0:
10399 return _("PT_GETREGS (reg structure)");
10400 case NT_NETBSDCORE_FIRSTMACH+2:
10401 return _("PT_GETFPREGS (fpreg structure)");
10407 /* On all other arch's, PT_GETREGS == mach+1 and
10408 PT_GETFPREGS == mach+3. */
10412 case NT_NETBSDCORE_FIRSTMACH+1:
10413 return _("PT_GETREGS (reg structure)");
10414 case NT_NETBSDCORE_FIRSTMACH+3:
10415 return _("PT_GETFPREGS (fpreg structure)");
10421 sprintf (buff, _("PT_FIRSTMACH+%d"), e_type - NT_NETBSDCORE_FIRSTMACH);
10425 /* Note that by the ELF standard, the name field is already null byte
10426 terminated, and namesz includes the terminating null byte.
10427 I.E. the value of namesz for the name "FSF" is 4.
10429 If the value of namesz is zero, there is no name present. */
10431 process_note (Elf_Internal_Note *pnote)
10435 if (pnote->namesz == 0)
10437 /* If there is no note name, then use the default set of
10438 note type strings. */
10439 nt = get_note_type (pnote->type);
10441 else if (strncmp (pnote->namedata, "NetBSD-CORE", 11) == 0)
10443 /* NetBSD-specific core file notes. */
10444 nt = get_netbsd_elfcore_note_type (pnote->type);
10448 /* Don't recognize this note name; just use the default set of
10449 note type strings. */
10450 nt = get_note_type (pnote->type);
10453 printf (" %s\t\t0x%08lx\t%s\n",
10454 pnote->namesz ? pnote->namedata : "(NONE)",
10455 pnote->descsz, nt);
10461 process_corefile_note_segment (FILE *file, bfd_vma offset, bfd_vma length)
10463 Elf_External_Note *pnotes;
10464 Elf_External_Note *external;
10470 pnotes = get_data (NULL, file, offset, length, _("notes"));
10476 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
10477 (unsigned long) offset, (unsigned long) length);
10478 printf (_(" Owner\t\tData size\tDescription\n"));
10480 while (external < (Elf_External_Note *)((char *) pnotes + length))
10482 Elf_External_Note *next;
10483 Elf_Internal_Note inote;
10486 inote.type = BYTE_GET (external->type);
10487 inote.namesz = BYTE_GET (external->namesz);
10488 inote.namedata = external->name;
10489 inote.descsz = BYTE_GET (external->descsz);
10490 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
10491 inote.descpos = offset + (inote.descdata - (char *) pnotes);
10493 next = (Elf_External_Note *)(inote.descdata + align_power (inote.descsz, 2));
10495 if (((char *) next) > (((char *) pnotes) + length))
10497 warn (_("corrupt note found at offset %x into core notes\n"),
10498 ((char *) external) - ((char *) pnotes));
10499 warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
10500 inote.type, inote.namesz, inote.descsz);
10506 /* Verify that name is null terminated. It appears that at least
10507 one version of Linux (RedHat 6.0) generates corefiles that don't
10508 comply with the ELF spec by failing to include the null byte in
10510 if (inote.namedata[inote.namesz] != '\0')
10512 temp = malloc (inote.namesz + 1);
10516 error (_("Out of memory\n"));
10521 strncpy (temp, inote.namedata, inote.namesz);
10522 temp[inote.namesz] = 0;
10524 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
10525 inote.namedata = temp;
10528 res &= process_note (& inote);
10543 process_corefile_note_segments (FILE *file)
10545 Elf_Internal_Phdr *segment;
10549 if (! get_program_headers (file))
10552 for (i = 0, segment = program_headers;
10553 i < elf_header.e_phnum;
10556 if (segment->p_type == PT_NOTE)
10557 res &= process_corefile_note_segment (file,
10558 (bfd_vma) segment->p_offset,
10559 (bfd_vma) segment->p_filesz);
10566 process_corefile_contents (FILE *file)
10568 /* If we have not been asked to display the notes then do nothing. */
10572 /* If file is not a core file then exit. */
10573 if (elf_header.e_type != ET_CORE)
10576 /* No program headers means no NOTE segment. */
10577 if (elf_header.e_phnum == 0)
10579 printf (_("No note segments present in the core file.\n"));
10583 return process_corefile_note_segments (file);
10587 process_arch_specific (FILE *file)
10592 switch (elf_header.e_machine)
10595 case EM_MIPS_RS3_LE:
10596 return process_mips_specific (file);
10605 get_file_header (FILE *file)
10607 /* Read in the identity array. */
10608 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
10611 /* Determine how to read the rest of the header. */
10612 switch (elf_header.e_ident[EI_DATA])
10614 default: /* fall through */
10615 case ELFDATANONE: /* fall through */
10617 byte_get = byte_get_little_endian;
10618 byte_put = byte_put_little_endian;
10621 byte_get = byte_get_big_endian;
10622 byte_put = byte_put_big_endian;
10626 /* For now we only support 32 bit and 64 bit ELF files. */
10627 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
10629 /* Read in the rest of the header. */
10632 Elf32_External_Ehdr ehdr32;
10634 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
10637 elf_header.e_type = BYTE_GET (ehdr32.e_type);
10638 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
10639 elf_header.e_version = BYTE_GET (ehdr32.e_version);
10640 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
10641 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
10642 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
10643 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
10644 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
10645 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
10646 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
10647 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
10648 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
10649 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
10653 Elf64_External_Ehdr ehdr64;
10655 /* If we have been compiled with sizeof (bfd_vma) == 4, then
10656 we will not be able to cope with the 64bit data found in
10657 64 ELF files. Detect this now and abort before we start
10658 overwriting things. */
10659 if (sizeof (bfd_vma) < 8)
10661 error (_("This instance of readelf has been built without support for a\n\
10662 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10666 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
10669 elf_header.e_type = BYTE_GET (ehdr64.e_type);
10670 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
10671 elf_header.e_version = BYTE_GET (ehdr64.e_version);
10672 elf_header.e_entry = BYTE_GET8 (ehdr64.e_entry);
10673 elf_header.e_phoff = BYTE_GET8 (ehdr64.e_phoff);
10674 elf_header.e_shoff = BYTE_GET8 (ehdr64.e_shoff);
10675 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
10676 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
10677 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
10678 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
10679 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
10680 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
10681 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
10684 if (elf_header.e_shoff)
10686 /* There may be some extensions in the first section header. Don't
10687 bomb if we can't read it. */
10689 get_32bit_section_headers (file, 1);
10691 get_64bit_section_headers (file, 1);
10697 /* Process one ELF object file according to the command line options.
10698 This file may actually be stored in an archive. The file is
10699 positioned at the start of the ELF object. */
10702 process_object (char *file_name, FILE *file)
10706 if (! get_file_header (file))
10708 error (_("%s: Failed to read file header\n"), file_name);
10712 /* Initialise per file variables. */
10713 for (i = NUM_ELEM (version_info); i--;)
10714 version_info[i] = 0;
10716 for (i = NUM_ELEM (dynamic_info); i--;)
10717 dynamic_info[i] = 0;
10719 /* Process the file. */
10721 printf (_("\nFile: %s\n"), file_name);
10723 if (! process_file_header ())
10726 if (! process_section_headers (file)
10727 || ! process_section_groups (file))
10729 /* Without loaded section headers and section groups we
10730 cannot process lots of things. */
10731 do_unwind = do_version = do_dump = do_arch = 0;
10733 if (! do_using_dynamic)
10734 do_syms = do_reloc = 0;
10737 if (process_program_headers (file))
10738 process_dynamic_section (file);
10740 process_relocs (file);
10742 process_unwind (file);
10744 process_symbol_table (file);
10746 process_syminfo (file);
10748 process_version_sections (file);
10750 process_section_contents (file);
10752 process_corefile_contents (file);
10754 process_gnu_liblist (file);
10756 process_arch_specific (file);
10758 if (program_headers)
10760 free (program_headers);
10761 program_headers = NULL;
10764 if (section_headers)
10766 free (section_headers);
10767 section_headers = NULL;
10772 free (string_table);
10773 string_table = NULL;
10774 string_table_length = 0;
10777 if (dynamic_strings)
10779 free (dynamic_strings);
10780 dynamic_strings = NULL;
10783 if (dynamic_symbols)
10785 free (dynamic_symbols);
10786 dynamic_symbols = NULL;
10787 num_dynamic_syms = 0;
10790 if (dynamic_syminfo)
10792 free (dynamic_syminfo);
10793 dynamic_syminfo = NULL;
10796 if (section_headers_groups)
10798 free (section_headers_groups);
10799 section_headers_groups = NULL;
10802 if (section_groups)
10804 struct group_list *g, *next;
10806 for (i = 0; i < group_count; i++)
10808 for (g = section_groups [i].root; g != NULL; g = next)
10815 free (section_groups);
10816 section_groups = NULL;
10822 /* Process an ELF archive. The file is positioned just after the
10826 process_archive (char *file_name, FILE *file)
10828 struct ar_hdr arhdr;
10830 unsigned long size;
10831 char *longnames = NULL;
10832 unsigned long longnames_size = 0;
10833 size_t file_name_size;
10838 got = fread (&arhdr, 1, sizeof arhdr, file);
10839 if (got != sizeof arhdr)
10844 error (_("%s: failed to read archive header\n"), file_name);
10848 if (memcmp (arhdr.ar_name, "/ ", 16) == 0)
10850 /* This is the archive symbol table. Skip it.
10851 FIXME: We should have an option to dump it. */
10852 size = strtoul (arhdr.ar_size, NULL, 10);
10853 if (fseek (file, size + (size & 1), SEEK_CUR) != 0)
10855 error (_("%s: failed to skip archive symbol table\n"), file_name);
10859 got = fread (&arhdr, 1, sizeof arhdr, file);
10860 if (got != sizeof arhdr)
10865 error (_("%s: failed to read archive header\n"), file_name);
10870 if (memcmp (arhdr.ar_name, "// ", 16) == 0)
10872 /* This is the archive string table holding long member
10875 longnames_size = strtoul (arhdr.ar_size, NULL, 10);
10877 longnames = malloc (longnames_size);
10878 if (longnames == NULL)
10880 error (_("Out of memory\n"));
10884 if (fread (longnames, longnames_size, 1, file) != 1)
10887 error(_("%s: failed to read string table\n"), file_name);
10891 if ((longnames_size & 1) != 0)
10894 got = fread (&arhdr, 1, sizeof arhdr, file);
10895 if (got != sizeof arhdr)
10902 error (_("%s: failed to read archive header\n"), file_name);
10907 file_name_size = strlen (file_name);
10916 if (arhdr.ar_name[0] == '/')
10920 off = strtoul (arhdr.ar_name + 1, NULL, 10);
10921 if (off >= longnames_size)
10923 error (_("%s: invalid archive string table offset %lu\n"), off);
10928 name = longnames + off;
10929 nameend = memchr (name, '/', longnames_size - off);
10933 name = arhdr.ar_name;
10934 nameend = memchr (name, '/', 16);
10937 if (nameend == NULL)
10939 error (_("%s: bad archive file name\n"));
10944 namealc = malloc (file_name_size + (nameend - name) + 3);
10945 if (namealc == NULL)
10947 error (_("Out of memory\n"));
10952 memcpy (namealc, file_name, file_name_size);
10953 namealc[file_name_size] = '(';
10954 memcpy (namealc + file_name_size + 1, name, nameend - name);
10955 namealc[file_name_size + 1 + (nameend - name)] = ')';
10956 namealc[file_name_size + 2 + (nameend - name)] = '\0';
10958 archive_file_offset = ftell (file);
10959 archive_file_size = strtoul (arhdr.ar_size, NULL, 10);
10961 ret |= process_object (namealc, file);
10966 (archive_file_offset
10967 + archive_file_size
10968 + (archive_file_size & 1)),
10971 error (_("%s: failed to seek to next archive header\n"), file_name);
10976 got = fread (&arhdr, 1, sizeof arhdr, file);
10977 if (got != sizeof arhdr)
10982 error (_("%s: failed to read archive header\n"), file_name);
10988 if (longnames != 0)
10995 process_file (char *file_name)
10998 struct stat statbuf;
10999 char armag[SARMAG];
11002 if (stat (file_name, &statbuf) < 0)
11004 if (errno == ENOENT)
11005 error (_("'%s': No such file\n"), file_name);
11007 error (_("Could not locate '%s'. System error message: %s\n"),
11008 file_name, strerror (errno));
11012 if (! S_ISREG (statbuf.st_mode))
11014 error (_("'%s' is not an ordinary file\n"), file_name);
11018 file = fopen (file_name, "rb");
11021 error (_("Input file '%s' is not readable.\n"), file_name);
11025 if (fread (armag, SARMAG, 1, file) != 1)
11027 error (_("%s: Failed to read file header\n"), file_name);
11032 if (memcmp (armag, ARMAG, SARMAG) == 0)
11033 ret = process_archive (file_name, file);
11037 archive_file_size = archive_file_offset = 0;
11038 ret = process_object (file_name, file);
11046 #ifdef SUPPORT_DISASSEMBLY
11047 /* Needed by the i386 disassembler. For extra credit, someone could
11048 fix this so that we insert symbolic addresses here, esp for GOT/PLT
11052 print_address (unsigned int addr, FILE *outfile)
11054 fprintf (outfile,"0x%8.8x", addr);
11057 /* Needed by the i386 disassembler. */
11059 db_task_printsym (unsigned int addr)
11061 print_address (addr, stderr);
11066 main (int argc, char **argv)
11069 char *cmdline_dump_sects = NULL;
11070 unsigned num_cmdline_dump_sects = 0;
11072 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
11073 setlocale (LC_MESSAGES, "");
11075 #if defined (HAVE_SETLOCALE)
11076 setlocale (LC_CTYPE, "");
11078 bindtextdomain (PACKAGE, LOCALEDIR);
11079 textdomain (PACKAGE);
11081 parse_args (argc, argv);
11083 if (optind < (argc - 1))
11086 /* When processing more than one file remember the dump requests
11087 issued on command line to reset them after each file. */
11088 if (optind + 1 < argc && dump_sects != NULL)
11090 cmdline_dump_sects = malloc (num_dump_sects);
11091 if (cmdline_dump_sects == NULL)
11092 error (_("Out of memory allocating dump request table."));
11095 memcpy (cmdline_dump_sects, dump_sects, num_dump_sects);
11096 num_cmdline_dump_sects = num_dump_sects;
11101 while (optind < argc)
11103 err |= process_file (argv[optind++]);
11105 /* Reset dump requests. */
11106 if (optind < argc && dump_sects != NULL)
11108 num_dump_sects = num_cmdline_dump_sects;
11109 if (num_cmdline_dump_sects > 0)
11110 memcpy (dump_sects, cmdline_dump_sects, num_cmdline_dump_sects);
11114 if (dump_sects != NULL)
11116 if (cmdline_dump_sects != NULL)
11117 free (cmdline_dump_sects);