1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
24 /* The difference between readelf and objdump:
26 Both programs are capabale of displaying the contents of ELF format files,
27 so why does the binutils project have two file dumpers ?
29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
44 #include <sys/types.h>
50 /* Define BFD64 here, even if our default architecture is 32 bit ELF
51 as this will allow us to read in and parse 64bit and 32bit ELF files.
52 Only do this if we believe that the compiler can support a 64 bit
53 data type. For now we only rely on GCC being able to do this. */
59 #include "elf/common.h"
60 #include "elf/external.h"
61 #include "elf/internal.h"
62 #include "elf/dwarf2.h"
64 /* The following headers use the elf/reloc-macros.h file to
65 automatically generate relocation recognition functions
66 such as elf_mips_reloc_type() */
68 #define RELOC_MACROS_GEN_FUNC
70 #include "elf/alpha.h"
90 #include "elf/m68hc11.h"
91 #include "elf/mcore.h"
94 #include "elf/mn10200.h"
95 #include "elf/mn10300.h"
96 #include "elf/msp430.h"
100 #include "elf/ppc64.h"
101 #include "elf/s390.h"
103 #include "elf/sparc.h"
104 #include "elf/v850.h"
106 #include "elf/x86-64.h"
107 #include "elf/xstormy16.h"
108 #include "elf/iq2000.h"
109 #include "elf/xtensa.h"
115 #include "libiberty.h"
117 char *program_name = "readelf";
118 long archive_file_offset;
119 unsigned long archive_file_size;
120 unsigned long dynamic_addr;
121 bfd_size_type dynamic_size;
122 char *dynamic_strings;
124 unsigned long string_table_length;
125 unsigned long num_dynamic_syms;
126 Elf_Internal_Sym *dynamic_symbols;
127 Elf_Internal_Syminfo *dynamic_syminfo;
128 unsigned long dynamic_syminfo_offset;
129 unsigned int dynamic_syminfo_nent;
130 char program_interpreter[64];
131 bfd_vma dynamic_info[DT_JMPREL + 1];
132 bfd_vma version_info[16];
133 Elf_Internal_Ehdr elf_header;
134 Elf_Internal_Shdr *section_headers;
135 Elf_Internal_Phdr *program_headers;
136 Elf_Internal_Dyn *dynamic_segment;
137 Elf_Internal_Shdr *symtab_shndx_hdr;
145 int do_using_dynamic;
153 int do_debug_abbrevs;
155 int do_debug_pubnames;
156 int do_debug_aranges;
158 int do_debug_frames_interp;
159 int do_debug_macinfo;
166 /* A dynamic array of flags indicating which sections require dumping. */
167 char *dump_sects = NULL;
168 unsigned int num_dump_sects = 0;
170 #define HEX_DUMP (1 << 0)
171 #define DISASS_DUMP (1 << 1)
172 #define DEBUG_DUMP (1 << 2)
174 /* How to rpint a vma value. */
175 typedef enum print_mode
187 static bfd_vma (*byte_get) (unsigned char *, int);
188 static void (*byte_put) (unsigned char *, bfd_vma, int);
190 typedef int Elf32_Word;
194 #define SECTION_NAME(X) ((X) == NULL ? "<none>" : \
195 ((X)->sh_name >= string_table_length \
196 ? "<corrupt>" : string_table + (X)->sh_name))
198 /* Given st_shndx I, map to section_headers index. */
199 #define SECTION_HEADER_INDEX(I) \
200 ((I) < SHN_LORESERVE \
202 : ((I) <= SHN_HIRESERVE \
204 : (I) - (SHN_HIRESERVE + 1 - SHN_LORESERVE)))
206 /* Reverse of the above. */
207 #define SECTION_HEADER_NUM(N) \
208 ((N) < SHN_LORESERVE \
210 : (N) + (SHN_HIRESERVE + 1 - SHN_LORESERVE))
212 #define SECTION_HEADER(I) (section_headers + SECTION_HEADER_INDEX (I))
214 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
216 #define BYTE_GET(field) byte_get (field, sizeof (field))
218 /* If we can support a 64 bit data type then BFD64 should be defined
219 and sizeof (bfd_vma) == 8. In this case when translating from an
220 external 8 byte field to an internal field, we can assume that the
221 internal field is also 8 bytes wide and so we can extract all the data.
222 If, however, BFD64 is not defined, then we must assume that the
223 internal data structure only has 4 byte wide fields that are the
224 equivalent of the 8 byte wide external counterparts, and so we must
225 truncate the data. */
227 #define BYTE_GET8(field) byte_get (field, -8)
229 #define BYTE_GET8(field) byte_get (field, 8)
232 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
234 #define GET_ELF_SYMBOLS(file, section) \
235 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
236 : get_64bit_elf_symbols (file, section))
240 error (const char *message, ...)
244 va_start (args, message);
245 fprintf (stderr, _("%s: Error: "), program_name);
246 vfprintf (stderr, message, args);
251 warn (const char *message, ...)
255 va_start (args, message);
256 fprintf (stderr, _("%s: Warning: "), program_name);
257 vfprintf (stderr, message, args);
262 get_data (void *var, FILE *file, long offset, size_t size, const char *reason)
269 if (fseek (file, archive_file_offset + offset, SEEK_SET))
271 error (_("Unable to seek to 0x%x for %s\n"),
272 archive_file_offset + offset, reason);
279 mvar = malloc (size);
283 error (_("Out of memory allocating 0x%x bytes for %s\n"),
289 if (fread (mvar, size, 1, file) != 1)
291 error (_("Unable to read in 0x%x bytes of %s\n"), size, reason);
301 byte_get_little_endian (unsigned char *field, int size)
309 return ((unsigned int) (field[0]))
310 | (((unsigned int) (field[1])) << 8);
314 /* We want to extract data from an 8 byte wide field and
315 place it into a 4 byte wide field. Since this is a little
316 endian source we can just use the 4 byte extraction code. */
320 return ((unsigned long) (field[0]))
321 | (((unsigned long) (field[1])) << 8)
322 | (((unsigned long) (field[2])) << 16)
323 | (((unsigned long) (field[3])) << 24);
328 /* This is a special case, generated by the BYTE_GET8 macro.
329 It means that we are loading an 8 byte value from a field
330 in an external structure into an 8 byte value in a field
331 in an internal structure. */
332 return ((bfd_vma) (field[0]))
333 | (((bfd_vma) (field[1])) << 8)
334 | (((bfd_vma) (field[2])) << 16)
335 | (((bfd_vma) (field[3])) << 24)
336 | (((bfd_vma) (field[4])) << 32)
337 | (((bfd_vma) (field[5])) << 40)
338 | (((bfd_vma) (field[6])) << 48)
339 | (((bfd_vma) (field[7])) << 56);
342 error (_("Unhandled data length: %d\n"), size);
348 byte_get_signed (unsigned char *field, int size)
350 bfd_vma x = byte_get (field, size);
355 return (x ^ 0x80) - 0x80;
357 return (x ^ 0x8000) - 0x8000;
359 return (x ^ 0x80000000) - 0x80000000;
369 byte_put_little_endian (unsigned char *field, bfd_vma value, int size)
374 field[7] = (((value >> 24) >> 24) >> 8) & 0xff;
375 field[6] = ((value >> 24) >> 24) & 0xff;
376 field[5] = ((value >> 24) >> 16) & 0xff;
377 field[4] = ((value >> 24) >> 8) & 0xff;
380 field[3] = (value >> 24) & 0xff;
381 field[2] = (value >> 16) & 0xff;
384 field[1] = (value >> 8) & 0xff;
387 field[0] = value & 0xff;
391 error (_("Unhandled data length: %d\n"), size);
396 /* Print a VMA value. */
398 print_vma (bfd_vma vma, print_mode mode)
410 printf ("%8.8lx", (unsigned long) vma);
416 printf ("%5ld", (long) vma);
424 printf ("%lx", (unsigned long) vma);
428 printf ("%ld", (unsigned long) vma);
432 printf ("%lu", (unsigned long) vma);
454 #if BFD_HOST_64BIT_LONG
457 if (_bfd_int64_high (vma))
458 printf ("%lx%8.8lx", _bfd_int64_high (vma), _bfd_int64_low (vma));
460 printf ("%lx", _bfd_int64_low (vma));
465 #if BFD_HOST_64BIT_LONG
468 if (_bfd_int64_high (vma))
470 printf ("++%ld", _bfd_int64_low (vma));
472 printf ("%ld", _bfd_int64_low (vma));
477 #if BFD_HOST_64BIT_LONG
479 printf ("%5ld", vma);
481 printf ("%#lx", vma);
483 if (_bfd_int64_high (vma))
485 printf ("++%ld", _bfd_int64_low (vma));
486 else if (vma <= 99999)
487 printf ("%5ld", _bfd_int64_low (vma));
489 printf ("%#lx", _bfd_int64_low (vma));
494 #if BFD_HOST_64BIT_LONG
497 if (_bfd_int64_high (vma))
499 printf ("++%lu", _bfd_int64_low (vma));
501 printf ("%lu", _bfd_int64_low (vma));
509 /* Display a symbol on stdout. If do_wide is not true then
510 format the symbol to be at most WIDTH characters,
511 truncating as necessary. If WIDTH is negative then
512 format the string to be exactly - WIDTH characters,
513 truncating or padding as necessary. */
516 print_symbol (int width, const char *symbol)
519 printf ("%s", symbol);
521 printf ("%-*.*s", width, width, symbol);
523 printf ("%-.*s", width, symbol);
527 byte_get_big_endian (unsigned char *field, int size)
535 return ((unsigned int) (field[1])) | (((int) (field[0])) << 8);
538 return ((unsigned long) (field[3]))
539 | (((unsigned long) (field[2])) << 8)
540 | (((unsigned long) (field[1])) << 16)
541 | (((unsigned long) (field[0])) << 24);
545 /* Although we are extracing data from an 8 byte wide field, we
546 are returning only 4 bytes of data. */
547 return ((unsigned long) (field[7]))
548 | (((unsigned long) (field[6])) << 8)
549 | (((unsigned long) (field[5])) << 16)
550 | (((unsigned long) (field[4])) << 24);
554 /* This is a special case, generated by the BYTE_GET8 macro.
555 It means that we are loading an 8 byte value from a field
556 in an external structure into an 8 byte value in a field
557 in an internal structure. */
558 return ((bfd_vma) (field[7]))
559 | (((bfd_vma) (field[6])) << 8)
560 | (((bfd_vma) (field[5])) << 16)
561 | (((bfd_vma) (field[4])) << 24)
562 | (((bfd_vma) (field[3])) << 32)
563 | (((bfd_vma) (field[2])) << 40)
564 | (((bfd_vma) (field[1])) << 48)
565 | (((bfd_vma) (field[0])) << 56);
569 error (_("Unhandled data length: %d\n"), size);
575 byte_put_big_endian (unsigned char *field, bfd_vma value, int size)
580 field[7] = value & 0xff;
581 field[6] = (value >> 8) & 0xff;
582 field[5] = (value >> 16) & 0xff;
583 field[4] = (value >> 24) & 0xff;
588 field[3] = value & 0xff;
589 field[2] = (value >> 8) & 0xff;
593 field[1] = value & 0xff;
597 field[0] = value & 0xff;
601 error (_("Unhandled data length: %d\n"), size);
606 /* Guess the relocation size commonly used by the specific machines. */
609 guess_is_rela (unsigned long e_machine)
613 /* Targets that use REL relocations. */
628 /* Targets that use RELA relocations. */
643 case EM_CYGNUS_MN10200:
645 case EM_CYGNUS_MN10300:
691 warn (_("Don't know about relocations on this machine architecture\n"));
697 slurp_rela_relocs (FILE *file,
698 unsigned long rel_offset,
699 unsigned long rel_size,
700 Elf_Internal_Rela **relasp,
701 unsigned long *nrelasp)
703 Elf_Internal_Rela *relas;
704 unsigned long nrelas;
709 Elf32_External_Rela *erelas;
711 erelas = get_data (NULL, file, rel_offset, rel_size, _("relocs"));
715 nrelas = rel_size / sizeof (Elf32_External_Rela);
717 relas = malloc (nrelas * sizeof (Elf_Internal_Rela));
721 error(_("out of memory parsing relocs"));
725 for (i = 0; i < nrelas; i++)
727 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
728 relas[i].r_info = BYTE_GET (erelas[i].r_info);
729 relas[i].r_addend = BYTE_GET (erelas[i].r_addend);
736 Elf64_External_Rela *erelas;
738 erelas = get_data (NULL, file, rel_offset, rel_size, _("relocs"));
742 nrelas = rel_size / sizeof (Elf64_External_Rela);
744 relas = malloc (nrelas * sizeof (Elf_Internal_Rela));
748 error(_("out of memory parsing relocs"));
752 for (i = 0; i < nrelas; i++)
754 relas[i].r_offset = BYTE_GET8 (erelas[i].r_offset);
755 relas[i].r_info = BYTE_GET8 (erelas[i].r_info);
756 relas[i].r_addend = BYTE_GET8 (erelas[i].r_addend);
767 slurp_rel_relocs (FILE *file,
768 unsigned long rel_offset,
769 unsigned long rel_size,
770 Elf_Internal_Rela **relsp,
771 unsigned long *nrelsp)
773 Elf_Internal_Rela *rels;
779 Elf32_External_Rel *erels;
781 erels = get_data (NULL, file, rel_offset, rel_size, _("relocs"));
785 nrels = rel_size / sizeof (Elf32_External_Rel);
787 rels = malloc (nrels * sizeof (Elf_Internal_Rela));
791 error(_("out of memory parsing relocs"));
795 for (i = 0; i < nrels; i++)
797 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
798 rels[i].r_info = BYTE_GET (erels[i].r_info);
799 rels[i].r_addend = 0;
806 Elf64_External_Rel *erels;
808 erels = get_data (NULL, file, rel_offset, rel_size, _("relocs"));
812 nrels = rel_size / sizeof (Elf64_External_Rel);
814 rels = malloc (nrels * sizeof (Elf_Internal_Rela));
818 error(_("out of memory parsing relocs"));
822 for (i = 0; i < nrels; i++)
824 rels[i].r_offset = BYTE_GET8 (erels[i].r_offset);
825 rels[i].r_info = BYTE_GET8 (erels[i].r_info);
826 rels[i].r_addend = 0;
836 /* Display the contents of the relocation data found at the specified
840 dump_relocations (FILE *file,
841 unsigned long rel_offset,
842 unsigned long rel_size,
843 Elf_Internal_Sym *symtab,
849 Elf_Internal_Rela *rels;
852 if (is_rela == UNKNOWN)
853 is_rela = guess_is_rela (elf_header.e_machine);
857 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
862 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
871 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
873 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
878 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
880 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
888 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
890 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
895 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
897 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
901 for (i = 0; i < rel_size; i++)
904 const char *rtype2 = NULL;
905 const char *rtype3 = NULL;
908 bfd_vma symtab_index;
913 offset = rels[i].r_offset;
914 info = rels[i].r_info;
918 type = ELF32_R_TYPE (info);
919 symtab_index = ELF32_R_SYM (info);
923 /* The #ifdef BFD64 below is to prevent a compile time warning.
924 We know that if we do not have a 64 bit data type that we
925 will never execute this code anyway. */
927 if (elf_header.e_machine == EM_MIPS)
929 /* In little-endian objects, r_info isn't really a 64-bit
930 little-endian value: it has a 32-bit little-endian
931 symbol index followed by four individual byte fields.
932 Reorder INFO accordingly. */
933 if (elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
934 info = (((info & 0xffffffff) << 32)
935 | ((info >> 56) & 0xff)
936 | ((info >> 40) & 0xff00)
937 | ((info >> 24) & 0xff0000)
938 | ((info >> 8) & 0xff000000));
939 type = ELF64_MIPS_R_TYPE (info);
940 type2 = ELF64_MIPS_R_TYPE2 (info);
941 type3 = ELF64_MIPS_R_TYPE3 (info);
943 else if (elf_header.e_machine == EM_SPARCV9)
944 type = ELF64_R_TYPE_ID (info);
946 type = ELF64_R_TYPE (info);
948 symtab_index = ELF64_R_SYM (info);
954 #ifdef _bfd_int64_low
955 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset), _bfd_int64_low (info));
957 printf ("%8.8lx %8.8lx ", offset, info);
962 #ifdef _bfd_int64_low
964 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
965 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
966 _bfd_int64_high (offset),
967 _bfd_int64_low (offset),
968 _bfd_int64_high (info),
969 _bfd_int64_low (info));
972 ? "%16.16lx %16.16lx "
973 : "%12.12lx %12.12lx ",
978 switch (elf_header.e_machine)
986 rtype = elf_m32r_reloc_type (type);
991 rtype = elf_i386_reloc_type (type);
996 rtype = elf_m68hc11_reloc_type (type);
1000 rtype = elf_m68k_reloc_type (type);
1004 rtype = elf_i960_reloc_type (type);
1009 rtype = elf_avr_reloc_type (type);
1012 case EM_OLD_SPARCV9:
1013 case EM_SPARC32PLUS:
1016 rtype = elf_sparc_reloc_type (type);
1020 case EM_CYGNUS_V850:
1021 rtype = v850_reloc_type (type);
1025 case EM_CYGNUS_D10V:
1026 rtype = elf_d10v_reloc_type (type);
1030 case EM_CYGNUS_D30V:
1031 rtype = elf_d30v_reloc_type (type);
1035 rtype = elf_dlx_reloc_type (type);
1039 rtype = elf_sh_reloc_type (type);
1043 case EM_CYGNUS_MN10300:
1044 rtype = elf_mn10300_reloc_type (type);
1048 case EM_CYGNUS_MN10200:
1049 rtype = elf_mn10200_reloc_type (type);
1053 case EM_CYGNUS_FR30:
1054 rtype = elf_fr30_reloc_type (type);
1058 rtype = elf_frv_reloc_type (type);
1062 rtype = elf_mcore_reloc_type (type);
1066 rtype = elf_mmix_reloc_type (type);
1071 rtype = elf_msp430_reloc_type (type);
1075 rtype = elf_ppc_reloc_type (type);
1079 rtype = elf_ppc64_reloc_type (type);
1083 case EM_MIPS_RS3_LE:
1084 rtype = elf_mips_reloc_type (type);
1087 rtype2 = elf_mips_reloc_type (type2);
1088 rtype3 = elf_mips_reloc_type (type3);
1093 rtype = elf_alpha_reloc_type (type);
1097 rtype = elf_arm_reloc_type (type);
1101 rtype = elf_arc_reloc_type (type);
1105 rtype = elf_hppa_reloc_type (type);
1111 rtype = elf_h8_reloc_type (type);
1116 rtype = elf_or32_reloc_type (type);
1121 rtype = elf_pj_reloc_type (type);
1124 rtype = elf_ia64_reloc_type (type);
1128 rtype = elf_cris_reloc_type (type);
1132 rtype = elf_i860_reloc_type (type);
1136 rtype = elf_x86_64_reloc_type (type);
1140 rtype = i370_reloc_type (type);
1145 rtype = elf_s390_reloc_type (type);
1149 rtype = elf_xstormy16_reloc_type (type);
1153 rtype = elf_vax_reloc_type (type);
1158 rtype = elf_ip2k_reloc_type (type);
1162 rtype = elf_iq2000_reloc_type (type);
1167 rtype = elf_xtensa_reloc_type (type);
1172 #ifdef _bfd_int64_low
1173 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type));
1175 printf (_("unrecognized: %-7lx"), type);
1178 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1182 if (symtab == NULL || symtab_index >= nsyms)
1183 printf (" bad symbol index: %08lx", (unsigned long) symtab_index);
1186 Elf_Internal_Sym *psym;
1188 psym = symtab + symtab_index;
1191 print_vma (psym->st_value, LONG_HEX);
1192 printf (is_32bit_elf ? " " : " ");
1194 if (psym->st_name == 0)
1196 const char *sec_name = "<null>";
1199 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1201 bfd_vma sec_index = (bfd_vma) -1;
1203 if (psym->st_shndx < SHN_LORESERVE)
1204 sec_index = psym->st_shndx;
1205 else if (psym->st_shndx > SHN_LORESERVE)
1206 sec_index = psym->st_shndx - (SHN_HIRESERVE + 1
1209 if (sec_index != (bfd_vma) -1)
1210 sec_name = SECTION_NAME (section_headers + sec_index);
1211 else if (psym->st_shndx == SHN_ABS)
1213 else if (psym->st_shndx == SHN_COMMON)
1214 sec_name = "COMMON";
1215 else if (elf_header.e_machine == EM_IA_64
1216 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1217 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1218 sec_name = "ANSI_COM";
1221 sprintf (name_buf, "<section 0x%x>",
1222 (unsigned int) psym->st_shndx);
1223 sec_name = name_buf;
1226 print_symbol (22, sec_name);
1228 else if (strtab == NULL)
1229 printf (_("<string table index %3ld>"), psym->st_name);
1231 print_symbol (22, strtab + psym->st_name);
1234 printf (" + %lx", (unsigned long) rels[i].r_addend);
1239 printf ("%*c", is_32bit_elf ? (do_wide ? 34 : 28) : (do_wide ? 26 : 20), ' ');
1240 print_vma (rels[i].r_addend, LONG_HEX);
1243 if (elf_header.e_machine == EM_SPARCV9
1244 && !strcmp (rtype, "R_SPARC_OLO10"))
1245 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info));
1249 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1251 printf (" Type2: ");
1254 #ifdef _bfd_int64_low
1255 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2));
1257 printf (_("unrecognized: %-7lx"), type2);
1260 printf ("%-17.17s", rtype2);
1262 printf("\n Type3: ");
1265 #ifdef _bfd_int64_low
1266 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3));
1268 printf (_("unrecognized: %-7lx"), type3);
1271 printf ("%-17.17s", rtype3);
1283 get_mips_dynamic_type (unsigned long type)
1287 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1288 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1289 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1290 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1291 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1292 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1293 case DT_MIPS_MSYM: return "MIPS_MSYM";
1294 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1295 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1296 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1297 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1298 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1299 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1300 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1301 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1302 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1303 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1304 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1305 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1306 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1307 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1308 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1309 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1310 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1311 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1312 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1313 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1314 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1315 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1316 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1317 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1318 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1319 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1320 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1321 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1322 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1323 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1324 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1325 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1326 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1327 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1328 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1329 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1336 get_sparc64_dynamic_type (unsigned long type)
1340 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1347 get_ppc64_dynamic_type (unsigned long type)
1351 case DT_PPC64_GLINK: return "PPC64_GLINK";
1352 case DT_PPC64_OPD: return "PPC64_OPD";
1353 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1360 get_parisc_dynamic_type (unsigned long type)
1364 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1365 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1366 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1367 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1368 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1369 case DT_HP_PREINIT: return "HP_PREINIT";
1370 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1371 case DT_HP_NEEDED: return "HP_NEEDED";
1372 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1373 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1374 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1375 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1376 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1383 get_ia64_dynamic_type (unsigned long type)
1387 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1394 get_dynamic_type (unsigned long type)
1396 static char buff[32];
1400 case DT_NULL: return "NULL";
1401 case DT_NEEDED: return "NEEDED";
1402 case DT_PLTRELSZ: return "PLTRELSZ";
1403 case DT_PLTGOT: return "PLTGOT";
1404 case DT_HASH: return "HASH";
1405 case DT_STRTAB: return "STRTAB";
1406 case DT_SYMTAB: return "SYMTAB";
1407 case DT_RELA: return "RELA";
1408 case DT_RELASZ: return "RELASZ";
1409 case DT_RELAENT: return "RELAENT";
1410 case DT_STRSZ: return "STRSZ";
1411 case DT_SYMENT: return "SYMENT";
1412 case DT_INIT: return "INIT";
1413 case DT_FINI: return "FINI";
1414 case DT_SONAME: return "SONAME";
1415 case DT_RPATH: return "RPATH";
1416 case DT_SYMBOLIC: return "SYMBOLIC";
1417 case DT_REL: return "REL";
1418 case DT_RELSZ: return "RELSZ";
1419 case DT_RELENT: return "RELENT";
1420 case DT_PLTREL: return "PLTREL";
1421 case DT_DEBUG: return "DEBUG";
1422 case DT_TEXTREL: return "TEXTREL";
1423 case DT_JMPREL: return "JMPREL";
1424 case DT_BIND_NOW: return "BIND_NOW";
1425 case DT_INIT_ARRAY: return "INIT_ARRAY";
1426 case DT_FINI_ARRAY: return "FINI_ARRAY";
1427 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1428 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1429 case DT_RUNPATH: return "RUNPATH";
1430 case DT_FLAGS: return "FLAGS";
1432 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1433 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1435 case DT_CHECKSUM: return "CHECKSUM";
1436 case DT_PLTPADSZ: return "PLTPADSZ";
1437 case DT_MOVEENT: return "MOVEENT";
1438 case DT_MOVESZ: return "MOVESZ";
1439 case DT_FEATURE: return "FEATURE";
1440 case DT_POSFLAG_1: return "POSFLAG_1";
1441 case DT_SYMINSZ: return "SYMINSZ";
1442 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
1444 case DT_ADDRRNGLO: return "ADDRRNGLO";
1445 case DT_CONFIG: return "CONFIG";
1446 case DT_DEPAUDIT: return "DEPAUDIT";
1447 case DT_AUDIT: return "AUDIT";
1448 case DT_PLTPAD: return "PLTPAD";
1449 case DT_MOVETAB: return "MOVETAB";
1450 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
1452 case DT_VERSYM: return "VERSYM";
1454 case DT_RELACOUNT: return "RELACOUNT";
1455 case DT_RELCOUNT: return "RELCOUNT";
1456 case DT_FLAGS_1: return "FLAGS_1";
1457 case DT_VERDEF: return "VERDEF";
1458 case DT_VERDEFNUM: return "VERDEFNUM";
1459 case DT_VERNEED: return "VERNEED";
1460 case DT_VERNEEDNUM: return "VERNEEDNUM";
1462 case DT_AUXILIARY: return "AUXILIARY";
1463 case DT_USED: return "USED";
1464 case DT_FILTER: return "FILTER";
1466 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1467 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1468 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1469 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1470 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1473 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1477 switch (elf_header.e_machine)
1480 case EM_MIPS_RS3_LE:
1481 result = get_mips_dynamic_type (type);
1484 result = get_sparc64_dynamic_type (type);
1487 result = get_ppc64_dynamic_type (type);
1490 result = get_ia64_dynamic_type (type);
1500 sprintf (buff, _("Processor Specific: %lx"), type);
1502 else if ((type >= DT_LOOS) && (type <= DT_HIOS))
1506 switch (elf_header.e_machine)
1509 result = get_parisc_dynamic_type (type);
1519 sprintf (buff, _("Operating System specific: %lx"), type);
1522 sprintf (buff, _("<unknown>: %lx"), type);
1529 get_file_type (unsigned e_type)
1531 static char buff[32];
1535 case ET_NONE: return _("NONE (None)");
1536 case ET_REL: return _("REL (Relocatable file)");
1537 case ET_EXEC: return _("EXEC (Executable file)");
1538 case ET_DYN: return _("DYN (Shared object file)");
1539 case ET_CORE: return _("CORE (Core file)");
1542 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1543 sprintf (buff, _("Processor Specific: (%x)"), e_type);
1544 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1545 sprintf (buff, _("OS Specific: (%x)"), e_type);
1547 sprintf (buff, _("<unknown>: %x"), e_type);
1553 get_machine_name (unsigned e_machine)
1555 static char buff[64]; /* XXX */
1559 case EM_NONE: return _("None");
1560 case EM_M32: return "WE32100";
1561 case EM_SPARC: return "Sparc";
1562 case EM_386: return "Intel 80386";
1563 case EM_68K: return "MC68000";
1564 case EM_88K: return "MC88000";
1565 case EM_486: return "Intel 80486";
1566 case EM_860: return "Intel 80860";
1567 case EM_MIPS: return "MIPS R3000";
1568 case EM_S370: return "IBM System/370";
1569 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
1570 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
1571 case EM_PARISC: return "HPPA";
1572 case EM_PPC_OLD: return "Power PC (old)";
1573 case EM_SPARC32PLUS: return "Sparc v8+" ;
1574 case EM_960: return "Intel 90860";
1575 case EM_PPC: return "PowerPC";
1576 case EM_PPC64: return "PowerPC64";
1577 case EM_V800: return "NEC V800";
1578 case EM_FR20: return "Fujitsu FR20";
1579 case EM_RH32: return "TRW RH32";
1580 case EM_MCORE: return "MCORE";
1581 case EM_ARM: return "ARM";
1582 case EM_OLD_ALPHA: return "Digital Alpha (old)";
1583 case EM_SH: return "Renesas / SuperH SH";
1584 case EM_SPARCV9: return "Sparc v9";
1585 case EM_TRICORE: return "Siemens Tricore";
1586 case EM_ARC: return "ARC";
1587 case EM_H8_300: return "Renesas H8/300";
1588 case EM_H8_300H: return "Renesas H8/300H";
1589 case EM_H8S: return "Renesas H8S";
1590 case EM_H8_500: return "Renesas H8/500";
1591 case EM_IA_64: return "Intel IA-64";
1592 case EM_MIPS_X: return "Stanford MIPS-X";
1593 case EM_COLDFIRE: return "Motorola Coldfire";
1594 case EM_68HC12: return "Motorola M68HC12";
1595 case EM_ALPHA: return "Alpha";
1596 case EM_CYGNUS_D10V:
1597 case EM_D10V: return "d10v";
1598 case EM_CYGNUS_D30V:
1599 case EM_D30V: return "d30v";
1600 case EM_CYGNUS_M32R:
1601 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
1602 case EM_CYGNUS_V850:
1603 case EM_V850: return "NEC v850";
1604 case EM_CYGNUS_MN10300:
1605 case EM_MN10300: return "mn10300";
1606 case EM_CYGNUS_MN10200:
1607 case EM_MN10200: return "mn10200";
1608 case EM_CYGNUS_FR30:
1609 case EM_FR30: return "Fujitsu FR30";
1610 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
1612 case EM_PJ: return "picoJava";
1613 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1614 case EM_PCP: return "Siemens PCP";
1615 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1616 case EM_NDR1: return "Denso NDR1 microprocesspr";
1617 case EM_STARCORE: return "Motorola Star*Core processor";
1618 case EM_ME16: return "Toyota ME16 processor";
1619 case EM_ST100: return "STMicroelectronics ST100 processor";
1620 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
1621 case EM_FX66: return "Siemens FX66 microcontroller";
1622 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1623 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1624 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
1625 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1626 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1627 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1628 case EM_SVX: return "Silicon Graphics SVx";
1629 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1630 case EM_VAX: return "Digital VAX";
1632 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1633 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
1634 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
1635 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
1636 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
1637 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
1638 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
1639 case EM_PRISM: return "Vitesse Prism";
1640 case EM_X86_64: return "Advanced Micro Devices X86-64";
1642 case EM_S390: return "IBM S/390";
1643 case EM_XSTORMY16: return "Sanyo Xstormy16 CPU core";
1645 case EM_OR32: return "OpenRISC";
1646 case EM_DLX: return "OpenDLX";
1648 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
1649 case EM_IQ2000: return "Vitesse IQ2000";
1651 case EM_XTENSA: return "Tensilica Xtensa Processor";
1653 sprintf (buff, _("<unknown>: %x"), e_machine);
1659 decode_ARM_machine_flags (unsigned e_flags, char buf[])
1664 eabi = EF_ARM_EABI_VERSION (e_flags);
1665 e_flags &= ~ EF_ARM_EABIMASK;
1667 /* Handle "generic" ARM flags. */
1668 if (e_flags & EF_ARM_RELEXEC)
1670 strcat (buf, ", relocatable executable");
1671 e_flags &= ~ EF_ARM_RELEXEC;
1674 if (e_flags & EF_ARM_HASENTRY)
1676 strcat (buf, ", has entry point");
1677 e_flags &= ~ EF_ARM_HASENTRY;
1680 /* Now handle EABI specific flags. */
1684 strcat (buf, ", <unrecognized EABI>");
1689 case EF_ARM_EABI_VER1:
1690 strcat (buf, ", Version1 EABI");
1695 /* Process flags one bit at a time. */
1696 flag = e_flags & - e_flags;
1701 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
1702 strcat (buf, ", sorted symbol tables");
1712 case EF_ARM_EABI_VER2:
1713 strcat (buf, ", Version2 EABI");
1718 /* Process flags one bit at a time. */
1719 flag = e_flags & - e_flags;
1724 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
1725 strcat (buf, ", sorted symbol tables");
1728 case EF_ARM_DYNSYMSUSESEGIDX:
1729 strcat (buf, ", dynamic symbols use segment index");
1732 case EF_ARM_MAPSYMSFIRST:
1733 strcat (buf, ", mapping symbols precede others");
1743 case EF_ARM_EABI_VER3:
1744 strcat (buf, ", Version3 EABI");
1749 /* Process flags one bit at a time. */
1750 flag = e_flags & - e_flags;
1756 strcat (buf, ", BE8");
1760 strcat (buf, ", LE8");
1770 case EF_ARM_EABI_UNKNOWN:
1771 strcat (buf, ", GNU EABI");
1776 /* Process flags one bit at a time. */
1777 flag = e_flags & - e_flags;
1782 case EF_ARM_INTERWORK:
1783 strcat (buf, ", interworking enabled");
1786 case EF_ARM_APCS_26:
1787 strcat (buf, ", uses APCS/26");
1790 case EF_ARM_APCS_FLOAT:
1791 strcat (buf, ", uses APCS/float");
1795 strcat (buf, ", position independent");
1799 strcat (buf, ", 8 bit structure alignment");
1802 case EF_ARM_NEW_ABI:
1803 strcat (buf, ", uses new ABI");
1806 case EF_ARM_OLD_ABI:
1807 strcat (buf, ", uses old ABI");
1810 case EF_ARM_SOFT_FLOAT:
1811 strcat (buf, ", software FP");
1814 case EF_ARM_MAVERICK_FLOAT:
1815 strcat (buf, ", Maverick FP");
1826 strcat (buf,", <unknown>");
1830 get_machine_flags (unsigned e_flags, unsigned e_machine)
1832 static char buf[1024];
1844 decode_ARM_machine_flags (e_flags, buf);
1848 if (e_flags & EF_CPU32)
1849 strcat (buf, ", cpu32");
1850 if (e_flags & EF_M68000)
1851 strcat (buf, ", m68000");
1855 if (e_flags & EF_PPC_EMB)
1856 strcat (buf, ", emb");
1858 if (e_flags & EF_PPC_RELOCATABLE)
1859 strcat (buf, ", relocatable");
1861 if (e_flags & EF_PPC_RELOCATABLE_LIB)
1862 strcat (buf, ", relocatable-lib");
1866 case EM_CYGNUS_V850:
1867 switch (e_flags & EF_V850_ARCH)
1870 strcat (buf, ", v850e1");
1873 strcat (buf, ", v850e");
1876 strcat (buf, ", v850");
1879 strcat (buf, ", unknown v850 architecture variant");
1885 case EM_CYGNUS_M32R:
1886 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
1887 strcat (buf, ", m32r");
1892 case EM_MIPS_RS3_LE:
1893 if (e_flags & EF_MIPS_NOREORDER)
1894 strcat (buf, ", noreorder");
1896 if (e_flags & EF_MIPS_PIC)
1897 strcat (buf, ", pic");
1899 if (e_flags & EF_MIPS_CPIC)
1900 strcat (buf, ", cpic");
1902 if (e_flags & EF_MIPS_UCODE)
1903 strcat (buf, ", ugen_reserved");
1905 if (e_flags & EF_MIPS_ABI2)
1906 strcat (buf, ", abi2");
1908 if (e_flags & EF_MIPS_OPTIONS_FIRST)
1909 strcat (buf, ", odk first");
1911 if (e_flags & EF_MIPS_32BITMODE)
1912 strcat (buf, ", 32bitmode");
1914 switch ((e_flags & EF_MIPS_MACH))
1916 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
1917 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
1918 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
1919 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
1920 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
1921 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
1922 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
1923 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
1924 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
1926 /* We simply ignore the field in this case to avoid confusion:
1927 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
1930 default: strcat (buf, ", unknown CPU"); break;
1933 switch ((e_flags & EF_MIPS_ABI))
1935 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
1936 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
1937 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
1938 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
1940 /* We simply ignore the field in this case to avoid confusion:
1941 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
1942 This means it is likely to be an o32 file, but not for
1945 default: strcat (buf, ", unknown ABI"); break;
1948 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
1949 strcat (buf, ", mdmx");
1951 if (e_flags & EF_MIPS_ARCH_ASE_M16)
1952 strcat (buf, ", mips16");
1954 switch ((e_flags & EF_MIPS_ARCH))
1956 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
1957 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
1958 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
1959 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
1960 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
1961 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
1962 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
1963 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
1964 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
1965 default: strcat (buf, ", unknown ISA"); break;
1971 if (e_flags & EF_SPARC_32PLUS)
1972 strcat (buf, ", v8+");
1974 if (e_flags & EF_SPARC_SUN_US1)
1975 strcat (buf, ", ultrasparcI");
1977 if (e_flags & EF_SPARC_SUN_US3)
1978 strcat (buf, ", ultrasparcIII");
1980 if (e_flags & EF_SPARC_HAL_R1)
1981 strcat (buf, ", halr1");
1983 if (e_flags & EF_SPARC_LEDATA)
1984 strcat (buf, ", ledata");
1986 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
1987 strcat (buf, ", tso");
1989 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
1990 strcat (buf, ", pso");
1992 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
1993 strcat (buf, ", rmo");
1997 switch (e_flags & EF_PARISC_ARCH)
1999 case EFA_PARISC_1_0:
2000 strcpy (buf, ", PA-RISC 1.0");
2002 case EFA_PARISC_1_1:
2003 strcpy (buf, ", PA-RISC 1.1");
2005 case EFA_PARISC_2_0:
2006 strcpy (buf, ", PA-RISC 2.0");
2011 if (e_flags & EF_PARISC_TRAPNIL)
2012 strcat (buf, ", trapnil");
2013 if (e_flags & EF_PARISC_EXT)
2014 strcat (buf, ", ext");
2015 if (e_flags & EF_PARISC_LSB)
2016 strcat (buf, ", lsb");
2017 if (e_flags & EF_PARISC_WIDE)
2018 strcat (buf, ", wide");
2019 if (e_flags & EF_PARISC_NO_KABP)
2020 strcat (buf, ", no kabp");
2021 if (e_flags & EF_PARISC_LAZYSWAP)
2022 strcat (buf, ", lazyswap");
2027 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2028 strcat (buf, ", new calling convention");
2030 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2031 strcat (buf, ", gnu calling convention");
2035 if ((e_flags & EF_IA_64_ABI64))
2036 strcat (buf, ", 64-bit");
2038 strcat (buf, ", 32-bit");
2039 if ((e_flags & EF_IA_64_REDUCEDFP))
2040 strcat (buf, ", reduced fp model");
2041 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2042 strcat (buf, ", no function descriptors, constant gp");
2043 else if ((e_flags & EF_IA_64_CONS_GP))
2044 strcat (buf, ", constant gp");
2045 if ((e_flags & EF_IA_64_ABSOLUTE))
2046 strcat (buf, ", absolute");
2050 if ((e_flags & EF_VAX_NONPIC))
2051 strcat (buf, ", non-PIC");
2052 if ((e_flags & EF_VAX_DFLOAT))
2053 strcat (buf, ", D-Float");
2054 if ((e_flags & EF_VAX_GFLOAT))
2055 strcat (buf, ", G-Float");
2064 get_osabi_name (unsigned int osabi)
2066 static char buff[32];
2070 case ELFOSABI_NONE: return "UNIX - System V";
2071 case ELFOSABI_HPUX: return "UNIX - HP-UX";
2072 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
2073 case ELFOSABI_LINUX: return "UNIX - Linux";
2074 case ELFOSABI_HURD: return "GNU/Hurd";
2075 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
2076 case ELFOSABI_AIX: return "UNIX - AIX";
2077 case ELFOSABI_IRIX: return "UNIX - IRIX";
2078 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
2079 case ELFOSABI_TRU64: return "UNIX - TRU64";
2080 case ELFOSABI_MODESTO: return "Novell - Modesto";
2081 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
2082 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
2083 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
2084 case ELFOSABI_AROS: return "Amiga Research OS";
2085 case ELFOSABI_STANDALONE: return _("Standalone App");
2086 case ELFOSABI_ARM: return "ARM";
2088 sprintf (buff, _("<unknown: %x>"), osabi);
2094 get_mips_segment_type (unsigned long type)
2098 case PT_MIPS_REGINFO:
2100 case PT_MIPS_RTPROC:
2102 case PT_MIPS_OPTIONS:
2112 get_parisc_segment_type (unsigned long type)
2116 case PT_HP_TLS: return "HP_TLS";
2117 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
2118 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
2119 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
2120 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
2121 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
2122 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
2123 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
2124 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
2125 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
2126 case PT_HP_PARALLEL: return "HP_PARALLEL";
2127 case PT_HP_FASTBIND: return "HP_FASTBIND";
2128 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
2129 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
2138 get_ia64_segment_type (unsigned long type)
2142 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
2143 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
2144 case PT_HP_TLS: return "HP_TLS";
2145 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
2146 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
2147 case PT_IA_64_HP_STACK: return "HP_STACK";
2156 get_segment_type (unsigned long p_type)
2158 static char buff[32];
2162 case PT_NULL: return "NULL";
2163 case PT_LOAD: return "LOAD";
2164 case PT_DYNAMIC: return "DYNAMIC";
2165 case PT_INTERP: return "INTERP";
2166 case PT_NOTE: return "NOTE";
2167 case PT_SHLIB: return "SHLIB";
2168 case PT_PHDR: return "PHDR";
2169 case PT_TLS: return "TLS";
2171 case PT_GNU_EH_FRAME:
2172 return "GNU_EH_FRAME";
2173 case PT_GNU_STACK: return "STACK";
2176 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
2180 switch (elf_header.e_machine)
2183 case EM_MIPS_RS3_LE:
2184 result = get_mips_segment_type (p_type);
2187 result = get_parisc_segment_type (p_type);
2190 result = get_ia64_segment_type (p_type);
2200 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
2202 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
2206 switch (elf_header.e_machine)
2209 result = get_parisc_segment_type (p_type);
2212 result = get_ia64_segment_type (p_type);
2222 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
2225 sprintf (buff, _("<unknown>: %lx"), p_type);
2232 get_mips_section_type_name (unsigned int sh_type)
2236 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
2237 case SHT_MIPS_MSYM: return "MIPS_MSYM";
2238 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
2239 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
2240 case SHT_MIPS_UCODE: return "MIPS_UCODE";
2241 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
2242 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
2243 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
2244 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
2245 case SHT_MIPS_RELD: return "MIPS_RELD";
2246 case SHT_MIPS_IFACE: return "MIPS_IFACE";
2247 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
2248 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
2249 case SHT_MIPS_SHDR: return "MIPS_SHDR";
2250 case SHT_MIPS_FDESC: return "MIPS_FDESC";
2251 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
2252 case SHT_MIPS_DENSE: return "MIPS_DENSE";
2253 case SHT_MIPS_PDESC: return "MIPS_PDESC";
2254 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
2255 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
2256 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
2257 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
2258 case SHT_MIPS_LINE: return "MIPS_LINE";
2259 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
2260 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
2261 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
2262 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
2263 case SHT_MIPS_DWARF: return "MIPS_DWARF";
2264 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
2265 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
2266 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
2267 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
2268 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
2269 case SHT_MIPS_XLATE: return "MIPS_XLATE";
2270 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
2271 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
2272 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
2273 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
2274 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
2282 get_parisc_section_type_name (unsigned int sh_type)
2286 case SHT_PARISC_EXT: return "PARISC_EXT";
2287 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
2288 case SHT_PARISC_DOC: return "PARISC_DOC";
2296 get_ia64_section_type_name (unsigned int sh_type)
2298 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2299 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
2300 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
2304 case SHT_IA_64_EXT: return "IA_64_EXT";
2305 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
2306 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
2314 get_section_type_name (unsigned int sh_type)
2316 static char buff[32];
2320 case SHT_NULL: return "NULL";
2321 case SHT_PROGBITS: return "PROGBITS";
2322 case SHT_SYMTAB: return "SYMTAB";
2323 case SHT_STRTAB: return "STRTAB";
2324 case SHT_RELA: return "RELA";
2325 case SHT_HASH: return "HASH";
2326 case SHT_DYNAMIC: return "DYNAMIC";
2327 case SHT_NOTE: return "NOTE";
2328 case SHT_NOBITS: return "NOBITS";
2329 case SHT_REL: return "REL";
2330 case SHT_SHLIB: return "SHLIB";
2331 case SHT_DYNSYM: return "DYNSYM";
2332 case SHT_INIT_ARRAY: return "INIT_ARRAY";
2333 case SHT_FINI_ARRAY: return "FINI_ARRAY";
2334 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2335 case SHT_GROUP: return "GROUP";
2336 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
2337 case SHT_GNU_verdef: return "VERDEF";
2338 case SHT_GNU_verneed: return "VERNEED";
2339 case SHT_GNU_versym: return "VERSYM";
2340 case 0x6ffffff0: return "VERSYM";
2341 case 0x6ffffffc: return "VERDEF";
2342 case 0x7ffffffd: return "AUXILIARY";
2343 case 0x7fffffff: return "FILTER";
2344 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
2347 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
2351 switch (elf_header.e_machine)
2354 case EM_MIPS_RS3_LE:
2355 result = get_mips_section_type_name (sh_type);
2358 result = get_parisc_section_type_name (sh_type);
2361 result = get_ia64_section_type_name (sh_type);
2371 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
2373 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
2374 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
2375 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
2376 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
2378 sprintf (buff, _("<unknown>: %x"), sh_type);
2384 #define OPTION_DEBUG_DUMP 512
2386 struct option options[] =
2388 {"all", no_argument, 0, 'a'},
2389 {"file-header", no_argument, 0, 'h'},
2390 {"program-headers", no_argument, 0, 'l'},
2391 {"headers", no_argument, 0, 'e'},
2392 {"histogram", no_argument, 0, 'I'},
2393 {"segments", no_argument, 0, 'l'},
2394 {"sections", no_argument, 0, 'S'},
2395 {"section-headers", no_argument, 0, 'S'},
2396 {"symbols", no_argument, 0, 's'},
2397 {"syms", no_argument, 0, 's'},
2398 {"relocs", no_argument, 0, 'r'},
2399 {"notes", no_argument, 0, 'n'},
2400 {"dynamic", no_argument, 0, 'd'},
2401 {"arch-specific", no_argument, 0, 'A'},
2402 {"version-info", no_argument, 0, 'V'},
2403 {"use-dynamic", no_argument, 0, 'D'},
2404 {"hex-dump", required_argument, 0, 'x'},
2405 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
2406 {"unwind", no_argument, 0, 'u'},
2407 #ifdef SUPPORT_DISASSEMBLY
2408 {"instruction-dump", required_argument, 0, 'i'},
2411 {"version", no_argument, 0, 'v'},
2412 {"wide", no_argument, 0, 'W'},
2413 {"help", no_argument, 0, 'H'},
2414 {0, no_argument, 0, 0}
2420 fprintf (stdout, _("Usage: readelf <option(s)> elf-file(s)\n"));
2421 fprintf (stdout, _(" Display information about the contents of ELF format files\n"));
2422 fprintf (stdout, _(" Options are:\n\
2423 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2424 -h --file-header Display the ELF file header\n\
2425 -l --program-headers Display the program headers\n\
2426 --segments An alias for --program-headers\n\
2427 -S --section-headers Display the sections' header\n\
2428 --sections An alias for --section-headers\n\
2429 -e --headers Equivalent to: -h -l -S\n\
2430 -s --syms Display the symbol table\n\
2431 --symbols An alias for --syms\n\
2432 -n --notes Display the core notes (if present)\n\
2433 -r --relocs Display the relocations (if present)\n\
2434 -u --unwind Display the unwind info (if present)\n\
2435 -d --dynamic Display the dynamic segment (if present)\n\
2436 -V --version-info Display the version sections (if present)\n\
2437 -A --arch-specific Display architecture specific information (if any).\n\
2438 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2439 -x --hex-dump=<number> Dump the contents of section <number>\n\
2440 -w[liaprmfFso] or\n\
2441 --debug-dump[=line,=info,=abbrev,=pubnames,=ranges,=macro,=frames,=str,=loc]\n\
2442 Display the contents of DWARF2 debug sections\n"));
2443 #ifdef SUPPORT_DISASSEMBLY
2444 fprintf (stdout, _("\
2445 -i --instruction-dump=<number>\n\
2446 Disassemble the contents of section <number>\n"));
2448 fprintf (stdout, _("\
2449 -I --histogram Display histogram of bucket list lengths\n\
2450 -W --wide Allow output width to exceed 80 characters\n\
2451 -H --help Display this information\n\
2452 -v --version Display the version number of readelf\n"));
2453 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
2459 request_dump (unsigned int section, int type)
2461 if (section >= num_dump_sects)
2463 char *new_dump_sects;
2465 new_dump_sects = calloc (section + 1, 1);
2467 if (new_dump_sects == NULL)
2468 error (_("Out of memory allocating dump request table."));
2471 /* Copy current flag settings. */
2472 memcpy (new_dump_sects, dump_sects, num_dump_sects);
2476 dump_sects = new_dump_sects;
2477 num_dump_sects = section + 1;
2482 dump_sects[section] |= type;
2488 parse_args (int argc, char **argv)
2495 while ((c = getopt_long
2496 (argc, argv, "ersuahnldSDAIw::x:i:vVWH", options, NULL)) != EOF)
2563 section = strtoul (optarg, & cp, 0);
2564 if (! *cp && section >= 0)
2566 request_dump (section, HEX_DUMP);
2576 unsigned int index = 0;
2580 while (optarg[index])
2581 switch (optarg[index++])
2590 do_debug_abbrevs = 1;
2600 do_debug_pubnames = 1;
2605 do_debug_aranges = 1;
2609 do_debug_frames_interp = 1;
2611 do_debug_frames = 1;
2616 do_debug_macinfo = 1;
2630 warn (_("Unrecognized debug option '%s'\n"), optarg);
2635 case OPTION_DEBUG_DUMP:
2641 static const char *debug_dump_opt[]
2642 = { "line", "info", "abbrev", "pubnames", "ranges",
2643 "macro", "frames", "frames-interp", "str", "loc", NULL };
2652 for (index = 0; debug_dump_opt[index]; index++)
2654 size_t len = strlen (debug_dump_opt[index]);
2656 if (strncmp (p, debug_dump_opt[index], len) == 0
2657 && (p[len] == ',' || p[len] == '\0'))
2666 do_debug_abbrevs = 1;
2677 do_debug_pubnames = 1;
2681 do_debug_aranges = 1;
2686 do_debug_frames_interp = 1;
2687 do_debug_frames = 1;
2691 do_debug_macinfo = 1;
2704 if (debug_dump_opt[index] == NULL)
2706 warn (_("Unrecognized debug option '%s'\n"), p);
2707 p = strchr (p, ',');
2717 #ifdef SUPPORT_DISASSEMBLY
2720 section = strtoul (optarg, & cp, 0);
2721 if (! *cp && section >= 0)
2723 request_dump (section, DISASS_DUMP);
2729 print_version (program_name);
2739 /* xgettext:c-format */
2740 error (_("Invalid option '-%c'\n"), c);
2747 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
2748 && !do_segments && !do_header && !do_dump && !do_version
2749 && !do_histogram && !do_debugging && !do_arch && !do_notes)
2753 warn (_("Nothing to do.\n"));
2759 get_elf_class (unsigned int elf_class)
2761 static char buff[32];
2765 case ELFCLASSNONE: return _("none");
2766 case ELFCLASS32: return "ELF32";
2767 case ELFCLASS64: return "ELF64";
2769 sprintf (buff, _("<unknown: %x>"), elf_class);
2775 get_data_encoding (unsigned int encoding)
2777 static char buff[32];
2781 case ELFDATANONE: return _("none");
2782 case ELFDATA2LSB: return _("2's complement, little endian");
2783 case ELFDATA2MSB: return _("2's complement, big endian");
2785 sprintf (buff, _("<unknown: %x>"), encoding);
2790 /* Decode the data held in 'elf_header'. */
2793 process_file_header (void)
2795 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
2796 || elf_header.e_ident[EI_MAG1] != ELFMAG1
2797 || elf_header.e_ident[EI_MAG2] != ELFMAG2
2798 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
2801 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2809 printf (_("ELF Header:\n"));
2810 printf (_(" Magic: "));
2811 for (i = 0; i < EI_NIDENT; i++)
2812 printf ("%2.2x ", elf_header.e_ident[i]);
2814 printf (_(" Class: %s\n"),
2815 get_elf_class (elf_header.e_ident[EI_CLASS]));
2816 printf (_(" Data: %s\n"),
2817 get_data_encoding (elf_header.e_ident[EI_DATA]));
2818 printf (_(" Version: %d %s\n"),
2819 elf_header.e_ident[EI_VERSION],
2820 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
2822 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2825 printf (_(" OS/ABI: %s\n"),
2826 get_osabi_name (elf_header.e_ident[EI_OSABI]));
2827 printf (_(" ABI Version: %d\n"),
2828 elf_header.e_ident[EI_ABIVERSION]);
2829 printf (_(" Type: %s\n"),
2830 get_file_type (elf_header.e_type));
2831 printf (_(" Machine: %s\n"),
2832 get_machine_name (elf_header.e_machine));
2833 printf (_(" Version: 0x%lx\n"),
2834 (unsigned long) elf_header.e_version);
2836 printf (_(" Entry point address: "));
2837 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2838 printf (_("\n Start of program headers: "));
2839 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
2840 printf (_(" (bytes into file)\n Start of section headers: "));
2841 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
2842 printf (_(" (bytes into file)\n"));
2844 printf (_(" Flags: 0x%lx%s\n"),
2845 (unsigned long) elf_header.e_flags,
2846 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
2847 printf (_(" Size of this header: %ld (bytes)\n"),
2848 (long) elf_header.e_ehsize);
2849 printf (_(" Size of program headers: %ld (bytes)\n"),
2850 (long) elf_header.e_phentsize);
2851 printf (_(" Number of program headers: %ld\n"),
2852 (long) elf_header.e_phnum);
2853 printf (_(" Size of section headers: %ld (bytes)\n"),
2854 (long) elf_header.e_shentsize);
2855 printf (_(" Number of section headers: %ld"),
2856 (long) elf_header.e_shnum);
2857 if (section_headers != NULL && elf_header.e_shnum == 0)
2858 printf (" (%ld)", (long) section_headers[0].sh_size);
2859 putc ('\n', stdout);
2860 printf (_(" Section header string table index: %ld"),
2861 (long) elf_header.e_shstrndx);
2862 if (section_headers != NULL && elf_header.e_shstrndx == SHN_XINDEX)
2863 printf (" (%ld)", (long) section_headers[0].sh_link);
2864 putc ('\n', stdout);
2867 if (section_headers != NULL)
2869 if (elf_header.e_shnum == 0)
2870 elf_header.e_shnum = section_headers[0].sh_size;
2871 if (elf_header.e_shstrndx == SHN_XINDEX)
2872 elf_header.e_shstrndx = section_headers[0].sh_link;
2873 free (section_headers);
2874 section_headers = NULL;
2882 get_32bit_program_headers (FILE *file, Elf_Internal_Phdr *program_headers)
2884 Elf32_External_Phdr *phdrs;
2885 Elf32_External_Phdr *external;
2886 Elf_Internal_Phdr *internal;
2889 phdrs = get_data (NULL, file, elf_header.e_phoff,
2890 elf_header.e_phentsize * elf_header.e_phnum,
2891 _("program headers"));
2895 for (i = 0, internal = program_headers, external = phdrs;
2896 i < elf_header.e_phnum;
2897 i++, internal++, external++)
2899 internal->p_type = BYTE_GET (external->p_type);
2900 internal->p_offset = BYTE_GET (external->p_offset);
2901 internal->p_vaddr = BYTE_GET (external->p_vaddr);
2902 internal->p_paddr = BYTE_GET (external->p_paddr);
2903 internal->p_filesz = BYTE_GET (external->p_filesz);
2904 internal->p_memsz = BYTE_GET (external->p_memsz);
2905 internal->p_flags = BYTE_GET (external->p_flags);
2906 internal->p_align = BYTE_GET (external->p_align);
2915 get_64bit_program_headers (FILE *file, Elf_Internal_Phdr *program_headers)
2917 Elf64_External_Phdr *phdrs;
2918 Elf64_External_Phdr *external;
2919 Elf_Internal_Phdr *internal;
2922 phdrs = get_data (NULL, file, elf_header.e_phoff,
2923 elf_header.e_phentsize * elf_header.e_phnum,
2924 _("program headers"));
2928 for (i = 0, internal = program_headers, external = phdrs;
2929 i < elf_header.e_phnum;
2930 i++, internal++, external++)
2932 internal->p_type = BYTE_GET (external->p_type);
2933 internal->p_flags = BYTE_GET (external->p_flags);
2934 internal->p_offset = BYTE_GET8 (external->p_offset);
2935 internal->p_vaddr = BYTE_GET8 (external->p_vaddr);
2936 internal->p_paddr = BYTE_GET8 (external->p_paddr);
2937 internal->p_filesz = BYTE_GET8 (external->p_filesz);
2938 internal->p_memsz = BYTE_GET8 (external->p_memsz);
2939 internal->p_align = BYTE_GET8 (external->p_align);
2947 /* Returns 1 if the program headers were read into `program_headers'. */
2950 get_program_headers (FILE *file)
2952 Elf_Internal_Phdr *phdrs;
2954 /* Check cache of prior read. */
2955 if (program_headers != NULL)
2958 phdrs = malloc (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
2962 error (_("Out of memory\n"));
2967 ? get_32bit_program_headers (file, phdrs)
2968 : get_64bit_program_headers (file, phdrs))
2970 program_headers = phdrs;
2978 /* Returns 1 if the program headers were loaded. */
2981 process_program_headers (FILE *file)
2983 Elf_Internal_Phdr *segment;
2986 if (elf_header.e_phnum == 0)
2989 printf (_("\nThere are no program headers in this file.\n"));
2993 if (do_segments && !do_header)
2995 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
2996 printf (_("Entry point "));
2997 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2998 printf (_("\nThere are %d program headers, starting at offset "),
2999 elf_header.e_phnum);
3000 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3004 if (! get_program_headers (file))
3009 if (elf_header.e_phnum > 1)
3010 printf (_("\nProgram Headers:\n"));
3012 printf (_("\nProgram Headers:\n"));
3016 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3019 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3023 (_(" Type Offset VirtAddr PhysAddr\n"));
3025 (_(" FileSiz MemSiz Flags Align\n"));
3032 for (i = 0, segment = program_headers;
3033 i < elf_header.e_phnum;
3038 printf (" %-14.14s ", get_segment_type (segment->p_type));
3042 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3043 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
3044 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
3045 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
3046 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
3048 (segment->p_flags & PF_R ? 'R' : ' '),
3049 (segment->p_flags & PF_W ? 'W' : ' '),
3050 (segment->p_flags & PF_X ? 'E' : ' '));
3051 printf ("%#lx", (unsigned long) segment->p_align);
3055 if ((unsigned long) segment->p_offset == segment->p_offset)
3056 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3059 print_vma (segment->p_offset, FULL_HEX);
3063 print_vma (segment->p_vaddr, FULL_HEX);
3065 print_vma (segment->p_paddr, FULL_HEX);
3068 if ((unsigned long) segment->p_filesz == segment->p_filesz)
3069 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
3072 print_vma (segment->p_filesz, FULL_HEX);
3076 if ((unsigned long) segment->p_memsz == segment->p_memsz)
3077 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
3080 print_vma (segment->p_offset, FULL_HEX);
3084 (segment->p_flags & PF_R ? 'R' : ' '),
3085 (segment->p_flags & PF_W ? 'W' : ' '),
3086 (segment->p_flags & PF_X ? 'E' : ' '));
3088 if ((unsigned long) segment->p_align == segment->p_align)
3089 printf ("%#lx", (unsigned long) segment->p_align);
3092 print_vma (segment->p_align, PREFIX_HEX);
3097 print_vma (segment->p_offset, FULL_HEX);
3099 print_vma (segment->p_vaddr, FULL_HEX);
3101 print_vma (segment->p_paddr, FULL_HEX);
3103 print_vma (segment->p_filesz, FULL_HEX);
3105 print_vma (segment->p_memsz, FULL_HEX);
3107 (segment->p_flags & PF_R ? 'R' : ' '),
3108 (segment->p_flags & PF_W ? 'W' : ' '),
3109 (segment->p_flags & PF_X ? 'E' : ' '));
3110 print_vma (segment->p_align, HEX);
3114 switch (segment->p_type)
3118 error (_("more than one dynamic segment\n"));
3120 dynamic_addr = segment->p_offset;
3121 dynamic_size = segment->p_filesz;
3125 if (fseek (file, archive_file_offset + (long) segment->p_offset,
3127 error (_("Unable to find program interpreter name\n"));
3130 program_interpreter[0] = 0;
3131 fscanf (file, "%63s", program_interpreter);
3134 printf (_("\n [Requesting program interpreter: %s]"),
3135 program_interpreter);
3141 putc ('\n', stdout);
3144 if (do_segments && section_headers != NULL)
3146 printf (_("\n Section to Segment mapping:\n"));
3147 printf (_(" Segment Sections...\n"));
3149 assert (string_table != NULL);
3151 for (i = 0; i < elf_header.e_phnum; i++)
3154 Elf_Internal_Shdr *section;
3156 segment = program_headers + i;
3157 section = section_headers;
3159 printf (" %2.2d ", i);
3161 for (j = 1; j < elf_header.e_shnum; j++, section++)
3163 if (section->sh_size > 0
3164 /* Compare allocated sections by VMA, unallocated
3165 sections by file offset. */
3166 && (section->sh_flags & SHF_ALLOC
3167 ? (section->sh_addr >= segment->p_vaddr
3168 && section->sh_addr + section->sh_size
3169 <= segment->p_vaddr + segment->p_memsz)
3170 : ((bfd_vma) section->sh_offset >= segment->p_offset
3171 && (section->sh_offset + section->sh_size
3172 <= segment->p_offset + segment->p_filesz))))
3173 printf ("%s ", SECTION_NAME (section));
3184 /* Find the file offset corresponding to VMA by using the program headers. */
3187 offset_from_vma (FILE *file, bfd_vma vma, bfd_size_type size)
3189 Elf_Internal_Phdr *seg;
3191 if (! get_program_headers (file))
3193 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3197 for (seg = program_headers;
3198 seg < program_headers + elf_header.e_phnum;
3201 if (seg->p_type != PT_LOAD)
3204 if (vma >= (seg->p_vaddr & -seg->p_align)
3205 && vma + size <= seg->p_vaddr + seg->p_filesz)
3206 return vma - seg->p_vaddr + seg->p_offset;
3209 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3216 get_32bit_section_headers (FILE *file, unsigned int num)
3218 Elf32_External_Shdr *shdrs;
3219 Elf_Internal_Shdr *internal;
3222 shdrs = get_data (NULL, file, elf_header.e_shoff,
3223 elf_header.e_shentsize * num, _("section headers"));
3227 section_headers = malloc (num * sizeof (Elf_Internal_Shdr));
3229 if (section_headers == NULL)
3231 error (_("Out of memory\n"));
3235 for (i = 0, internal = section_headers;
3239 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
3240 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
3241 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
3242 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
3243 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
3244 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
3245 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
3246 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
3247 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3248 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
3257 get_64bit_section_headers (FILE *file, unsigned int num)
3259 Elf64_External_Shdr *shdrs;
3260 Elf_Internal_Shdr *internal;
3263 shdrs = get_data (NULL, file, elf_header.e_shoff,
3264 elf_header.e_shentsize * num, _("section headers"));
3268 section_headers = malloc (num * sizeof (Elf_Internal_Shdr));
3270 if (section_headers == NULL)
3272 error (_("Out of memory\n"));
3276 for (i = 0, internal = section_headers;
3280 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
3281 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
3282 internal->sh_flags = BYTE_GET8 (shdrs[i].sh_flags);
3283 internal->sh_addr = BYTE_GET8 (shdrs[i].sh_addr);
3284 internal->sh_size = BYTE_GET8 (shdrs[i].sh_size);
3285 internal->sh_entsize = BYTE_GET8 (shdrs[i].sh_entsize);
3286 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
3287 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
3288 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
3289 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3297 static Elf_Internal_Sym *
3298 get_32bit_elf_symbols (FILE *file, Elf_Internal_Shdr *section)
3300 unsigned long number;
3301 Elf32_External_Sym *esyms;
3302 Elf_External_Sym_Shndx *shndx;
3303 Elf_Internal_Sym *isyms;
3304 Elf_Internal_Sym *psym;
3307 esyms = get_data (NULL, file, section->sh_offset, section->sh_size,
3313 if (symtab_shndx_hdr != NULL
3314 && (symtab_shndx_hdr->sh_link
3315 == (unsigned long) SECTION_HEADER_NUM (section - section_headers)))
3317 shndx = get_data (NULL, file, symtab_shndx_hdr->sh_offset,
3318 symtab_shndx_hdr->sh_size, _("symtab shndx"));
3326 number = section->sh_size / section->sh_entsize;
3327 isyms = malloc (number * sizeof (Elf_Internal_Sym));
3331 error (_("Out of memory\n"));
3338 for (j = 0, psym = isyms;
3342 psym->st_name = BYTE_GET (esyms[j].st_name);
3343 psym->st_value = BYTE_GET (esyms[j].st_value);
3344 psym->st_size = BYTE_GET (esyms[j].st_size);
3345 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
3346 if (psym->st_shndx == SHN_XINDEX && shndx != NULL)
3348 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
3349 psym->st_info = BYTE_GET (esyms[j].st_info);
3350 psym->st_other = BYTE_GET (esyms[j].st_other);
3360 static Elf_Internal_Sym *
3361 get_64bit_elf_symbols (FILE *file, Elf_Internal_Shdr *section)
3363 unsigned long number;
3364 Elf64_External_Sym *esyms;
3365 Elf_External_Sym_Shndx *shndx;
3366 Elf_Internal_Sym *isyms;
3367 Elf_Internal_Sym *psym;
3370 esyms = get_data (NULL, file, section->sh_offset, section->sh_size,
3376 if (symtab_shndx_hdr != NULL
3377 && (symtab_shndx_hdr->sh_link
3378 == (unsigned long) SECTION_HEADER_NUM (section - section_headers)))
3380 shndx = get_data (NULL, file, symtab_shndx_hdr->sh_offset,
3381 symtab_shndx_hdr->sh_size, _("symtab shndx"));
3389 number = section->sh_size / section->sh_entsize;
3390 isyms = malloc (number * sizeof (Elf_Internal_Sym));
3394 error (_("Out of memory\n"));
3401 for (j = 0, psym = isyms;
3405 psym->st_name = BYTE_GET (esyms[j].st_name);
3406 psym->st_info = BYTE_GET (esyms[j].st_info);
3407 psym->st_other = BYTE_GET (esyms[j].st_other);
3408 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
3409 if (psym->st_shndx == SHN_XINDEX && shndx != NULL)
3411 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
3412 psym->st_value = BYTE_GET8 (esyms[j].st_value);
3413 psym->st_size = BYTE_GET8 (esyms[j].st_size);
3424 get_elf_section_flags (bfd_vma sh_flags)
3426 static char buff[32];
3434 flag = sh_flags & - sh_flags;
3439 case SHF_WRITE: strcat (buff, "W"); break;
3440 case SHF_ALLOC: strcat (buff, "A"); break;
3441 case SHF_EXECINSTR: strcat (buff, "X"); break;
3442 case SHF_MERGE: strcat (buff, "M"); break;
3443 case SHF_STRINGS: strcat (buff, "S"); break;
3444 case SHF_INFO_LINK: strcat (buff, "I"); break;
3445 case SHF_LINK_ORDER: strcat (buff, "L"); break;
3446 case SHF_OS_NONCONFORMING: strcat (buff, "O"); break;
3447 case SHF_GROUP: strcat (buff, "G"); break;
3448 case SHF_TLS: strcat (buff, "T"); break;
3451 if (flag & SHF_MASKOS)
3454 sh_flags &= ~ SHF_MASKOS;
3456 else if (flag & SHF_MASKPROC)
3459 sh_flags &= ~ SHF_MASKPROC;
3471 process_section_headers (FILE *file)
3473 Elf_Internal_Shdr *section;
3476 section_headers = NULL;
3478 if (elf_header.e_shnum == 0)
3481 printf (_("\nThere are no sections in this file.\n"));
3486 if (do_sections && !do_header)
3487 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3488 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
3492 if (! get_32bit_section_headers (file, elf_header.e_shnum))
3495 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
3498 /* Read in the string table, so that we have names to display. */
3499 section = SECTION_HEADER (elf_header.e_shstrndx);
3501 if (section->sh_size != 0)
3503 string_table = get_data (NULL, file, section->sh_offset,
3504 section->sh_size, _("string table"));
3506 if (string_table == NULL)
3509 string_table_length = section->sh_size;
3512 /* Scan the sections for the dynamic symbol table
3513 and dynamic string table and debug sections. */
3514 dynamic_symbols = NULL;
3515 dynamic_strings = NULL;
3516 dynamic_syminfo = NULL;
3517 symtab_shndx_hdr = NULL;
3519 for (i = 0, section = section_headers;
3520 i < elf_header.e_shnum;
3523 char *name = SECTION_NAME (section);
3525 if (section->sh_type == SHT_DYNSYM)
3527 if (dynamic_symbols != NULL)
3529 error (_("File contains multiple dynamic symbol tables\n"));
3533 num_dynamic_syms = section->sh_size / section->sh_entsize;
3534 dynamic_symbols = GET_ELF_SYMBOLS (file, section);
3536 else if (section->sh_type == SHT_STRTAB
3537 && strcmp (name, ".dynstr") == 0)
3539 if (dynamic_strings != NULL)
3541 error (_("File contains multiple dynamic string tables\n"));
3545 dynamic_strings = get_data (NULL, file, section->sh_offset,
3546 section->sh_size, _("dynamic strings"));
3548 else if (section->sh_type == SHT_SYMTAB_SHNDX)
3550 if (symtab_shndx_hdr != NULL)
3552 error (_("File contains multiple symtab shndx tables\n"));
3555 symtab_shndx_hdr = section;
3557 else if ((do_debugging || do_debug_info || do_debug_abbrevs
3558 || do_debug_lines || do_debug_pubnames || do_debug_aranges
3559 || do_debug_frames || do_debug_macinfo || do_debug_str
3561 && strncmp (name, ".debug_", 7) == 0)
3566 || (do_debug_info && (strcmp (name, "info") == 0))
3567 || (do_debug_abbrevs && (strcmp (name, "abbrev") == 0))
3568 || (do_debug_lines && (strcmp (name, "line") == 0))
3569 || (do_debug_pubnames && (strcmp (name, "pubnames") == 0))
3570 || (do_debug_aranges && (strcmp (name, "aranges") == 0))
3571 || (do_debug_frames && (strcmp (name, "frame") == 0))
3572 || (do_debug_macinfo && (strcmp (name, "macinfo") == 0))
3573 || (do_debug_str && (strcmp (name, "str") == 0))
3574 || (do_debug_loc && (strcmp (name, "loc") == 0))
3576 request_dump (i, DEBUG_DUMP);
3578 /* linkonce section to be combined with .debug_info at link time. */
3579 else if ((do_debugging || do_debug_info)
3580 && strncmp (name, ".gnu.linkonce.wi.", 17) == 0)
3581 request_dump (i, DEBUG_DUMP);
3582 else if (do_debug_frames && strcmp (name, ".eh_frame") == 0)
3583 request_dump (i, DEBUG_DUMP);
3589 if (elf_header.e_shnum > 1)
3590 printf (_("\nSection Headers:\n"));
3592 printf (_("\nSection Header:\n"));
3596 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
3599 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
3602 printf (_(" [Nr] Name Type Address Offset\n"));
3603 printf (_(" Size EntSize Flags Link Info Align\n"));
3606 for (i = 0, section = section_headers;
3607 i < elf_header.e_shnum;
3610 printf (" [%2u] %-17.17s %-15.15s ",
3611 SECTION_HEADER_NUM (i),
3612 SECTION_NAME (section),
3613 get_section_type_name (section->sh_type));
3617 print_vma (section->sh_addr, LONG_HEX);
3619 printf ( " %6.6lx %6.6lx %2.2lx",
3620 (unsigned long) section->sh_offset,
3621 (unsigned long) section->sh_size,
3622 (unsigned long) section->sh_entsize);
3624 printf (" %3s ", get_elf_section_flags (section->sh_flags));
3626 printf ("%2ld %3lx %2ld\n",
3627 (unsigned long) section->sh_link,
3628 (unsigned long) section->sh_info,
3629 (unsigned long) section->sh_addralign);
3633 print_vma (section->sh_addr, LONG_HEX);
3635 if ((long) section->sh_offset == section->sh_offset)
3636 printf (" %6.6lx", (unsigned long) section->sh_offset);
3640 print_vma (section->sh_offset, LONG_HEX);
3643 if ((unsigned long) section->sh_size == section->sh_size)
3644 printf (" %6.6lx", (unsigned long) section->sh_size);
3648 print_vma (section->sh_size, LONG_HEX);
3651 if ((unsigned long) section->sh_entsize == section->sh_entsize)
3652 printf (" %2.2lx", (unsigned long) section->sh_entsize);
3656 print_vma (section->sh_entsize, LONG_HEX);
3659 printf (" %3s ", get_elf_section_flags (section->sh_flags));
3661 printf ("%2ld %3lx ",
3662 (unsigned long) section->sh_link,
3663 (unsigned long) section->sh_info);
3665 if ((unsigned long) section->sh_addralign == section->sh_addralign)
3666 printf ("%2ld\n", (unsigned long) section->sh_addralign);
3669 print_vma (section->sh_addralign, DEC);
3676 print_vma (section->sh_addr, LONG_HEX);
3677 if ((long) section->sh_offset == section->sh_offset)
3678 printf (" %8.8lx", (unsigned long) section->sh_offset);
3682 print_vma (section->sh_offset, LONG_HEX);
3685 print_vma (section->sh_size, LONG_HEX);
3687 print_vma (section->sh_entsize, LONG_HEX);
3689 printf (" %3s ", get_elf_section_flags (section->sh_flags));
3691 printf (" %2ld %3lx %ld\n",
3692 (unsigned long) section->sh_link,
3693 (unsigned long) section->sh_info,
3694 (unsigned long) section->sh_addralign);
3698 printf (_("Key to Flags:\n\
3699 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
3700 I (info), L (link order), G (group), x (unknown)\n\
3701 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3712 } dynamic_relocations [] =
3714 { "REL", DT_REL, DT_RELSZ, FALSE },
3715 { "RELA", DT_RELA, DT_RELASZ, TRUE },
3716 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
3719 /* Process the reloc section. */
3721 process_relocs (FILE *file)
3723 unsigned long rel_size;
3724 unsigned long rel_offset;
3730 if (do_using_dynamic)
3734 int has_dynamic_reloc;
3737 has_dynamic_reloc = 0;
3739 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
3741 is_rela = dynamic_relocations [i].rela;
3742 name = dynamic_relocations [i].name;
3743 rel_size = dynamic_info [dynamic_relocations [i].size];
3744 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
3746 has_dynamic_reloc |= rel_size;
3748 if (is_rela == UNKNOWN)
3750 if (dynamic_relocations [i].reloc == DT_JMPREL)
3751 switch (dynamic_info[DT_PLTREL])
3765 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
3766 name, rel_offset, rel_size);
3768 dump_relocations (file,
3769 offset_from_vma (file, rel_offset, rel_size),
3771 dynamic_symbols, num_dynamic_syms,
3772 dynamic_strings, is_rela);
3776 if (! has_dynamic_reloc)
3777 printf (_("\nThere are no dynamic relocations in this file.\n"));
3781 Elf_Internal_Shdr *section;
3785 for (i = 0, section = section_headers;
3786 i < elf_header.e_shnum;
3789 if ( section->sh_type != SHT_RELA
3790 && section->sh_type != SHT_REL)
3793 rel_offset = section->sh_offset;
3794 rel_size = section->sh_size;
3798 Elf_Internal_Shdr *strsec;
3799 Elf_Internal_Sym *symtab;
3802 unsigned long nsyms;
3804 printf (_("\nRelocation section "));
3806 if (string_table == NULL)
3807 printf ("%d", section->sh_name);
3809 printf (_("'%s'"), SECTION_NAME (section));
3811 printf (_(" at offset 0x%lx contains %lu entries:\n"),
3812 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
3817 if (section->sh_link)
3819 Elf_Internal_Shdr *symsec;
3821 symsec = SECTION_HEADER (section->sh_link);
3822 nsyms = symsec->sh_size / symsec->sh_entsize;
3823 symtab = GET_ELF_SYMBOLS (file, symsec);
3828 strsec = SECTION_HEADER (symsec->sh_link);
3830 strtab = get_data (NULL, file, strsec->sh_offset,
3831 strsec->sh_size, _("string table"));
3833 is_rela = section->sh_type == SHT_RELA;
3835 dump_relocations (file, rel_offset, rel_size,
3836 symtab, nsyms, strtab, is_rela);
3848 printf (_("\nThere are no relocations in this file.\n"));
3854 #include "unwind-ia64.h"
3856 /* An absolute address consists of a section and an offset. If the
3857 section is NULL, the offset itself is the address, otherwise, the
3858 address equals to LOAD_ADDRESS(section) + offset. */
3862 unsigned short section;
3868 struct unw_table_entry
3870 struct absaddr start;
3872 struct absaddr info;
3874 *table; /* Unwind table. */
3875 unsigned long table_len; /* Length of unwind table. */
3876 unsigned char *info; /* Unwind info. */
3877 unsigned long info_size; /* Size of unwind info. */
3878 bfd_vma info_addr; /* starting address of unwind info. */
3879 bfd_vma seg_base; /* Starting address of segment. */
3880 Elf_Internal_Sym *symtab; /* The symbol table. */
3881 unsigned long nsyms; /* Number of symbols. */
3882 char *strtab; /* The string table. */
3883 unsigned long strtab_size; /* Size of string table. */
3887 find_symbol_for_address (struct unw_aux_info *aux,
3888 struct absaddr addr,
3889 const char **symname,
3892 bfd_vma dist = 0x100000;
3893 Elf_Internal_Sym *sym, *best = NULL;
3896 for (i = 0, sym = aux->symtab; i < aux->nsyms; ++i, ++sym)
3898 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
3899 && sym->st_name != 0
3900 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
3901 && addr.offset >= sym->st_value
3902 && addr.offset - sym->st_value < dist)
3905 dist = addr.offset - sym->st_value;
3912 *symname = (best->st_name >= aux->strtab_size
3913 ? "<corrupt>" : aux->strtab + best->st_name);
3918 *offset = addr.offset;
3922 dump_ia64_unwind (struct unw_aux_info *aux)
3925 struct unw_table_entry *tp;
3928 addr_size = is_32bit_elf ? 4 : 8;
3930 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
3934 const unsigned char *dp;
3935 const unsigned char *head;
3936 const char *procname;
3938 find_symbol_for_address (aux, tp->start, &procname, &offset);
3940 fputs ("\n<", stdout);
3944 fputs (procname, stdout);
3947 printf ("+%lx", (unsigned long) offset);
3950 fputs (">: [", stdout);
3951 print_vma (tp->start.offset, PREFIX_HEX);
3952 fputc ('-', stdout);
3953 print_vma (tp->end.offset, PREFIX_HEX);
3954 printf ("], info at +0x%lx\n",
3955 (unsigned long) (tp->info.offset - aux->seg_base));
3957 head = aux->info + (tp->info.offset - aux->info_addr);
3958 stamp = BYTE_GET8 ((unsigned char *) head);
3960 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
3961 (unsigned) UNW_VER (stamp),
3962 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
3963 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
3964 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
3965 (unsigned long) (addr_size * UNW_LENGTH (stamp)));
3967 if (UNW_VER (stamp) != 1)
3969 printf ("\tUnknown version.\n");
3974 for (dp = head + 8; dp < head + 8 + addr_size * UNW_LENGTH (stamp);)
3975 dp = unw_decode (dp, in_body, & in_body);
3980 slurp_ia64_unwind_table (FILE *file,
3981 struct unw_aux_info *aux,
3982 Elf_Internal_Shdr *sec)
3984 unsigned long size, addr_size, nrelas, i;
3985 Elf_Internal_Phdr *seg;
3986 struct unw_table_entry *tep;
3987 Elf_Internal_Shdr *relsec;
3988 Elf_Internal_Rela *rela, *rp;
3989 unsigned char *table, *tp;
3990 Elf_Internal_Sym *sym;
3991 const char *relname;
3993 addr_size = is_32bit_elf ? 4 : 8;
3995 /* First, find the starting address of the segment that includes
3998 if (elf_header.e_phnum)
4000 if (! get_program_headers (file))
4003 for (seg = program_headers;
4004 seg < program_headers + elf_header.e_phnum;
4007 if (seg->p_type != PT_LOAD)
4010 if (sec->sh_addr >= seg->p_vaddr
4011 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
4013 aux->seg_base = seg->p_vaddr;
4019 /* Second, build the unwind table from the contents of the unwind section: */
4020 size = sec->sh_size;
4021 table = get_data (NULL, file, sec->sh_offset, size, _("unwind table"));
4025 tep = aux->table = xmalloc (size / (3 * addr_size) * sizeof (aux->table[0]));
4026 for (tp = table; tp < table + size; tp += 3 * addr_size, ++tep)
4028 tep->start.section = SHN_UNDEF;
4029 tep->end.section = SHN_UNDEF;
4030 tep->info.section = SHN_UNDEF;
4033 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
4034 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
4035 tep->info.offset = byte_get ((unsigned char *) tp + 8, 4);
4039 tep->start.offset = BYTE_GET8 ((unsigned char *) tp + 0);
4040 tep->end.offset = BYTE_GET8 ((unsigned char *) tp + 8);
4041 tep->info.offset = BYTE_GET8 ((unsigned char *) tp + 16);
4043 tep->start.offset += aux->seg_base;
4044 tep->end.offset += aux->seg_base;
4045 tep->info.offset += aux->seg_base;
4049 /* Third, apply any relocations to the unwind table: */
4051 for (relsec = section_headers;
4052 relsec < section_headers + elf_header.e_shnum;
4055 if (relsec->sh_type != SHT_RELA
4056 || SECTION_HEADER (relsec->sh_info) != sec)
4059 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
4063 for (rp = rela; rp < rela + nrelas; ++rp)
4067 relname = elf_ia64_reloc_type (ELF32_R_TYPE (rp->r_info));
4068 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
4070 if (ELF32_ST_TYPE (sym->st_info) != STT_SECTION)
4072 warn (_("Skipping unexpected symbol type %u\n"),
4073 ELF32_ST_TYPE (sym->st_info));
4079 relname = elf_ia64_reloc_type (ELF64_R_TYPE (rp->r_info));
4080 sym = aux->symtab + ELF64_R_SYM (rp->r_info);
4082 if (ELF64_ST_TYPE (sym->st_info) != STT_SECTION)
4084 warn (_("Skipping unexpected symbol type %u\n"),
4085 ELF64_ST_TYPE (sym->st_info));
4090 if (strncmp (relname, "R_IA64_SEGREL", 13) != 0)
4092 warn (_("Skipping unexpected relocation type %s\n"), relname);
4096 i = rp->r_offset / (3 * addr_size);
4098 switch (rp->r_offset/addr_size % 3)
4101 aux->table[i].start.section = sym->st_shndx;
4102 aux->table[i].start.offset += rp->r_addend;
4105 aux->table[i].end.section = sym->st_shndx;
4106 aux->table[i].end.offset += rp->r_addend;
4109 aux->table[i].info.section = sym->st_shndx;
4110 aux->table[i].info.offset += rp->r_addend;
4120 aux->table_len = size / (3 * addr_size);
4125 process_unwind (FILE *file)
4127 Elf_Internal_Shdr *sec, *unwsec = NULL, *strsec;
4128 unsigned long i, addr_size, unwcount = 0, unwstart = 0;
4129 struct unw_aux_info aux;
4134 if (elf_header.e_machine != EM_IA_64)
4136 printf (_("\nThere are no unwind sections in this file.\n"));
4140 memset (& aux, 0, sizeof (aux));
4142 addr_size = is_32bit_elf ? 4 : 8;
4144 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
4146 if (sec->sh_type == SHT_SYMTAB)
4148 aux.nsyms = sec->sh_size / sec->sh_entsize;
4149 aux.symtab = GET_ELF_SYMBOLS (file, sec);
4151 strsec = SECTION_HEADER (sec->sh_link);
4152 aux.strtab_size = strsec->sh_size;
4153 aux.strtab = get_data (NULL, file, strsec->sh_offset,
4154 aux.strtab_size, _("string table"));
4156 else if (sec->sh_type == SHT_IA_64_UNWIND)
4161 printf (_("\nThere are no unwind sections in this file.\n"));
4163 while (unwcount-- > 0)
4168 for (i = unwstart, sec = section_headers + unwstart;
4169 i < elf_header.e_shnum; ++i, ++sec)
4170 if (sec->sh_type == SHT_IA_64_UNWIND)
4177 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
4179 if (strncmp (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once,
4182 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO */
4183 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
4184 suffix = SECTION_NAME (unwsec) + len;
4185 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
4187 if (strncmp (SECTION_NAME (sec),
4188 ELF_STRING_ia64_unwind_info_once, len2) == 0
4189 && strcmp (SECTION_NAME (sec) + len2, suffix) == 0)
4194 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
4195 .IA_64.unwind or BAR -> .IA_64.unwind_info */
4196 len = sizeof (ELF_STRING_ia64_unwind) - 1;
4197 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
4199 if (strncmp (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind,
4201 suffix = SECTION_NAME (unwsec) + len;
4202 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
4204 if (strncmp (SECTION_NAME (sec),
4205 ELF_STRING_ia64_unwind_info, len2) == 0
4206 && strcmp (SECTION_NAME (sec) + len2, suffix) == 0)
4210 if (i == elf_header.e_shnum)
4212 printf (_("\nCould not find unwind info section for "));
4214 if (string_table == NULL)
4215 printf ("%d", unwsec->sh_name);
4217 printf (_("'%s'"), SECTION_NAME (unwsec));
4221 aux.info_size = sec->sh_size;
4222 aux.info_addr = sec->sh_addr;
4223 aux.info = get_data (NULL, file, sec->sh_offset, aux.info_size,
4226 printf (_("\nUnwind section "));
4228 if (string_table == NULL)
4229 printf ("%d", unwsec->sh_name);
4231 printf (_("'%s'"), SECTION_NAME (unwsec));
4233 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4234 (unsigned long) unwsec->sh_offset,
4235 (unsigned long) (unwsec->sh_size / (3 * addr_size)));
4237 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
4239 if (aux.table_len > 0)
4240 dump_ia64_unwind (& aux);
4243 free ((char *) aux.table);
4245 free ((char *) aux.info);
4254 free ((char *) aux.strtab);
4260 dynamic_segment_mips_val (Elf_Internal_Dyn *entry)
4262 switch (entry->d_tag)
4265 if (entry->d_un.d_val == 0)
4269 static const char * opts[] =
4271 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
4272 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
4273 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
4274 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
4279 for (cnt = 0; cnt < NUM_ELEM (opts); ++cnt)
4280 if (entry->d_un.d_val & (1 << cnt))
4282 printf ("%s%s", first ? "" : " ", opts[cnt]);
4289 case DT_MIPS_IVERSION:
4290 if (dynamic_strings != NULL)
4291 printf ("Interface Version: %s\n",
4292 dynamic_strings + entry->d_un.d_val);
4294 printf ("%ld\n", (long) entry->d_un.d_ptr);
4297 case DT_MIPS_TIME_STAMP:
4302 time_t time = entry->d_un.d_val;
4303 tmp = gmtime (&time);
4304 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
4305 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
4306 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4307 printf ("Time Stamp: %s\n", timebuf);
4311 case DT_MIPS_RLD_VERSION:
4312 case DT_MIPS_LOCAL_GOTNO:
4313 case DT_MIPS_CONFLICTNO:
4314 case DT_MIPS_LIBLISTNO:
4315 case DT_MIPS_SYMTABNO:
4316 case DT_MIPS_UNREFEXTNO:
4317 case DT_MIPS_HIPAGENO:
4318 case DT_MIPS_DELTA_CLASS_NO:
4319 case DT_MIPS_DELTA_INSTANCE_NO:
4320 case DT_MIPS_DELTA_RELOC_NO:
4321 case DT_MIPS_DELTA_SYM_NO:
4322 case DT_MIPS_DELTA_CLASSSYM_NO:
4323 case DT_MIPS_COMPACT_SIZE:
4324 printf ("%ld\n", (long) entry->d_un.d_ptr);
4328 printf ("%#lx\n", (long) entry->d_un.d_ptr);
4334 dynamic_segment_parisc_val (Elf_Internal_Dyn *entry)
4336 switch (entry->d_tag)
4338 case DT_HP_DLD_FLAGS:
4347 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
4348 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
4349 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
4350 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
4351 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
4352 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
4353 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
4354 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
4355 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
4356 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
4357 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" }
4361 bfd_vma val = entry->d_un.d_val;
4363 for (cnt = 0; cnt < sizeof (flags) / sizeof (flags[0]); ++cnt)
4364 if (val & flags[cnt].bit)
4368 fputs (flags[cnt].str, stdout);
4370 val ^= flags[cnt].bit;
4373 if (val != 0 || first)
4377 print_vma (val, HEX);
4383 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
4390 dynamic_segment_ia64_val (Elf_Internal_Dyn *entry)
4392 switch (entry->d_tag)
4394 case DT_IA_64_PLT_RESERVE:
4395 /* First 3 slots reserved. */
4396 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
4398 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
4402 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
4409 get_32bit_dynamic_segment (FILE *file)
4411 Elf32_External_Dyn *edyn;
4412 Elf_Internal_Dyn *entry;
4415 edyn = get_data (NULL, file, dynamic_addr, dynamic_size,
4416 _("dynamic segment"));
4420 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
4421 how large this .dynamic is now. We can do this even before the byte
4422 swapping since the DT_NULL tag is recognizable. */
4424 while (*(Elf32_Word *) edyn[dynamic_size++].d_tag != DT_NULL)
4427 dynamic_segment = malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
4429 if (dynamic_segment == NULL)
4431 error (_("Out of memory\n"));
4436 for (i = 0, entry = dynamic_segment;
4440 entry->d_tag = BYTE_GET (edyn[i].d_tag);
4441 entry->d_un.d_val = BYTE_GET (edyn[i].d_un.d_val);
4450 get_64bit_dynamic_segment (FILE *file)
4452 Elf64_External_Dyn *edyn;
4453 Elf_Internal_Dyn *entry;
4456 edyn = get_data (NULL, file, dynamic_addr, dynamic_size,
4457 _("dynamic segment"));
4461 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
4462 how large this .dynamic is now. We can do this even before the byte
4463 swapping since the DT_NULL tag is recognizable. */
4465 while (*(bfd_vma *) edyn[dynamic_size++].d_tag != DT_NULL)
4468 dynamic_segment = malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
4470 if (dynamic_segment == NULL)
4472 error (_("Out of memory\n"));
4477 for (i = 0, entry = dynamic_segment;
4481 entry->d_tag = BYTE_GET8 (edyn[i].d_tag);
4482 entry->d_un.d_val = BYTE_GET8 (edyn[i].d_un.d_val);
4491 get_dynamic_flags (bfd_vma flags)
4493 static char buff[128];
4501 flag = flags & - flags;
4509 case DF_ORIGIN: strcpy (p, "ORIGIN"); break;
4510 case DF_SYMBOLIC: strcpy (p, "SYMBOLIC"); break;
4511 case DF_TEXTREL: strcpy (p, "TEXTREL"); break;
4512 case DF_BIND_NOW: strcpy (p, "BIND_NOW"); break;
4513 case DF_STATIC_TLS: strcpy (p, "STATIC_TLS"); break;
4514 default: strcpy (p, "unknown"); break;
4517 p = strchr (p, '\0');
4522 /* Parse and display the contents of the dynamic segment. */
4524 process_dynamic_segment (FILE *file)
4526 Elf_Internal_Dyn *entry;
4529 if (dynamic_size == 0)
4532 printf (_("\nThere is no dynamic segment in this file.\n"));
4539 if (! get_32bit_dynamic_segment (file))
4542 else if (! get_64bit_dynamic_segment (file))
4545 /* Find the appropriate symbol table. */
4546 if (dynamic_symbols == NULL)
4548 for (i = 0, entry = dynamic_segment;
4552 Elf_Internal_Shdr section;
4554 if (entry->d_tag != DT_SYMTAB)
4557 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
4559 /* Since we do not know how big the symbol table is,
4560 we default to reading in the entire file (!) and
4561 processing that. This is overkill, I know, but it
4563 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
4565 if (archive_file_offset != 0)
4566 section.sh_size = archive_file_size - section.sh_offset;
4569 if (fseek (file, 0, SEEK_END))
4570 error (_("Unable to seek to end of file!"));
4572 section.sh_size = ftell (file) - section.sh_offset;
4576 section.sh_entsize = sizeof (Elf32_External_Sym);
4578 section.sh_entsize = sizeof (Elf64_External_Sym);
4580 num_dynamic_syms = section.sh_size / section.sh_entsize;
4581 if (num_dynamic_syms < 1)
4583 error (_("Unable to determine the number of symbols to load\n"));
4587 dynamic_symbols = GET_ELF_SYMBOLS (file, §ion);
4591 /* Similarly find a string table. */
4592 if (dynamic_strings == NULL)
4594 for (i = 0, entry = dynamic_segment;
4598 unsigned long offset;
4601 if (entry->d_tag != DT_STRTAB)
4604 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
4606 /* Since we do not know how big the string table is,
4607 we default to reading in the entire file (!) and
4608 processing that. This is overkill, I know, but it
4611 offset = offset_from_vma (file, entry->d_un.d_val, 0);
4613 if (archive_file_offset != 0)
4614 str_tab_len = archive_file_size - offset;
4617 if (fseek (file, 0, SEEK_END))
4618 error (_("Unable to seek to end of file\n"));
4619 str_tab_len = ftell (file) - offset;
4622 if (str_tab_len < 1)
4625 (_("Unable to determine the length of the dynamic string table\n"));
4629 dynamic_strings = get_data (NULL, file, offset, str_tab_len,
4630 _("dynamic string table"));
4635 /* And find the syminfo section if available. */
4636 if (dynamic_syminfo == NULL)
4638 unsigned long syminsz = 0;
4640 for (i = 0, entry = dynamic_segment;
4644 if (entry->d_tag == DT_SYMINENT)
4646 /* Note: these braces are necessary to avoid a syntax
4647 error from the SunOS4 C compiler. */
4648 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
4650 else if (entry->d_tag == DT_SYMINSZ)
4651 syminsz = entry->d_un.d_val;
4652 else if (entry->d_tag == DT_SYMINFO)
4653 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
4657 if (dynamic_syminfo_offset != 0 && syminsz != 0)
4659 Elf_External_Syminfo *extsyminfo;
4660 Elf_Internal_Syminfo *syminfo;
4662 /* There is a syminfo section. Read the data. */
4663 extsyminfo = get_data (NULL, file, dynamic_syminfo_offset, syminsz,
4664 _("symbol information"));
4668 dynamic_syminfo = malloc (syminsz);
4669 if (dynamic_syminfo == NULL)
4671 error (_("Out of memory\n"));
4675 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
4676 for (i = 0, syminfo = dynamic_syminfo; i < dynamic_syminfo_nent;
4679 syminfo->si_boundto = BYTE_GET (extsyminfo[i].si_boundto);
4680 syminfo->si_flags = BYTE_GET (extsyminfo[i].si_flags);
4687 if (do_dynamic && dynamic_addr)
4688 printf (_("\nDynamic segment at offset 0x%lx contains %ld entries:\n"),
4689 dynamic_addr, (long) dynamic_size);
4691 printf (_(" Tag Type Name/Value\n"));
4693 for (i = 0, entry = dynamic_segment;
4702 print_vma (entry->d_tag, FULL_HEX);
4703 dtype = get_dynamic_type (entry->d_tag);
4704 printf (" (%s)%*s", dtype,
4705 ((is_32bit_elf ? 27 : 19)
4706 - (int) strlen (dtype)),
4710 switch (entry->d_tag)
4714 puts (get_dynamic_flags (entry->d_un.d_val));
4724 switch (entry->d_tag)
4727 printf (_("Auxiliary library"));
4731 printf (_("Filter library"));
4735 printf (_("Configuration file"));
4739 printf (_("Dependency audit library"));
4743 printf (_("Audit library"));
4747 if (dynamic_strings)
4748 printf (": [%s]\n", dynamic_strings + entry->d_un.d_val);
4752 print_vma (entry->d_un.d_val, PREFIX_HEX);
4761 printf (_("Flags:"));
4763 if (entry->d_un.d_val == 0)
4764 printf (_(" None\n"));
4767 unsigned long int val = entry->d_un.d_val;
4769 if (val & DTF_1_PARINIT)
4771 printf (" PARINIT");
4772 val ^= DTF_1_PARINIT;
4774 if (val & DTF_1_CONFEXP)
4776 printf (" CONFEXP");
4777 val ^= DTF_1_CONFEXP;
4780 printf (" %lx", val);
4789 printf (_("Flags:"));
4791 if (entry->d_un.d_val == 0)
4792 printf (_(" None\n"));
4795 unsigned long int val = entry->d_un.d_val;
4797 if (val & DF_P1_LAZYLOAD)
4799 printf (" LAZYLOAD");
4800 val ^= DF_P1_LAZYLOAD;
4802 if (val & DF_P1_GROUPPERM)
4804 printf (" GROUPPERM");
4805 val ^= DF_P1_GROUPPERM;
4808 printf (" %lx", val);
4817 printf (_("Flags:"));
4818 if (entry->d_un.d_val == 0)
4819 printf (_(" None\n"));
4822 unsigned long int val = entry->d_un.d_val;
4829 if (val & DF_1_GLOBAL)
4834 if (val & DF_1_GROUP)
4839 if (val & DF_1_NODELETE)
4841 printf (" NODELETE");
4842 val ^= DF_1_NODELETE;
4844 if (val & DF_1_LOADFLTR)
4846 printf (" LOADFLTR");
4847 val ^= DF_1_LOADFLTR;
4849 if (val & DF_1_INITFIRST)
4851 printf (" INITFIRST");
4852 val ^= DF_1_INITFIRST;
4854 if (val & DF_1_NOOPEN)
4859 if (val & DF_1_ORIGIN)
4864 if (val & DF_1_DIRECT)
4869 if (val & DF_1_TRANS)
4874 if (val & DF_1_INTERPOSE)
4876 printf (" INTERPOSE");
4877 val ^= DF_1_INTERPOSE;
4879 if (val & DF_1_NODEFLIB)
4881 printf (" NODEFLIB");
4882 val ^= DF_1_NODEFLIB;
4884 if (val & DF_1_NODUMP)
4889 if (val & DF_1_CONLFAT)
4891 printf (" CONLFAT");
4892 val ^= DF_1_CONLFAT;
4895 printf (" %lx", val);
4902 dynamic_info[entry->d_tag] = entry->d_un.d_val;
4904 puts (get_dynamic_type (entry->d_un.d_val));
4924 dynamic_info[entry->d_tag] = entry->d_un.d_val;
4930 if (dynamic_strings == NULL)
4933 name = dynamic_strings + entry->d_un.d_val;
4937 switch (entry->d_tag)
4940 printf (_("Shared library: [%s]"), name);
4942 if (strcmp (name, program_interpreter) == 0)
4943 printf (_(" program interpreter"));
4947 printf (_("Library soname: [%s]"), name);
4951 printf (_("Library rpath: [%s]"), name);
4955 printf (_("Library runpath: [%s]"), name);
4959 print_vma (entry->d_un.d_val, PREFIX_HEX);
4964 print_vma (entry->d_un.d_val, PREFIX_HEX);
4977 dynamic_info[entry->d_tag] = entry->d_un.d_val;
4981 case DT_INIT_ARRAYSZ:
4982 case DT_FINI_ARRAYSZ:
4983 case DT_GNU_CONFLICTSZ:
4984 case DT_GNU_LIBLISTSZ:
4987 print_vma (entry->d_un.d_val, UNSIGNED);
4988 printf (" (bytes)\n");
4998 print_vma (entry->d_un.d_val, UNSIGNED);
5011 if (dynamic_strings != NULL && entry->d_tag == DT_USED)
5015 name = dynamic_strings + entry->d_un.d_val;
5019 printf (_("Not needed object: [%s]\n"), name);
5024 print_vma (entry->d_un.d_val, PREFIX_HEX);
5030 /* The value of this entry is ignored. */
5035 case DT_GNU_PRELINKED:
5039 time_t time = entry->d_un.d_val;
5041 tmp = gmtime (&time);
5042 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
5043 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
5044 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
5050 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
5051 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
5056 switch (elf_header.e_machine)
5059 case EM_MIPS_RS3_LE:
5060 dynamic_segment_mips_val (entry);
5063 dynamic_segment_parisc_val (entry);
5066 dynamic_segment_ia64_val (entry);
5069 print_vma (entry->d_un.d_val, PREFIX_HEX);
5081 get_ver_flags (unsigned int flags)
5083 static char buff[32];
5090 if (flags & VER_FLG_BASE)
5091 strcat (buff, "BASE ");
5093 if (flags & VER_FLG_WEAK)
5095 if (flags & VER_FLG_BASE)
5096 strcat (buff, "| ");
5098 strcat (buff, "WEAK ");
5101 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK))
5102 strcat (buff, "| <unknown>");
5107 /* Display the contents of the version sections. */
5109 process_version_sections (FILE *file)
5111 Elf_Internal_Shdr *section;
5118 for (i = 0, section = section_headers;
5119 i < elf_header.e_shnum;
5122 switch (section->sh_type)
5124 case SHT_GNU_verdef:
5126 Elf_External_Verdef *edefs;
5133 (_("\nVersion definition section '%s' contains %ld entries:\n"),
5134 SECTION_NAME (section), section->sh_info);
5136 printf (_(" Addr: 0x"));
5137 printf_vma (section->sh_addr);
5138 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5139 (unsigned long) section->sh_offset, section->sh_link,
5140 SECTION_NAME (SECTION_HEADER (section->sh_link)));
5142 edefs = get_data (NULL, file, section->sh_offset, section->sh_size,
5143 _("version definition section"));
5147 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
5150 Elf_External_Verdef *edef;
5151 Elf_Internal_Verdef ent;
5152 Elf_External_Verdaux *eaux;
5153 Elf_Internal_Verdaux aux;
5157 vstart = ((char *) edefs) + idx;
5159 edef = (Elf_External_Verdef *) vstart;
5161 ent.vd_version = BYTE_GET (edef->vd_version);
5162 ent.vd_flags = BYTE_GET (edef->vd_flags);
5163 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
5164 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
5165 ent.vd_hash = BYTE_GET (edef->vd_hash);
5166 ent.vd_aux = BYTE_GET (edef->vd_aux);
5167 ent.vd_next = BYTE_GET (edef->vd_next);
5169 printf (_(" %#06x: Rev: %d Flags: %s"),
5170 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
5172 printf (_(" Index: %d Cnt: %d "),
5173 ent.vd_ndx, ent.vd_cnt);
5175 vstart += ent.vd_aux;
5177 eaux = (Elf_External_Verdaux *) vstart;
5179 aux.vda_name = BYTE_GET (eaux->vda_name);
5180 aux.vda_next = BYTE_GET (eaux->vda_next);
5182 if (dynamic_strings)
5183 printf (_("Name: %s\n"), dynamic_strings + aux.vda_name);
5185 printf (_("Name index: %ld\n"), aux.vda_name);
5187 isum = idx + ent.vd_aux;
5189 for (j = 1; j < ent.vd_cnt; j++)
5191 isum += aux.vda_next;
5192 vstart += aux.vda_next;
5194 eaux = (Elf_External_Verdaux *) vstart;
5196 aux.vda_name = BYTE_GET (eaux->vda_name);
5197 aux.vda_next = BYTE_GET (eaux->vda_next);
5199 if (dynamic_strings)
5200 printf (_(" %#06x: Parent %d: %s\n"),
5201 isum, j, dynamic_strings + aux.vda_name);
5203 printf (_(" %#06x: Parent %d, name index: %ld\n"),
5204 isum, j, aux.vda_name);
5214 case SHT_GNU_verneed:
5216 Elf_External_Verneed *eneed;
5222 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
5223 SECTION_NAME (section), section->sh_info);
5225 printf (_(" Addr: 0x"));
5226 printf_vma (section->sh_addr);
5227 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
5228 (unsigned long) section->sh_offset, section->sh_link,
5229 SECTION_NAME (SECTION_HEADER (section->sh_link)));
5231 eneed = get_data (NULL, file, section->sh_offset, section->sh_size,
5232 _("version need section"));
5236 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
5238 Elf_External_Verneed *entry;
5239 Elf_Internal_Verneed ent;
5244 vstart = ((char *) eneed) + idx;
5246 entry = (Elf_External_Verneed *) vstart;
5248 ent.vn_version = BYTE_GET (entry->vn_version);
5249 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
5250 ent.vn_file = BYTE_GET (entry->vn_file);
5251 ent.vn_aux = BYTE_GET (entry->vn_aux);
5252 ent.vn_next = BYTE_GET (entry->vn_next);
5254 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
5256 if (dynamic_strings)
5257 printf (_(" File: %s"), dynamic_strings + ent.vn_file);
5259 printf (_(" File: %lx"), ent.vn_file);
5261 printf (_(" Cnt: %d\n"), ent.vn_cnt);
5263 vstart += ent.vn_aux;
5265 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
5267 Elf_External_Vernaux *eaux;
5268 Elf_Internal_Vernaux aux;
5270 eaux = (Elf_External_Vernaux *) vstart;
5272 aux.vna_hash = BYTE_GET (eaux->vna_hash);
5273 aux.vna_flags = BYTE_GET (eaux->vna_flags);
5274 aux.vna_other = BYTE_GET (eaux->vna_other);
5275 aux.vna_name = BYTE_GET (eaux->vna_name);
5276 aux.vna_next = BYTE_GET (eaux->vna_next);
5278 if (dynamic_strings)
5279 printf (_(" %#06x: Name: %s"),
5280 isum, dynamic_strings + aux.vna_name);
5282 printf (_(" %#06x: Name index: %lx"),
5283 isum, aux.vna_name);
5285 printf (_(" Flags: %s Version: %d\n"),
5286 get_ver_flags (aux.vna_flags), aux.vna_other);
5288 isum += aux.vna_next;
5289 vstart += aux.vna_next;
5299 case SHT_GNU_versym:
5301 Elf_Internal_Shdr *link_section;
5304 unsigned char *edata;
5305 unsigned short *data;
5307 Elf_Internal_Sym *symbols;
5308 Elf_Internal_Shdr *string_sec;
5311 link_section = SECTION_HEADER (section->sh_link);
5312 total = section->sh_size / section->sh_entsize;
5316 symbols = GET_ELF_SYMBOLS (file, link_section);
5318 string_sec = SECTION_HEADER (link_section->sh_link);
5320 strtab = get_data (NULL, file, string_sec->sh_offset,
5321 string_sec->sh_size, _("version string table"));
5325 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
5326 SECTION_NAME (section), total);
5328 printf (_(" Addr: "));
5329 printf_vma (section->sh_addr);
5330 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5331 (unsigned long) section->sh_offset, section->sh_link,
5332 SECTION_NAME (link_section));
5334 off = offset_from_vma (file,
5335 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
5336 total * sizeof (short));
5337 edata = get_data (NULL, file, off, total * sizeof (short),
5338 _("version symbol data"));
5345 data = malloc (total * sizeof (short));
5347 for (cnt = total; cnt --;)
5348 data[cnt] = byte_get (edata + cnt * sizeof (short),
5353 for (cnt = 0; cnt < total; cnt += 4)
5356 int check_def, check_need;
5359 printf (" %03x:", cnt);
5361 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
5362 switch (data[cnt + j])
5365 fputs (_(" 0 (*local*) "), stdout);
5369 fputs (_(" 1 (*global*) "), stdout);
5373 nn = printf ("%4x%c", data[cnt + j] & 0x7fff,
5374 data[cnt + j] & 0x8000 ? 'h' : ' ');
5378 if (SECTION_HEADER (symbols[cnt + j].st_shndx)->sh_type
5381 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
5388 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
5390 Elf_Internal_Verneed ivn;
5391 unsigned long offset;
5393 offset = offset_from_vma
5394 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
5395 sizeof (Elf_External_Verneed));
5399 Elf_Internal_Vernaux ivna;
5400 Elf_External_Verneed evn;
5401 Elf_External_Vernaux evna;
5402 unsigned long a_off;
5404 get_data (&evn, file, offset, sizeof (evn),
5407 ivn.vn_aux = BYTE_GET (evn.vn_aux);
5408 ivn.vn_next = BYTE_GET (evn.vn_next);
5410 a_off = offset + ivn.vn_aux;
5414 get_data (&evna, file, a_off, sizeof (evna),
5415 _("version need aux (2)"));
5417 ivna.vna_next = BYTE_GET (evna.vna_next);
5418 ivna.vna_other = BYTE_GET (evna.vna_other);
5420 a_off += ivna.vna_next;
5422 while (ivna.vna_other != data[cnt + j]
5423 && ivna.vna_next != 0);
5425 if (ivna.vna_other == data[cnt + j])
5427 ivna.vna_name = BYTE_GET (evna.vna_name);
5429 name = strtab + ivna.vna_name;
5430 nn += printf ("(%s%-*s",
5432 12 - (int) strlen (name),
5438 offset += ivn.vn_next;
5440 while (ivn.vn_next);
5443 if (check_def && data[cnt + j] != 0x8001
5444 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
5446 Elf_Internal_Verdef ivd;
5447 Elf_External_Verdef evd;
5448 unsigned long offset;
5450 offset = offset_from_vma
5451 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
5456 get_data (&evd, file, offset, sizeof (evd),
5459 ivd.vd_next = BYTE_GET (evd.vd_next);
5460 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
5462 offset += ivd.vd_next;
5464 while (ivd.vd_ndx != (data[cnt + j] & 0x7fff)
5465 && ivd.vd_next != 0);
5467 if (ivd.vd_ndx == (data[cnt + j] & 0x7fff))
5469 Elf_External_Verdaux evda;
5470 Elf_Internal_Verdaux ivda;
5472 ivd.vd_aux = BYTE_GET (evd.vd_aux);
5474 get_data (&evda, file,
5475 offset - ivd.vd_next + ivd.vd_aux,
5476 sizeof (evda), _("version def aux"));
5478 ivda.vda_name = BYTE_GET (evda.vda_name);
5480 name = strtab + ivda.vda_name;
5481 nn += printf ("(%s%-*s",
5483 12 - (int) strlen (name),
5489 printf ("%*c", 18 - nn, ' ');
5507 printf (_("\nNo version information found in this file.\n"));
5513 get_symbol_binding (unsigned int binding)
5515 static char buff[32];
5519 case STB_LOCAL: return "LOCAL";
5520 case STB_GLOBAL: return "GLOBAL";
5521 case STB_WEAK: return "WEAK";
5523 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
5524 sprintf (buff, _("<processor specific>: %d"), binding);
5525 else if (binding >= STB_LOOS && binding <= STB_HIOS)
5526 sprintf (buff, _("<OS specific>: %d"), binding);
5528 sprintf (buff, _("<unknown>: %d"), binding);
5534 get_symbol_type (unsigned int type)
5536 static char buff[32];
5540 case STT_NOTYPE: return "NOTYPE";
5541 case STT_OBJECT: return "OBJECT";
5542 case STT_FUNC: return "FUNC";
5543 case STT_SECTION: return "SECTION";
5544 case STT_FILE: return "FILE";
5545 case STT_COMMON: return "COMMON";
5546 case STT_TLS: return "TLS";
5548 if (type >= STT_LOPROC && type <= STT_HIPROC)
5550 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
5551 return "THUMB_FUNC";
5553 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
5556 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
5557 return "PARISC_MILLI";
5559 sprintf (buff, _("<processor specific>: %d"), type);
5561 else if (type >= STT_LOOS && type <= STT_HIOS)
5563 if (elf_header.e_machine == EM_PARISC)
5565 if (type == STT_HP_OPAQUE)
5567 if (type == STT_HP_STUB)
5571 sprintf (buff, _("<OS specific>: %d"), type);
5574 sprintf (buff, _("<unknown>: %d"), type);
5580 get_symbol_visibility (unsigned int visibility)
5584 case STV_DEFAULT: return "DEFAULT";
5585 case STV_INTERNAL: return "INTERNAL";
5586 case STV_HIDDEN: return "HIDDEN";
5587 case STV_PROTECTED: return "PROTECTED";
5593 get_symbol_index_type (unsigned int type)
5595 static char buff[32];
5599 case SHN_UNDEF: return "UND";
5600 case SHN_ABS: return "ABS";
5601 case SHN_COMMON: return "COM";
5603 if (type == SHN_IA_64_ANSI_COMMON
5604 && elf_header.e_machine == EM_IA_64
5605 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
5607 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
5608 sprintf (buff, "PRC[0x%04x]", type);
5609 else if (type >= SHN_LOOS && type <= SHN_HIOS)
5610 sprintf (buff, "OS [0x%04x]", type);
5611 else if (type >= SHN_LORESERVE && type <= SHN_HIRESERVE)
5612 sprintf (buff, "RSV[0x%04x]", type);
5614 sprintf (buff, "%3d", type);
5622 get_dynamic_data (FILE *file, unsigned int number)
5624 unsigned char *e_data;
5627 e_data = malloc (number * 4);
5631 error (_("Out of memory\n"));
5635 if (fread (e_data, 4, number, file) != number)
5637 error (_("Unable to read in dynamic data\n"));
5641 i_data = malloc (number * sizeof (*i_data));
5645 error (_("Out of memory\n"));
5651 i_data[number] = byte_get (e_data + number * 4, 4);
5658 /* Dump the symbol table. */
5660 process_symbol_table (FILE *file)
5662 Elf_Internal_Shdr *section;
5663 unsigned char nb[4];
5664 unsigned char nc[4];
5667 int *buckets = NULL;
5670 if (! do_syms && !do_histogram)
5673 if (dynamic_info[DT_HASH] && ((do_using_dynamic && dynamic_strings != NULL)
5677 (archive_file_offset
5678 + offset_from_vma (file, dynamic_info[DT_HASH],
5679 sizeof nb + sizeof nc)),
5682 error (_("Unable to seek to start of dynamic information"));
5686 if (fread (nb, sizeof (nb), 1, file) != 1)
5688 error (_("Failed to read in number of buckets\n"));
5692 if (fread (nc, sizeof (nc), 1, file) != 1)
5694 error (_("Failed to read in number of chains\n"));
5698 nbuckets = byte_get (nb, 4);
5699 nchains = byte_get (nc, 4);
5701 buckets = get_dynamic_data (file, nbuckets);
5702 chains = get_dynamic_data (file, nchains);
5704 if (buckets == NULL || chains == NULL)
5709 && dynamic_info[DT_HASH] && do_using_dynamic && dynamic_strings != NULL)
5714 printf (_("\nSymbol table for image:\n"));
5716 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5718 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5720 for (hn = 0; hn < nbuckets; hn++)
5725 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
5727 Elf_Internal_Sym *psym;
5729 psym = dynamic_symbols + si;
5731 printf (" %3d %3d: ", si, hn);
5732 print_vma (psym->st_value, LONG_HEX);
5734 print_vma (psym->st_size, DEC_5);
5736 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
5737 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
5738 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5739 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
5740 print_symbol (25, dynamic_strings + psym->st_name);
5745 else if (do_syms && !do_using_dynamic)
5749 for (i = 0, section = section_headers;
5750 i < elf_header.e_shnum;
5755 Elf_Internal_Sym *symtab;
5756 Elf_Internal_Sym *psym;
5759 if ( section->sh_type != SHT_SYMTAB
5760 && section->sh_type != SHT_DYNSYM)
5763 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
5764 SECTION_NAME (section),
5765 (unsigned long) (section->sh_size / section->sh_entsize));
5767 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5769 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5771 symtab = GET_ELF_SYMBOLS (file, section);
5775 if (section->sh_link == elf_header.e_shstrndx)
5776 strtab = string_table;
5779 Elf_Internal_Shdr *string_sec;
5781 string_sec = SECTION_HEADER (section->sh_link);
5783 strtab = get_data (NULL, file, string_sec->sh_offset,
5784 string_sec->sh_size, _("string table"));
5787 for (si = 0, psym = symtab;
5788 si < section->sh_size / section->sh_entsize;
5791 printf ("%6d: ", si);
5792 print_vma (psym->st_value, LONG_HEX);
5794 print_vma (psym->st_size, DEC_5);
5795 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
5796 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
5797 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5798 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
5799 print_symbol (25, strtab + psym->st_name);
5801 if (section->sh_type == SHT_DYNSYM &&
5802 version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
5804 unsigned char data[2];
5805 unsigned short vers_data;
5806 unsigned long offset;
5810 offset = offset_from_vma
5811 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
5812 sizeof data + si * sizeof (vers_data));
5814 get_data (&data, file, offset + si * sizeof (vers_data),
5815 sizeof (data), _("version data"));
5817 vers_data = byte_get (data, 2);
5819 is_nobits = (SECTION_HEADER (psym->st_shndx)->sh_type
5822 check_def = (psym->st_shndx != SHN_UNDEF);
5824 if ((vers_data & 0x8000) || vers_data > 1)
5826 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
5827 && (is_nobits || ! check_def))
5829 Elf_External_Verneed evn;
5830 Elf_Internal_Verneed ivn;
5831 Elf_Internal_Vernaux ivna;
5833 /* We must test both. */
5834 offset = offset_from_vma
5835 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
5840 unsigned long vna_off;
5842 get_data (&evn, file, offset, sizeof (evn),
5845 ivn.vn_aux = BYTE_GET (evn.vn_aux);
5846 ivn.vn_next = BYTE_GET (evn.vn_next);
5848 vna_off = offset + ivn.vn_aux;
5852 Elf_External_Vernaux evna;
5854 get_data (&evna, file, vna_off,
5856 _("version need aux (3)"));
5858 ivna.vna_other = BYTE_GET (evna.vna_other);
5859 ivna.vna_next = BYTE_GET (evna.vna_next);
5860 ivna.vna_name = BYTE_GET (evna.vna_name);
5862 vna_off += ivna.vna_next;
5864 while (ivna.vna_other != vers_data
5865 && ivna.vna_next != 0);
5867 if (ivna.vna_other == vers_data)
5870 offset += ivn.vn_next;
5872 while (ivn.vn_next != 0);
5874 if (ivna.vna_other == vers_data)
5877 strtab + ivna.vna_name, ivna.vna_other);
5880 else if (! is_nobits)
5881 error (_("bad dynamic symbol"));
5888 if (vers_data != 0x8001
5889 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
5891 Elf_Internal_Verdef ivd;
5892 Elf_Internal_Verdaux ivda;
5893 Elf_External_Verdaux evda;
5894 unsigned long offset;
5896 offset = offset_from_vma
5898 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
5899 sizeof (Elf_External_Verdef));
5903 Elf_External_Verdef evd;
5905 get_data (&evd, file, offset, sizeof (evd),
5908 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
5909 ivd.vd_aux = BYTE_GET (evd.vd_aux);
5910 ivd.vd_next = BYTE_GET (evd.vd_next);
5912 offset += ivd.vd_next;
5914 while (ivd.vd_ndx != (vers_data & 0x7fff)
5915 && ivd.vd_next != 0);
5917 offset -= ivd.vd_next;
5918 offset += ivd.vd_aux;
5920 get_data (&evda, file, offset, sizeof (evda),
5921 _("version def aux"));
5923 ivda.vda_name = BYTE_GET (evda.vda_name);
5925 if (psym->st_name != ivda.vda_name)
5926 printf ((vers_data & 0x8000)
5928 strtab + ivda.vda_name);
5938 if (strtab != string_table)
5944 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
5946 if (do_histogram && buckets != NULL)
5953 int nzero_counts = 0;
5956 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
5958 printf (_(" Length Number %% of total Coverage\n"));
5960 lengths = calloc (nbuckets, sizeof (int));
5961 if (lengths == NULL)
5963 error (_("Out of memory"));
5966 for (hn = 0; hn < nbuckets; ++hn)
5971 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
5974 if (maxlength < ++lengths[hn])
5979 counts = calloc (maxlength + 1, sizeof (int));
5982 error (_("Out of memory"));
5986 for (hn = 0; hn < nbuckets; ++hn)
5987 ++counts[lengths[hn]];
5991 printf (" 0 %-10d (%5.1f%%)\n",
5992 counts[0], (counts[0] * 100.0) / nbuckets);
5993 for (si = 1; si <= maxlength; ++si)
5995 nzero_counts += counts[si] * si;
5996 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
5997 si, counts[si], (counts[si] * 100.0) / nbuckets,
5998 (nzero_counts * 100.0) / nsyms);
6006 if (buckets != NULL)
6016 process_syminfo (FILE *file ATTRIBUTE_UNUSED)
6020 if (dynamic_syminfo == NULL
6022 /* No syminfo, this is ok. */
6025 /* There better should be a dynamic symbol section. */
6026 if (dynamic_symbols == NULL || dynamic_strings == NULL)
6030 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
6031 dynamic_syminfo_offset, dynamic_syminfo_nent);
6033 printf (_(" Num: Name BoundTo Flags\n"));
6034 for (i = 0; i < dynamic_syminfo_nent; ++i)
6036 unsigned short int flags = dynamic_syminfo[i].si_flags;
6038 printf ("%4d: ", i);
6039 print_symbol (30, dynamic_strings + dynamic_symbols[i].st_name);
6042 switch (dynamic_syminfo[i].si_boundto)
6044 case SYMINFO_BT_SELF:
6045 fputs ("SELF ", stdout);
6047 case SYMINFO_BT_PARENT:
6048 fputs ("PARENT ", stdout);
6051 if (dynamic_syminfo[i].si_boundto > 0
6052 && dynamic_syminfo[i].si_boundto < dynamic_size)
6057 [dynamic_syminfo[i].si_boundto].d_un.d_val));
6061 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
6065 if (flags & SYMINFO_FLG_DIRECT)
6067 if (flags & SYMINFO_FLG_PASSTHRU)
6068 printf (" PASSTHRU");
6069 if (flags & SYMINFO_FLG_COPY)
6071 if (flags & SYMINFO_FLG_LAZYLOAD)
6072 printf (" LAZYLOAD");
6080 #ifdef SUPPORT_DISASSEMBLY
6082 disassemble_section (Elf_Internal_Shdr *section, FILE *file)
6084 printf (_("\nAssembly dump of section %s\n"),
6085 SECTION_NAME (section));
6087 /* XXX -- to be done --- XXX */
6094 dump_section (Elf_Internal_Shdr *section, FILE *file)
6096 bfd_size_type bytes;
6098 unsigned char *data;
6099 unsigned char *start;
6101 bytes = section->sh_size;
6103 if (bytes == 0 || section->sh_type == SHT_NOBITS)
6105 printf (_("\nSection '%s' has no data to dump.\n"),
6106 SECTION_NAME (section));
6110 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
6112 addr = section->sh_addr;
6114 start = get_data (NULL, file, section->sh_offset, bytes, _("section data"));
6126 lbytes = (bytes > 16 ? 16 : bytes);
6128 printf (" 0x%8.8lx ", (unsigned long) addr);
6130 switch (elf_header.e_ident[EI_DATA])
6134 for (j = 15; j >= 0; j --)
6137 printf ("%2.2x", data[j]);
6147 for (j = 0; j < 16; j++)
6150 printf ("%2.2x", data[j]);
6160 for (j = 0; j < lbytes; j++)
6163 if (k >= ' ' && k < 0x7f)
6182 static unsigned long int
6183 read_leb128 (unsigned char *data, int *length_return, int sign)
6185 unsigned long int result = 0;
6186 unsigned int num_read = 0;
6195 result |= (byte & 0x7f) << shift;
6200 while (byte & 0x80);
6202 if (length_return != NULL)
6203 *length_return = num_read;
6205 if (sign && (shift < 32) && (byte & 0x40))
6206 result |= -1 << shift;
6211 typedef struct State_Machine_Registers
6213 unsigned long address;
6216 unsigned int column;
6220 /* This variable hold the number of the last entry seen
6221 in the File Table. */
6222 unsigned int last_file_entry;
6225 static SMR state_machine_regs;
6228 reset_state_machine (int is_stmt)
6230 state_machine_regs.address = 0;
6231 state_machine_regs.file = 1;
6232 state_machine_regs.line = 1;
6233 state_machine_regs.column = 0;
6234 state_machine_regs.is_stmt = is_stmt;
6235 state_machine_regs.basic_block = 0;
6236 state_machine_regs.end_sequence = 0;
6237 state_machine_regs.last_file_entry = 0;
6240 /* Handled an extend line op. Returns true if this is the end
6243 process_extended_line_op (unsigned char *data, int is_stmt, int pointer_size)
6245 unsigned char op_code;
6248 unsigned char *name;
6251 len = read_leb128 (data, & bytes_read, 0);
6256 warn (_("badly formed extended line op encountered!\n"));
6263 printf (_(" Extended opcode %d: "), op_code);
6267 case DW_LNE_end_sequence:
6268 printf (_("End of Sequence\n\n"));
6269 reset_state_machine (is_stmt);
6272 case DW_LNE_set_address:
6273 adr = byte_get (data, pointer_size);
6274 printf (_("set Address to 0x%lx\n"), adr);
6275 state_machine_regs.address = adr;
6278 case DW_LNE_define_file:
6279 printf (_(" define new File Table entry\n"));
6280 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6282 printf (_(" %d\t"), ++state_machine_regs.last_file_entry);
6284 data += strlen ((char *) data) + 1;
6285 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6287 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6289 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6290 printf (_("%s\n\n"), name);
6294 printf (_("UNKNOWN: length %d\n"), len - bytes_read);
6301 /* Finds section NAME inside FILE and returns a
6302 pointer to it, or NULL upon failure. */
6304 static Elf_Internal_Shdr *
6305 find_section (const char * name)
6307 Elf_Internal_Shdr *sec;
6310 for (i = elf_header.e_shnum, sec = section_headers + i - 1;
6312 if (strcmp (SECTION_NAME (sec), name) == 0)
6315 if (i && sec && sec->sh_size != 0)
6321 /* Size of pointers in the .debug_line section. This information is not
6322 really present in that section. It's obtained before dumping the debug
6323 sections by doing some pre-scan of the .debug_info section. */
6324 static unsigned int * debug_line_pointer_sizes = NULL;
6325 static unsigned int num_debug_line_pointer_sizes = 0;
6327 /* Locate and scan the .debug_info section in the file and record the pointer
6328 sizes for the compilation units in it. Usually an executable will have
6329 just one pointer size, but this is not guaranteed, and so we try not to
6330 make any assumptions. Returns zero upon failure, or the number of
6331 compilation units upon success. */
6334 get_debug_line_pointer_sizes (FILE * file)
6336 Elf_Internal_Shdr * section;
6337 unsigned char * start;
6338 unsigned char * end;
6339 unsigned char * begin;
6340 unsigned long length;
6341 unsigned int num_units;
6344 section = find_section (".debug_info");
6345 if (section == NULL)
6348 length = section->sh_size;
6349 start = get_data (NULL, file, section->sh_offset, section->sh_size,
6350 _("extracting pointer sizes from .debug_info section"));
6354 end = start + section->sh_size;
6355 /* First scan the section to get the number of comp units. */
6356 for (begin = start, num_units = 0; begin < end; num_units++)
6358 /* Read the first 4 bytes. For a 32-bit DWARF section, this will
6359 be the length. For a 64-bit DWARF section, it'll be the escape
6360 code 0xffffffff followed by an 8 byte length. */
6361 length = byte_get (begin, 4);
6363 if (length == 0xffffffff)
6365 length = byte_get (begin + 4, 8);
6366 begin += length + 12;
6369 begin += length + 4;
6374 error (_("No comp units in .debug_info section ?"));
6379 /* Then allocate an array to hold the pointer sizes. */
6380 debug_line_pointer_sizes = malloc (num_units * sizeof * debug_line_pointer_sizes);
6381 if (debug_line_pointer_sizes == NULL)
6383 error (_("Not enough memory for a pointer size array of %u entries"),
6389 /* Populate the array. */
6390 for (begin = start, unit = 0; begin < end; unit++)
6392 length = byte_get (begin, 4);
6393 if (length == 0xffffffff)
6395 /* For 64-bit DWARF, the 1-byte address_size field is 22 bytes
6396 from the start of the section. This is computed as follows:
6398 unit_length: 12 bytes
6400 debug_abbrev_offset: 8 bytes
6401 -----------------------------
6404 debug_line_pointer_sizes [unit] = byte_get (begin + 22, 1);
6405 length = byte_get (begin + 4, 8);
6406 begin += length + 12;
6410 /* For 32-bit DWARF, the 1-byte address_size field is 10 bytes from
6411 the start of the section:
6413 unit_length: 4 bytes
6415 debug_abbrev_offset: 4 bytes
6416 -----------------------------
6419 debug_line_pointer_sizes [unit] = byte_get (begin + 10, 1);
6420 begin += length + 4;
6425 num_debug_line_pointer_sizes = num_units;
6430 display_debug_lines (Elf_Internal_Shdr *section,
6431 unsigned char *start, FILE *file)
6433 unsigned char *hdrptr;
6434 DWARF2_Internal_LineInfo info;
6435 unsigned char *standard_opcodes;
6436 unsigned char *data = start;
6437 unsigned char *end = start + section->sh_size;
6438 unsigned char *end_of_sequence;
6441 int initial_length_size;
6442 unsigned int comp_unit = 0;
6444 printf (_("\nDump of debug contents of section %s:\n\n"),
6445 SECTION_NAME (section));
6447 if (num_debug_line_pointer_sizes == 0)
6448 get_debug_line_pointer_sizes (file);
6452 unsigned int pointer_size;
6456 /* Check the length of the block. */
6457 info.li_length = byte_get (hdrptr, 4);
6460 if (info.li_length == 0xffffffff)
6462 /* This section is 64-bit DWARF 3. */
6463 info.li_length = byte_get (hdrptr, 8);
6466 initial_length_size = 12;
6471 initial_length_size = 4;
6474 if (info.li_length + initial_length_size > section->sh_size)
6477 (_("The line info appears to be corrupt - the section is too small\n"));
6481 /* Check its version number. */
6482 info.li_version = byte_get (hdrptr, 2);
6484 if (info.li_version != 2 && info.li_version != 3)
6486 warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
6490 info.li_prologue_length = byte_get (hdrptr, offset_size);
6491 hdrptr += offset_size;
6492 info.li_min_insn_length = byte_get (hdrptr, 1);
6494 info.li_default_is_stmt = byte_get (hdrptr, 1);
6496 info.li_line_base = byte_get (hdrptr, 1);
6498 info.li_line_range = byte_get (hdrptr, 1);
6500 info.li_opcode_base = byte_get (hdrptr, 1);
6503 /* Sign extend the line base field. */
6504 info.li_line_base <<= 24;
6505 info.li_line_base >>= 24;
6507 /* Get the pointer size from the comp unit associated
6508 with this block of line number information. */
6509 if (comp_unit >= num_debug_line_pointer_sizes)
6511 error (_("Not enough comp units for .debug_lines section\n"));
6516 pointer_size = debug_line_pointer_sizes [comp_unit];
6520 printf (_(" Length: %ld\n"), info.li_length);
6521 printf (_(" DWARF Version: %d\n"), info.li_version);
6522 printf (_(" Prologue Length: %d\n"), info.li_prologue_length);
6523 printf (_(" Minimum Instruction Length: %d\n"), info.li_min_insn_length);
6524 printf (_(" Initial value of 'is_stmt': %d\n"), info.li_default_is_stmt);
6525 printf (_(" Line Base: %d\n"), info.li_line_base);
6526 printf (_(" Line Range: %d\n"), info.li_line_range);
6527 printf (_(" Opcode Base: %d\n"), info.li_opcode_base);
6528 printf (_(" (Pointer size: %u)\n"), pointer_size);
6530 end_of_sequence = data + info.li_length + initial_length_size;
6532 reset_state_machine (info.li_default_is_stmt);
6534 /* Display the contents of the Opcodes table. */
6535 standard_opcodes = hdrptr;
6537 printf (_("\n Opcodes:\n"));
6539 for (i = 1; i < info.li_opcode_base; i++)
6540 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
6542 /* Display the contents of the Directory table. */
6543 data = standard_opcodes + info.li_opcode_base - 1;
6546 printf (_("\n The Directory Table is empty.\n"));
6549 printf (_("\n The Directory Table:\n"));
6553 printf (_(" %s\n"), data);
6555 data += strlen ((char *) data) + 1;
6559 /* Skip the NUL at the end of the table. */
6562 /* Display the contents of the File Name table. */
6564 printf (_("\n The File Name Table is empty.\n"));
6567 printf (_("\n The File Name Table:\n"));
6568 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6572 unsigned char *name;
6575 printf (_(" %d\t"), ++state_machine_regs.last_file_entry);
6578 data += strlen ((char *) data) + 1;
6580 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6582 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6584 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6586 printf (_("%s\n"), name);
6590 /* Skip the NUL at the end of the table. */
6593 /* Now display the statements. */
6594 printf (_("\n Line Number Statements:\n"));
6597 while (data < end_of_sequence)
6599 unsigned char op_code;
6605 if (op_code >= info.li_opcode_base)
6607 op_code -= info.li_opcode_base;
6608 adv = (op_code / info.li_line_range) * info.li_min_insn_length;
6609 state_machine_regs.address += adv;
6610 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
6611 op_code, adv, state_machine_regs.address);
6612 adv = (op_code % info.li_line_range) + info.li_line_base;
6613 state_machine_regs.line += adv;
6614 printf (_(" and Line by %d to %d\n"),
6615 adv, state_machine_regs.line);
6617 else switch (op_code)
6619 case DW_LNS_extended_op:
6620 data += process_extended_line_op (data, info.li_default_is_stmt,
6625 printf (_(" Copy\n"));
6628 case DW_LNS_advance_pc:
6629 adv = info.li_min_insn_length * read_leb128 (data, & bytes_read, 0);
6631 state_machine_regs.address += adv;
6632 printf (_(" Advance PC by %d to %lx\n"), adv,
6633 state_machine_regs.address);
6636 case DW_LNS_advance_line:
6637 adv = read_leb128 (data, & bytes_read, 1);
6639 state_machine_regs.line += adv;
6640 printf (_(" Advance Line by %d to %d\n"), adv,
6641 state_machine_regs.line);
6644 case DW_LNS_set_file:
6645 adv = read_leb128 (data, & bytes_read, 0);
6647 printf (_(" Set File Name to entry %d in the File Name Table\n"),
6649 state_machine_regs.file = adv;
6652 case DW_LNS_set_column:
6653 adv = read_leb128 (data, & bytes_read, 0);
6655 printf (_(" Set column to %d\n"), adv);
6656 state_machine_regs.column = adv;
6659 case DW_LNS_negate_stmt:
6660 adv = state_machine_regs.is_stmt;
6662 printf (_(" Set is_stmt to %d\n"), adv);
6663 state_machine_regs.is_stmt = adv;
6666 case DW_LNS_set_basic_block:
6667 printf (_(" Set basic block\n"));
6668 state_machine_regs.basic_block = 1;
6671 case DW_LNS_const_add_pc:
6672 adv = (((255 - info.li_opcode_base) / info.li_line_range)
6673 * info.li_min_insn_length);
6674 state_machine_regs.address += adv;
6675 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv,
6676 state_machine_regs.address);
6679 case DW_LNS_fixed_advance_pc:
6680 adv = byte_get (data, 2);
6682 state_machine_regs.address += adv;
6683 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
6684 adv, state_machine_regs.address);
6687 case DW_LNS_set_prologue_end:
6688 printf (_(" Set prologue_end to true\n"));
6691 case DW_LNS_set_epilogue_begin:
6692 printf (_(" Set epilogue_begin to true\n"));
6695 case DW_LNS_set_isa:
6696 adv = read_leb128 (data, & bytes_read, 0);
6698 printf (_(" Set ISA to %d\n"), adv);
6702 printf (_(" Unknown opcode %d with operands: "), op_code);
6705 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
6707 printf ("0x%lx%s", read_leb128 (data, &bytes_read, 0),
6708 i == 1 ? "" : ", ");
6723 display_debug_pubnames (Elf_Internal_Shdr *section,
6724 unsigned char *start,
6725 FILE *file ATTRIBUTE_UNUSED)
6727 DWARF2_Internal_PubNames pubnames;
6730 end = start + section->sh_size;
6732 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
6736 unsigned char *data;
6737 unsigned long offset;
6738 int offset_size, initial_length_size;
6742 pubnames.pn_length = byte_get (data, 4);
6744 if (pubnames.pn_length == 0xffffffff)
6746 pubnames.pn_length = byte_get (data, 8);
6749 initial_length_size = 12;
6754 initial_length_size = 4;
6757 pubnames.pn_version = byte_get (data, 2);
6759 pubnames.pn_offset = byte_get (data, offset_size);
6760 data += offset_size;
6761 pubnames.pn_size = byte_get (data, offset_size);
6762 data += offset_size;
6764 start += pubnames.pn_length + initial_length_size;
6766 if (pubnames.pn_version != 2 && pubnames.pn_version != 3)
6768 static int warned = 0;
6772 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
6779 printf (_(" Length: %ld\n"),
6780 pubnames.pn_length);
6781 printf (_(" Version: %d\n"),
6782 pubnames.pn_version);
6783 printf (_(" Offset into .debug_info section: %ld\n"),
6784 pubnames.pn_offset);
6785 printf (_(" Size of area in .debug_info section: %ld\n"),
6788 printf (_("\n Offset\tName\n"));
6792 offset = byte_get (data, offset_size);
6796 data += offset_size;
6797 printf (" %ld\t\t%s\n", offset, data);
6798 data += strlen ((char *) data) + 1;
6801 while (offset != 0);
6809 get_TAG_name (unsigned long tag)
6813 case DW_TAG_padding: return "DW_TAG_padding";
6814 case DW_TAG_array_type: return "DW_TAG_array_type";
6815 case DW_TAG_class_type: return "DW_TAG_class_type";
6816 case DW_TAG_entry_point: return "DW_TAG_entry_point";
6817 case DW_TAG_enumeration_type: return "DW_TAG_enumeration_type";
6818 case DW_TAG_formal_parameter: return "DW_TAG_formal_parameter";
6819 case DW_TAG_imported_declaration: return "DW_TAG_imported_declaration";
6820 case DW_TAG_label: return "DW_TAG_label";
6821 case DW_TAG_lexical_block: return "DW_TAG_lexical_block";
6822 case DW_TAG_member: return "DW_TAG_member";
6823 case DW_TAG_pointer_type: return "DW_TAG_pointer_type";
6824 case DW_TAG_reference_type: return "DW_TAG_reference_type";
6825 case DW_TAG_compile_unit: return "DW_TAG_compile_unit";
6826 case DW_TAG_string_type: return "DW_TAG_string_type";
6827 case DW_TAG_structure_type: return "DW_TAG_structure_type";
6828 case DW_TAG_subroutine_type: return "DW_TAG_subroutine_type";
6829 case DW_TAG_typedef: return "DW_TAG_typedef";
6830 case DW_TAG_union_type: return "DW_TAG_union_type";
6831 case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters";
6832 case DW_TAG_variant: return "DW_TAG_variant";
6833 case DW_TAG_common_block: return "DW_TAG_common_block";
6834 case DW_TAG_common_inclusion: return "DW_TAG_common_inclusion";
6835 case DW_TAG_inheritance: return "DW_TAG_inheritance";
6836 case DW_TAG_inlined_subroutine: return "DW_TAG_inlined_subroutine";
6837 case DW_TAG_module: return "DW_TAG_module";
6838 case DW_TAG_ptr_to_member_type: return "DW_TAG_ptr_to_member_type";
6839 case DW_TAG_set_type: return "DW_TAG_set_type";
6840 case DW_TAG_subrange_type: return "DW_TAG_subrange_type";
6841 case DW_TAG_with_stmt: return "DW_TAG_with_stmt";
6842 case DW_TAG_access_declaration: return "DW_TAG_access_declaration";
6843 case DW_TAG_base_type: return "DW_TAG_base_type";
6844 case DW_TAG_catch_block: return "DW_TAG_catch_block";
6845 case DW_TAG_const_type: return "DW_TAG_const_type";
6846 case DW_TAG_constant: return "DW_TAG_constant";
6847 case DW_TAG_enumerator: return "DW_TAG_enumerator";
6848 case DW_TAG_file_type: return "DW_TAG_file_type";
6849 case DW_TAG_friend: return "DW_TAG_friend";
6850 case DW_TAG_namelist: return "DW_TAG_namelist";
6851 case DW_TAG_namelist_item: return "DW_TAG_namelist_item";
6852 case DW_TAG_packed_type: return "DW_TAG_packed_type";
6853 case DW_TAG_subprogram: return "DW_TAG_subprogram";
6854 case DW_TAG_template_type_param: return "DW_TAG_template_type_param";
6855 case DW_TAG_template_value_param: return "DW_TAG_template_value_param";
6856 case DW_TAG_thrown_type: return "DW_TAG_thrown_type";
6857 case DW_TAG_try_block: return "DW_TAG_try_block";
6858 case DW_TAG_variant_part: return "DW_TAG_variant_part";
6859 case DW_TAG_variable: return "DW_TAG_variable";
6860 case DW_TAG_volatile_type: return "DW_TAG_volatile_type";
6861 case DW_TAG_MIPS_loop: return "DW_TAG_MIPS_loop";
6862 case DW_TAG_format_label: return "DW_TAG_format_label";
6863 case DW_TAG_function_template: return "DW_TAG_function_template";
6864 case DW_TAG_class_template: return "DW_TAG_class_template";
6865 /* DWARF 2.1 values. */
6866 case DW_TAG_dwarf_procedure: return "DW_TAG_dwarf_procedure";
6867 case DW_TAG_restrict_type: return "DW_TAG_restrict_type";
6868 case DW_TAG_interface_type: return "DW_TAG_interface_type";
6869 case DW_TAG_namespace: return "DW_TAG_namespace";
6870 case DW_TAG_imported_module: return "DW_TAG_imported_module";
6871 case DW_TAG_unspecified_type: return "DW_TAG_unspecified_type";
6872 case DW_TAG_partial_unit: return "DW_TAG_partial_unit";
6873 case DW_TAG_imported_unit: return "DW_TAG_imported_unit";
6875 case DW_TAG_upc_shared_type: return "DW_TAG_upc_shared_type";
6876 case DW_TAG_upc_strict_type: return "DW_TAG_upc_strict_type";
6877 case DW_TAG_upc_relaxed_type: return "DW_TAG_upc_relaxed_type";
6880 static char buffer[100];
6882 sprintf (buffer, _("Unknown TAG value: %lx"), tag);
6889 get_AT_name (unsigned long attribute)
6893 case DW_AT_sibling: return "DW_AT_sibling";
6894 case DW_AT_location: return "DW_AT_location";
6895 case DW_AT_name: return "DW_AT_name";
6896 case DW_AT_ordering: return "DW_AT_ordering";
6897 case DW_AT_subscr_data: return "DW_AT_subscr_data";
6898 case DW_AT_byte_size: return "DW_AT_byte_size";
6899 case DW_AT_bit_offset: return "DW_AT_bit_offset";
6900 case DW_AT_bit_size: return "DW_AT_bit_size";
6901 case DW_AT_element_list: return "DW_AT_element_list";
6902 case DW_AT_stmt_list: return "DW_AT_stmt_list";
6903 case DW_AT_low_pc: return "DW_AT_low_pc";
6904 case DW_AT_high_pc: return "DW_AT_high_pc";
6905 case DW_AT_language: return "DW_AT_language";
6906 case DW_AT_member: return "DW_AT_member";
6907 case DW_AT_discr: return "DW_AT_discr";
6908 case DW_AT_discr_value: return "DW_AT_discr_value";
6909 case DW_AT_visibility: return "DW_AT_visibility";
6910 case DW_AT_import: return "DW_AT_import";
6911 case DW_AT_string_length: return "DW_AT_string_length";
6912 case DW_AT_common_reference: return "DW_AT_common_reference";
6913 case DW_AT_comp_dir: return "DW_AT_comp_dir";
6914 case DW_AT_const_value: return "DW_AT_const_value";
6915 case DW_AT_containing_type: return "DW_AT_containing_type";
6916 case DW_AT_default_value: return "DW_AT_default_value";
6917 case DW_AT_inline: return "DW_AT_inline";
6918 case DW_AT_is_optional: return "DW_AT_is_optional";
6919 case DW_AT_lower_bound: return "DW_AT_lower_bound";
6920 case DW_AT_producer: return "DW_AT_producer";
6921 case DW_AT_prototyped: return "DW_AT_prototyped";
6922 case DW_AT_return_addr: return "DW_AT_return_addr";
6923 case DW_AT_start_scope: return "DW_AT_start_scope";
6924 case DW_AT_stride_size: return "DW_AT_stride_size";
6925 case DW_AT_upper_bound: return "DW_AT_upper_bound";
6926 case DW_AT_abstract_origin: return "DW_AT_abstract_origin";
6927 case DW_AT_accessibility: return "DW_AT_accessibility";
6928 case DW_AT_address_class: return "DW_AT_address_class";
6929 case DW_AT_artificial: return "DW_AT_artificial";
6930 case DW_AT_base_types: return "DW_AT_base_types";
6931 case DW_AT_calling_convention: return "DW_AT_calling_convention";
6932 case DW_AT_count: return "DW_AT_count";
6933 case DW_AT_data_member_location: return "DW_AT_data_member_location";
6934 case DW_AT_decl_column: return "DW_AT_decl_column";
6935 case DW_AT_decl_file: return "DW_AT_decl_file";
6936 case DW_AT_decl_line: return "DW_AT_decl_line";
6937 case DW_AT_declaration: return "DW_AT_declaration";
6938 case DW_AT_discr_list: return "DW_AT_discr_list";
6939 case DW_AT_encoding: return "DW_AT_encoding";
6940 case DW_AT_external: return "DW_AT_external";
6941 case DW_AT_frame_base: return "DW_AT_frame_base";
6942 case DW_AT_friend: return "DW_AT_friend";
6943 case DW_AT_identifier_case: return "DW_AT_identifier_case";
6944 case DW_AT_macro_info: return "DW_AT_macro_info";
6945 case DW_AT_namelist_items: return "DW_AT_namelist_items";
6946 case DW_AT_priority: return "DW_AT_priority";
6947 case DW_AT_segment: return "DW_AT_segment";
6948 case DW_AT_specification: return "DW_AT_specification";
6949 case DW_AT_static_link: return "DW_AT_static_link";
6950 case DW_AT_type: return "DW_AT_type";
6951 case DW_AT_use_location: return "DW_AT_use_location";
6952 case DW_AT_variable_parameter: return "DW_AT_variable_parameter";
6953 case DW_AT_virtuality: return "DW_AT_virtuality";
6954 case DW_AT_vtable_elem_location: return "DW_AT_vtable_elem_location";
6955 /* DWARF 2.1 values. */
6956 case DW_AT_allocated: return "DW_AT_allocated";
6957 case DW_AT_associated: return "DW_AT_associated";
6958 case DW_AT_data_location: return "DW_AT_data_location";
6959 case DW_AT_stride: return "DW_AT_stride";
6960 case DW_AT_entry_pc: return "DW_AT_entry_pc";
6961 case DW_AT_use_UTF8: return "DW_AT_use_UTF8";
6962 case DW_AT_extension: return "DW_AT_extension";
6963 case DW_AT_ranges: return "DW_AT_ranges";
6964 case DW_AT_trampoline: return "DW_AT_trampoline";
6965 case DW_AT_call_column: return "DW_AT_call_column";
6966 case DW_AT_call_file: return "DW_AT_call_file";
6967 case DW_AT_call_line: return "DW_AT_call_line";
6968 /* SGI/MIPS extensions. */
6969 case DW_AT_MIPS_fde: return "DW_AT_MIPS_fde";
6970 case DW_AT_MIPS_loop_begin: return "DW_AT_MIPS_loop_begin";
6971 case DW_AT_MIPS_tail_loop_begin: return "DW_AT_MIPS_tail_loop_begin";
6972 case DW_AT_MIPS_epilog_begin: return "DW_AT_MIPS_epilog_begin";
6973 case DW_AT_MIPS_loop_unroll_factor: return "DW_AT_MIPS_loop_unroll_factor";
6974 case DW_AT_MIPS_software_pipeline_depth:
6975 return "DW_AT_MIPS_software_pipeline_depth";
6976 case DW_AT_MIPS_linkage_name: return "DW_AT_MIPS_linkage_name";
6977 case DW_AT_MIPS_stride: return "DW_AT_MIPS_stride";
6978 case DW_AT_MIPS_abstract_name: return "DW_AT_MIPS_abstract_name";
6979 case DW_AT_MIPS_clone_origin: return "DW_AT_MIPS_clone_origin";
6980 case DW_AT_MIPS_has_inlines: return "DW_AT_MIPS_has_inlines";
6981 /* GNU extensions. */
6982 case DW_AT_sf_names: return "DW_AT_sf_names";
6983 case DW_AT_src_info: return "DW_AT_src_info";
6984 case DW_AT_mac_info: return "DW_AT_mac_info";
6985 case DW_AT_src_coords: return "DW_AT_src_coords";
6986 case DW_AT_body_begin: return "DW_AT_body_begin";
6987 case DW_AT_body_end: return "DW_AT_body_end";
6988 case DW_AT_GNU_vector: return "DW_AT_GNU_vector";
6989 /* UPC extension. */
6990 case DW_AT_upc_threads_scaled: return "DW_AT_upc_threads_scaled";
6993 static char buffer[100];
6995 sprintf (buffer, _("Unknown AT value: %lx"), attribute);
7002 get_FORM_name (unsigned long form)
7006 case DW_FORM_addr: return "DW_FORM_addr";
7007 case DW_FORM_block2: return "DW_FORM_block2";
7008 case DW_FORM_block4: return "DW_FORM_block4";
7009 case DW_FORM_data2: return "DW_FORM_data2";
7010 case DW_FORM_data4: return "DW_FORM_data4";
7011 case DW_FORM_data8: return "DW_FORM_data8";
7012 case DW_FORM_string: return "DW_FORM_string";
7013 case DW_FORM_block: return "DW_FORM_block";
7014 case DW_FORM_block1: return "DW_FORM_block1";
7015 case DW_FORM_data1: return "DW_FORM_data1";
7016 case DW_FORM_flag: return "DW_FORM_flag";
7017 case DW_FORM_sdata: return "DW_FORM_sdata";
7018 case DW_FORM_strp: return "DW_FORM_strp";
7019 case DW_FORM_udata: return "DW_FORM_udata";
7020 case DW_FORM_ref_addr: return "DW_FORM_ref_addr";
7021 case DW_FORM_ref1: return "DW_FORM_ref1";
7022 case DW_FORM_ref2: return "DW_FORM_ref2";
7023 case DW_FORM_ref4: return "DW_FORM_ref4";
7024 case DW_FORM_ref8: return "DW_FORM_ref8";
7025 case DW_FORM_ref_udata: return "DW_FORM_ref_udata";
7026 case DW_FORM_indirect: return "DW_FORM_indirect";
7029 static char buffer[100];
7031 sprintf (buffer, _("Unknown FORM value: %lx"), form);
7037 /* FIXME: There are better and more efficient ways to handle
7038 these structures. For now though, I just want something that
7039 is simple to implement. */
7040 typedef struct abbrev_attr
7042 unsigned long attribute;
7044 struct abbrev_attr *next;
7048 typedef struct abbrev_entry
7050 unsigned long entry;
7053 struct abbrev_attr *first_attr;
7054 struct abbrev_attr *last_attr;
7055 struct abbrev_entry *next;
7059 static abbrev_entry *first_abbrev = NULL;
7060 static abbrev_entry *last_abbrev = NULL;
7065 abbrev_entry *abbrev;
7067 for (abbrev = first_abbrev; abbrev;)
7069 abbrev_entry *next = abbrev->next;
7072 for (attr = abbrev->first_attr; attr;)
7074 abbrev_attr *next = attr->next;
7084 last_abbrev = first_abbrev = NULL;
7088 add_abbrev (unsigned long number, unsigned long tag, int children)
7090 abbrev_entry *entry;
7092 entry = malloc (sizeof (*entry));
7098 entry->entry = number;
7100 entry->children = children;
7101 entry->first_attr = NULL;
7102 entry->last_attr = NULL;
7105 if (first_abbrev == NULL)
7106 first_abbrev = entry;
7108 last_abbrev->next = entry;
7110 last_abbrev = entry;
7114 add_abbrev_attr (unsigned long attribute, unsigned long form)
7118 attr = malloc (sizeof (*attr));
7124 attr->attribute = attribute;
7128 if (last_abbrev->first_attr == NULL)
7129 last_abbrev->first_attr = attr;
7131 last_abbrev->last_attr->next = attr;
7133 last_abbrev->last_attr = attr;
7136 /* Processes the (partial) contents of a .debug_abbrev section.
7137 Returns NULL if the end of the section was encountered.
7138 Returns the address after the last byte read if the end of
7139 an abbreviation set was found. */
7141 static unsigned char *
7142 process_abbrev_section (unsigned char *start, unsigned char *end)
7144 if (first_abbrev != NULL)
7150 unsigned long entry;
7152 unsigned long attribute;
7155 entry = read_leb128 (start, & bytes_read, 0);
7156 start += bytes_read;
7158 /* A single zero is supposed to end the section according
7159 to the standard. If there's more, then signal that to
7162 return start == end ? NULL : start;
7164 tag = read_leb128 (start, & bytes_read, 0);
7165 start += bytes_read;
7167 children = *start++;
7169 add_abbrev (entry, tag, children);
7175 attribute = read_leb128 (start, & bytes_read, 0);
7176 start += bytes_read;
7178 form = read_leb128 (start, & bytes_read, 0);
7179 start += bytes_read;
7182 add_abbrev_attr (attribute, form);
7184 while (attribute != 0);
7192 display_debug_macinfo (Elf_Internal_Shdr *section,
7193 unsigned char *start,
7194 FILE *file ATTRIBUTE_UNUSED)
7196 unsigned char *end = start + section->sh_size;
7197 unsigned char *curr = start;
7198 unsigned int bytes_read;
7199 enum dwarf_macinfo_record_type op;
7201 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
7205 unsigned int lineno;
7213 case DW_MACINFO_start_file:
7215 unsigned int filenum;
7217 lineno = read_leb128 (curr, & bytes_read, 0);
7219 filenum = read_leb128 (curr, & bytes_read, 0);
7222 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"), lineno, filenum);
7226 case DW_MACINFO_end_file:
7227 printf (_(" DW_MACINFO_end_file\n"));
7230 case DW_MACINFO_define:
7231 lineno = read_leb128 (curr, & bytes_read, 0);
7234 curr += strlen (string) + 1;
7235 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"), lineno, string);
7238 case DW_MACINFO_undef:
7239 lineno = read_leb128 (curr, & bytes_read, 0);
7242 curr += strlen (string) + 1;
7243 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"), lineno, string);
7246 case DW_MACINFO_vendor_ext:
7248 unsigned int constant;
7250 constant = read_leb128 (curr, & bytes_read, 0);
7253 curr += strlen (string) + 1;
7254 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"), constant, string);
7265 display_debug_abbrev (Elf_Internal_Shdr *section,
7266 unsigned char *start,
7267 FILE *file ATTRIBUTE_UNUSED)
7269 abbrev_entry *entry;
7270 unsigned char *end = start + section->sh_size;
7272 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
7276 start = process_abbrev_section (start, end);
7278 if (first_abbrev == NULL)
7281 printf (_(" Number TAG\n"));
7283 for (entry = first_abbrev; entry; entry = entry->next)
7287 printf (_(" %ld %s [%s]\n"),
7289 get_TAG_name (entry->tag),
7290 entry->children ? _("has children") : _("no children"));
7292 for (attr = entry->first_attr; attr; attr = attr->next)
7294 printf (_(" %-18s %s\n"),
7295 get_AT_name (attr->attribute),
7296 get_FORM_name (attr->form));
7310 static unsigned char *
7311 display_block (unsigned char *data, unsigned long length)
7313 printf (_(" %lu byte block: "), length);
7316 printf ("%lx ", (unsigned long) byte_get (data++, 1));
7322 decode_location_expression (unsigned char * data,
7323 unsigned int pointer_size,
7324 unsigned long length)
7328 unsigned long uvalue;
7329 unsigned char *end = data + length;
7338 printf ("DW_OP_addr: %lx",
7339 (unsigned long) byte_get (data, pointer_size));
7340 data += pointer_size;
7343 printf ("DW_OP_deref");
7346 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data++, 1));
7349 printf ("DW_OP_const1s: %ld", (long) byte_get (data++, 1));
7352 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2));
7356 printf ("DW_OP_const2s: %ld", (long) byte_get (data, 2));
7360 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
7364 printf ("DW_OP_const4s: %ld", (long) byte_get (data, 4));
7368 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
7369 (unsigned long) byte_get (data + 4, 4));
7373 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
7374 (long) byte_get (data + 4, 4));
7378 printf ("DW_OP_constu: %lu", read_leb128 (data, &bytes_read, 0));
7382 printf ("DW_OP_consts: %ld", read_leb128 (data, &bytes_read, 1));
7386 printf ("DW_OP_dup");
7389 printf ("DW_OP_drop");
7392 printf ("DW_OP_over");
7395 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data++, 1));
7398 printf ("DW_OP_swap");
7401 printf ("DW_OP_rot");
7404 printf ("DW_OP_xderef");
7407 printf ("DW_OP_abs");
7410 printf ("DW_OP_and");
7413 printf ("DW_OP_div");
7416 printf ("DW_OP_minus");
7419 printf ("DW_OP_mod");
7422 printf ("DW_OP_mul");
7425 printf ("DW_OP_neg");
7428 printf ("DW_OP_not");
7431 printf ("DW_OP_or");
7434 printf ("DW_OP_plus");
7436 case DW_OP_plus_uconst:
7437 printf ("DW_OP_plus_uconst: %lu",
7438 read_leb128 (data, &bytes_read, 0));
7442 printf ("DW_OP_shl");
7445 printf ("DW_OP_shr");
7448 printf ("DW_OP_shra");
7451 printf ("DW_OP_xor");
7454 printf ("DW_OP_bra: %ld", (long) byte_get (data, 2));
7458 printf ("DW_OP_eq");
7461 printf ("DW_OP_ge");
7464 printf ("DW_OP_gt");
7467 printf ("DW_OP_le");
7470 printf ("DW_OP_lt");
7473 printf ("DW_OP_ne");
7476 printf ("DW_OP_skip: %ld", (long) byte_get (data, 2));
7512 printf ("DW_OP_lit%d", op - DW_OP_lit0);
7547 printf ("DW_OP_reg%d", op - DW_OP_reg0);
7582 printf ("DW_OP_breg%d: %ld", op - DW_OP_breg0,
7583 read_leb128 (data, &bytes_read, 1));
7588 printf ("DW_OP_regx: %lu", read_leb128 (data, &bytes_read, 0));
7592 printf ("DW_OP_fbreg: %ld", read_leb128 (data, &bytes_read, 1));
7596 uvalue = read_leb128 (data, &bytes_read, 0);
7598 printf ("DW_OP_bregx: %lu %ld", uvalue,
7599 read_leb128 (data, &bytes_read, 1));
7603 printf ("DW_OP_piece: %lu", read_leb128 (data, &bytes_read, 0));
7606 case DW_OP_deref_size:
7607 printf ("DW_OP_deref_size: %ld", (long) byte_get (data++, 1));
7609 case DW_OP_xderef_size:
7610 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data++, 1));
7613 printf ("DW_OP_nop");
7616 /* DWARF 3 extensions. */
7617 case DW_OP_push_object_address:
7618 printf ("DW_OP_push_object_address");
7621 printf ("DW_OP_call2: <%lx>", (long) byte_get (data, 2));
7625 printf ("DW_OP_call4: <%lx>", (long) byte_get (data, 4));
7628 case DW_OP_call_ref:
7629 printf ("DW_OP_call_ref");
7632 /* GNU extensions. */
7633 case DW_OP_GNU_push_tls_address:
7634 printf ("DW_OP_GNU_push_tls_address");
7638 if (op >= DW_OP_lo_user
7639 && op <= DW_OP_hi_user)
7640 printf (_("(User defined location op)"));
7642 printf (_("(Unknown location op)"));
7643 /* No way to tell where the next op is, so just bail. */
7647 /* Separate the ops. */
7653 static const char *debug_loc_contents;
7654 static bfd_vma debug_loc_size;
7657 load_debug_loc (FILE *file)
7659 Elf_Internal_Shdr *sec;
7661 /* If it is already loaded, do nothing. */
7662 if (debug_loc_contents != NULL)
7665 /* Locate the .debug_loc section. */
7666 sec = find_section (".debug_loc");
7670 debug_loc_size = sec->sh_size;
7672 debug_loc_contents = get_data (NULL, file, sec->sh_offset, sec->sh_size,
7673 _("debug_loc section data"));
7677 free_debug_loc (void)
7679 if (debug_loc_contents == NULL)
7682 free ((char *) debug_loc_contents);
7683 debug_loc_contents = NULL;
7689 display_debug_loc (Elf_Internal_Shdr *section,
7690 unsigned char *start, FILE *file)
7692 unsigned char *section_end;
7693 unsigned long bytes;
7694 unsigned char *section_begin = start;
7696 unsigned int comp_unit = 0;
7698 addr = section->sh_addr;
7699 bytes = section->sh_size;
7700 section_end = start + bytes;
7704 printf (_("\nThe .debug_loc section is empty.\n"));
7708 if (num_debug_line_pointer_sizes == 0)
7709 get_debug_line_pointer_sizes (file);
7711 printf (_("Contents of the .debug_loc section:\n\n"));
7712 printf (_("\n Offset Begin End Expression\n"));
7714 while (start < section_end)
7716 unsigned long begin;
7718 unsigned short length;
7719 unsigned long offset;
7720 unsigned int pointer_size;
7722 offset = start - section_begin;
7724 /* Get the pointer size from the comp unit associated
7725 with this block of location information. */
7726 if (comp_unit >= num_debug_line_pointer_sizes)
7728 error (_("Not enough comp units for .debug_loc section\n"));
7733 pointer_size = debug_line_pointer_sizes [comp_unit];
7739 begin = byte_get (start, pointer_size);
7740 start += pointer_size;
7741 end = byte_get (start, pointer_size);
7742 start += pointer_size;
7744 if (begin == 0 && end == 0)
7747 /* For now, skip any base address specifiers. */
7748 if (begin == 0xffffffff)
7754 length = byte_get (start, 2);
7757 printf (" %8.8lx %8.8lx %8.8lx (", offset, begin, end);
7758 decode_location_expression (start, pointer_size, length);
7768 static const char *debug_str_contents;
7769 static bfd_vma debug_str_size;
7772 load_debug_str (FILE *file)
7774 Elf_Internal_Shdr *sec;
7776 /* If it is already loaded, do nothing. */
7777 if (debug_str_contents != NULL)
7780 /* Locate the .debug_str section. */
7781 sec = find_section (".debug_str");
7785 debug_str_size = sec->sh_size;
7787 debug_str_contents = get_data (NULL, file, sec->sh_offset, sec->sh_size,
7788 _("debug_str section data"));
7792 free_debug_str (void)
7794 if (debug_str_contents == NULL)
7797 free ((char *) debug_str_contents);
7798 debug_str_contents = NULL;
7803 fetch_indirect_string (unsigned long offset)
7805 if (debug_str_contents == NULL)
7806 return _("<no .debug_str section>");
7808 if (offset > debug_str_size)
7809 return _("<offset is too big>");
7811 return debug_str_contents + offset;
7815 display_debug_str (Elf_Internal_Shdr *section,
7816 unsigned char *start,
7817 FILE *file ATTRIBUTE_UNUSED)
7819 unsigned long bytes;
7822 addr = section->sh_addr;
7823 bytes = section->sh_size;
7827 printf (_("\nThe .debug_str section is empty.\n"));
7831 printf (_("Contents of the .debug_str section:\n\n"));
7839 lbytes = (bytes > 16 ? 16 : bytes);
7841 printf (" 0x%8.8lx ", (unsigned long) addr);
7843 for (j = 0; j < 16; j++)
7846 printf ("%2.2x", start[j]);
7854 for (j = 0; j < lbytes; j++)
7857 if (k >= ' ' && k < 0x80)
7873 static unsigned char *
7874 read_and_display_attr_value (unsigned long attribute,
7876 unsigned char *data,
7877 unsigned long cu_offset,
7878 unsigned long pointer_size,
7879 unsigned long offset_size,
7882 unsigned long uvalue = 0;
7883 unsigned char *block_start = NULL;
7891 case DW_FORM_ref_addr:
7892 if (dwarf_version == 2)
7894 uvalue = byte_get (data, pointer_size);
7895 data += pointer_size;
7897 else if (dwarf_version == 3)
7899 uvalue = byte_get (data, offset_size);
7900 data += offset_size;
7904 error (_("Internal error: DWARF version is not 2 or 3.\n"));
7909 uvalue = byte_get (data, pointer_size);
7910 data += pointer_size;
7914 uvalue = byte_get (data, offset_size);
7915 data += offset_size;
7921 uvalue = byte_get (data++, 1);
7926 uvalue = byte_get (data, 2);
7932 uvalue = byte_get (data, 4);
7937 uvalue = read_leb128 (data, & bytes_read, 1);
7941 case DW_FORM_ref_udata:
7943 uvalue = read_leb128 (data, & bytes_read, 0);
7947 case DW_FORM_indirect:
7948 form = read_leb128 (data, & bytes_read, 0);
7950 printf (" %s", get_FORM_name (form));
7951 return read_and_display_attr_value (attribute, form, data, cu_offset,
7952 pointer_size, offset_size,
7958 case DW_FORM_ref_addr:
7959 printf (" <#%lx>", uvalue);
7965 case DW_FORM_ref_udata:
7966 printf (" <%lx>", uvalue + cu_offset);
7970 printf (" %#lx", uvalue);
7978 printf (" %ld", uvalue);
7983 uvalue = byte_get (data, 4);
7984 printf (" %lx", uvalue);
7985 printf (" %lx", (unsigned long) byte_get (data + 4, 4));
7989 case DW_FORM_string:
7990 printf (" %s", data);
7991 data += strlen ((char *) data) + 1;
7995 uvalue = read_leb128 (data, & bytes_read, 0);
7996 block_start = data + bytes_read;
7997 data = display_block (block_start, uvalue);
8000 case DW_FORM_block1:
8001 uvalue = byte_get (data, 1);
8002 block_start = data + 1;
8003 data = display_block (block_start, uvalue);
8006 case DW_FORM_block2:
8007 uvalue = byte_get (data, 2);
8008 block_start = data + 2;
8009 data = display_block (block_start, uvalue);
8012 case DW_FORM_block4:
8013 uvalue = byte_get (data, 4);
8014 block_start = data + 4;
8015 data = display_block (block_start, uvalue);
8019 printf (_(" (indirect string, offset: 0x%lx): %s"),
8020 uvalue, fetch_indirect_string (uvalue));
8023 case DW_FORM_indirect:
8024 /* Handled above. */
8028 warn (_("Unrecognized form: %d\n"), form);
8032 /* For some attributes we can display further information. */
8041 case DW_INL_not_inlined:
8042 printf (_("(not inlined)"));
8044 case DW_INL_inlined:
8045 printf (_("(inlined)"));
8047 case DW_INL_declared_not_inlined:
8048 printf (_("(declared as inline but ignored)"));
8050 case DW_INL_declared_inlined:
8051 printf (_("(declared as inline and inlined)"));
8054 printf (_(" (Unknown inline attribute value: %lx)"), uvalue);
8059 case DW_AT_language:
8062 case DW_LANG_C: printf ("(non-ANSI C)"); break;
8063 case DW_LANG_C89: printf ("(ANSI C)"); break;
8064 case DW_LANG_C_plus_plus: printf ("(C++)"); break;
8065 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break;
8066 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break;
8067 case DW_LANG_Modula2: printf ("(Modula 2)"); break;
8068 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break;
8069 case DW_LANG_Ada83: printf ("(Ada)"); break;
8070 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break;
8071 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break;
8072 /* DWARF 2.1 values. */
8073 case DW_LANG_C99: printf ("(ANSI C99)"); break;
8074 case DW_LANG_Ada95: printf ("(ADA 95)"); break;
8075 case DW_LANG_Fortran95: printf ("(Fortran 95)"); break;
8076 /* MIPS extension. */
8077 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
8078 /* UPC extension. */
8079 case DW_LANG_Upc: printf ("(Unified Parallel C)"); break;
8081 printf ("(Unknown: %lx)", uvalue);
8086 case DW_AT_encoding:
8089 case DW_ATE_void: printf ("(void)"); break;
8090 case DW_ATE_address: printf ("(machine address)"); break;
8091 case DW_ATE_boolean: printf ("(boolean)"); break;
8092 case DW_ATE_complex_float: printf ("(complex float)"); break;
8093 case DW_ATE_float: printf ("(float)"); break;
8094 case DW_ATE_signed: printf ("(signed)"); break;
8095 case DW_ATE_signed_char: printf ("(signed char)"); break;
8096 case DW_ATE_unsigned: printf ("(unsigned)"); break;
8097 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
8098 /* DWARF 2.1 value. */
8099 case DW_ATE_imaginary_float: printf ("(imaginary float)"); break;
8101 if (uvalue >= DW_ATE_lo_user
8102 && uvalue <= DW_ATE_hi_user)
8103 printf ("(user defined type)");
8105 printf ("(unknown type)");
8110 case DW_AT_accessibility:
8113 case DW_ACCESS_public: printf ("(public)"); break;
8114 case DW_ACCESS_protected: printf ("(protected)"); break;
8115 case DW_ACCESS_private: printf ("(private)"); break;
8117 printf ("(unknown accessibility)");
8122 case DW_AT_visibility:
8125 case DW_VIS_local: printf ("(local)"); break;
8126 case DW_VIS_exported: printf ("(exported)"); break;
8127 case DW_VIS_qualified: printf ("(qualified)"); break;
8128 default: printf ("(unknown visibility)"); break;
8132 case DW_AT_virtuality:
8135 case DW_VIRTUALITY_none: printf ("(none)"); break;
8136 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
8137 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
8138 default: printf ("(unknown virtuality)"); break;
8142 case DW_AT_identifier_case:
8145 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
8146 case DW_ID_up_case: printf ("(up_case)"); break;
8147 case DW_ID_down_case: printf ("(down_case)"); break;
8148 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
8149 default: printf ("(unknown case)"); break;
8153 case DW_AT_calling_convention:
8156 case DW_CC_normal: printf ("(normal)"); break;
8157 case DW_CC_program: printf ("(program)"); break;
8158 case DW_CC_nocall: printf ("(nocall)"); break;
8160 if (uvalue >= DW_CC_lo_user
8161 && uvalue <= DW_CC_hi_user)
8162 printf ("(user defined)");
8164 printf ("(unknown convention)");
8168 case DW_AT_ordering:
8171 case -1: printf ("(undefined)"); break;
8172 case 0: printf ("(row major)"); break;
8173 case 1: printf ("(column major)"); break;
8177 case DW_AT_frame_base:
8178 case DW_AT_location:
8179 case DW_AT_data_member_location:
8180 case DW_AT_vtable_elem_location:
8181 case DW_AT_allocated:
8182 case DW_AT_associated:
8183 case DW_AT_data_location:
8185 case DW_AT_upper_bound:
8186 case DW_AT_lower_bound:
8190 decode_location_expression (block_start, pointer_size, uvalue);
8193 else if (form == DW_FORM_data4 || form == DW_FORM_data8)
8196 printf ("location list");
8208 static unsigned char *
8209 read_and_display_attr (unsigned long attribute,
8211 unsigned char *data,
8212 unsigned long cu_offset,
8213 unsigned long pointer_size,
8214 unsigned long offset_size,
8217 printf (" %-18s:", get_AT_name (attribute));
8218 data = read_and_display_attr_value (attribute, form, data, cu_offset,
8219 pointer_size, offset_size, dwarf_version);
8225 display_debug_info (Elf_Internal_Shdr *section,
8226 unsigned char *start,
8229 unsigned char *end = start + section->sh_size;
8230 unsigned char *section_begin = start;
8232 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
8234 load_debug_str (file);
8235 load_debug_loc (file);
8239 DWARF2_Internal_CompUnit compunit;
8240 Elf_Internal_Shdr *relsec;
8241 unsigned char *hdrptr;
8242 unsigned char *cu_abbrev_offset_ptr;
8243 unsigned char *tags;
8245 unsigned long cu_offset;
8247 int initial_length_size;
8251 compunit.cu_length = byte_get (hdrptr, 4);
8254 if (compunit.cu_length == 0xffffffff)
8256 compunit.cu_length = byte_get (hdrptr, 8);
8259 initial_length_size = 12;
8264 initial_length_size = 4;
8267 compunit.cu_version = byte_get (hdrptr, 2);
8270 /* Apply addends of RELA relocations. */
8271 for (relsec = section_headers;
8272 relsec < section_headers + elf_header.e_shnum;
8275 unsigned long nrelas;
8276 Elf_Internal_Rela *rela, *rp;
8277 Elf_Internal_Shdr *symsec;
8278 Elf_Internal_Sym *symtab;
8279 Elf_Internal_Sym *sym;
8281 if (relsec->sh_type != SHT_RELA
8282 || SECTION_HEADER (relsec->sh_info) != section
8283 || relsec->sh_size == 0)
8286 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
8290 symsec = SECTION_HEADER (relsec->sh_link);
8291 symtab = GET_ELF_SYMBOLS (file, symsec);
8293 for (rp = rela; rp < rela + nrelas; ++rp)
8297 if (rp->r_offset >= (bfd_vma) (hdrptr - section_begin)
8298 && section->sh_size > (bfd_vma) offset_size
8299 && rp->r_offset <= section->sh_size - offset_size)
8300 loc = section_begin + rp->r_offset;
8306 sym = symtab + ELF32_R_SYM (rp->r_info);
8308 if (ELF32_R_SYM (rp->r_info) != 0
8309 && ELF32_ST_TYPE (sym->st_info) != STT_SECTION)
8311 warn (_("Skipping unexpected symbol type %u\n"),
8312 ELF32_ST_TYPE (sym->st_info));
8318 sym = symtab + ELF64_R_SYM (rp->r_info);
8320 if (ELF64_R_SYM (rp->r_info) != 0
8321 && ELF64_ST_TYPE (sym->st_info) != STT_SECTION)
8323 warn (_("Skipping unexpected symbol type %u\n"),
8324 ELF64_ST_TYPE (sym->st_info));
8329 byte_put (loc, rp->r_addend, offset_size);
8336 cu_abbrev_offset_ptr = hdrptr;
8337 compunit.cu_abbrev_offset = byte_get (hdrptr, offset_size);
8338 hdrptr += offset_size;
8340 compunit.cu_pointer_size = byte_get (hdrptr, 1);
8344 cu_offset = start - section_begin;
8345 start += compunit.cu_length + initial_length_size;
8347 printf (_(" Compilation Unit @ %lx:\n"), cu_offset);
8348 printf (_(" Length: %ld\n"), compunit.cu_length);
8349 printf (_(" Version: %d\n"), compunit.cu_version);
8350 printf (_(" Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
8351 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
8353 if (compunit.cu_version != 2 && compunit.cu_version != 3)
8355 warn (_("Only version 2 and 3 DWARF debug information is currently supported.\n"));
8361 /* Read in the abbrevs used by this compilation unit. */
8363 Elf_Internal_Shdr *sec;
8364 unsigned char *begin;
8366 /* Locate the .debug_abbrev section and process it. */
8367 sec = find_section (".debug_abbrev");
8370 warn (_("Unable to locate .debug_abbrev section!\n"));
8374 begin = get_data (NULL, file, sec->sh_offset, sec->sh_size,
8375 _("debug_abbrev section data"));
8379 process_abbrev_section (begin + compunit.cu_abbrev_offset,
8380 begin + sec->sh_size);
8386 while (tags < start)
8389 unsigned long abbrev_number;
8390 abbrev_entry *entry;
8393 abbrev_number = read_leb128 (tags, & bytes_read, 0);
8396 /* A null DIE marks the end of a list of children. */
8397 if (abbrev_number == 0)
8403 /* Scan through the abbreviation list until we reach the
8405 for (entry = first_abbrev;
8406 entry && entry->entry != abbrev_number;
8407 entry = entry->next)
8412 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
8417 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
8419 (unsigned long) (tags - section_begin - bytes_read),
8421 get_TAG_name (entry->tag));
8423 for (attr = entry->first_attr; attr; attr = attr->next)
8424 tags = read_and_display_attr (attr->attribute,
8427 compunit.cu_pointer_size,
8429 compunit.cu_version);
8431 if (entry->children)
8445 display_debug_aranges (Elf_Internal_Shdr *section,
8446 unsigned char *start,
8447 FILE *file ATTRIBUTE_UNUSED)
8449 unsigned char *end = start + section->sh_size;
8451 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
8455 unsigned char *hdrptr;
8456 DWARF2_Internal_ARange arange;
8457 unsigned char *ranges;
8458 unsigned long length;
8459 unsigned long address;
8462 int initial_length_size;
8466 arange.ar_length = byte_get (hdrptr, 4);
8469 if (arange.ar_length == 0xffffffff)
8471 arange.ar_length = byte_get (hdrptr, 8);
8474 initial_length_size = 12;
8479 initial_length_size = 4;
8482 arange.ar_version = byte_get (hdrptr, 2);
8485 arange.ar_info_offset = byte_get (hdrptr, offset_size);
8486 hdrptr += offset_size;
8488 arange.ar_pointer_size = byte_get (hdrptr, 1);
8491 arange.ar_segment_size = byte_get (hdrptr, 1);
8494 if (arange.ar_version != 2 && arange.ar_version != 3)
8496 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
8500 printf (_(" Length: %ld\n"), arange.ar_length);
8501 printf (_(" Version: %d\n"), arange.ar_version);
8502 printf (_(" Offset into .debug_info: %lx\n"), arange.ar_info_offset);
8503 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
8504 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
8506 printf (_("\n Address Length\n"));
8510 /* Must pad to an alignment boundary that is twice the pointer size. */
8511 excess = (hdrptr - start) % (2 * arange.ar_pointer_size);
8513 ranges += (2 * arange.ar_pointer_size) - excess;
8517 address = byte_get (ranges, arange.ar_pointer_size);
8519 ranges += arange.ar_pointer_size;
8521 length = byte_get (ranges, arange.ar_pointer_size);
8523 ranges += arange.ar_pointer_size;
8525 /* A pair of zeros marks the end of the list. */
8526 if (address == 0 && length == 0)
8529 printf (" %8.8lx %lu\n", address, length);
8532 start += arange.ar_length + initial_length_size;
8540 typedef struct Frame_Chunk
8542 struct Frame_Chunk *next;
8543 unsigned char *chunk_start;
8545 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
8546 short int *col_type;
8549 unsigned int code_factor;
8551 unsigned long pc_begin;
8552 unsigned long pc_range;
8556 unsigned char fde_encoding;
8557 unsigned char cfa_exp;
8561 /* A marker for a col_type that means this column was never referenced
8562 in the frame info. */
8563 #define DW_CFA_unreferenced (-1)
8566 frame_need_space (Frame_Chunk *fc, int reg)
8568 int prev = fc->ncols;
8570 if (reg < fc->ncols)
8573 fc->ncols = reg + 1;
8574 fc->col_type = xrealloc (fc->col_type, fc->ncols * sizeof (short int));
8575 fc->col_offset = xrealloc (fc->col_offset, fc->ncols * sizeof (int));
8577 while (prev < fc->ncols)
8579 fc->col_type[prev] = DW_CFA_unreferenced;
8580 fc->col_offset[prev] = 0;
8586 frame_display_row (Frame_Chunk *fc, int *need_col_headers, int *max_regs)
8591 if (*max_regs < fc->ncols)
8592 *max_regs = fc->ncols;
8594 if (*need_col_headers)
8596 *need_col_headers = 0;
8598 printf (" LOC CFA ");
8600 for (r = 0; r < *max_regs; r++)
8601 if (fc->col_type[r] != DW_CFA_unreferenced)
8606 printf ("r%-4d", r);
8612 printf ("%08lx ", fc->pc_begin);
8614 strcpy (tmp, "exp");
8616 sprintf (tmp, "r%d%+d", fc->cfa_reg, fc->cfa_offset);
8617 printf ("%-8s ", tmp);
8619 for (r = 0; r < fc->ncols; r++)
8621 if (fc->col_type[r] != DW_CFA_unreferenced)
8623 switch (fc->col_type[r])
8625 case DW_CFA_undefined:
8628 case DW_CFA_same_value:
8632 sprintf (tmp, "c%+d", fc->col_offset[r]);
8634 case DW_CFA_register:
8635 sprintf (tmp, "r%d", fc->col_offset[r]);
8637 case DW_CFA_expression:
8638 strcpy (tmp, "exp");
8641 strcpy (tmp, "n/a");
8644 printf ("%-5s", tmp);
8651 size_of_encoded_value (int encoding)
8653 switch (encoding & 0x7)
8656 case 0: return is_32bit_elf ? 4 : 8;
8664 get_encoded_value (unsigned char *data, int encoding)
8666 int size = size_of_encoded_value (encoding);
8667 if (encoding & DW_EH_PE_signed)
8668 return byte_get_signed (data, size);
8670 return byte_get (data, size);
8673 #define GET(N) byte_get (start, N); start += N
8674 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
8675 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
8678 display_debug_frames (Elf_Internal_Shdr *section,
8679 unsigned char *start,
8680 FILE *file ATTRIBUTE_UNUSED)
8682 unsigned char *end = start + section->sh_size;
8683 unsigned char *section_start = start;
8684 Frame_Chunk *chunks = 0;
8685 Frame_Chunk *remembered_state = 0;
8687 int is_eh = (strcmp (SECTION_NAME (section), ".eh_frame") == 0);
8690 int addr_size = is_32bit_elf ? 4 : 8;
8692 printf (_("The section %s contains:\n"), SECTION_NAME (section));
8696 unsigned char *saved_start;
8697 unsigned char *block_end;
8698 unsigned long length;
8699 unsigned long cie_id;
8702 int need_col_headers = 1;
8703 unsigned char *augmentation_data = NULL;
8704 unsigned long augmentation_data_len = 0;
8705 int encoded_ptr_size = addr_size;
8707 int initial_length_size;
8709 saved_start = start;
8710 length = byte_get (start, 4); start += 4;
8714 printf ("\n%08lx ZERO terminator\n\n",
8715 (unsigned long)(saved_start - section_start));
8719 if (length == 0xffffffff)
8721 length = byte_get (start, 8);
8724 initial_length_size = 12;
8729 initial_length_size = 4;
8732 block_end = saved_start + length + initial_length_size;
8733 cie_id = byte_get (start, offset_size); start += offset_size;
8735 if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
8739 fc = xmalloc (sizeof (Frame_Chunk));
8740 memset (fc, 0, sizeof (Frame_Chunk));
8744 fc->chunk_start = saved_start;
8746 fc->col_type = xmalloc (sizeof (short int));
8747 fc->col_offset = xmalloc (sizeof (int));
8748 frame_need_space (fc, max_regs-1);
8752 fc->augmentation = start;
8753 start = strchr (start, '\0') + 1;
8755 if (fc->augmentation[0] == 'z')
8757 fc->code_factor = LEB ();
8758 fc->data_factor = SLEB ();
8759 fc->ra = byte_get (start, 1); start += 1;
8760 augmentation_data_len = LEB ();
8761 augmentation_data = start;
8762 start += augmentation_data_len;
8764 else if (strcmp (fc->augmentation, "eh") == 0)
8767 fc->code_factor = LEB ();
8768 fc->data_factor = SLEB ();
8769 fc->ra = byte_get (start, 1); start += 1;
8773 fc->code_factor = LEB ();
8774 fc->data_factor = SLEB ();
8775 fc->ra = byte_get (start, 1); start += 1;
8779 if (do_debug_frames_interp)
8780 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
8781 (unsigned long)(saved_start - section_start), length, cie_id,
8782 fc->augmentation, fc->code_factor, fc->data_factor,
8786 printf ("\n%08lx %08lx %08lx CIE\n",
8787 (unsigned long)(saved_start - section_start), length, cie_id);
8788 printf (" Version: %d\n", version);
8789 printf (" Augmentation: \"%s\"\n", fc->augmentation);
8790 printf (" Code alignment factor: %u\n", fc->code_factor);
8791 printf (" Data alignment factor: %d\n", fc->data_factor);
8792 printf (" Return address column: %d\n", fc->ra);
8794 if (augmentation_data_len)
8797 printf (" Augmentation data: ");
8798 for (i = 0; i < augmentation_data_len; ++i)
8799 printf (" %02x", augmentation_data[i]);
8805 if (augmentation_data_len)
8807 unsigned char *p, *q;
8808 p = fc->augmentation + 1;
8809 q = augmentation_data;
8816 q += 1 + size_of_encoded_value (*q);
8818 fc->fde_encoding = *q++;
8824 if (fc->fde_encoding)
8825 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
8828 frame_need_space (fc, fc->ra);
8832 unsigned char *look_for;
8833 static Frame_Chunk fde_fc;
8836 memset (fc, 0, sizeof (Frame_Chunk));
8838 look_for = is_eh ? start - 4 - cie_id : section_start + cie_id;
8840 for (cie = chunks; cie ; cie = cie->next)
8841 if (cie->chunk_start == look_for)
8846 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
8847 cie_id, saved_start);
8850 fc->col_type = xmalloc (sizeof (short int));
8851 fc->col_offset = xmalloc (sizeof (int));
8852 frame_need_space (fc, max_regs - 1);
8854 fc->augmentation = "";
8855 fc->fde_encoding = 0;
8859 fc->ncols = cie->ncols;
8860 fc->col_type = xmalloc (fc->ncols * sizeof (short int));
8861 fc->col_offset = xmalloc (fc->ncols * sizeof (int));
8862 memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
8863 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
8864 fc->augmentation = cie->augmentation;
8865 fc->code_factor = cie->code_factor;
8866 fc->data_factor = cie->data_factor;
8867 fc->cfa_reg = cie->cfa_reg;
8868 fc->cfa_offset = cie->cfa_offset;
8870 frame_need_space (fc, max_regs-1);
8871 fc->fde_encoding = cie->fde_encoding;
8874 if (fc->fde_encoding)
8875 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
8877 fc->pc_begin = get_encoded_value (start, fc->fde_encoding);
8878 if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel)
8879 fc->pc_begin += section->sh_addr + (start - section_start);
8880 start += encoded_ptr_size;
8881 fc->pc_range = byte_get (start, encoded_ptr_size);
8882 start += encoded_ptr_size;
8884 if (cie->augmentation[0] == 'z')
8886 augmentation_data_len = LEB ();
8887 augmentation_data = start;
8888 start += augmentation_data_len;
8891 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
8892 (unsigned long)(saved_start - section_start), length, cie_id,
8893 (unsigned long)(cie->chunk_start - section_start),
8894 fc->pc_begin, fc->pc_begin + fc->pc_range);
8895 if (! do_debug_frames_interp && augmentation_data_len)
8898 printf (" Augmentation data: ");
8899 for (i = 0; i < augmentation_data_len; ++i)
8900 printf (" %02x", augmentation_data[i]);
8906 /* At this point, fc is the current chunk, cie (if any) is set, and we're
8907 about to interpret instructions for the chunk. */
8908 /* ??? At present we need to do this always, since this sizes the
8909 fc->col_type and fc->col_offset arrays, which we write into always.
8910 We should probably split the interpreted and non-interpreted bits
8911 into two different routines, since there's so much that doesn't
8912 really overlap between them. */
8913 if (1 || do_debug_frames_interp)
8915 /* Start by making a pass over the chunk, allocating storage
8916 and taking note of what registers are used. */
8917 unsigned char *tmp = start;
8919 while (start < block_end)
8922 unsigned long reg, tmp;
8929 /* Warning: if you add any more cases to this switch, be
8930 sure to add them to the corresponding switch below. */
8933 case DW_CFA_advance_loc:
8937 frame_need_space (fc, opa);
8938 fc->col_type[opa] = DW_CFA_undefined;
8940 case DW_CFA_restore:
8941 frame_need_space (fc, opa);
8942 fc->col_type[opa] = DW_CFA_undefined;
8944 case DW_CFA_set_loc:
8945 start += encoded_ptr_size;
8947 case DW_CFA_advance_loc1:
8950 case DW_CFA_advance_loc2:
8953 case DW_CFA_advance_loc4:
8956 case DW_CFA_offset_extended:
8957 reg = LEB (); LEB ();
8958 frame_need_space (fc, reg);
8959 fc->col_type[reg] = DW_CFA_undefined;
8961 case DW_CFA_restore_extended:
8963 frame_need_space (fc, reg);
8964 fc->col_type[reg] = DW_CFA_undefined;
8966 case DW_CFA_undefined:
8968 frame_need_space (fc, reg);
8969 fc->col_type[reg] = DW_CFA_undefined;
8971 case DW_CFA_same_value:
8973 frame_need_space (fc, reg);
8974 fc->col_type[reg] = DW_CFA_undefined;
8976 case DW_CFA_register:
8977 reg = LEB (); LEB ();
8978 frame_need_space (fc, reg);
8979 fc->col_type[reg] = DW_CFA_undefined;
8981 case DW_CFA_def_cfa:
8984 case DW_CFA_def_cfa_register:
8987 case DW_CFA_def_cfa_offset:
8990 case DW_CFA_def_cfa_expression:
8994 case DW_CFA_expression:
8998 frame_need_space (fc, reg);
8999 fc->col_type[reg] = DW_CFA_undefined;
9001 case DW_CFA_offset_extended_sf:
9002 reg = LEB (); SLEB ();
9003 frame_need_space (fc, reg);
9004 fc->col_type[reg] = DW_CFA_undefined;
9006 case DW_CFA_def_cfa_sf:
9009 case DW_CFA_def_cfa_offset_sf:
9012 case DW_CFA_MIPS_advance_loc8:
9015 case DW_CFA_GNU_args_size:
9018 case DW_CFA_GNU_negative_offset_extended:
9019 reg = LEB (); LEB ();
9020 frame_need_space (fc, reg);
9021 fc->col_type[reg] = DW_CFA_undefined;
9030 /* Now we know what registers are used, make a second pass over
9031 the chunk, this time actually printing out the info. */
9033 while (start < block_end)
9036 unsigned long ul, reg, roffs;
9045 /* Warning: if you add any more cases to this switch, be
9046 sure to add them to the corresponding switch above. */
9049 case DW_CFA_advance_loc:
9050 if (do_debug_frames_interp)
9051 frame_display_row (fc, &need_col_headers, &max_regs);
9053 printf (" DW_CFA_advance_loc: %d to %08lx\n",
9054 opa * fc->code_factor,
9055 fc->pc_begin + opa * fc->code_factor);
9056 fc->pc_begin += opa * fc->code_factor;
9061 if (! do_debug_frames_interp)
9062 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
9063 opa, roffs * fc->data_factor);
9064 fc->col_type[opa] = DW_CFA_offset;
9065 fc->col_offset[opa] = roffs * fc->data_factor;
9068 case DW_CFA_restore:
9069 if (! do_debug_frames_interp)
9070 printf (" DW_CFA_restore: r%d\n", opa);
9071 fc->col_type[opa] = cie->col_type[opa];
9072 fc->col_offset[opa] = cie->col_offset[opa];
9075 case DW_CFA_set_loc:
9076 vma = get_encoded_value (start, fc->fde_encoding);
9077 if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel)
9078 vma += section->sh_addr + (start - section_start);
9079 start += encoded_ptr_size;
9080 if (do_debug_frames_interp)
9081 frame_display_row (fc, &need_col_headers, &max_regs);
9083 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma);
9087 case DW_CFA_advance_loc1:
9088 ofs = byte_get (start, 1); start += 1;
9089 if (do_debug_frames_interp)
9090 frame_display_row (fc, &need_col_headers, &max_regs);
9092 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
9093 ofs * fc->code_factor,
9094 fc->pc_begin + ofs * fc->code_factor);
9095 fc->pc_begin += ofs * fc->code_factor;
9098 case DW_CFA_advance_loc2:
9099 ofs = byte_get (start, 2); start += 2;
9100 if (do_debug_frames_interp)
9101 frame_display_row (fc, &need_col_headers, &max_regs);
9103 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
9104 ofs * fc->code_factor,
9105 fc->pc_begin + ofs * fc->code_factor);
9106 fc->pc_begin += ofs * fc->code_factor;
9109 case DW_CFA_advance_loc4:
9110 ofs = byte_get (start, 4); start += 4;
9111 if (do_debug_frames_interp)
9112 frame_display_row (fc, &need_col_headers, &max_regs);
9114 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
9115 ofs * fc->code_factor,
9116 fc->pc_begin + ofs * fc->code_factor);
9117 fc->pc_begin += ofs * fc->code_factor;
9120 case DW_CFA_offset_extended:
9123 if (! do_debug_frames_interp)
9124 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
9125 reg, roffs * fc->data_factor);
9126 fc->col_type[reg] = DW_CFA_offset;
9127 fc->col_offset[reg] = roffs * fc->data_factor;
9130 case DW_CFA_restore_extended:
9132 if (! do_debug_frames_interp)
9133 printf (" DW_CFA_restore_extended: r%ld\n", reg);
9134 fc->col_type[reg] = cie->col_type[reg];
9135 fc->col_offset[reg] = cie->col_offset[reg];
9138 case DW_CFA_undefined:
9140 if (! do_debug_frames_interp)
9141 printf (" DW_CFA_undefined: r%ld\n", reg);
9142 fc->col_type[reg] = DW_CFA_undefined;
9143 fc->col_offset[reg] = 0;
9146 case DW_CFA_same_value:
9148 if (! do_debug_frames_interp)
9149 printf (" DW_CFA_same_value: r%ld\n", reg);
9150 fc->col_type[reg] = DW_CFA_same_value;
9151 fc->col_offset[reg] = 0;
9154 case DW_CFA_register:
9157 if (! do_debug_frames_interp)
9158 printf (" DW_CFA_register: r%ld in r%ld\n", reg, roffs);
9159 fc->col_type[reg] = DW_CFA_register;
9160 fc->col_offset[reg] = roffs;
9163 case DW_CFA_remember_state:
9164 if (! do_debug_frames_interp)
9165 printf (" DW_CFA_remember_state\n");
9166 rs = xmalloc (sizeof (Frame_Chunk));
9167 rs->ncols = fc->ncols;
9168 rs->col_type = xmalloc (rs->ncols * sizeof (short int));
9169 rs->col_offset = xmalloc (rs->ncols * sizeof (int));
9170 memcpy (rs->col_type, fc->col_type, rs->ncols);
9171 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
9172 rs->next = remembered_state;
9173 remembered_state = rs;
9176 case DW_CFA_restore_state:
9177 if (! do_debug_frames_interp)
9178 printf (" DW_CFA_restore_state\n");
9179 rs = remembered_state;
9182 remembered_state = rs->next;
9183 frame_need_space (fc, rs->ncols-1);
9184 memcpy (fc->col_type, rs->col_type, rs->ncols);
9185 memcpy (fc->col_offset, rs->col_offset,
9186 rs->ncols * sizeof (int));
9187 free (rs->col_type);
9188 free (rs->col_offset);
9191 else if (do_debug_frames_interp)
9192 printf ("Mismatched DW_CFA_restore_state\n");
9195 case DW_CFA_def_cfa:
9196 fc->cfa_reg = LEB ();
9197 fc->cfa_offset = LEB ();
9199 if (! do_debug_frames_interp)
9200 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
9201 fc->cfa_reg, fc->cfa_offset);
9204 case DW_CFA_def_cfa_register:
9205 fc->cfa_reg = LEB ();
9207 if (! do_debug_frames_interp)
9208 printf (" DW_CFA_def_cfa_reg: r%d\n", fc->cfa_reg);
9211 case DW_CFA_def_cfa_offset:
9212 fc->cfa_offset = LEB ();
9213 if (! do_debug_frames_interp)
9214 printf (" DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
9218 if (! do_debug_frames_interp)
9219 printf (" DW_CFA_nop\n");
9222 case DW_CFA_def_cfa_expression:
9224 if (! do_debug_frames_interp)
9226 printf (" DW_CFA_def_cfa_expression (");
9227 decode_location_expression (start, addr_size, ul);
9234 case DW_CFA_expression:
9237 if (! do_debug_frames_interp)
9239 printf (" DW_CFA_expression: r%ld (", reg);
9240 decode_location_expression (start, addr_size, ul);
9243 fc->col_type[reg] = DW_CFA_expression;
9247 case DW_CFA_offset_extended_sf:
9250 frame_need_space (fc, reg);
9251 if (! do_debug_frames_interp)
9252 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
9253 reg, l * fc->data_factor);
9254 fc->col_type[reg] = DW_CFA_offset;
9255 fc->col_offset[reg] = l * fc->data_factor;
9258 case DW_CFA_def_cfa_sf:
9259 fc->cfa_reg = LEB ();
9260 fc->cfa_offset = SLEB ();
9262 if (! do_debug_frames_interp)
9263 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
9264 fc->cfa_reg, fc->cfa_offset);
9267 case DW_CFA_def_cfa_offset_sf:
9268 fc->cfa_offset = SLEB ();
9269 if (! do_debug_frames_interp)
9270 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc->cfa_offset);
9273 case DW_CFA_MIPS_advance_loc8:
9274 ofs = byte_get (start, 8); start += 8;
9275 if (do_debug_frames_interp)
9276 frame_display_row (fc, &need_col_headers, &max_regs);
9278 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
9279 ofs * fc->code_factor,
9280 fc->pc_begin + ofs * fc->code_factor);
9281 fc->pc_begin += ofs * fc->code_factor;
9284 case DW_CFA_GNU_window_save:
9285 if (! do_debug_frames_interp)
9286 printf (" DW_CFA_GNU_window_save\n");
9289 case DW_CFA_GNU_args_size:
9291 if (! do_debug_frames_interp)
9292 printf (" DW_CFA_GNU_args_size: %ld\n", ul);
9295 case DW_CFA_GNU_negative_offset_extended:
9298 frame_need_space (fc, reg);
9299 if (! do_debug_frames_interp)
9300 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
9301 reg, l * fc->data_factor);
9302 fc->col_type[reg] = DW_CFA_offset;
9303 fc->col_offset[reg] = l * fc->data_factor;
9307 fprintf (stderr, "unsupported or unknown DW_CFA_%d\n", op);
9312 if (do_debug_frames_interp)
9313 frame_display_row (fc, &need_col_headers, &max_regs);
9328 display_debug_not_supported (Elf_Internal_Shdr *section,
9329 unsigned char *start ATTRIBUTE_UNUSED,
9330 FILE *file ATTRIBUTE_UNUSED)
9332 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
9333 SECTION_NAME (section));
9338 /* A structure containing the name of a debug section
9339 and a pointer to a function that can decode it. */
9342 const char *const name;
9343 int (*display) (Elf_Internal_Shdr *, unsigned char *, FILE *);
9347 { ".debug_abbrev", display_debug_abbrev },
9348 { ".debug_aranges", display_debug_aranges },
9349 { ".debug_frame", display_debug_frames },
9350 { ".debug_info", display_debug_info },
9351 { ".debug_line", display_debug_lines },
9352 { ".debug_pubnames", display_debug_pubnames },
9353 { ".eh_frame", display_debug_frames },
9354 { ".debug_macinfo", display_debug_macinfo },
9355 { ".debug_str", display_debug_str },
9356 { ".debug_loc", display_debug_loc },
9357 { ".debug_pubtypes", display_debug_not_supported },
9358 { ".debug_ranges", display_debug_not_supported },
9359 { ".debug_static_func", display_debug_not_supported },
9360 { ".debug_static_vars", display_debug_not_supported },
9361 { ".debug_types", display_debug_not_supported },
9362 { ".debug_weaknames", display_debug_not_supported }
9366 display_debug_section (Elf_Internal_Shdr *section, FILE *file)
9368 char *name = SECTION_NAME (section);
9369 bfd_size_type length;
9370 unsigned char *start;
9373 length = section->sh_size;
9376 printf (_("\nSection '%s' has no debugging data.\n"), name);
9380 start = get_data (NULL, file, section->sh_offset, length,
9381 _("debug section data"));
9385 /* See if we know how to display the contents of this section. */
9386 if (strncmp (name, ".gnu.linkonce.wi.", 17) == 0)
9387 name = ".debug_info";
9389 for (i = NUM_ELEM (debug_displays); i--;)
9390 if (strcmp (debug_displays[i].name, name) == 0)
9392 debug_displays[i].display (section, start, file);
9397 printf (_("Unrecognized debug section: %s\n"), name);
9401 /* If we loaded in the abbrev section at some point,
9402 we must release it here. */
9409 process_section_contents (FILE *file)
9411 Elf_Internal_Shdr *section;
9417 for (i = 0, section = section_headers;
9418 i < elf_header.e_shnum && i < num_dump_sects;
9421 #ifdef SUPPORT_DISASSEMBLY
9422 if (dump_sects[i] & DISASS_DUMP)
9423 disassemble_section (section, file);
9425 if (dump_sects[i] & HEX_DUMP)
9426 dump_section (section, file);
9428 if (dump_sects[i] & DEBUG_DUMP)
9429 display_debug_section (section, file);
9432 if (i < num_dump_sects)
9433 warn (_("Some sections were not dumped because they do not exist!\n"));
9439 process_mips_fpe_exception (int mask)
9444 if (mask & OEX_FPU_INEX)
9445 fputs ("INEX", stdout), first = 0;
9446 if (mask & OEX_FPU_UFLO)
9447 printf ("%sUFLO", first ? "" : "|"), first = 0;
9448 if (mask & OEX_FPU_OFLO)
9449 printf ("%sOFLO", first ? "" : "|"), first = 0;
9450 if (mask & OEX_FPU_DIV0)
9451 printf ("%sDIV0", first ? "" : "|"), first = 0;
9452 if (mask & OEX_FPU_INVAL)
9453 printf ("%sINVAL", first ? "" : "|");
9456 fputs ("0", stdout);
9460 process_mips_specific (FILE *file)
9462 Elf_Internal_Dyn *entry;
9463 size_t liblist_offset = 0;
9464 size_t liblistno = 0;
9465 size_t conflictsno = 0;
9466 size_t options_offset = 0;
9467 size_t conflicts_offset = 0;
9469 /* We have a lot of special sections. Thanks SGI! */
9470 if (dynamic_segment == NULL)
9471 /* No information available. */
9474 for (entry = dynamic_segment; entry->d_tag != DT_NULL; ++entry)
9475 switch (entry->d_tag)
9477 case DT_MIPS_LIBLIST:
9479 = offset_from_vma (file, entry->d_un.d_val,
9480 liblistno * sizeof (Elf32_External_Lib));
9482 case DT_MIPS_LIBLISTNO:
9483 liblistno = entry->d_un.d_val;
9485 case DT_MIPS_OPTIONS:
9486 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
9488 case DT_MIPS_CONFLICT:
9490 = offset_from_vma (file, entry->d_un.d_val,
9491 conflictsno * sizeof (Elf32_External_Conflict));
9493 case DT_MIPS_CONFLICTNO:
9494 conflictsno = entry->d_un.d_val;
9500 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
9502 Elf32_External_Lib *elib;
9505 elib = get_data (NULL, file, liblist_offset,
9506 liblistno * sizeof (Elf32_External_Lib),
9510 printf ("\nSection '.liblist' contains %lu entries:\n",
9511 (unsigned long) liblistno);
9512 fputs (" Library Time Stamp Checksum Version Flags\n",
9515 for (cnt = 0; cnt < liblistno; ++cnt)
9522 liblist.l_name = BYTE_GET (elib[cnt].l_name);
9523 time = BYTE_GET (elib[cnt].l_time_stamp);
9524 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
9525 liblist.l_version = BYTE_GET (elib[cnt].l_version);
9526 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
9528 tmp = gmtime (&time);
9529 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
9530 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9531 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9533 printf ("%3lu: ", (unsigned long) cnt);
9534 print_symbol (20, dynamic_strings + liblist.l_name);
9535 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
9538 if (liblist.l_flags == 0)
9549 { " EXACT_MATCH", LL_EXACT_MATCH },
9550 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
9551 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
9552 { " EXPORTS", LL_EXPORTS },
9553 { " DELAY_LOAD", LL_DELAY_LOAD },
9554 { " DELTA", LL_DELTA }
9556 int flags = liblist.l_flags;
9560 fcnt < sizeof (l_flags_vals) / sizeof (l_flags_vals[0]);
9562 if ((flags & l_flags_vals[fcnt].bit) != 0)
9564 fputs (l_flags_vals[fcnt].name, stdout);
9565 flags ^= l_flags_vals[fcnt].bit;
9568 printf (" %#x", (unsigned int) flags);
9578 if (options_offset != 0)
9580 Elf_External_Options *eopt;
9581 Elf_Internal_Shdr *sect = section_headers;
9582 Elf_Internal_Options *iopt;
9583 Elf_Internal_Options *option;
9587 /* Find the section header so that we get the size. */
9588 while (sect->sh_type != SHT_MIPS_OPTIONS)
9591 eopt = get_data (NULL, file, options_offset, sect->sh_size,
9595 iopt = malloc ((sect->sh_size / sizeof (eopt)) * sizeof (*iopt));
9598 error (_("Out of memory"));
9605 while (offset < sect->sh_size)
9607 Elf_External_Options *eoption;
9609 eoption = (Elf_External_Options *) ((char *) eopt + offset);
9611 option->kind = BYTE_GET (eoption->kind);
9612 option->size = BYTE_GET (eoption->size);
9613 option->section = BYTE_GET (eoption->section);
9614 option->info = BYTE_GET (eoption->info);
9616 offset += option->size;
9622 printf (_("\nSection '%s' contains %d entries:\n"),
9623 SECTION_NAME (sect), cnt);
9631 switch (option->kind)
9634 /* This shouldn't happen. */
9635 printf (" NULL %d %lx", option->section, option->info);
9638 printf (" REGINFO ");
9639 if (elf_header.e_machine == EM_MIPS)
9642 Elf32_External_RegInfo *ereg;
9643 Elf32_RegInfo reginfo;
9645 ereg = (Elf32_External_RegInfo *) (option + 1);
9646 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
9647 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
9648 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
9649 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
9650 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
9651 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
9653 printf ("GPR %08lx GP 0x%lx\n",
9655 (unsigned long) reginfo.ri_gp_value);
9656 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9657 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
9658 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
9663 Elf64_External_RegInfo *ereg;
9664 Elf64_Internal_RegInfo reginfo;
9666 ereg = (Elf64_External_RegInfo *) (option + 1);
9667 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
9668 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
9669 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
9670 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
9671 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
9672 reginfo.ri_gp_value = BYTE_GET8 (ereg->ri_gp_value);
9674 printf ("GPR %08lx GP 0x",
9675 reginfo.ri_gprmask);
9676 printf_vma (reginfo.ri_gp_value);
9679 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9680 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
9681 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
9685 case ODK_EXCEPTIONS:
9686 fputs (" EXCEPTIONS fpe_min(", stdout);
9687 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
9688 fputs (") fpe_max(", stdout);
9689 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
9690 fputs (")", stdout);
9692 if (option->info & OEX_PAGE0)
9693 fputs (" PAGE0", stdout);
9694 if (option->info & OEX_SMM)
9695 fputs (" SMM", stdout);
9696 if (option->info & OEX_FPDBUG)
9697 fputs (" FPDBUG", stdout);
9698 if (option->info & OEX_DISMISS)
9699 fputs (" DISMISS", stdout);
9702 fputs (" PAD ", stdout);
9703 if (option->info & OPAD_PREFIX)
9704 fputs (" PREFIX", stdout);
9705 if (option->info & OPAD_POSTFIX)
9706 fputs (" POSTFIX", stdout);
9707 if (option->info & OPAD_SYMBOL)
9708 fputs (" SYMBOL", stdout);
9711 fputs (" HWPATCH ", stdout);
9712 if (option->info & OHW_R4KEOP)
9713 fputs (" R4KEOP", stdout);
9714 if (option->info & OHW_R8KPFETCH)
9715 fputs (" R8KPFETCH", stdout);
9716 if (option->info & OHW_R5KEOP)
9717 fputs (" R5KEOP", stdout);
9718 if (option->info & OHW_R5KCVTL)
9719 fputs (" R5KCVTL", stdout);
9722 fputs (" FILL ", stdout);
9723 /* XXX Print content of info word? */
9726 fputs (" TAGS ", stdout);
9727 /* XXX Print content of info word? */
9730 fputs (" HWAND ", stdout);
9731 if (option->info & OHWA0_R4KEOP_CHECKED)
9732 fputs (" R4KEOP_CHECKED", stdout);
9733 if (option->info & OHWA0_R4KEOP_CLEAN)
9734 fputs (" R4KEOP_CLEAN", stdout);
9737 fputs (" HWOR ", stdout);
9738 if (option->info & OHWA0_R4KEOP_CHECKED)
9739 fputs (" R4KEOP_CHECKED", stdout);
9740 if (option->info & OHWA0_R4KEOP_CLEAN)
9741 fputs (" R4KEOP_CLEAN", stdout);
9744 printf (" GP_GROUP %#06lx self-contained %#06lx",
9745 option->info & OGP_GROUP,
9746 (option->info & OGP_SELF) >> 16);
9749 printf (" IDENT %#06lx self-contained %#06lx",
9750 option->info & OGP_GROUP,
9751 (option->info & OGP_SELF) >> 16);
9754 /* This shouldn't happen. */
9755 printf (" %3d ??? %d %lx",
9756 option->kind, option->section, option->info);
9760 len = sizeof (*eopt);
9761 while (len < option->size)
9762 if (((char *) option)[len] >= ' '
9763 && ((char *) option)[len] < 0x7f)
9764 printf ("%c", ((char *) option)[len++]);
9766 printf ("\\%03o", ((char *) option)[len++]);
9768 fputs ("\n", stdout);
9776 if (conflicts_offset != 0 && conflictsno != 0)
9778 Elf32_Conflict *iconf;
9781 if (dynamic_symbols == NULL)
9783 error (_("conflict list found without a dynamic symbol table"));
9787 iconf = malloc (conflictsno * sizeof (*iconf));
9790 error (_("Out of memory"));
9796 Elf32_External_Conflict *econf32;
9798 econf32 = get_data (NULL, file, conflicts_offset,
9799 conflictsno * sizeof (*econf32), _("conflict"));
9803 for (cnt = 0; cnt < conflictsno; ++cnt)
9804 iconf[cnt] = BYTE_GET (econf32[cnt]);
9810 Elf64_External_Conflict *econf64;
9812 econf64 = get_data (NULL, file, conflicts_offset,
9813 conflictsno * sizeof (*econf64), _("conflict"));
9817 for (cnt = 0; cnt < conflictsno; ++cnt)
9818 iconf[cnt] = BYTE_GET (econf64[cnt]);
9823 printf (_("\nSection '.conflict' contains %lu entries:\n"),
9824 (unsigned long) conflictsno);
9825 puts (_(" Num: Index Value Name"));
9827 for (cnt = 0; cnt < conflictsno; ++cnt)
9829 Elf_Internal_Sym *psym = & dynamic_symbols[iconf[cnt]];
9831 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
9832 print_vma (psym->st_value, FULL_HEX);
9834 print_symbol (25, dynamic_strings + psym->st_name);
9845 process_gnu_liblist (FILE *file)
9847 Elf_Internal_Shdr *section, *string_sec;
9848 Elf32_External_Lib *elib;
9856 for (i = 0, section = section_headers;
9857 i < elf_header.e_shnum;
9860 switch (section->sh_type)
9862 case SHT_GNU_LIBLIST:
9863 elib = get_data (NULL, file, section->sh_offset, section->sh_size,
9868 string_sec = SECTION_HEADER (section->sh_link);
9870 strtab = get_data (NULL, file, string_sec->sh_offset,
9871 string_sec->sh_size, _("liblist string table"));
9874 || section->sh_entsize != sizeof (Elf32_External_Lib))
9880 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
9881 SECTION_NAME (section),
9882 (long) (section->sh_size / sizeof (Elf32_External_Lib)));
9884 puts (" Library Time Stamp Checksum Version Flags");
9886 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
9894 liblist.l_name = BYTE_GET (elib[cnt].l_name);
9895 time = BYTE_GET (elib[cnt].l_time_stamp);
9896 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
9897 liblist.l_version = BYTE_GET (elib[cnt].l_version);
9898 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
9900 tmp = gmtime (&time);
9901 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
9902 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9903 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9905 printf ("%3lu: ", (unsigned long) cnt);
9907 printf ("%-20s", strtab + liblist.l_name);
9909 printf ("%-20.20s", strtab + liblist.l_name);
9910 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
9911 liblist.l_version, liblist.l_flags);
9922 get_note_type (unsigned e_type)
9924 static char buff[64];
9928 case NT_AUXV: return _("NT_AUXV (auxiliary vector)");
9929 case NT_PRSTATUS: return _("NT_PRSTATUS (prstatus structure)");
9930 case NT_FPREGSET: return _("NT_FPREGSET (floating point registers)");
9931 case NT_PRPSINFO: return _("NT_PRPSINFO (prpsinfo structure)");
9932 case NT_TASKSTRUCT: return _("NT_TASKSTRUCT (task structure)");
9933 case NT_PRXFPREG: return _("NT_PRXFPREG (user_xfpregs structure)");
9934 case NT_PSTATUS: return _("NT_PSTATUS (pstatus structure)");
9935 case NT_FPREGS: return _("NT_FPREGS (floating point registers)");
9936 case NT_PSINFO: return _("NT_PSINFO (psinfo structure)");
9937 case NT_LWPSTATUS: return _("NT_LWPSTATUS (lwpstatus_t structure)");
9938 case NT_LWPSINFO: return _("NT_LWPSINFO (lwpsinfo_t structure)");
9939 case NT_WIN32PSTATUS: return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9941 sprintf (buff, _("Unknown note type: (0x%08x)"), e_type);
9947 get_netbsd_elfcore_note_type (unsigned e_type)
9949 static char buff[64];
9951 if (e_type == NT_NETBSDCORE_PROCINFO)
9953 /* NetBSD core "procinfo" structure. */
9954 return _("NetBSD procinfo structure");
9957 /* As of Jan 2002 there are no other machine-independent notes
9958 defined for NetBSD core files. If the note type is less
9959 than the start of the machine-dependent note types, we don't
9962 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9964 sprintf (buff, _("Unknown note type: (0x%08x)"), e_type);
9968 switch (elf_header.e_machine)
9970 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
9971 and PT_GETFPREGS == mach+2. */
9976 case EM_SPARC32PLUS:
9980 case NT_NETBSDCORE_FIRSTMACH+0:
9981 return _("PT_GETREGS (reg structure)");
9982 case NT_NETBSDCORE_FIRSTMACH+2:
9983 return _("PT_GETFPREGS (fpreg structure)");
9989 /* On all other arch's, PT_GETREGS == mach+1 and
9990 PT_GETFPREGS == mach+3. */
9994 case NT_NETBSDCORE_FIRSTMACH+1:
9995 return _("PT_GETREGS (reg structure)");
9996 case NT_NETBSDCORE_FIRSTMACH+3:
9997 return _("PT_GETFPREGS (fpreg structure)");
10003 sprintf (buff, _("PT_FIRSTMACH+%d"), e_type - NT_NETBSDCORE_FIRSTMACH);
10007 /* Note that by the ELF standard, the name field is already null byte
10008 terminated, and namesz includes the terminating null byte.
10009 I.E. the value of namesz for the name "FSF" is 4.
10011 If the value of namesz is zero, there is no name present. */
10013 process_note (Elf_Internal_Note *pnote)
10017 if (pnote->namesz == 0)
10019 /* If there is no note name, then use the default set of
10020 note type strings. */
10021 nt = get_note_type (pnote->type);
10023 else if (strncmp (pnote->namedata, "NetBSD-CORE", 11) == 0)
10025 /* NetBSD-specific core file notes. */
10026 nt = get_netbsd_elfcore_note_type (pnote->type);
10030 /* Don't recognize this note name; just use the default set of
10031 note type strings. */
10032 nt = get_note_type (pnote->type);
10035 printf (" %s\t\t0x%08lx\t%s\n",
10036 pnote->namesz ? pnote->namedata : "(NONE)",
10037 pnote->descsz, nt);
10043 process_corefile_note_segment (FILE *file, bfd_vma offset, bfd_vma length)
10045 Elf_External_Note *pnotes;
10046 Elf_External_Note *external;
10052 pnotes = get_data (NULL, file, offset, length, _("notes"));
10058 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
10059 (unsigned long) offset, (unsigned long) length);
10060 printf (_(" Owner\t\tData size\tDescription\n"));
10062 while (external < (Elf_External_Note *)((char *) pnotes + length))
10064 Elf_External_Note *next;
10065 Elf_Internal_Note inote;
10068 inote.type = BYTE_GET (external->type);
10069 inote.namesz = BYTE_GET (external->namesz);
10070 inote.namedata = external->name;
10071 inote.descsz = BYTE_GET (external->descsz);
10072 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
10073 inote.descpos = offset + (inote.descdata - (char *) pnotes);
10075 next = (Elf_External_Note *)(inote.descdata + align_power (inote.descsz, 2));
10077 if (((char *) next) > (((char *) pnotes) + length))
10079 warn (_("corrupt note found at offset %x into core notes\n"),
10080 ((char *) external) - ((char *) pnotes));
10081 warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
10082 inote.type, inote.namesz, inote.descsz);
10088 /* Verify that name is null terminated. It appears that at least
10089 one version of Linux (RedHat 6.0) generates corefiles that don't
10090 comply with the ELF spec by failing to include the null byte in
10092 if (inote.namedata[inote.namesz] != '\0')
10094 temp = malloc (inote.namesz + 1);
10098 error (_("Out of memory\n"));
10103 strncpy (temp, inote.namedata, inote.namesz);
10104 temp[inote.namesz] = 0;
10106 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
10107 inote.namedata = temp;
10110 res &= process_note (& inote);
10125 process_corefile_note_segments (FILE *file)
10127 Elf_Internal_Phdr *segment;
10131 if (! get_program_headers (file))
10134 for (i = 0, segment = program_headers;
10135 i < elf_header.e_phnum;
10138 if (segment->p_type == PT_NOTE)
10139 res &= process_corefile_note_segment (file,
10140 (bfd_vma) segment->p_offset,
10141 (bfd_vma) segment->p_filesz);
10148 process_corefile_contents (FILE *file)
10150 /* If we have not been asked to display the notes then do nothing. */
10154 /* If file is not a core file then exit. */
10155 if (elf_header.e_type != ET_CORE)
10158 /* No program headers means no NOTE segment. */
10159 if (elf_header.e_phnum == 0)
10161 printf (_("No note segments present in the core file.\n"));
10165 return process_corefile_note_segments (file);
10169 process_arch_specific (FILE *file)
10174 switch (elf_header.e_machine)
10177 case EM_MIPS_RS3_LE:
10178 return process_mips_specific (file);
10187 get_file_header (FILE *file)
10189 /* Read in the identity array. */
10190 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
10193 /* Determine how to read the rest of the header. */
10194 switch (elf_header.e_ident[EI_DATA])
10196 default: /* fall through */
10197 case ELFDATANONE: /* fall through */
10199 byte_get = byte_get_little_endian;
10200 byte_put = byte_put_little_endian;
10203 byte_get = byte_get_big_endian;
10204 byte_put = byte_put_big_endian;
10208 /* For now we only support 32 bit and 64 bit ELF files. */
10209 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
10211 /* Read in the rest of the header. */
10214 Elf32_External_Ehdr ehdr32;
10216 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
10219 elf_header.e_type = BYTE_GET (ehdr32.e_type);
10220 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
10221 elf_header.e_version = BYTE_GET (ehdr32.e_version);
10222 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
10223 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
10224 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
10225 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
10226 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
10227 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
10228 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
10229 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
10230 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
10231 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
10235 Elf64_External_Ehdr ehdr64;
10237 /* If we have been compiled with sizeof (bfd_vma) == 4, then
10238 we will not be able to cope with the 64bit data found in
10239 64 ELF files. Detect this now and abort before we start
10240 overwriting things. */
10241 if (sizeof (bfd_vma) < 8)
10243 error (_("This instance of readelf has been built without support for a\n\
10244 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10248 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
10251 elf_header.e_type = BYTE_GET (ehdr64.e_type);
10252 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
10253 elf_header.e_version = BYTE_GET (ehdr64.e_version);
10254 elf_header.e_entry = BYTE_GET8 (ehdr64.e_entry);
10255 elf_header.e_phoff = BYTE_GET8 (ehdr64.e_phoff);
10256 elf_header.e_shoff = BYTE_GET8 (ehdr64.e_shoff);
10257 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
10258 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
10259 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
10260 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
10261 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
10262 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
10263 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
10266 if (elf_header.e_shoff)
10268 /* There may be some extensions in the first section header. Don't
10269 bomb if we can't read it. */
10271 get_32bit_section_headers (file, 1);
10273 get_64bit_section_headers (file, 1);
10279 /* Process one ELF object file according to the command line options.
10280 This file may actually be stored in an archive. The file is
10281 positioned at the start of the ELF object. */
10284 process_object (char *file_name, FILE *file)
10288 if (! get_file_header (file))
10290 error (_("%s: Failed to read file header\n"), file_name);
10294 /* Initialise per file variables. */
10295 for (i = NUM_ELEM (version_info); i--;)
10296 version_info[i] = 0;
10298 for (i = NUM_ELEM (dynamic_info); i--;)
10299 dynamic_info[i] = 0;
10301 /* Process the file. */
10303 printf (_("\nFile: %s\n"), file_name);
10305 if (! process_file_header ())
10308 if (! process_section_headers (file))
10310 /* Without loaded section headers we
10311 cannot process lots of things. */
10312 do_unwind = do_version = do_dump = do_arch = 0;
10314 if (! do_using_dynamic)
10315 do_syms = do_reloc = 0;
10318 if (process_program_headers (file))
10319 process_dynamic_segment (file);
10321 process_relocs (file);
10323 process_unwind (file);
10325 process_symbol_table (file);
10327 process_syminfo (file);
10329 process_version_sections (file);
10331 process_section_contents (file);
10333 process_corefile_contents (file);
10335 process_gnu_liblist (file);
10337 process_arch_specific (file);
10339 if (program_headers)
10341 free (program_headers);
10342 program_headers = NULL;
10345 if (section_headers)
10347 free (section_headers);
10348 section_headers = NULL;
10353 free (string_table);
10354 string_table = NULL;
10355 string_table_length = 0;
10358 if (dynamic_strings)
10360 free (dynamic_strings);
10361 dynamic_strings = NULL;
10364 if (dynamic_symbols)
10366 free (dynamic_symbols);
10367 dynamic_symbols = NULL;
10368 num_dynamic_syms = 0;
10371 if (dynamic_syminfo)
10373 free (dynamic_syminfo);
10374 dynamic_syminfo = NULL;
10380 /* Process an ELF archive. The file is positioned just after the
10384 process_archive (char *file_name, FILE *file)
10386 struct ar_hdr arhdr;
10388 unsigned long size;
10389 char *longnames = NULL;
10390 unsigned long longnames_size = 0;
10391 size_t file_name_size;
10396 got = fread (&arhdr, 1, sizeof arhdr, file);
10397 if (got != sizeof arhdr)
10402 error (_("%s: failed to read archive header\n"), file_name);
10406 if (memcmp (arhdr.ar_name, "/ ", 16) == 0)
10408 /* This is the archive symbol table. Skip it.
10409 FIXME: We should have an option to dump it. */
10410 size = strtoul (arhdr.ar_size, NULL, 10);
10411 if (fseek (file, size + (size & 1), SEEK_CUR) != 0)
10413 error (_("%s: failed to skip archive symbol table\n"), file_name);
10417 got = fread (&arhdr, 1, sizeof arhdr, file);
10418 if (got != sizeof arhdr)
10423 error (_("%s: failed to read archive header\n"), file_name);
10428 if (memcmp (arhdr.ar_name, "// ", 16) == 0)
10430 /* This is the archive string table holding long member
10433 longnames_size = strtoul (arhdr.ar_size, NULL, 10);
10435 longnames = malloc (longnames_size);
10436 if (longnames == NULL)
10438 error (_("Out of memory\n"));
10442 if (fread (longnames, longnames_size, 1, file) != 1)
10445 error(_("%s: failed to read string table\n"), file_name);
10449 if ((longnames_size & 1) != 0)
10452 got = fread (&arhdr, 1, sizeof arhdr, file);
10453 if (got != sizeof arhdr)
10460 error (_("%s: failed to read archive header\n"), file_name);
10465 file_name_size = strlen (file_name);
10474 if (arhdr.ar_name[0] == '/')
10478 off = strtoul (arhdr.ar_name + 1, NULL, 10);
10479 if (off >= longnames_size)
10481 error (_("%s: invalid archive string table offset %lu\n"), off);
10486 name = longnames + off;
10487 nameend = memchr (name, '/', longnames_size - off);
10491 name = arhdr.ar_name;
10492 nameend = memchr (name, '/', 16);
10495 if (nameend == NULL)
10497 error (_("%s: bad archive file name\n"));
10502 namealc = malloc (file_name_size + (nameend - name) + 3);
10503 if (namealc == NULL)
10505 error (_("Out of memory\n"));
10510 memcpy (namealc, file_name, file_name_size);
10511 namealc[file_name_size] = '(';
10512 memcpy (namealc + file_name_size + 1, name, nameend - name);
10513 namealc[file_name_size + 1 + (nameend - name)] = ')';
10514 namealc[file_name_size + 2 + (nameend - name)] = '\0';
10516 archive_file_offset = ftell (file);
10517 archive_file_size = strtoul (arhdr.ar_size, NULL, 10);
10519 ret |= process_object (namealc, file);
10524 (archive_file_offset
10525 + archive_file_size
10526 + (archive_file_size & 1)),
10529 error (_("%s: failed to seek to next archive header\n"), file_name);
10534 got = fread (&arhdr, 1, sizeof arhdr, file);
10535 if (got != sizeof arhdr)
10540 error (_("%s: failed to read archive header\n"), file_name);
10546 if (longnames != 0)
10553 process_file (char *file_name)
10556 struct stat statbuf;
10557 char armag[SARMAG];
10560 if (stat (file_name, &statbuf) < 0)
10562 if (errno == ENOENT)
10563 error (_("'%s': No such file\n"), file_name);
10565 error (_("Could not locate '%s'. System error message: %s\n"),
10566 file_name, strerror (errno));
10570 if (! S_ISREG (statbuf.st_mode))
10572 error (_("'%s' is not an ordinary file\n"), file_name);
10576 file = fopen (file_name, "rb");
10579 error (_("Input file '%s' is not readable.\n"), file_name);
10583 if (fread (armag, SARMAG, 1, file) != 1)
10585 error (_("%s: Failed to read file header\n"), file_name);
10590 if (memcmp (armag, ARMAG, SARMAG) == 0)
10591 ret = process_archive (file_name, file);
10595 archive_file_size = archive_file_offset = 0;
10596 ret = process_object (file_name, file);
10604 #ifdef SUPPORT_DISASSEMBLY
10605 /* Needed by the i386 disassembler. For extra credit, someone could
10606 fix this so that we insert symbolic addresses here, esp for GOT/PLT
10610 print_address (unsigned int addr, FILE *outfile)
10612 fprintf (outfile,"0x%8.8x", addr);
10615 /* Needed by the i386 disassembler. */
10617 db_task_printsym (unsigned int addr)
10619 print_address (addr, stderr);
10624 main (int argc, char **argv)
10627 char *cmdline_dump_sects = NULL;
10628 unsigned num_cmdline_dump_sects = 0;
10630 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
10631 setlocale (LC_MESSAGES, "");
10633 #if defined (HAVE_SETLOCALE)
10634 setlocale (LC_CTYPE, "");
10636 bindtextdomain (PACKAGE, LOCALEDIR);
10637 textdomain (PACKAGE);
10639 parse_args (argc, argv);
10641 if (optind < (argc - 1))
10644 /* When processing more than one file remember the dump requests
10645 issued on command line to reset them after each file. */
10646 if (optind + 1 < argc && dump_sects != NULL)
10648 cmdline_dump_sects = malloc (num_dump_sects);
10649 if (cmdline_dump_sects == NULL)
10650 error (_("Out of memory allocating dump request table."));
10653 memcpy (cmdline_dump_sects, dump_sects, num_dump_sects);
10654 num_cmdline_dump_sects = num_dump_sects;
10659 while (optind < argc)
10661 err |= process_file (argv[optind++]);
10663 /* Reset dump requests. */
10664 if (optind < argc && dump_sects != NULL)
10666 num_dump_sects = num_cmdline_dump_sects;
10667 if (num_cmdline_dump_sects > 0)
10668 memcpy (dump_sects, cmdline_dump_sects, num_cmdline_dump_sects);
10672 if (dump_sects != NULL)
10674 if (cmdline_dump_sects != NULL)
10675 free (cmdline_dump_sects);