1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004
3 Free Software Foundation, Inc.
5 Originally developed by Eric Youngdale <eric@andante.jic.com>
6 Modifications by Nick Clifton <nickc@redhat.com>
8 This file is part of GNU Binutils.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
25 /* The difference between readelf and objdump:
27 Both programs are capable of displaying the contents of ELF format files,
28 so why does the binutils project have two file dumpers ?
30 The reason is that objdump sees an ELF file through a BFD filter of the
31 world; if BFD has a bug where, say, it disagrees about a machine constant
32 in e_flags, then the odds are good that it will remain internally
33 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
34 GAS sees it the BFD way. There was need for a tool to go find out what
35 the file actually says.
37 This is why the readelf program does not link against the BFD library - it
38 exists as an independent program to help verify the correct working of BFD.
40 There is also the case that readelf can provide more information about an
41 ELF file than is provided by objdump. In particular it can display DWARF
42 debugging information which (at the moment) objdump cannot. */
45 #include <sys/types.h>
51 /* Define BFD64 here, even if our default architecture is 32 bit ELF
52 as this will allow us to read in and parse 64bit and 32bit ELF files.
53 Only do this if we believe that the compiler can support a 64 bit
54 data type. For now we only rely on GCC being able to do this. */
60 #include "elf/common.h"
61 #include "elf/external.h"
62 #include "elf/internal.h"
63 #include "elf/dwarf2.h"
65 /* The following headers use the elf/reloc-macros.h file to
66 automatically generate relocation recognition functions
67 such as elf_mips_reloc_type() */
69 #define RELOC_MACROS_GEN_FUNC
71 #include "elf/alpha.h"
91 #include "elf/m68hc11.h"
92 #include "elf/mcore.h"
95 #include "elf/mn10200.h"
96 #include "elf/mn10300.h"
97 #include "elf/msp430.h"
101 #include "elf/ppc64.h"
102 #include "elf/s390.h"
104 #include "elf/sparc.h"
105 #include "elf/v850.h"
107 #include "elf/x86-64.h"
108 #include "elf/xstormy16.h"
110 #include "elf/iq2000.h"
111 #include "elf/xtensa.h"
117 #include "libiberty.h"
119 char *program_name
= "readelf";
120 long archive_file_offset
;
121 unsigned long archive_file_size
;
122 unsigned long dynamic_addr
;
123 bfd_size_type dynamic_size
;
124 unsigned int dynamic_nent
;
125 char *dynamic_strings
;
126 unsigned long dynamic_strings_length
;
128 unsigned long string_table_length
;
129 unsigned long num_dynamic_syms
;
130 Elf_Internal_Sym
*dynamic_symbols
;
131 Elf_Internal_Syminfo
*dynamic_syminfo
;
132 unsigned long dynamic_syminfo_offset
;
133 unsigned int dynamic_syminfo_nent
;
134 char program_interpreter
[64];
135 bfd_vma dynamic_info
[DT_JMPREL
+ 1];
136 bfd_vma version_info
[16];
137 Elf_Internal_Ehdr elf_header
;
138 Elf_Internal_Shdr
*section_headers
;
139 Elf_Internal_Phdr
*program_headers
;
140 Elf_Internal_Dyn
*dynamic_section
;
141 Elf_Internal_Shdr
*symtab_shndx_hdr
;
147 int do_section_groups
;
150 int do_using_dynamic
;
158 int do_debug_abbrevs
;
160 int do_debug_pubnames
;
161 int do_debug_aranges
;
163 int do_debug_frames_interp
;
164 int do_debug_macinfo
;
173 struct group_list
*next
;
174 unsigned int section_index
;
179 struct group_list
*root
;
180 unsigned int group_index
;
183 struct group
*section_groups
;
184 size_t group_count
= 0;
186 struct group
**section_headers_groups
;
188 /* A dynamic array of flags indicating which sections require dumping. */
189 char *dump_sects
= NULL
;
190 unsigned int num_dump_sects
= 0;
192 #define HEX_DUMP (1 << 0)
193 #define DISASS_DUMP (1 << 1)
194 #define DEBUG_DUMP (1 << 2)
196 /* How to rpint a vma value. */
197 typedef enum print_mode
209 static bfd_vma (*byte_get
) (unsigned char *, int);
210 static void (*byte_put
) (unsigned char *, bfd_vma
, int);
214 #define SECTION_NAME(X) ((X) == NULL ? "<none>" : \
215 ((X)->sh_name >= string_table_length \
216 ? "<corrupt>" : string_table + (X)->sh_name))
218 /* Given st_shndx I, map to section_headers index. */
219 #define SECTION_HEADER_INDEX(I) \
220 ((I) < SHN_LORESERVE \
222 : ((I) <= SHN_HIRESERVE \
224 : (I) - (SHN_HIRESERVE + 1 - SHN_LORESERVE)))
226 /* Reverse of the above. */
227 #define SECTION_HEADER_NUM(N) \
228 ((N) < SHN_LORESERVE \
230 : (N) + (SHN_HIRESERVE + 1 - SHN_LORESERVE))
232 #define SECTION_HEADER(I) (section_headers + SECTION_HEADER_INDEX (I))
234 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
236 #define BYTE_GET(field) byte_get (field, sizeof (field))
238 /* If we can support a 64 bit data type then BFD64 should be defined
239 and sizeof (bfd_vma) == 8. In this case when translating from an
240 external 8 byte field to an internal field, we can assume that the
241 internal field is also 8 bytes wide and so we can extract all the data.
242 If, however, BFD64 is not defined, then we must assume that the
243 internal data structure only has 4 byte wide fields that are the
244 equivalent of the 8 byte wide external counterparts, and so we must
245 truncate the data. */
247 #define BYTE_GET8(field) byte_get (field, -8)
249 #define BYTE_GET8(field) byte_get (field, 8)
252 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
254 #define GET_ELF_SYMBOLS(file, section) \
255 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
256 : get_64bit_elf_symbols (file, section))
258 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
259 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
260 already been called and verified that the string exists. */
261 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
264 error (const char *message
, ...)
268 va_start (args
, message
);
269 fprintf (stderr
, _("%s: Error: "), program_name
);
270 vfprintf (stderr
, message
, args
);
275 warn (const char *message
, ...)
279 va_start (args
, message
);
280 fprintf (stderr
, _("%s: Warning: "), program_name
);
281 vfprintf (stderr
, message
, args
);
286 get_data (void *var
, FILE *file
, long offset
, size_t size
, const char *reason
)
293 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
295 error (_("Unable to seek to 0x%x for %s\n"),
296 archive_file_offset
+ offset
, reason
);
303 mvar
= malloc (size
);
307 error (_("Out of memory allocating 0x%x bytes for %s\n"),
313 if (fread (mvar
, size
, 1, file
) != 1)
315 error (_("Unable to read in 0x%x bytes of %s\n"), size
, reason
);
325 byte_get_little_endian (unsigned char *field
, int size
)
333 return ((unsigned int) (field
[0]))
334 | (((unsigned int) (field
[1])) << 8);
338 /* We want to extract data from an 8 byte wide field and
339 place it into a 4 byte wide field. Since this is a little
340 endian source we can just use the 4 byte extraction code. */
344 return ((unsigned long) (field
[0]))
345 | (((unsigned long) (field
[1])) << 8)
346 | (((unsigned long) (field
[2])) << 16)
347 | (((unsigned long) (field
[3])) << 24);
352 /* This is a special case, generated by the BYTE_GET8 macro.
353 It means that we are loading an 8 byte value from a field
354 in an external structure into an 8 byte value in a field
355 in an internal structure. */
356 return ((bfd_vma
) (field
[0]))
357 | (((bfd_vma
) (field
[1])) << 8)
358 | (((bfd_vma
) (field
[2])) << 16)
359 | (((bfd_vma
) (field
[3])) << 24)
360 | (((bfd_vma
) (field
[4])) << 32)
361 | (((bfd_vma
) (field
[5])) << 40)
362 | (((bfd_vma
) (field
[6])) << 48)
363 | (((bfd_vma
) (field
[7])) << 56);
366 error (_("Unhandled data length: %d\n"), size
);
372 byte_get_signed (unsigned char *field
, int size
)
374 bfd_vma x
= byte_get (field
, size
);
379 return (x
^ 0x80) - 0x80;
381 return (x
^ 0x8000) - 0x8000;
383 return (x
^ 0x80000000) - 0x80000000;
393 byte_put_little_endian (unsigned char *field
, bfd_vma value
, int size
)
398 field
[7] = (((value
>> 24) >> 24) >> 8) & 0xff;
399 field
[6] = ((value
>> 24) >> 24) & 0xff;
400 field
[5] = ((value
>> 24) >> 16) & 0xff;
401 field
[4] = ((value
>> 24) >> 8) & 0xff;
404 field
[3] = (value
>> 24) & 0xff;
405 field
[2] = (value
>> 16) & 0xff;
408 field
[1] = (value
>> 8) & 0xff;
411 field
[0] = value
& 0xff;
415 error (_("Unhandled data length: %d\n"), size
);
420 /* Print a VMA value. */
422 print_vma (bfd_vma vma
, print_mode mode
)
434 printf ("%8.8lx", (unsigned long) vma
);
440 printf ("%5ld", (long) vma
);
448 printf ("%lx", (unsigned long) vma
);
452 printf ("%ld", (unsigned long) vma
);
456 printf ("%lu", (unsigned long) vma
);
478 #if BFD_HOST_64BIT_LONG
481 if (_bfd_int64_high (vma
))
482 printf ("%lx%8.8lx", _bfd_int64_high (vma
), _bfd_int64_low (vma
));
484 printf ("%lx", _bfd_int64_low (vma
));
489 #if BFD_HOST_64BIT_LONG
492 if (_bfd_int64_high (vma
))
494 printf ("++%ld", _bfd_int64_low (vma
));
496 printf ("%ld", _bfd_int64_low (vma
));
501 #if BFD_HOST_64BIT_LONG
503 printf ("%5ld", vma
);
505 printf ("%#lx", vma
);
507 if (_bfd_int64_high (vma
))
509 printf ("++%ld", _bfd_int64_low (vma
));
510 else if (vma
<= 99999)
511 printf ("%5ld", _bfd_int64_low (vma
));
513 printf ("%#lx", _bfd_int64_low (vma
));
518 #if BFD_HOST_64BIT_LONG
521 if (_bfd_int64_high (vma
))
523 printf ("++%lu", _bfd_int64_low (vma
));
525 printf ("%lu", _bfd_int64_low (vma
));
533 /* Display a symbol on stdout. If do_wide is not true then
534 format the symbol to be at most WIDTH characters,
535 truncating as necessary. If WIDTH is negative then
536 format the string to be exactly - WIDTH characters,
537 truncating or padding as necessary. */
540 print_symbol (int width
, const char *symbol
)
543 printf ("%s", symbol
);
545 printf ("%-*.*s", width
, width
, symbol
);
547 printf ("%-.*s", width
, symbol
);
551 byte_get_big_endian (unsigned char *field
, int size
)
559 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
562 return ((unsigned long) (field
[3]))
563 | (((unsigned long) (field
[2])) << 8)
564 | (((unsigned long) (field
[1])) << 16)
565 | (((unsigned long) (field
[0])) << 24);
569 /* Although we are extracing data from an 8 byte wide field, we
570 are returning only 4 bytes of data. */
571 return ((unsigned long) (field
[7]))
572 | (((unsigned long) (field
[6])) << 8)
573 | (((unsigned long) (field
[5])) << 16)
574 | (((unsigned long) (field
[4])) << 24);
578 /* This is a special case, generated by the BYTE_GET8 macro.
579 It means that we are loading an 8 byte value from a field
580 in an external structure into an 8 byte value in a field
581 in an internal structure. */
582 return ((bfd_vma
) (field
[7]))
583 | (((bfd_vma
) (field
[6])) << 8)
584 | (((bfd_vma
) (field
[5])) << 16)
585 | (((bfd_vma
) (field
[4])) << 24)
586 | (((bfd_vma
) (field
[3])) << 32)
587 | (((bfd_vma
) (field
[2])) << 40)
588 | (((bfd_vma
) (field
[1])) << 48)
589 | (((bfd_vma
) (field
[0])) << 56);
593 error (_("Unhandled data length: %d\n"), size
);
599 byte_put_big_endian (unsigned char *field
, bfd_vma value
, int size
)
604 field
[7] = value
& 0xff;
605 field
[6] = (value
>> 8) & 0xff;
606 field
[5] = (value
>> 16) & 0xff;
607 field
[4] = (value
>> 24) & 0xff;
612 field
[3] = value
& 0xff;
613 field
[2] = (value
>> 8) & 0xff;
617 field
[1] = value
& 0xff;
621 field
[0] = value
& 0xff;
625 error (_("Unhandled data length: %d\n"), size
);
630 /* Guess the relocation size commonly used by the specific machines. */
633 guess_is_rela (unsigned long e_machine
)
637 /* Targets that use REL relocations. */
652 /* Targets that use RELA relocations. */
667 case EM_CYGNUS_MN10200
:
669 case EM_CYGNUS_MN10300
:
716 warn (_("Don't know about relocations on this machine architecture\n"));
722 slurp_rela_relocs (FILE *file
,
723 unsigned long rel_offset
,
724 unsigned long rel_size
,
725 Elf_Internal_Rela
**relasp
,
726 unsigned long *nrelasp
)
728 Elf_Internal_Rela
*relas
;
729 unsigned long nrelas
;
734 Elf32_External_Rela
*erelas
;
736 erelas
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
740 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
742 relas
= malloc (nrelas
* sizeof (Elf_Internal_Rela
));
746 error(_("out of memory parsing relocs"));
750 for (i
= 0; i
< nrelas
; i
++)
752 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
753 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
754 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
761 Elf64_External_Rela
*erelas
;
763 erelas
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
767 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
769 relas
= malloc (nrelas
* sizeof (Elf_Internal_Rela
));
773 error(_("out of memory parsing relocs"));
777 for (i
= 0; i
< nrelas
; i
++)
779 relas
[i
].r_offset
= BYTE_GET8 (erelas
[i
].r_offset
);
780 relas
[i
].r_info
= BYTE_GET8 (erelas
[i
].r_info
);
781 relas
[i
].r_addend
= BYTE_GET8 (erelas
[i
].r_addend
);
792 slurp_rel_relocs (FILE *file
,
793 unsigned long rel_offset
,
794 unsigned long rel_size
,
795 Elf_Internal_Rela
**relsp
,
796 unsigned long *nrelsp
)
798 Elf_Internal_Rela
*rels
;
804 Elf32_External_Rel
*erels
;
806 erels
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
810 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
812 rels
= malloc (nrels
* sizeof (Elf_Internal_Rela
));
816 error(_("out of memory parsing relocs"));
820 for (i
= 0; i
< nrels
; i
++)
822 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
823 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
824 rels
[i
].r_addend
= 0;
831 Elf64_External_Rel
*erels
;
833 erels
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
837 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
839 rels
= malloc (nrels
* sizeof (Elf_Internal_Rela
));
843 error(_("out of memory parsing relocs"));
847 for (i
= 0; i
< nrels
; i
++)
849 rels
[i
].r_offset
= BYTE_GET8 (erels
[i
].r_offset
);
850 rels
[i
].r_info
= BYTE_GET8 (erels
[i
].r_info
);
851 rels
[i
].r_addend
= 0;
861 /* Display the contents of the relocation data found at the specified
865 dump_relocations (FILE *file
,
866 unsigned long rel_offset
,
867 unsigned long rel_size
,
868 Elf_Internal_Sym
*symtab
,
871 unsigned long strtablen
,
875 Elf_Internal_Rela
*rels
;
878 if (is_rela
== UNKNOWN
)
879 is_rela
= guess_is_rela (elf_header
.e_machine
);
883 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
888 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
897 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
899 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
904 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
906 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
914 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
916 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
921 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
923 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
927 for (i
= 0; i
< rel_size
; i
++)
930 const char *rtype2
= NULL
;
931 const char *rtype3
= NULL
;
934 bfd_vma symtab_index
;
939 offset
= rels
[i
].r_offset
;
940 info
= rels
[i
].r_info
;
944 type
= ELF32_R_TYPE (info
);
945 symtab_index
= ELF32_R_SYM (info
);
949 /* The #ifdef BFD64 below is to prevent a compile time warning.
950 We know that if we do not have a 64 bit data type that we
951 will never execute this code anyway. */
953 if (elf_header
.e_machine
== EM_MIPS
)
955 /* In little-endian objects, r_info isn't really a 64-bit
956 little-endian value: it has a 32-bit little-endian
957 symbol index followed by four individual byte fields.
958 Reorder INFO accordingly. */
959 if (elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
960 info
= (((info
& 0xffffffff) << 32)
961 | ((info
>> 56) & 0xff)
962 | ((info
>> 40) & 0xff00)
963 | ((info
>> 24) & 0xff0000)
964 | ((info
>> 8) & 0xff000000));
965 type
= ELF64_MIPS_R_TYPE (info
);
966 type2
= ELF64_MIPS_R_TYPE2 (info
);
967 type3
= ELF64_MIPS_R_TYPE3 (info
);
969 else if (elf_header
.e_machine
== EM_SPARCV9
)
970 type
= ELF64_R_TYPE_ID (info
);
972 type
= ELF64_R_TYPE (info
);
974 symtab_index
= ELF64_R_SYM (info
);
980 #ifdef _bfd_int64_low
981 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset
), _bfd_int64_low (info
));
983 printf ("%8.8lx %8.8lx ", offset
, info
);
988 #ifdef _bfd_int64_low
990 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
991 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
992 _bfd_int64_high (offset
),
993 _bfd_int64_low (offset
),
994 _bfd_int64_high (info
),
995 _bfd_int64_low (info
));
998 ? "%16.16lx %16.16lx "
999 : "%12.12lx %12.12lx ",
1004 switch (elf_header
.e_machine
)
1011 case EM_CYGNUS_M32R
:
1012 rtype
= elf_m32r_reloc_type (type
);
1017 rtype
= elf_i386_reloc_type (type
);
1022 rtype
= elf_m68hc11_reloc_type (type
);
1026 rtype
= elf_m68k_reloc_type (type
);
1030 rtype
= elf_i960_reloc_type (type
);
1035 rtype
= elf_avr_reloc_type (type
);
1038 case EM_OLD_SPARCV9
:
1039 case EM_SPARC32PLUS
:
1042 rtype
= elf_sparc_reloc_type (type
);
1046 case EM_CYGNUS_V850
:
1047 rtype
= v850_reloc_type (type
);
1051 case EM_CYGNUS_D10V
:
1052 rtype
= elf_d10v_reloc_type (type
);
1056 case EM_CYGNUS_D30V
:
1057 rtype
= elf_d30v_reloc_type (type
);
1061 rtype
= elf_dlx_reloc_type (type
);
1065 rtype
= elf_sh_reloc_type (type
);
1069 case EM_CYGNUS_MN10300
:
1070 rtype
= elf_mn10300_reloc_type (type
);
1074 case EM_CYGNUS_MN10200
:
1075 rtype
= elf_mn10200_reloc_type (type
);
1079 case EM_CYGNUS_FR30
:
1080 rtype
= elf_fr30_reloc_type (type
);
1084 rtype
= elf_frv_reloc_type (type
);
1088 rtype
= elf_mcore_reloc_type (type
);
1092 rtype
= elf_mmix_reloc_type (type
);
1097 rtype
= elf_msp430_reloc_type (type
);
1101 rtype
= elf_ppc_reloc_type (type
);
1105 rtype
= elf_ppc64_reloc_type (type
);
1109 case EM_MIPS_RS3_LE
:
1110 rtype
= elf_mips_reloc_type (type
);
1113 rtype2
= elf_mips_reloc_type (type2
);
1114 rtype3
= elf_mips_reloc_type (type3
);
1119 rtype
= elf_alpha_reloc_type (type
);
1123 rtype
= elf_arm_reloc_type (type
);
1127 rtype
= elf_arc_reloc_type (type
);
1131 rtype
= elf_hppa_reloc_type (type
);
1137 rtype
= elf_h8_reloc_type (type
);
1142 rtype
= elf_or32_reloc_type (type
);
1147 rtype
= elf_pj_reloc_type (type
);
1150 rtype
= elf_ia64_reloc_type (type
);
1154 rtype
= elf_cris_reloc_type (type
);
1158 rtype
= elf_i860_reloc_type (type
);
1162 rtype
= elf_x86_64_reloc_type (type
);
1166 rtype
= i370_reloc_type (type
);
1171 rtype
= elf_s390_reloc_type (type
);
1175 rtype
= elf_xstormy16_reloc_type (type
);
1179 rtype
= elf_crx_reloc_type (type
);
1183 rtype
= elf_vax_reloc_type (type
);
1188 rtype
= elf_ip2k_reloc_type (type
);
1192 rtype
= elf_iq2000_reloc_type (type
);
1197 rtype
= elf_xtensa_reloc_type (type
);
1202 #ifdef _bfd_int64_low
1203 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type
));
1205 printf (_("unrecognized: %-7lx"), type
);
1208 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1212 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1213 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1216 Elf_Internal_Sym
*psym
;
1218 psym
= symtab
+ symtab_index
;
1221 print_vma (psym
->st_value
, LONG_HEX
);
1222 printf (is_32bit_elf
? " " : " ");
1224 if (psym
->st_name
== 0)
1226 const char *sec_name
= "<null>";
1229 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1231 bfd_vma sec_index
= (bfd_vma
) -1;
1233 if (psym
->st_shndx
< SHN_LORESERVE
)
1234 sec_index
= psym
->st_shndx
;
1235 else if (psym
->st_shndx
> SHN_HIRESERVE
)
1236 sec_index
= psym
->st_shndx
- (SHN_HIRESERVE
+ 1
1239 if (sec_index
!= (bfd_vma
) -1)
1240 sec_name
= SECTION_NAME (section_headers
+ sec_index
);
1241 else if (psym
->st_shndx
== SHN_ABS
)
1243 else if (psym
->st_shndx
== SHN_COMMON
)
1244 sec_name
= "COMMON";
1245 else if (elf_header
.e_machine
== EM_IA_64
1246 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1247 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1248 sec_name
= "ANSI_COM";
1251 sprintf (name_buf
, "<section 0x%x>",
1252 (unsigned int) psym
->st_shndx
);
1253 sec_name
= name_buf
;
1256 print_symbol (22, sec_name
);
1258 else if (strtab
== NULL
)
1259 printf (_("<string table index: %3ld>"), psym
->st_name
);
1260 else if (psym
->st_name
> strtablen
)
1261 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1263 print_symbol (22, strtab
+ psym
->st_name
);
1266 printf (" + %lx", (unsigned long) rels
[i
].r_addend
);
1271 printf ("%*c", is_32bit_elf
? (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1272 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1275 if (elf_header
.e_machine
== EM_SPARCV9
1276 && !strcmp (rtype
, "R_SPARC_OLO10"))
1277 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1281 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1283 printf (" Type2: ");
1286 #ifdef _bfd_int64_low
1287 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2
));
1289 printf (_("unrecognized: %-7lx"), type2
);
1292 printf ("%-17.17s", rtype2
);
1294 printf("\n Type3: ");
1297 #ifdef _bfd_int64_low
1298 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3
));
1300 printf (_("unrecognized: %-7lx"), type3
);
1303 printf ("%-17.17s", rtype3
);
1315 get_mips_dynamic_type (unsigned long type
)
1319 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1320 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1321 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1322 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1323 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1324 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1325 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1326 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1327 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1328 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1329 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1330 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1331 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1332 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1333 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1334 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1335 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1336 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1337 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1338 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1339 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1340 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1341 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1342 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1343 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1344 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1345 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1346 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1347 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1348 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1349 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1350 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1351 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1352 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1353 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1354 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1355 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1356 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1357 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1358 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1359 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1360 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1361 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1368 get_sparc64_dynamic_type (unsigned long type
)
1372 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1379 get_ppc64_dynamic_type (unsigned long type
)
1383 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1384 case DT_PPC64_OPD
: return "PPC64_OPD";
1385 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1392 get_parisc_dynamic_type (unsigned long type
)
1396 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1397 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1398 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1399 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1400 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1401 case DT_HP_PREINIT
: return "HP_PREINIT";
1402 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1403 case DT_HP_NEEDED
: return "HP_NEEDED";
1404 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1405 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1406 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1407 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1408 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1415 get_ia64_dynamic_type (unsigned long type
)
1419 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1426 get_dynamic_type (unsigned long type
)
1428 static char buff
[32];
1432 case DT_NULL
: return "NULL";
1433 case DT_NEEDED
: return "NEEDED";
1434 case DT_PLTRELSZ
: return "PLTRELSZ";
1435 case DT_PLTGOT
: return "PLTGOT";
1436 case DT_HASH
: return "HASH";
1437 case DT_STRTAB
: return "STRTAB";
1438 case DT_SYMTAB
: return "SYMTAB";
1439 case DT_RELA
: return "RELA";
1440 case DT_RELASZ
: return "RELASZ";
1441 case DT_RELAENT
: return "RELAENT";
1442 case DT_STRSZ
: return "STRSZ";
1443 case DT_SYMENT
: return "SYMENT";
1444 case DT_INIT
: return "INIT";
1445 case DT_FINI
: return "FINI";
1446 case DT_SONAME
: return "SONAME";
1447 case DT_RPATH
: return "RPATH";
1448 case DT_SYMBOLIC
: return "SYMBOLIC";
1449 case DT_REL
: return "REL";
1450 case DT_RELSZ
: return "RELSZ";
1451 case DT_RELENT
: return "RELENT";
1452 case DT_PLTREL
: return "PLTREL";
1453 case DT_DEBUG
: return "DEBUG";
1454 case DT_TEXTREL
: return "TEXTREL";
1455 case DT_JMPREL
: return "JMPREL";
1456 case DT_BIND_NOW
: return "BIND_NOW";
1457 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1458 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1459 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1460 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1461 case DT_RUNPATH
: return "RUNPATH";
1462 case DT_FLAGS
: return "FLAGS";
1464 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1465 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1467 case DT_CHECKSUM
: return "CHECKSUM";
1468 case DT_PLTPADSZ
: return "PLTPADSZ";
1469 case DT_MOVEENT
: return "MOVEENT";
1470 case DT_MOVESZ
: return "MOVESZ";
1471 case DT_FEATURE
: return "FEATURE";
1472 case DT_POSFLAG_1
: return "POSFLAG_1";
1473 case DT_SYMINSZ
: return "SYMINSZ";
1474 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1476 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1477 case DT_CONFIG
: return "CONFIG";
1478 case DT_DEPAUDIT
: return "DEPAUDIT";
1479 case DT_AUDIT
: return "AUDIT";
1480 case DT_PLTPAD
: return "PLTPAD";
1481 case DT_MOVETAB
: return "MOVETAB";
1482 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1484 case DT_VERSYM
: return "VERSYM";
1486 case DT_RELACOUNT
: return "RELACOUNT";
1487 case DT_RELCOUNT
: return "RELCOUNT";
1488 case DT_FLAGS_1
: return "FLAGS_1";
1489 case DT_VERDEF
: return "VERDEF";
1490 case DT_VERDEFNUM
: return "VERDEFNUM";
1491 case DT_VERNEED
: return "VERNEED";
1492 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1494 case DT_AUXILIARY
: return "AUXILIARY";
1495 case DT_USED
: return "USED";
1496 case DT_FILTER
: return "FILTER";
1498 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1499 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1500 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1501 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1502 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1505 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1509 switch (elf_header
.e_machine
)
1512 case EM_MIPS_RS3_LE
:
1513 result
= get_mips_dynamic_type (type
);
1516 result
= get_sparc64_dynamic_type (type
);
1519 result
= get_ppc64_dynamic_type (type
);
1522 result
= get_ia64_dynamic_type (type
);
1532 sprintf (buff
, _("Processor Specific: %lx"), type
);
1534 else if ((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1538 switch (elf_header
.e_machine
)
1541 result
= get_parisc_dynamic_type (type
);
1551 sprintf (buff
, _("Operating System specific: %lx"), type
);
1554 sprintf (buff
, _("<unknown>: %lx"), type
);
1561 get_file_type (unsigned e_type
)
1563 static char buff
[32];
1567 case ET_NONE
: return _("NONE (None)");
1568 case ET_REL
: return _("REL (Relocatable file)");
1569 case ET_EXEC
: return _("EXEC (Executable file)");
1570 case ET_DYN
: return _("DYN (Shared object file)");
1571 case ET_CORE
: return _("CORE (Core file)");
1574 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1575 sprintf (buff
, _("Processor Specific: (%x)"), e_type
);
1576 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1577 sprintf (buff
, _("OS Specific: (%x)"), e_type
);
1579 sprintf (buff
, _("<unknown>: %x"), e_type
);
1585 get_machine_name (unsigned e_machine
)
1587 static char buff
[64]; /* XXX */
1591 case EM_NONE
: return _("None");
1592 case EM_M32
: return "WE32100";
1593 case EM_SPARC
: return "Sparc";
1594 case EM_386
: return "Intel 80386";
1595 case EM_68K
: return "MC68000";
1596 case EM_88K
: return "MC88000";
1597 case EM_486
: return "Intel 80486";
1598 case EM_860
: return "Intel 80860";
1599 case EM_MIPS
: return "MIPS R3000";
1600 case EM_S370
: return "IBM System/370";
1601 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1602 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1603 case EM_PARISC
: return "HPPA";
1604 case EM_PPC_OLD
: return "Power PC (old)";
1605 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1606 case EM_960
: return "Intel 90860";
1607 case EM_PPC
: return "PowerPC";
1608 case EM_PPC64
: return "PowerPC64";
1609 case EM_V800
: return "NEC V800";
1610 case EM_FR20
: return "Fujitsu FR20";
1611 case EM_RH32
: return "TRW RH32";
1612 case EM_MCORE
: return "MCORE";
1613 case EM_ARM
: return "ARM";
1614 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1615 case EM_SH
: return "Renesas / SuperH SH";
1616 case EM_SPARCV9
: return "Sparc v9";
1617 case EM_TRICORE
: return "Siemens Tricore";
1618 case EM_ARC
: return "ARC";
1619 case EM_H8_300
: return "Renesas H8/300";
1620 case EM_H8_300H
: return "Renesas H8/300H";
1621 case EM_H8S
: return "Renesas H8S";
1622 case EM_H8_500
: return "Renesas H8/500";
1623 case EM_IA_64
: return "Intel IA-64";
1624 case EM_MIPS_X
: return "Stanford MIPS-X";
1625 case EM_COLDFIRE
: return "Motorola Coldfire";
1626 case EM_68HC12
: return "Motorola M68HC12";
1627 case EM_ALPHA
: return "Alpha";
1628 case EM_CYGNUS_D10V
:
1629 case EM_D10V
: return "d10v";
1630 case EM_CYGNUS_D30V
:
1631 case EM_D30V
: return "d30v";
1632 case EM_CYGNUS_M32R
:
1633 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1634 case EM_CYGNUS_V850
:
1635 case EM_V850
: return "NEC v850";
1636 case EM_CYGNUS_MN10300
:
1637 case EM_MN10300
: return "mn10300";
1638 case EM_CYGNUS_MN10200
:
1639 case EM_MN10200
: return "mn10200";
1640 case EM_CYGNUS_FR30
:
1641 case EM_FR30
: return "Fujitsu FR30";
1642 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1644 case EM_PJ
: return "picoJava";
1645 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1646 case EM_PCP
: return "Siemens PCP";
1647 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1648 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1649 case EM_STARCORE
: return "Motorola Star*Core processor";
1650 case EM_ME16
: return "Toyota ME16 processor";
1651 case EM_ST100
: return "STMicroelectronics ST100 processor";
1652 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1653 case EM_FX66
: return "Siemens FX66 microcontroller";
1654 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1655 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1656 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1657 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1658 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1659 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1660 case EM_SVX
: return "Silicon Graphics SVx";
1661 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1662 case EM_VAX
: return "Digital VAX";
1664 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1665 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1666 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1667 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1668 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1669 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1670 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1671 case EM_PRISM
: return "Vitesse Prism";
1672 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1674 case EM_S390
: return "IBM S/390";
1675 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1677 case EM_OR32
: return "OpenRISC";
1678 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1679 case EM_DLX
: return "OpenDLX";
1681 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1682 case EM_IQ2000
: return "Vitesse IQ2000";
1684 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1686 sprintf (buff
, _("<unknown>: %x"), e_machine
);
1692 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
1697 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1698 e_flags
&= ~ EF_ARM_EABIMASK
;
1700 /* Handle "generic" ARM flags. */
1701 if (e_flags
& EF_ARM_RELEXEC
)
1703 strcat (buf
, ", relocatable executable");
1704 e_flags
&= ~ EF_ARM_RELEXEC
;
1707 if (e_flags
& EF_ARM_HASENTRY
)
1709 strcat (buf
, ", has entry point");
1710 e_flags
&= ~ EF_ARM_HASENTRY
;
1713 /* Now handle EABI specific flags. */
1717 strcat (buf
, ", <unrecognized EABI>");
1722 case EF_ARM_EABI_VER1
:
1723 strcat (buf
, ", Version1 EABI");
1728 /* Process flags one bit at a time. */
1729 flag
= e_flags
& - e_flags
;
1734 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1735 strcat (buf
, ", sorted symbol tables");
1745 case EF_ARM_EABI_VER2
:
1746 strcat (buf
, ", Version2 EABI");
1751 /* Process flags one bit at a time. */
1752 flag
= e_flags
& - e_flags
;
1757 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1758 strcat (buf
, ", sorted symbol tables");
1761 case EF_ARM_DYNSYMSUSESEGIDX
:
1762 strcat (buf
, ", dynamic symbols use segment index");
1765 case EF_ARM_MAPSYMSFIRST
:
1766 strcat (buf
, ", mapping symbols precede others");
1776 case EF_ARM_EABI_VER3
:
1777 strcat (buf
, ", Version3 EABI");
1780 case EF_ARM_EABI_VER4
:
1781 strcat (buf
, ", Version4 EABI");
1786 /* Process flags one bit at a time. */
1787 flag
= e_flags
& - e_flags
;
1793 strcat (buf
, ", BE8");
1797 strcat (buf
, ", LE8");
1807 case EF_ARM_EABI_UNKNOWN
:
1808 strcat (buf
, ", GNU EABI");
1813 /* Process flags one bit at a time. */
1814 flag
= e_flags
& - e_flags
;
1819 case EF_ARM_INTERWORK
:
1820 strcat (buf
, ", interworking enabled");
1823 case EF_ARM_APCS_26
:
1824 strcat (buf
, ", uses APCS/26");
1827 case EF_ARM_APCS_FLOAT
:
1828 strcat (buf
, ", uses APCS/float");
1832 strcat (buf
, ", position independent");
1836 strcat (buf
, ", 8 bit structure alignment");
1839 case EF_ARM_NEW_ABI
:
1840 strcat (buf
, ", uses new ABI");
1843 case EF_ARM_OLD_ABI
:
1844 strcat (buf
, ", uses old ABI");
1847 case EF_ARM_SOFT_FLOAT
:
1848 strcat (buf
, ", software FP");
1851 case EF_ARM_VFP_FLOAT
:
1852 strcat (buf
, ", VFP");
1855 case EF_ARM_MAVERICK_FLOAT
:
1856 strcat (buf
, ", Maverick FP");
1867 strcat (buf
,", <unknown>");
1871 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
1873 static char buf
[1024];
1885 decode_ARM_machine_flags (e_flags
, buf
);
1889 switch (e_flags
& EF_FRV_CPU_MASK
)
1891 case EF_FRV_CPU_GENERIC
:
1895 strcat (buf
, ", fr???");
1898 case EF_FRV_CPU_FR300
:
1899 strcat (buf
, ", fr300");
1902 case EF_FRV_CPU_FR400
:
1903 strcat (buf
, ", fr400");
1905 case EF_FRV_CPU_FR405
:
1906 strcat (buf
, ", fr405");
1909 case EF_FRV_CPU_FR450
:
1910 strcat (buf
, ", fr450");
1913 case EF_FRV_CPU_FR500
:
1914 strcat (buf
, ", fr500");
1916 case EF_FRV_CPU_FR550
:
1917 strcat (buf
, ", fr550");
1920 case EF_FRV_CPU_SIMPLE
:
1921 strcat (buf
, ", simple");
1923 case EF_FRV_CPU_TOMCAT
:
1924 strcat (buf
, ", tomcat");
1930 if (e_flags
& EF_CPU32
)
1931 strcat (buf
, ", cpu32");
1932 if (e_flags
& EF_M68000
)
1933 strcat (buf
, ", m68000");
1937 if (e_flags
& EF_PPC_EMB
)
1938 strcat (buf
, ", emb");
1940 if (e_flags
& EF_PPC_RELOCATABLE
)
1941 strcat (buf
, ", relocatable");
1943 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
1944 strcat (buf
, ", relocatable-lib");
1948 case EM_CYGNUS_V850
:
1949 switch (e_flags
& EF_V850_ARCH
)
1952 strcat (buf
, ", v850e1");
1955 strcat (buf
, ", v850e");
1958 strcat (buf
, ", v850");
1961 strcat (buf
, ", unknown v850 architecture variant");
1967 case EM_CYGNUS_M32R
:
1968 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
1969 strcat (buf
, ", m32r");
1974 case EM_MIPS_RS3_LE
:
1975 if (e_flags
& EF_MIPS_NOREORDER
)
1976 strcat (buf
, ", noreorder");
1978 if (e_flags
& EF_MIPS_PIC
)
1979 strcat (buf
, ", pic");
1981 if (e_flags
& EF_MIPS_CPIC
)
1982 strcat (buf
, ", cpic");
1984 if (e_flags
& EF_MIPS_UCODE
)
1985 strcat (buf
, ", ugen_reserved");
1987 if (e_flags
& EF_MIPS_ABI2
)
1988 strcat (buf
, ", abi2");
1990 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
1991 strcat (buf
, ", odk first");
1993 if (e_flags
& EF_MIPS_32BITMODE
)
1994 strcat (buf
, ", 32bitmode");
1996 switch ((e_flags
& EF_MIPS_MACH
))
1998 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
1999 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2000 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2001 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2002 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2003 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2004 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2005 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2006 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2008 /* We simply ignore the field in this case to avoid confusion:
2009 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2012 default: strcat (buf
, ", unknown CPU"); break;
2015 switch ((e_flags
& EF_MIPS_ABI
))
2017 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2018 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2019 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2020 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2022 /* We simply ignore the field in this case to avoid confusion:
2023 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2024 This means it is likely to be an o32 file, but not for
2027 default: strcat (buf
, ", unknown ABI"); break;
2030 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2031 strcat (buf
, ", mdmx");
2033 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2034 strcat (buf
, ", mips16");
2036 switch ((e_flags
& EF_MIPS_ARCH
))
2038 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2039 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2040 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2041 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2042 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2043 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2044 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2045 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2046 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2047 default: strcat (buf
, ", unknown ISA"); break;
2053 switch ((e_flags
& EF_SH_MACH_MASK
))
2055 case EF_SH1
: strcat (buf
, ", sh1"); break;
2056 case EF_SH2
: strcat (buf
, ", sh2"); break;
2057 case EF_SH3
: strcat (buf
, ", sh3"); break;
2058 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2059 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2060 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2061 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2062 case EF_SH4
: strcat (buf
, ", sh4"); break;
2063 case EF_SH5
: strcat (buf
, ", sh5"); break;
2064 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2065 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2066 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2067 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2068 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2069 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2070 default: strcat (buf
, ", unknown ISA"); break;
2076 if (e_flags
& EF_SPARC_32PLUS
)
2077 strcat (buf
, ", v8+");
2079 if (e_flags
& EF_SPARC_SUN_US1
)
2080 strcat (buf
, ", ultrasparcI");
2082 if (e_flags
& EF_SPARC_SUN_US3
)
2083 strcat (buf
, ", ultrasparcIII");
2085 if (e_flags
& EF_SPARC_HAL_R1
)
2086 strcat (buf
, ", halr1");
2088 if (e_flags
& EF_SPARC_LEDATA
)
2089 strcat (buf
, ", ledata");
2091 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2092 strcat (buf
, ", tso");
2094 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2095 strcat (buf
, ", pso");
2097 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2098 strcat (buf
, ", rmo");
2102 switch (e_flags
& EF_PARISC_ARCH
)
2104 case EFA_PARISC_1_0
:
2105 strcpy (buf
, ", PA-RISC 1.0");
2107 case EFA_PARISC_1_1
:
2108 strcpy (buf
, ", PA-RISC 1.1");
2110 case EFA_PARISC_2_0
:
2111 strcpy (buf
, ", PA-RISC 2.0");
2116 if (e_flags
& EF_PARISC_TRAPNIL
)
2117 strcat (buf
, ", trapnil");
2118 if (e_flags
& EF_PARISC_EXT
)
2119 strcat (buf
, ", ext");
2120 if (e_flags
& EF_PARISC_LSB
)
2121 strcat (buf
, ", lsb");
2122 if (e_flags
& EF_PARISC_WIDE
)
2123 strcat (buf
, ", wide");
2124 if (e_flags
& EF_PARISC_NO_KABP
)
2125 strcat (buf
, ", no kabp");
2126 if (e_flags
& EF_PARISC_LAZYSWAP
)
2127 strcat (buf
, ", lazyswap");
2132 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2133 strcat (buf
, ", new calling convention");
2135 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2136 strcat (buf
, ", gnu calling convention");
2140 if ((e_flags
& EF_IA_64_ABI64
))
2141 strcat (buf
, ", 64-bit");
2143 strcat (buf
, ", 32-bit");
2144 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2145 strcat (buf
, ", reduced fp model");
2146 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2147 strcat (buf
, ", no function descriptors, constant gp");
2148 else if ((e_flags
& EF_IA_64_CONS_GP
))
2149 strcat (buf
, ", constant gp");
2150 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2151 strcat (buf
, ", absolute");
2155 if ((e_flags
& EF_VAX_NONPIC
))
2156 strcat (buf
, ", non-PIC");
2157 if ((e_flags
& EF_VAX_DFLOAT
))
2158 strcat (buf
, ", D-Float");
2159 if ((e_flags
& EF_VAX_GFLOAT
))
2160 strcat (buf
, ", G-Float");
2169 get_osabi_name (unsigned int osabi
)
2171 static char buff
[32];
2175 case ELFOSABI_NONE
: return "UNIX - System V";
2176 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2177 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2178 case ELFOSABI_LINUX
: return "UNIX - Linux";
2179 case ELFOSABI_HURD
: return "GNU/Hurd";
2180 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2181 case ELFOSABI_AIX
: return "UNIX - AIX";
2182 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2183 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2184 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2185 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2186 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2187 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2188 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2189 case ELFOSABI_AROS
: return "Amiga Research OS";
2190 case ELFOSABI_STANDALONE
: return _("Standalone App");
2191 case ELFOSABI_ARM
: return "ARM";
2193 sprintf (buff
, _("<unknown: %x>"), osabi
);
2199 get_mips_segment_type (unsigned long type
)
2203 case PT_MIPS_REGINFO
:
2205 case PT_MIPS_RTPROC
:
2207 case PT_MIPS_OPTIONS
:
2217 get_parisc_segment_type (unsigned long type
)
2221 case PT_HP_TLS
: return "HP_TLS";
2222 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2223 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2224 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2225 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2226 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2227 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2228 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2229 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2230 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2231 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2232 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2233 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2234 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2243 get_ia64_segment_type (unsigned long type
)
2247 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2248 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2249 case PT_HP_TLS
: return "HP_TLS";
2250 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2251 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2252 case PT_IA_64_HP_STACK
: return "HP_STACK";
2261 get_segment_type (unsigned long p_type
)
2263 static char buff
[32];
2267 case PT_NULL
: return "NULL";
2268 case PT_LOAD
: return "LOAD";
2269 case PT_DYNAMIC
: return "DYNAMIC";
2270 case PT_INTERP
: return "INTERP";
2271 case PT_NOTE
: return "NOTE";
2272 case PT_SHLIB
: return "SHLIB";
2273 case PT_PHDR
: return "PHDR";
2274 case PT_TLS
: return "TLS";
2276 case PT_GNU_EH_FRAME
:
2277 return "GNU_EH_FRAME";
2278 case PT_GNU_STACK
: return "GNU_STACK";
2279 case PT_GNU_RELRO
: return "GNU_RELRO";
2282 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2286 switch (elf_header
.e_machine
)
2289 case EM_MIPS_RS3_LE
:
2290 result
= get_mips_segment_type (p_type
);
2293 result
= get_parisc_segment_type (p_type
);
2296 result
= get_ia64_segment_type (p_type
);
2306 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2308 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2312 switch (elf_header
.e_machine
)
2315 result
= get_parisc_segment_type (p_type
);
2318 result
= get_ia64_segment_type (p_type
);
2328 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2331 sprintf (buff
, _("<unknown>: %lx"), p_type
);
2338 get_mips_section_type_name (unsigned int sh_type
)
2342 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2343 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2344 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2345 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2346 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2347 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2348 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2349 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2350 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2351 case SHT_MIPS_RELD
: return "MIPS_RELD";
2352 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2353 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2354 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2355 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2356 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2357 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2358 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2359 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2360 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2361 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2362 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2363 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2364 case SHT_MIPS_LINE
: return "MIPS_LINE";
2365 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2366 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2367 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2368 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2369 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2370 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2371 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2372 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2373 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2374 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2375 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2376 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2377 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2378 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2379 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2380 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2388 get_parisc_section_type_name (unsigned int sh_type
)
2392 case SHT_PARISC_EXT
: return "PARISC_EXT";
2393 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2394 case SHT_PARISC_DOC
: return "PARISC_DOC";
2402 get_ia64_section_type_name (unsigned int sh_type
)
2404 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2405 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2406 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2410 case SHT_IA_64_EXT
: return "IA_64_EXT";
2411 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2412 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2420 get_x86_64_section_type_name (unsigned int sh_type
)
2424 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2432 get_arm_section_type_name (unsigned int sh_type
)
2445 get_section_type_name (unsigned int sh_type
)
2447 static char buff
[32];
2451 case SHT_NULL
: return "NULL";
2452 case SHT_PROGBITS
: return "PROGBITS";
2453 case SHT_SYMTAB
: return "SYMTAB";
2454 case SHT_STRTAB
: return "STRTAB";
2455 case SHT_RELA
: return "RELA";
2456 case SHT_HASH
: return "HASH";
2457 case SHT_DYNAMIC
: return "DYNAMIC";
2458 case SHT_NOTE
: return "NOTE";
2459 case SHT_NOBITS
: return "NOBITS";
2460 case SHT_REL
: return "REL";
2461 case SHT_SHLIB
: return "SHLIB";
2462 case SHT_DYNSYM
: return "DYNSYM";
2463 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2464 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2465 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2466 case SHT_GROUP
: return "GROUP";
2467 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2468 case SHT_GNU_verdef
: return "VERDEF";
2469 case SHT_GNU_verneed
: return "VERNEED";
2470 case SHT_GNU_versym
: return "VERSYM";
2471 case 0x6ffffff0: return "VERSYM";
2472 case 0x6ffffffc: return "VERDEF";
2473 case 0x7ffffffd: return "AUXILIARY";
2474 case 0x7fffffff: return "FILTER";
2475 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2478 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2482 switch (elf_header
.e_machine
)
2485 case EM_MIPS_RS3_LE
:
2486 result
= get_mips_section_type_name (sh_type
);
2489 result
= get_parisc_section_type_name (sh_type
);
2492 result
= get_ia64_section_type_name (sh_type
);
2495 result
= get_x86_64_section_type_name (sh_type
);
2498 result
= get_arm_section_type_name (sh_type
);
2508 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2510 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2511 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2512 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2513 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2515 sprintf (buff
, _("<unknown>: %x"), sh_type
);
2521 #define OPTION_DEBUG_DUMP 512
2523 struct option options
[] =
2525 {"all", no_argument
, 0, 'a'},
2526 {"file-header", no_argument
, 0, 'h'},
2527 {"program-headers", no_argument
, 0, 'l'},
2528 {"headers", no_argument
, 0, 'e'},
2529 {"histogram", no_argument
, 0, 'I'},
2530 {"segments", no_argument
, 0, 'l'},
2531 {"sections", no_argument
, 0, 'S'},
2532 {"section-headers", no_argument
, 0, 'S'},
2533 {"section-groups", no_argument
, 0, 'g'},
2534 {"symbols", no_argument
, 0, 's'},
2535 {"syms", no_argument
, 0, 's'},
2536 {"relocs", no_argument
, 0, 'r'},
2537 {"notes", no_argument
, 0, 'n'},
2538 {"dynamic", no_argument
, 0, 'd'},
2539 {"arch-specific", no_argument
, 0, 'A'},
2540 {"version-info", no_argument
, 0, 'V'},
2541 {"use-dynamic", no_argument
, 0, 'D'},
2542 {"hex-dump", required_argument
, 0, 'x'},
2543 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2544 {"unwind", no_argument
, 0, 'u'},
2545 #ifdef SUPPORT_DISASSEMBLY
2546 {"instruction-dump", required_argument
, 0, 'i'},
2549 {"version", no_argument
, 0, 'v'},
2550 {"wide", no_argument
, 0, 'W'},
2551 {"help", no_argument
, 0, 'H'},
2552 {0, no_argument
, 0, 0}
2558 fprintf (stdout
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2559 fprintf (stdout
, _(" Display information about the contents of ELF format files\n"));
2560 fprintf (stdout
, _(" Options are:\n\
2561 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2562 -h --file-header Display the ELF file header\n\
2563 -l --program-headers Display the program headers\n\
2564 --segments An alias for --program-headers\n\
2565 -S --section-headers Display the sections' header\n\
2566 --sections An alias for --section-headers\n\
2567 -g --section-groups Display the section groups\n\
2568 -e --headers Equivalent to: -h -l -S\n\
2569 -s --syms Display the symbol table\n\
2570 --symbols An alias for --syms\n\
2571 -n --notes Display the core notes (if present)\n\
2572 -r --relocs Display the relocations (if present)\n\
2573 -u --unwind Display the unwind info (if present)\n\
2574 -d --dynamic Display the dynamic section (if present)\n\
2575 -V --version-info Display the version sections (if present)\n\
2576 -A --arch-specific Display architecture specific information (if any).\n\
2577 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2578 -x --hex-dump=<number> Dump the contents of section <number>\n\
2579 -w[liaprmfFso] or\n\
2580 --debug-dump[=line,=info,=abbrev,=pubnames,=ranges,=macro,=frames,=str,=loc]\n\
2581 Display the contents of DWARF2 debug sections\n"));
2582 #ifdef SUPPORT_DISASSEMBLY
2583 fprintf (stdout
, _("\
2584 -i --instruction-dump=<number>\n\
2585 Disassemble the contents of section <number>\n"));
2587 fprintf (stdout
, _("\
2588 -I --histogram Display histogram of bucket list lengths\n\
2589 -W --wide Allow output width to exceed 80 characters\n\
2590 -H --help Display this information\n\
2591 -v --version Display the version number of readelf\n"));
2592 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2598 request_dump (unsigned int section
, int type
)
2600 if (section
>= num_dump_sects
)
2602 char *new_dump_sects
;
2604 new_dump_sects
= calloc (section
+ 1, 1);
2606 if (new_dump_sects
== NULL
)
2607 error (_("Out of memory allocating dump request table."));
2610 /* Copy current flag settings. */
2611 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2615 dump_sects
= new_dump_sects
;
2616 num_dump_sects
= section
+ 1;
2621 dump_sects
[section
] |= type
;
2627 parse_args (int argc
, char **argv
)
2634 while ((c
= getopt_long
2635 (argc
, argv
, "ersuahnldSDAIgw::x:i:vVWH", options
, NULL
)) != EOF
)
2656 do_section_groups
++;
2664 do_section_groups
++;
2706 section
= strtoul (optarg
, & cp
, 0);
2707 if (! *cp
&& section
>= 0)
2709 request_dump (section
, HEX_DUMP
);
2719 unsigned int index
= 0;
2723 while (optarg
[index
])
2724 switch (optarg
[index
++])
2733 do_debug_abbrevs
= 1;
2743 do_debug_pubnames
= 1;
2748 do_debug_aranges
= 1;
2752 do_debug_frames_interp
= 1;
2754 do_debug_frames
= 1;
2759 do_debug_macinfo
= 1;
2773 warn (_("Unrecognized debug option '%s'\n"), optarg
);
2778 case OPTION_DEBUG_DUMP
:
2784 static const char *debug_dump_opt
[]
2785 = { "line", "info", "abbrev", "pubnames", "ranges",
2786 "macro", "frames", "frames-interp", "str", "loc", NULL
};
2795 for (index
= 0; debug_dump_opt
[index
]; index
++)
2797 size_t len
= strlen (debug_dump_opt
[index
]);
2799 if (strncmp (p
, debug_dump_opt
[index
], len
) == 0
2800 && (p
[len
] == ',' || p
[len
] == '\0'))
2809 do_debug_abbrevs
= 1;
2820 do_debug_pubnames
= 1;
2824 do_debug_aranges
= 1;
2829 do_debug_frames_interp
= 1;
2830 do_debug_frames
= 1;
2834 do_debug_macinfo
= 1;
2847 if (debug_dump_opt
[index
] == NULL
)
2849 warn (_("Unrecognized debug option '%s'\n"), p
);
2850 p
= strchr (p
, ',');
2860 #ifdef SUPPORT_DISASSEMBLY
2863 section
= strtoul (optarg
, & cp
, 0);
2864 if (! *cp
&& section
>= 0)
2866 request_dump (section
, DISASS_DUMP
);
2872 print_version (program_name
);
2882 /* xgettext:c-format */
2883 error (_("Invalid option '-%c'\n"), c
);
2890 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
2891 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
2892 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
2893 && !do_section_groups
)
2897 warn (_("Nothing to do.\n"));
2903 get_elf_class (unsigned int elf_class
)
2905 static char buff
[32];
2909 case ELFCLASSNONE
: return _("none");
2910 case ELFCLASS32
: return "ELF32";
2911 case ELFCLASS64
: return "ELF64";
2913 sprintf (buff
, _("<unknown: %x>"), elf_class
);
2919 get_data_encoding (unsigned int encoding
)
2921 static char buff
[32];
2925 case ELFDATANONE
: return _("none");
2926 case ELFDATA2LSB
: return _("2's complement, little endian");
2927 case ELFDATA2MSB
: return _("2's complement, big endian");
2929 sprintf (buff
, _("<unknown: %x>"), encoding
);
2934 /* Decode the data held in 'elf_header'. */
2937 process_file_header (void)
2939 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
2940 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
2941 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
2942 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
2945 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2953 printf (_("ELF Header:\n"));
2954 printf (_(" Magic: "));
2955 for (i
= 0; i
< EI_NIDENT
; i
++)
2956 printf ("%2.2x ", elf_header
.e_ident
[i
]);
2958 printf (_(" Class: %s\n"),
2959 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
2960 printf (_(" Data: %s\n"),
2961 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
2962 printf (_(" Version: %d %s\n"),
2963 elf_header
.e_ident
[EI_VERSION
],
2964 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
2966 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
2969 printf (_(" OS/ABI: %s\n"),
2970 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
2971 printf (_(" ABI Version: %d\n"),
2972 elf_header
.e_ident
[EI_ABIVERSION
]);
2973 printf (_(" Type: %s\n"),
2974 get_file_type (elf_header
.e_type
));
2975 printf (_(" Machine: %s\n"),
2976 get_machine_name (elf_header
.e_machine
));
2977 printf (_(" Version: 0x%lx\n"),
2978 (unsigned long) elf_header
.e_version
);
2980 printf (_(" Entry point address: "));
2981 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2982 printf (_("\n Start of program headers: "));
2983 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2984 printf (_(" (bytes into file)\n Start of section headers: "));
2985 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
2986 printf (_(" (bytes into file)\n"));
2988 printf (_(" Flags: 0x%lx%s\n"),
2989 (unsigned long) elf_header
.e_flags
,
2990 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
2991 printf (_(" Size of this header: %ld (bytes)\n"),
2992 (long) elf_header
.e_ehsize
);
2993 printf (_(" Size of program headers: %ld (bytes)\n"),
2994 (long) elf_header
.e_phentsize
);
2995 printf (_(" Number of program headers: %ld\n"),
2996 (long) elf_header
.e_phnum
);
2997 printf (_(" Size of section headers: %ld (bytes)\n"),
2998 (long) elf_header
.e_shentsize
);
2999 printf (_(" Number of section headers: %ld"),
3000 (long) elf_header
.e_shnum
);
3001 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
3002 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3003 putc ('\n', stdout
);
3004 printf (_(" Section header string table index: %ld"),
3005 (long) elf_header
.e_shstrndx
);
3006 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
3007 printf (" (%ld)", (long) section_headers
[0].sh_link
);
3008 putc ('\n', stdout
);
3011 if (section_headers
!= NULL
)
3013 if (elf_header
.e_shnum
== 0)
3014 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3015 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
3016 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3017 free (section_headers
);
3018 section_headers
= NULL
;
3026 get_32bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3028 Elf32_External_Phdr
*phdrs
;
3029 Elf32_External_Phdr
*external
;
3030 Elf_Internal_Phdr
*internal
;
3033 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3034 elf_header
.e_phentsize
* elf_header
.e_phnum
,
3035 _("program headers"));
3039 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3040 i
< elf_header
.e_phnum
;
3041 i
++, internal
++, external
++)
3043 internal
->p_type
= BYTE_GET (external
->p_type
);
3044 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3045 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3046 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3047 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3048 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3049 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3050 internal
->p_align
= BYTE_GET (external
->p_align
);
3059 get_64bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3061 Elf64_External_Phdr
*phdrs
;
3062 Elf64_External_Phdr
*external
;
3063 Elf_Internal_Phdr
*internal
;
3066 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3067 elf_header
.e_phentsize
* elf_header
.e_phnum
,
3068 _("program headers"));
3072 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3073 i
< elf_header
.e_phnum
;
3074 i
++, internal
++, external
++)
3076 internal
->p_type
= BYTE_GET (external
->p_type
);
3077 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3078 internal
->p_offset
= BYTE_GET8 (external
->p_offset
);
3079 internal
->p_vaddr
= BYTE_GET8 (external
->p_vaddr
);
3080 internal
->p_paddr
= BYTE_GET8 (external
->p_paddr
);
3081 internal
->p_filesz
= BYTE_GET8 (external
->p_filesz
);
3082 internal
->p_memsz
= BYTE_GET8 (external
->p_memsz
);
3083 internal
->p_align
= BYTE_GET8 (external
->p_align
);
3091 /* Returns 1 if the program headers were read into `program_headers'. */
3094 get_program_headers (FILE *file
)
3096 Elf_Internal_Phdr
*phdrs
;
3098 /* Check cache of prior read. */
3099 if (program_headers
!= NULL
)
3102 phdrs
= malloc (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
3106 error (_("Out of memory\n"));
3111 ? get_32bit_program_headers (file
, phdrs
)
3112 : get_64bit_program_headers (file
, phdrs
))
3114 program_headers
= phdrs
;
3122 /* Returns 1 if the program headers were loaded. */
3125 process_program_headers (FILE *file
)
3127 Elf_Internal_Phdr
*segment
;
3130 if (elf_header
.e_phnum
== 0)
3133 printf (_("\nThere are no program headers in this file.\n"));
3137 if (do_segments
&& !do_header
)
3139 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3140 printf (_("Entry point "));
3141 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3142 printf (_("\nThere are %d program headers, starting at offset "),
3143 elf_header
.e_phnum
);
3144 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3148 if (! get_program_headers (file
))
3153 if (elf_header
.e_phnum
> 1)
3154 printf (_("\nProgram Headers:\n"));
3156 printf (_("\nProgram Headers:\n"));
3160 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3163 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3167 (_(" Type Offset VirtAddr PhysAddr\n"));
3169 (_(" FileSiz MemSiz Flags Align\n"));
3176 for (i
= 0, segment
= program_headers
;
3177 i
< elf_header
.e_phnum
;
3182 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3186 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3187 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3188 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3189 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3190 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3192 (segment
->p_flags
& PF_R
? 'R' : ' '),
3193 (segment
->p_flags
& PF_W
? 'W' : ' '),
3194 (segment
->p_flags
& PF_X
? 'E' : ' '));
3195 printf ("%#lx", (unsigned long) segment
->p_align
);
3199 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3200 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3203 print_vma (segment
->p_offset
, FULL_HEX
);
3207 print_vma (segment
->p_vaddr
, FULL_HEX
);
3209 print_vma (segment
->p_paddr
, FULL_HEX
);
3212 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3213 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3216 print_vma (segment
->p_filesz
, FULL_HEX
);
3220 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3221 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3224 print_vma (segment
->p_offset
, FULL_HEX
);
3228 (segment
->p_flags
& PF_R
? 'R' : ' '),
3229 (segment
->p_flags
& PF_W
? 'W' : ' '),
3230 (segment
->p_flags
& PF_X
? 'E' : ' '));
3232 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3233 printf ("%#lx", (unsigned long) segment
->p_align
);
3236 print_vma (segment
->p_align
, PREFIX_HEX
);
3241 print_vma (segment
->p_offset
, FULL_HEX
);
3243 print_vma (segment
->p_vaddr
, FULL_HEX
);
3245 print_vma (segment
->p_paddr
, FULL_HEX
);
3247 print_vma (segment
->p_filesz
, FULL_HEX
);
3249 print_vma (segment
->p_memsz
, FULL_HEX
);
3251 (segment
->p_flags
& PF_R
? 'R' : ' '),
3252 (segment
->p_flags
& PF_W
? 'W' : ' '),
3253 (segment
->p_flags
& PF_X
? 'E' : ' '));
3254 print_vma (segment
->p_align
, HEX
);
3258 switch (segment
->p_type
)
3262 error (_("more than one dynamic segment\n"));
3264 /* Try to locate the .dynamic section. If there is
3265 a section header table, we can easily locate it. */
3266 if (section_headers
!= NULL
)
3268 Elf_Internal_Shdr
*sec
;
3271 for (j
= 0, sec
= section_headers
;
3272 j
< elf_header
.e_shnum
;
3274 if (strcmp (SECTION_NAME (sec
), ".dynamic") == 0)
3277 if (j
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
3279 error (_("no .dynamic section in the dynamic segment"));
3283 dynamic_addr
= sec
->sh_offset
;
3284 dynamic_size
= sec
->sh_size
;
3286 if (dynamic_addr
< segment
->p_offset
3287 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3288 warn (_("the .dynamic section is not contained within the dynamic segment"));
3289 else if (dynamic_addr
> segment
->p_offset
)
3290 warn (_("the .dynamic section is not the first section in the dynamic segment."));
3294 /* Otherwise, we can only assume that the .dynamic
3295 section is the first section in the DYNAMIC segment. */
3296 dynamic_addr
= segment
->p_offset
;
3297 dynamic_size
= segment
->p_filesz
;
3302 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3304 error (_("Unable to find program interpreter name\n"));
3307 program_interpreter
[0] = 0;
3308 fscanf (file
, "%63s", program_interpreter
);
3311 printf (_("\n [Requesting program interpreter: %s]"),
3312 program_interpreter
);
3318 putc ('\n', stdout
);
3321 if (do_segments
&& section_headers
!= NULL
)
3323 printf (_("\n Section to Segment mapping:\n"));
3324 printf (_(" Segment Sections...\n"));
3326 assert (string_table
!= NULL
);
3328 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3331 Elf_Internal_Shdr
*section
;
3333 segment
= program_headers
+ i
;
3334 section
= section_headers
;
3336 printf (" %2.2d ", i
);
3338 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3340 if (section
->sh_size
> 0
3341 /* Compare allocated sections by VMA, unallocated
3342 sections by file offset. */
3343 && (section
->sh_flags
& SHF_ALLOC
3344 ? (section
->sh_addr
>= segment
->p_vaddr
3345 && section
->sh_addr
+ section
->sh_size
3346 <= segment
->p_vaddr
+ segment
->p_memsz
)
3347 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
3348 && (section
->sh_offset
+ section
->sh_size
3349 <= segment
->p_offset
+ segment
->p_filesz
)))
3350 /* .tbss is special. It doesn't contribute memory space
3351 to normal segments. */
3352 && (!((section
->sh_flags
& SHF_TLS
) != 0
3353 && section
->sh_type
== SHT_NOBITS
)
3354 || segment
->p_type
== PT_TLS
))
3355 printf ("%s ", SECTION_NAME (section
));
3366 /* Find the file offset corresponding to VMA by using the program headers. */
3369 offset_from_vma (FILE *file
, bfd_vma vma
, bfd_size_type size
)
3371 Elf_Internal_Phdr
*seg
;
3373 if (! get_program_headers (file
))
3375 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3379 for (seg
= program_headers
;
3380 seg
< program_headers
+ elf_header
.e_phnum
;
3383 if (seg
->p_type
!= PT_LOAD
)
3386 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3387 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3388 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3391 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3398 get_32bit_section_headers (FILE *file
, unsigned int num
)
3400 Elf32_External_Shdr
*shdrs
;
3401 Elf_Internal_Shdr
*internal
;
3404 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3405 elf_header
.e_shentsize
* num
, _("section headers"));
3409 section_headers
= malloc (num
* sizeof (Elf_Internal_Shdr
));
3411 if (section_headers
== NULL
)
3413 error (_("Out of memory\n"));
3417 for (i
= 0, internal
= section_headers
;
3421 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3422 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3423 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3424 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3425 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3426 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3427 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3428 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3429 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3430 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3439 get_64bit_section_headers (FILE *file
, unsigned int num
)
3441 Elf64_External_Shdr
*shdrs
;
3442 Elf_Internal_Shdr
*internal
;
3445 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3446 elf_header
.e_shentsize
* num
, _("section headers"));
3450 section_headers
= malloc (num
* sizeof (Elf_Internal_Shdr
));
3452 if (section_headers
== NULL
)
3454 error (_("Out of memory\n"));
3458 for (i
= 0, internal
= section_headers
;
3462 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3463 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3464 internal
->sh_flags
= BYTE_GET8 (shdrs
[i
].sh_flags
);
3465 internal
->sh_addr
= BYTE_GET8 (shdrs
[i
].sh_addr
);
3466 internal
->sh_size
= BYTE_GET8 (shdrs
[i
].sh_size
);
3467 internal
->sh_entsize
= BYTE_GET8 (shdrs
[i
].sh_entsize
);
3468 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3469 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3470 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3471 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3479 static Elf_Internal_Sym
*
3480 get_32bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3482 unsigned long number
;
3483 Elf32_External_Sym
*esyms
;
3484 Elf_External_Sym_Shndx
*shndx
;
3485 Elf_Internal_Sym
*isyms
;
3486 Elf_Internal_Sym
*psym
;
3489 esyms
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
3495 if (symtab_shndx_hdr
!= NULL
3496 && (symtab_shndx_hdr
->sh_link
3497 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3499 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3500 symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3508 number
= section
->sh_size
/ section
->sh_entsize
;
3509 isyms
= malloc (number
* sizeof (Elf_Internal_Sym
));
3513 error (_("Out of memory\n"));
3520 for (j
= 0, psym
= isyms
;
3524 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3525 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3526 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3527 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3528 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3530 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3531 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3532 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3542 static Elf_Internal_Sym
*
3543 get_64bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3545 unsigned long number
;
3546 Elf64_External_Sym
*esyms
;
3547 Elf_External_Sym_Shndx
*shndx
;
3548 Elf_Internal_Sym
*isyms
;
3549 Elf_Internal_Sym
*psym
;
3552 esyms
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
3558 if (symtab_shndx_hdr
!= NULL
3559 && (symtab_shndx_hdr
->sh_link
3560 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3562 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3563 symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3571 number
= section
->sh_size
/ section
->sh_entsize
;
3572 isyms
= malloc (number
* sizeof (Elf_Internal_Sym
));
3576 error (_("Out of memory\n"));
3583 for (j
= 0, psym
= isyms
;
3587 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3588 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3589 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3590 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3591 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3593 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3594 psym
->st_value
= BYTE_GET8 (esyms
[j
].st_value
);
3595 psym
->st_size
= BYTE_GET8 (esyms
[j
].st_size
);
3606 get_elf_section_flags (bfd_vma sh_flags
)
3608 static char buff
[32];
3616 flag
= sh_flags
& - sh_flags
;
3621 case SHF_WRITE
: strcat (buff
, "W"); break;
3622 case SHF_ALLOC
: strcat (buff
, "A"); break;
3623 case SHF_EXECINSTR
: strcat (buff
, "X"); break;
3624 case SHF_MERGE
: strcat (buff
, "M"); break;
3625 case SHF_STRINGS
: strcat (buff
, "S"); break;
3626 case SHF_INFO_LINK
: strcat (buff
, "I"); break;
3627 case SHF_LINK_ORDER
: strcat (buff
, "L"); break;
3628 case SHF_OS_NONCONFORMING
: strcat (buff
, "O"); break;
3629 case SHF_GROUP
: strcat (buff
, "G"); break;
3630 case SHF_TLS
: strcat (buff
, "T"); break;
3633 if (flag
& SHF_MASKOS
)
3636 sh_flags
&= ~ SHF_MASKOS
;
3638 else if (flag
& SHF_MASKPROC
)
3641 sh_flags
&= ~ SHF_MASKPROC
;
3653 process_section_headers (FILE *file
)
3655 Elf_Internal_Shdr
*section
;
3658 section_headers
= NULL
;
3660 if (elf_header
.e_shnum
== 0)
3663 printf (_("\nThere are no sections in this file.\n"));
3668 if (do_sections
&& !do_header
)
3669 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3670 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
3674 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
3677 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
3680 /* Read in the string table, so that we have names to display. */
3681 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
3683 if (section
->sh_size
!= 0)
3685 string_table
= get_data (NULL
, file
, section
->sh_offset
,
3686 section
->sh_size
, _("string table"));
3688 if (string_table
== NULL
)
3691 string_table_length
= section
->sh_size
;
3694 /* Scan the sections for the dynamic symbol table
3695 and dynamic string table and debug sections. */
3696 dynamic_symbols
= NULL
;
3697 dynamic_strings
= NULL
;
3698 dynamic_syminfo
= NULL
;
3699 symtab_shndx_hdr
= NULL
;
3701 for (i
= 0, section
= section_headers
;
3702 i
< elf_header
.e_shnum
;
3705 char *name
= SECTION_NAME (section
);
3707 if (section
->sh_type
== SHT_DYNSYM
)
3709 if (dynamic_symbols
!= NULL
)
3711 error (_("File contains multiple dynamic symbol tables\n"));
3715 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
3716 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
3718 else if (section
->sh_type
== SHT_STRTAB
3719 && strcmp (name
, ".dynstr") == 0)
3721 if (dynamic_strings
!= NULL
)
3723 error (_("File contains multiple dynamic string tables\n"));
3727 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
3728 section
->sh_size
, _("dynamic strings"));
3729 dynamic_strings_length
= section
->sh_size
;
3731 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
3733 if (symtab_shndx_hdr
!= NULL
)
3735 error (_("File contains multiple symtab shndx tables\n"));
3738 symtab_shndx_hdr
= section
;
3740 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
3741 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
3742 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
3744 && strncmp (name
, ".debug_", 7) == 0)
3749 || (do_debug_info
&& (strcmp (name
, "info") == 0))
3750 || (do_debug_abbrevs
&& (strcmp (name
, "abbrev") == 0))
3751 || (do_debug_lines
&& (strcmp (name
, "line") == 0))
3752 || (do_debug_pubnames
&& (strcmp (name
, "pubnames") == 0))
3753 || (do_debug_aranges
&& (strcmp (name
, "aranges") == 0))
3754 || (do_debug_frames
&& (strcmp (name
, "frame") == 0))
3755 || (do_debug_macinfo
&& (strcmp (name
, "macinfo") == 0))
3756 || (do_debug_str
&& (strcmp (name
, "str") == 0))
3757 || (do_debug_loc
&& (strcmp (name
, "loc") == 0))
3759 request_dump (i
, DEBUG_DUMP
);
3761 /* linkonce section to be combined with .debug_info at link time. */
3762 else if ((do_debugging
|| do_debug_info
)
3763 && strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
3764 request_dump (i
, DEBUG_DUMP
);
3765 else if (do_debug_frames
&& strcmp (name
, ".eh_frame") == 0)
3766 request_dump (i
, DEBUG_DUMP
);
3772 if (elf_header
.e_shnum
> 1)
3773 printf (_("\nSection Headers:\n"));
3775 printf (_("\nSection Header:\n"));
3779 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
3782 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
3785 printf (_(" [Nr] Name Type Address Offset\n"));
3786 printf (_(" Size EntSize Flags Link Info Align\n"));
3789 for (i
= 0, section
= section_headers
;
3790 i
< elf_header
.e_shnum
;
3793 printf (" [%2u] %-17.17s %-15.15s ",
3794 SECTION_HEADER_NUM (i
),
3795 SECTION_NAME (section
),
3796 get_section_type_name (section
->sh_type
));
3800 print_vma (section
->sh_addr
, LONG_HEX
);
3802 printf ( " %6.6lx %6.6lx %2.2lx",
3803 (unsigned long) section
->sh_offset
,
3804 (unsigned long) section
->sh_size
,
3805 (unsigned long) section
->sh_entsize
);
3807 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3809 printf ("%2ld %3lu %2ld\n",
3810 (unsigned long) section
->sh_link
,
3811 (unsigned long) section
->sh_info
,
3812 (unsigned long) section
->sh_addralign
);
3816 print_vma (section
->sh_addr
, LONG_HEX
);
3818 if ((long) section
->sh_offset
== section
->sh_offset
)
3819 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
3823 print_vma (section
->sh_offset
, LONG_HEX
);
3826 if ((unsigned long) section
->sh_size
== section
->sh_size
)
3827 printf (" %6.6lx", (unsigned long) section
->sh_size
);
3831 print_vma (section
->sh_size
, LONG_HEX
);
3834 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
3835 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
3839 print_vma (section
->sh_entsize
, LONG_HEX
);
3842 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3844 printf ("%2ld %3lu ",
3845 (unsigned long) section
->sh_link
,
3846 (unsigned long) section
->sh_info
);
3848 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
3849 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
3852 print_vma (section
->sh_addralign
, DEC
);
3859 print_vma (section
->sh_addr
, LONG_HEX
);
3860 if ((long) section
->sh_offset
== section
->sh_offset
)
3861 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
3865 print_vma (section
->sh_offset
, LONG_HEX
);
3868 print_vma (section
->sh_size
, LONG_HEX
);
3870 print_vma (section
->sh_entsize
, LONG_HEX
);
3872 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3874 printf (" %2ld %3lu %ld\n",
3875 (unsigned long) section
->sh_link
,
3876 (unsigned long) section
->sh_info
,
3877 (unsigned long) section
->sh_addralign
);
3881 printf (_("Key to Flags:\n\
3882 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
3883 I (info), L (link order), G (group), x (unknown)\n\
3884 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3890 get_group_flags (unsigned int flags
)
3892 static char buff
[32];
3899 sprintf (buff
, _("[<unknown>: 0x%x]"), flags
);
3906 process_section_groups (FILE *file
)
3908 Elf_Internal_Shdr
*section
;
3910 struct group
*group
;
3912 if (elf_header
.e_shnum
== 0)
3914 if (do_section_groups
)
3915 printf (_("\nThere are no section groups in this file.\n"));
3920 if (section_headers
== NULL
)
3922 error (_("Section headers are not available!\n"));
3926 section_headers_groups
= calloc (elf_header
.e_shnum
,
3927 sizeof (struct group
*));
3929 if (section_headers_groups
== NULL
)
3931 error (_("Out of memory\n"));
3935 /* Scan the sections for the group section. */
3936 for (i
= 0, section
= section_headers
;
3937 i
< elf_header
.e_shnum
;
3939 if (section
->sh_type
== SHT_GROUP
)
3942 section_groups
= calloc (group_count
, sizeof (struct group
));
3944 if (section_groups
== NULL
)
3946 error (_("Out of memory\n"));
3950 for (i
= 0, section
= section_headers
, group
= section_groups
;
3951 i
< elf_header
.e_shnum
;
3954 if (section
->sh_type
== SHT_GROUP
)
3956 char *name
= SECTION_NAME (section
);
3957 char *group_name
, *strtab
, *start
, *indices
;
3958 unsigned int entry
, j
, size
;
3959 Elf_Internal_Sym
*sym
;
3960 Elf_Internal_Shdr
*symtab_sec
, *strtab_sec
, *sec
;
3961 Elf_Internal_Sym
*symtab
;
3963 /* Get the symbol table. */
3964 symtab_sec
= SECTION_HEADER (section
->sh_link
);
3965 if (symtab_sec
->sh_type
!= SHT_SYMTAB
)
3967 error (_("Bad sh_link in group section `%s'\n"), name
);
3970 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
3972 sym
= symtab
+ section
->sh_info
;
3974 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
3976 bfd_vma sec_index
= SECTION_HEADER_INDEX (sym
->st_shndx
);
3979 error (_("Bad sh_info in group section `%s'\n"), name
);
3983 group_name
= SECTION_NAME (section_headers
+ sec_index
);
3988 /* Get the string table. */
3989 strtab_sec
= SECTION_HEADER (symtab_sec
->sh_link
);
3990 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
3991 strtab_sec
->sh_size
,
3994 group_name
= strtab
+ sym
->st_name
;
3997 start
= get_data (NULL
, file
, section
->sh_offset
,
3998 section
->sh_size
, _("section data"));
4001 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4002 entry
= byte_get (indices
, 4);
4005 if (do_section_groups
)
4007 printf ("\n%s group section `%s' [%s] contains %u sections:\n",
4008 get_group_flags (entry
), name
, group_name
, size
);
4010 printf (_(" [Index] Name\n"));
4013 group
->group_index
= i
;
4015 for (j
= 0; j
< size
; j
++)
4017 struct group_list
*g
;
4019 entry
= byte_get (indices
, 4);
4022 if (section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4025 error (_("section [%5u] already in group section [%5u]\n"),
4026 entry
, section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4030 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4033 if (do_section_groups
)
4035 sec
= SECTION_HEADER (entry
);
4036 printf (" [%5u] %s\n",
4037 entry
, SECTION_NAME (sec
));
4040 g
= xmalloc (sizeof (struct group_list
));
4041 g
->section_index
= entry
;
4042 g
->next
= group
->root
;
4066 } dynamic_relocations
[] =
4068 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4069 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4070 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4073 /* Process the reloc section. */
4075 process_relocs (FILE *file
)
4077 unsigned long rel_size
;
4078 unsigned long rel_offset
;
4084 if (do_using_dynamic
)
4088 int has_dynamic_reloc
;
4091 has_dynamic_reloc
= 0;
4093 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4095 is_rela
= dynamic_relocations
[i
].rela
;
4096 name
= dynamic_relocations
[i
].name
;
4097 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4098 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4100 has_dynamic_reloc
|= rel_size
;
4102 if (is_rela
== UNKNOWN
)
4104 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4105 switch (dynamic_info
[DT_PLTREL
])
4119 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4120 name
, rel_offset
, rel_size
);
4122 dump_relocations (file
,
4123 offset_from_vma (file
, rel_offset
, rel_size
),
4125 dynamic_symbols
, num_dynamic_syms
,
4126 dynamic_strings
, dynamic_strings_length
, is_rela
);
4130 if (! has_dynamic_reloc
)
4131 printf (_("\nThere are no dynamic relocations in this file.\n"));
4135 Elf_Internal_Shdr
*section
;
4139 for (i
= 0, section
= section_headers
;
4140 i
< elf_header
.e_shnum
;
4143 if ( section
->sh_type
!= SHT_RELA
4144 && section
->sh_type
!= SHT_REL
)
4147 rel_offset
= section
->sh_offset
;
4148 rel_size
= section
->sh_size
;
4152 Elf_Internal_Shdr
*strsec
;
4155 printf (_("\nRelocation section "));
4157 if (string_table
== NULL
)
4158 printf ("%d", section
->sh_name
);
4160 printf (_("'%s'"), SECTION_NAME (section
));
4162 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4163 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4165 is_rela
= section
->sh_type
== SHT_RELA
;
4167 if (section
->sh_link
)
4169 Elf_Internal_Shdr
*symsec
;
4170 Elf_Internal_Sym
*symtab
;
4171 unsigned long nsyms
;
4172 unsigned long strtablen
;
4173 char *strtab
= NULL
;
4175 symsec
= SECTION_HEADER (section
->sh_link
);
4176 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4177 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4182 strsec
= SECTION_HEADER (symsec
->sh_link
);
4184 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4185 strsec
->sh_size
, _("string table"));
4186 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4188 dump_relocations (file
, rel_offset
, rel_size
,
4189 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4195 dump_relocations (file
, rel_offset
, rel_size
,
4196 NULL
, 0, NULL
, 0, is_rela
);
4203 printf (_("\nThere are no relocations in this file.\n"));
4209 #include "unwind-ia64.h"
4211 /* An absolute address consists of a section and an offset. If the
4212 section is NULL, the offset itself is the address, otherwise, the
4213 address equals to LOAD_ADDRESS(section) + offset. */
4217 unsigned short section
;
4223 struct unw_table_entry
4225 struct absaddr start
;
4227 struct absaddr info
;
4229 *table
; /* Unwind table. */
4230 unsigned long table_len
; /* Length of unwind table. */
4231 unsigned char *info
; /* Unwind info. */
4232 unsigned long info_size
; /* Size of unwind info. */
4233 bfd_vma info_addr
; /* starting address of unwind info. */
4234 bfd_vma seg_base
; /* Starting address of segment. */
4235 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4236 unsigned long nsyms
; /* Number of symbols. */
4237 char *strtab
; /* The string table. */
4238 unsigned long strtab_size
; /* Size of string table. */
4242 find_symbol_for_address (struct unw_aux_info
*aux
,
4243 struct absaddr addr
,
4244 const char **symname
,
4247 bfd_vma dist
= 0x100000;
4248 Elf_Internal_Sym
*sym
, *best
= NULL
;
4251 for (i
= 0, sym
= aux
->symtab
; i
< aux
->nsyms
; ++i
, ++sym
)
4253 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4254 && sym
->st_name
!= 0
4255 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4256 && addr
.offset
>= sym
->st_value
4257 && addr
.offset
- sym
->st_value
< dist
)
4260 dist
= addr
.offset
- sym
->st_value
;
4267 *symname
= (best
->st_name
>= aux
->strtab_size
4268 ? "<corrupt>" : aux
->strtab
+ best
->st_name
);
4273 *offset
= addr
.offset
;
4277 dump_ia64_unwind (struct unw_aux_info
*aux
)
4280 struct unw_table_entry
*tp
;
4283 addr_size
= is_32bit_elf
? 4 : 8;
4285 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4289 const unsigned char *dp
;
4290 const unsigned char *head
;
4291 const char *procname
;
4293 find_symbol_for_address (aux
, tp
->start
, &procname
, &offset
);
4295 fputs ("\n<", stdout
);
4299 fputs (procname
, stdout
);
4302 printf ("+%lx", (unsigned long) offset
);
4305 fputs (">: [", stdout
);
4306 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4307 fputc ('-', stdout
);
4308 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4309 printf ("], info at +0x%lx\n",
4310 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4312 head
= aux
->info
+ (tp
->info
.offset
- aux
->info_addr
);
4313 stamp
= BYTE_GET8 ((unsigned char *) head
);
4315 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4316 (unsigned) UNW_VER (stamp
),
4317 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4318 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4319 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4320 (unsigned long) (addr_size
* UNW_LENGTH (stamp
)));
4322 if (UNW_VER (stamp
) != 1)
4324 printf ("\tUnknown version.\n");
4329 for (dp
= head
+ 8; dp
< head
+ 8 + addr_size
* UNW_LENGTH (stamp
);)
4330 dp
= unw_decode (dp
, in_body
, & in_body
);
4335 slurp_ia64_unwind_table (FILE *file
,
4336 struct unw_aux_info
*aux
,
4337 Elf_Internal_Shdr
*sec
)
4339 unsigned long size
, addr_size
, nrelas
, i
;
4340 Elf_Internal_Phdr
*seg
;
4341 struct unw_table_entry
*tep
;
4342 Elf_Internal_Shdr
*relsec
;
4343 Elf_Internal_Rela
*rela
, *rp
;
4344 unsigned char *table
, *tp
;
4345 Elf_Internal_Sym
*sym
;
4346 const char *relname
;
4348 addr_size
= is_32bit_elf
? 4 : 8;
4350 /* First, find the starting address of the segment that includes
4353 if (elf_header
.e_phnum
)
4355 if (! get_program_headers (file
))
4358 for (seg
= program_headers
;
4359 seg
< program_headers
+ elf_header
.e_phnum
;
4362 if (seg
->p_type
!= PT_LOAD
)
4365 if (sec
->sh_addr
>= seg
->p_vaddr
4366 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4368 aux
->seg_base
= seg
->p_vaddr
;
4374 /* Second, build the unwind table from the contents of the unwind section: */
4375 size
= sec
->sh_size
;
4376 table
= get_data (NULL
, file
, sec
->sh_offset
, size
, _("unwind table"));
4380 tep
= aux
->table
= xmalloc (size
/ (3 * addr_size
) * sizeof (aux
->table
[0]));
4381 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * addr_size
, ++tep
)
4383 tep
->start
.section
= SHN_UNDEF
;
4384 tep
->end
.section
= SHN_UNDEF
;
4385 tep
->info
.section
= SHN_UNDEF
;
4388 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4389 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4390 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
4394 tep
->start
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 0);
4395 tep
->end
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 8);
4396 tep
->info
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 16);
4398 tep
->start
.offset
+= aux
->seg_base
;
4399 tep
->end
.offset
+= aux
->seg_base
;
4400 tep
->info
.offset
+= aux
->seg_base
;
4404 /* Third, apply any relocations to the unwind table: */
4406 for (relsec
= section_headers
;
4407 relsec
< section_headers
+ elf_header
.e_shnum
;
4410 if (relsec
->sh_type
!= SHT_RELA
4411 || SECTION_HEADER (relsec
->sh_info
) != sec
)
4414 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
4418 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4422 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4423 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4427 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4428 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4431 if (strncmp (relname
, "R_IA64_SEGREL", 13) != 0)
4433 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4437 i
= rp
->r_offset
/ (3 * addr_size
);
4439 switch (rp
->r_offset
/addr_size
% 3)
4442 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4443 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
4446 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4447 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
4450 aux
->table
[i
].info
.section
= sym
->st_shndx
;
4451 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
4461 aux
->table_len
= size
/ (3 * addr_size
);
4466 process_unwind (FILE *file
)
4468 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
4469 unsigned long i
, addr_size
, unwcount
= 0, unwstart
= 0;
4470 struct unw_aux_info aux
;
4475 if (elf_header
.e_machine
!= EM_IA_64
)
4477 printf (_("\nThere are no unwind sections in this file.\n"));
4481 memset (& aux
, 0, sizeof (aux
));
4483 addr_size
= is_32bit_elf
? 4 : 8;
4485 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4487 if (sec
->sh_type
== SHT_SYMTAB
)
4489 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
4490 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
4492 strsec
= SECTION_HEADER (sec
->sh_link
);
4493 aux
.strtab_size
= strsec
->sh_size
;
4494 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4495 aux
.strtab_size
, _("string table"));
4497 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4502 printf (_("\nThere are no unwind sections in this file.\n"));
4504 while (unwcount
-- > 0)
4509 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
4510 i
< elf_header
.e_shnum
; ++i
, ++sec
)
4511 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4518 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
4520 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
4522 /* We need to find which section group it is in. */
4523 struct group_list
*g
= section_headers_groups
[i
]->root
;
4525 for (; g
!= NULL
; g
= g
->next
)
4527 sec
= SECTION_HEADER (g
->section_index
);
4528 if (strcmp (SECTION_NAME (sec
),
4529 ELF_STRING_ia64_unwind_info
) == 0)
4534 i
= elf_header
.e_shnum
;
4536 else if (strncmp (SECTION_NAME (unwsec
),
4537 ELF_STRING_ia64_unwind_once
, len
) == 0)
4539 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO */
4540 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
4541 suffix
= SECTION_NAME (unwsec
) + len
;
4542 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4544 if (strncmp (SECTION_NAME (sec
),
4545 ELF_STRING_ia64_unwind_info_once
, len2
) == 0
4546 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
4551 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
4552 .IA_64.unwind or BAR -> .IA_64.unwind_info */
4553 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
4554 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
4556 if (strncmp (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
,
4558 suffix
= SECTION_NAME (unwsec
) + len
;
4559 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4561 if (strncmp (SECTION_NAME (sec
),
4562 ELF_STRING_ia64_unwind_info
, len2
) == 0
4563 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
4567 if (i
== elf_header
.e_shnum
)
4569 printf (_("\nCould not find unwind info section for "));
4571 if (string_table
== NULL
)
4572 printf ("%d", unwsec
->sh_name
);
4574 printf (_("'%s'"), SECTION_NAME (unwsec
));
4578 aux
.info_size
= sec
->sh_size
;
4579 aux
.info_addr
= sec
->sh_addr
;
4580 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, aux
.info_size
,
4583 printf (_("\nUnwind section "));
4585 if (string_table
== NULL
)
4586 printf ("%d", unwsec
->sh_name
);
4588 printf (_("'%s'"), SECTION_NAME (unwsec
));
4590 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4591 (unsigned long) unwsec
->sh_offset
,
4592 (unsigned long) (unwsec
->sh_size
/ (3 * addr_size
)));
4594 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
4596 if (aux
.table_len
> 0)
4597 dump_ia64_unwind (& aux
);
4600 free ((char *) aux
.table
);
4602 free ((char *) aux
.info
);
4611 free ((char *) aux
.strtab
);
4617 dynamic_section_mips_val (Elf_Internal_Dyn
*entry
)
4619 switch (entry
->d_tag
)
4622 if (entry
->d_un
.d_val
== 0)
4626 static const char * opts
[] =
4628 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
4629 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
4630 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
4631 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
4636 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++cnt
)
4637 if (entry
->d_un
.d_val
& (1 << cnt
))
4639 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
4646 case DT_MIPS_IVERSION
:
4647 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
4648 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
4650 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
4653 case DT_MIPS_TIME_STAMP
:
4658 time_t time
= entry
->d_un
.d_val
;
4659 tmp
= gmtime (&time
);
4660 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
4661 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
4662 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
4663 printf ("Time Stamp: %s\n", timebuf
);
4667 case DT_MIPS_RLD_VERSION
:
4668 case DT_MIPS_LOCAL_GOTNO
:
4669 case DT_MIPS_CONFLICTNO
:
4670 case DT_MIPS_LIBLISTNO
:
4671 case DT_MIPS_SYMTABNO
:
4672 case DT_MIPS_UNREFEXTNO
:
4673 case DT_MIPS_HIPAGENO
:
4674 case DT_MIPS_DELTA_CLASS_NO
:
4675 case DT_MIPS_DELTA_INSTANCE_NO
:
4676 case DT_MIPS_DELTA_RELOC_NO
:
4677 case DT_MIPS_DELTA_SYM_NO
:
4678 case DT_MIPS_DELTA_CLASSSYM_NO
:
4679 case DT_MIPS_COMPACT_SIZE
:
4680 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
4684 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
4690 dynamic_section_parisc_val (Elf_Internal_Dyn
*entry
)
4692 switch (entry
->d_tag
)
4694 case DT_HP_DLD_FLAGS
:
4703 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
4704 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
4705 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
4706 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
4707 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
4708 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
4709 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
4710 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
4711 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
4712 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
4713 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
4717 bfd_vma val
= entry
->d_un
.d_val
;
4719 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
4720 if (val
& flags
[cnt
].bit
)
4724 fputs (flags
[cnt
].str
, stdout
);
4726 val
^= flags
[cnt
].bit
;
4729 if (val
!= 0 || first
)
4733 print_vma (val
, HEX
);
4739 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
4746 dynamic_section_ia64_val (Elf_Internal_Dyn
*entry
)
4748 switch (entry
->d_tag
)
4750 case DT_IA_64_PLT_RESERVE
:
4751 /* First 3 slots reserved. */
4752 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
4754 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
4758 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
4765 get_32bit_dynamic_section (FILE *file
)
4767 Elf32_External_Dyn
*edyn
, *ext
;
4768 Elf_Internal_Dyn
*entry
;
4770 edyn
= get_data (NULL
, file
, dynamic_addr
, dynamic_size
,
4771 _("dynamic section"));
4775 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
4776 might not have the luxury of section headers. Look for the DT_NULL
4777 terminator to determine the number of entries. */
4778 for (ext
= edyn
, dynamic_nent
= 0;
4779 (char *) ext
< (char *) edyn
+ dynamic_size
;
4783 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
4787 dynamic_section
= malloc (dynamic_nent
* sizeof (*entry
));
4788 if (dynamic_section
== NULL
)
4790 error (_("Out of memory\n"));
4795 for (ext
= edyn
, entry
= dynamic_section
;
4796 entry
< dynamic_section
+ dynamic_nent
;
4799 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
4800 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
4809 get_64bit_dynamic_section (FILE *file
)
4811 Elf64_External_Dyn
*edyn
, *ext
;
4812 Elf_Internal_Dyn
*entry
;
4814 edyn
= get_data (NULL
, file
, dynamic_addr
, dynamic_size
,
4815 _("dynamic section"));
4819 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
4820 might not have the luxury of section headers. Look for the DT_NULL
4821 terminator to determine the number of entries. */
4822 for (ext
= edyn
, dynamic_nent
= 0;
4823 (char *) ext
< (char *) edyn
+ dynamic_size
;
4827 if (BYTE_GET8 (ext
->d_tag
) == DT_NULL
)
4831 dynamic_section
= malloc (dynamic_nent
* sizeof (*entry
));
4832 if (dynamic_section
== NULL
)
4834 error (_("Out of memory\n"));
4839 for (ext
= edyn
, entry
= dynamic_section
;
4840 entry
< dynamic_section
+ dynamic_nent
;
4843 entry
->d_tag
= BYTE_GET8 (ext
->d_tag
);
4844 entry
->d_un
.d_val
= BYTE_GET8 (ext
->d_un
.d_val
);
4853 get_dynamic_flags (bfd_vma flags
)
4855 static char buff
[128];
4863 flag
= flags
& - flags
;
4871 case DF_ORIGIN
: strcpy (p
, "ORIGIN"); break;
4872 case DF_SYMBOLIC
: strcpy (p
, "SYMBOLIC"); break;
4873 case DF_TEXTREL
: strcpy (p
, "TEXTREL"); break;
4874 case DF_BIND_NOW
: strcpy (p
, "BIND_NOW"); break;
4875 case DF_STATIC_TLS
: strcpy (p
, "STATIC_TLS"); break;
4876 default: strcpy (p
, "unknown"); break;
4879 p
= strchr (p
, '\0');
4884 /* Parse and display the contents of the dynamic section. */
4887 process_dynamic_section (FILE *file
)
4889 Elf_Internal_Dyn
*entry
;
4891 if (dynamic_size
== 0)
4894 printf (_("\nThere is no dynamic section in this file.\n"));
4901 if (! get_32bit_dynamic_section (file
))
4904 else if (! get_64bit_dynamic_section (file
))
4907 /* Find the appropriate symbol table. */
4908 if (dynamic_symbols
== NULL
)
4910 for (entry
= dynamic_section
;
4911 entry
< dynamic_section
+ dynamic_nent
;
4914 Elf_Internal_Shdr section
;
4916 if (entry
->d_tag
!= DT_SYMTAB
)
4919 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
4921 /* Since we do not know how big the symbol table is,
4922 we default to reading in the entire file (!) and
4923 processing that. This is overkill, I know, but it
4925 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
4927 if (archive_file_offset
!= 0)
4928 section
.sh_size
= archive_file_size
- section
.sh_offset
;
4931 if (fseek (file
, 0, SEEK_END
))
4932 error (_("Unable to seek to end of file!"));
4934 section
.sh_size
= ftell (file
) - section
.sh_offset
;
4938 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
4940 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
4942 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
4943 if (num_dynamic_syms
< 1)
4945 error (_("Unable to determine the number of symbols to load\n"));
4949 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
4953 /* Similarly find a string table. */
4954 if (dynamic_strings
== NULL
)
4956 for (entry
= dynamic_section
;
4957 entry
< dynamic_section
+ dynamic_nent
;
4960 unsigned long offset
;
4963 if (entry
->d_tag
!= DT_STRTAB
)
4966 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
4968 /* Since we do not know how big the string table is,
4969 we default to reading in the entire file (!) and
4970 processing that. This is overkill, I know, but it
4973 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
4975 if (archive_file_offset
!= 0)
4976 str_tab_len
= archive_file_size
- offset
;
4979 if (fseek (file
, 0, SEEK_END
))
4980 error (_("Unable to seek to end of file\n"));
4981 str_tab_len
= ftell (file
) - offset
;
4984 if (str_tab_len
< 1)
4987 (_("Unable to determine the length of the dynamic string table\n"));
4991 dynamic_strings
= get_data (NULL
, file
, offset
, str_tab_len
,
4992 _("dynamic string table"));
4993 dynamic_strings_length
= str_tab_len
;
4998 /* And find the syminfo section if available. */
4999 if (dynamic_syminfo
== NULL
)
5001 unsigned long syminsz
= 0;
5003 for (entry
= dynamic_section
;
5004 entry
< dynamic_section
+ dynamic_nent
;
5007 if (entry
->d_tag
== DT_SYMINENT
)
5009 /* Note: these braces are necessary to avoid a syntax
5010 error from the SunOS4 C compiler. */
5011 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
5013 else if (entry
->d_tag
== DT_SYMINSZ
)
5014 syminsz
= entry
->d_un
.d_val
;
5015 else if (entry
->d_tag
== DT_SYMINFO
)
5016 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
5020 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
5022 Elf_External_Syminfo
*extsyminfo
, *extsym
;
5023 Elf_Internal_Syminfo
*syminfo
;
5025 /* There is a syminfo section. Read the data. */
5026 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, syminsz
,
5027 _("symbol information"));
5031 dynamic_syminfo
= malloc (syminsz
);
5032 if (dynamic_syminfo
== NULL
)
5034 error (_("Out of memory\n"));
5038 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
5039 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
5040 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
5041 ++syminfo
, ++extsym
)
5043 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
5044 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
5051 if (do_dynamic
&& dynamic_addr
)
5052 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
5053 dynamic_addr
, dynamic_nent
);
5055 printf (_(" Tag Type Name/Value\n"));
5057 for (entry
= dynamic_section
;
5058 entry
< dynamic_section
+ dynamic_nent
;
5066 print_vma (entry
->d_tag
, FULL_HEX
);
5067 dtype
= get_dynamic_type (entry
->d_tag
);
5068 printf (" (%s)%*s", dtype
,
5069 ((is_32bit_elf
? 27 : 19)
5070 - (int) strlen (dtype
)),
5074 switch (entry
->d_tag
)
5078 puts (get_dynamic_flags (entry
->d_un
.d_val
));
5088 switch (entry
->d_tag
)
5091 printf (_("Auxiliary library"));
5095 printf (_("Filter library"));
5099 printf (_("Configuration file"));
5103 printf (_("Dependency audit library"));
5107 printf (_("Audit library"));
5111 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5112 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5116 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5125 printf (_("Flags:"));
5127 if (entry
->d_un
.d_val
== 0)
5128 printf (_(" None\n"));
5131 unsigned long int val
= entry
->d_un
.d_val
;
5133 if (val
& DTF_1_PARINIT
)
5135 printf (" PARINIT");
5136 val
^= DTF_1_PARINIT
;
5138 if (val
& DTF_1_CONFEXP
)
5140 printf (" CONFEXP");
5141 val
^= DTF_1_CONFEXP
;
5144 printf (" %lx", val
);
5153 printf (_("Flags:"));
5155 if (entry
->d_un
.d_val
== 0)
5156 printf (_(" None\n"));
5159 unsigned long int val
= entry
->d_un
.d_val
;
5161 if (val
& DF_P1_LAZYLOAD
)
5163 printf (" LAZYLOAD");
5164 val
^= DF_P1_LAZYLOAD
;
5166 if (val
& DF_P1_GROUPPERM
)
5168 printf (" GROUPPERM");
5169 val
^= DF_P1_GROUPPERM
;
5172 printf (" %lx", val
);
5181 printf (_("Flags:"));
5182 if (entry
->d_un
.d_val
== 0)
5183 printf (_(" None\n"));
5186 unsigned long int val
= entry
->d_un
.d_val
;
5193 if (val
& DF_1_GLOBAL
)
5198 if (val
& DF_1_GROUP
)
5203 if (val
& DF_1_NODELETE
)
5205 printf (" NODELETE");
5206 val
^= DF_1_NODELETE
;
5208 if (val
& DF_1_LOADFLTR
)
5210 printf (" LOADFLTR");
5211 val
^= DF_1_LOADFLTR
;
5213 if (val
& DF_1_INITFIRST
)
5215 printf (" INITFIRST");
5216 val
^= DF_1_INITFIRST
;
5218 if (val
& DF_1_NOOPEN
)
5223 if (val
& DF_1_ORIGIN
)
5228 if (val
& DF_1_DIRECT
)
5233 if (val
& DF_1_TRANS
)
5238 if (val
& DF_1_INTERPOSE
)
5240 printf (" INTERPOSE");
5241 val
^= DF_1_INTERPOSE
;
5243 if (val
& DF_1_NODEFLIB
)
5245 printf (" NODEFLIB");
5246 val
^= DF_1_NODEFLIB
;
5248 if (val
& DF_1_NODUMP
)
5253 if (val
& DF_1_CONLFAT
)
5255 printf (" CONLFAT");
5256 val
^= DF_1_CONLFAT
;
5259 printf (" %lx", val
);
5266 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5268 puts (get_dynamic_type (entry
->d_un
.d_val
));
5288 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5294 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5295 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
5301 switch (entry
->d_tag
)
5304 printf (_("Shared library: [%s]"), name
);
5306 if (strcmp (name
, program_interpreter
) == 0)
5307 printf (_(" program interpreter"));
5311 printf (_("Library soname: [%s]"), name
);
5315 printf (_("Library rpath: [%s]"), name
);
5319 printf (_("Library runpath: [%s]"), name
);
5323 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5328 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5341 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5345 case DT_INIT_ARRAYSZ
:
5346 case DT_FINI_ARRAYSZ
:
5347 case DT_GNU_CONFLICTSZ
:
5348 case DT_GNU_LIBLISTSZ
:
5351 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5352 printf (" (bytes)\n");
5362 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5375 if (entry
->d_tag
== DT_USED
5376 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5378 char *name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
5382 printf (_("Not needed object: [%s]\n"), name
);
5387 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5393 /* The value of this entry is ignored. */
5398 case DT_GNU_PRELINKED
:
5402 time_t time
= entry
->d_un
.d_val
;
5404 tmp
= gmtime (&time
);
5405 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
5406 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5407 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5413 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
5414 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
5419 switch (elf_header
.e_machine
)
5422 case EM_MIPS_RS3_LE
:
5423 dynamic_section_mips_val (entry
);
5426 dynamic_section_parisc_val (entry
);
5429 dynamic_section_ia64_val (entry
);
5432 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5444 get_ver_flags (unsigned int flags
)
5446 static char buff
[32];
5453 if (flags
& VER_FLG_BASE
)
5454 strcat (buff
, "BASE ");
5456 if (flags
& VER_FLG_WEAK
)
5458 if (flags
& VER_FLG_BASE
)
5459 strcat (buff
, "| ");
5461 strcat (buff
, "WEAK ");
5464 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
5465 strcat (buff
, "| <unknown>");
5470 /* Display the contents of the version sections. */
5472 process_version_sections (FILE *file
)
5474 Elf_Internal_Shdr
*section
;
5481 for (i
= 0, section
= section_headers
;
5482 i
< elf_header
.e_shnum
;
5485 switch (section
->sh_type
)
5487 case SHT_GNU_verdef
:
5489 Elf_External_Verdef
*edefs
;
5496 (_("\nVersion definition section '%s' contains %ld entries:\n"),
5497 SECTION_NAME (section
), section
->sh_info
);
5499 printf (_(" Addr: 0x"));
5500 printf_vma (section
->sh_addr
);
5501 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5502 (unsigned long) section
->sh_offset
, section
->sh_link
,
5503 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
5505 edefs
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
5506 _("version definition section"));
5510 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
5513 Elf_External_Verdef
*edef
;
5514 Elf_Internal_Verdef ent
;
5515 Elf_External_Verdaux
*eaux
;
5516 Elf_Internal_Verdaux aux
;
5520 vstart
= ((char *) edefs
) + idx
;
5522 edef
= (Elf_External_Verdef
*) vstart
;
5524 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
5525 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
5526 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
5527 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
5528 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
5529 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
5530 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
5532 printf (_(" %#06x: Rev: %d Flags: %s"),
5533 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
5535 printf (_(" Index: %d Cnt: %d "),
5536 ent
.vd_ndx
, ent
.vd_cnt
);
5538 vstart
+= ent
.vd_aux
;
5540 eaux
= (Elf_External_Verdaux
*) vstart
;
5542 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
5543 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
5545 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
5546 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
5548 printf (_("Name index: %ld\n"), aux
.vda_name
);
5550 isum
= idx
+ ent
.vd_aux
;
5552 for (j
= 1; j
< ent
.vd_cnt
; j
++)
5554 isum
+= aux
.vda_next
;
5555 vstart
+= aux
.vda_next
;
5557 eaux
= (Elf_External_Verdaux
*) vstart
;
5559 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
5560 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
5562 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
5563 printf (_(" %#06x: Parent %d: %s\n"),
5564 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
5566 printf (_(" %#06x: Parent %d, name index: %ld\n"),
5567 isum
, j
, aux
.vda_name
);
5577 case SHT_GNU_verneed
:
5579 Elf_External_Verneed
*eneed
;
5585 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
5586 SECTION_NAME (section
), section
->sh_info
);
5588 printf (_(" Addr: 0x"));
5589 printf_vma (section
->sh_addr
);
5590 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
5591 (unsigned long) section
->sh_offset
, section
->sh_link
,
5592 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
5594 eneed
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
5595 _("version need section"));
5599 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
5601 Elf_External_Verneed
*entry
;
5602 Elf_Internal_Verneed ent
;
5607 vstart
= ((char *) eneed
) + idx
;
5609 entry
= (Elf_External_Verneed
*) vstart
;
5611 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
5612 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
5613 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
5614 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
5615 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
5617 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
5619 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
5620 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
5622 printf (_(" File: %lx"), ent
.vn_file
);
5624 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
5626 vstart
+= ent
.vn_aux
;
5628 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
5630 Elf_External_Vernaux
*eaux
;
5631 Elf_Internal_Vernaux aux
;
5633 eaux
= (Elf_External_Vernaux
*) vstart
;
5635 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
5636 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
5637 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
5638 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
5639 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
5641 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
5642 printf (_(" %#06x: Name: %s"),
5643 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
5645 printf (_(" %#06x: Name index: %lx"),
5646 isum
, aux
.vna_name
);
5648 printf (_(" Flags: %s Version: %d\n"),
5649 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
5651 isum
+= aux
.vna_next
;
5652 vstart
+= aux
.vna_next
;
5662 case SHT_GNU_versym
:
5664 Elf_Internal_Shdr
*link_section
;
5667 unsigned char *edata
;
5668 unsigned short *data
;
5670 Elf_Internal_Sym
*symbols
;
5671 Elf_Internal_Shdr
*string_sec
;
5674 link_section
= SECTION_HEADER (section
->sh_link
);
5675 total
= section
->sh_size
/ section
->sh_entsize
;
5679 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
5681 string_sec
= SECTION_HEADER (link_section
->sh_link
);
5683 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
5684 string_sec
->sh_size
, _("version string table"));
5688 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
5689 SECTION_NAME (section
), total
);
5691 printf (_(" Addr: "));
5692 printf_vma (section
->sh_addr
);
5693 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5694 (unsigned long) section
->sh_offset
, section
->sh_link
,
5695 SECTION_NAME (link_section
));
5697 off
= offset_from_vma (file
,
5698 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
5699 total
* sizeof (short));
5700 edata
= get_data (NULL
, file
, off
, total
* sizeof (short),
5701 _("version symbol data"));
5708 data
= malloc (total
* sizeof (short));
5710 for (cnt
= total
; cnt
--;)
5711 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
5716 for (cnt
= 0; cnt
< total
; cnt
+= 4)
5719 int check_def
, check_need
;
5722 printf (" %03x:", cnt
);
5724 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
5725 switch (data
[cnt
+ j
])
5728 fputs (_(" 0 (*local*) "), stdout
);
5732 fputs (_(" 1 (*global*) "), stdout
);
5736 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
5737 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
5741 if (SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
5744 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
5751 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
5753 Elf_Internal_Verneed ivn
;
5754 unsigned long offset
;
5756 offset
= offset_from_vma
5757 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
5758 sizeof (Elf_External_Verneed
));
5762 Elf_Internal_Vernaux ivna
;
5763 Elf_External_Verneed evn
;
5764 Elf_External_Vernaux evna
;
5765 unsigned long a_off
;
5767 get_data (&evn
, file
, offset
, sizeof (evn
),
5770 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
5771 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
5773 a_off
= offset
+ ivn
.vn_aux
;
5777 get_data (&evna
, file
, a_off
, sizeof (evna
),
5778 _("version need aux (2)"));
5780 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
5781 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
5783 a_off
+= ivna
.vna_next
;
5785 while (ivna
.vna_other
!= data
[cnt
+ j
]
5786 && ivna
.vna_next
!= 0);
5788 if (ivna
.vna_other
== data
[cnt
+ j
])
5790 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
5792 name
= strtab
+ ivna
.vna_name
;
5793 nn
+= printf ("(%s%-*s",
5795 12 - (int) strlen (name
),
5801 offset
+= ivn
.vn_next
;
5803 while (ivn
.vn_next
);
5806 if (check_def
&& data
[cnt
+ j
] != 0x8001
5807 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
5809 Elf_Internal_Verdef ivd
;
5810 Elf_External_Verdef evd
;
5811 unsigned long offset
;
5813 offset
= offset_from_vma
5814 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
5819 get_data (&evd
, file
, offset
, sizeof (evd
),
5822 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
5823 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
5825 offset
+= ivd
.vd_next
;
5827 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
5828 && ivd
.vd_next
!= 0);
5830 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
5832 Elf_External_Verdaux evda
;
5833 Elf_Internal_Verdaux ivda
;
5835 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
5837 get_data (&evda
, file
,
5838 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
5839 sizeof (evda
), _("version def aux"));
5841 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
5843 name
= strtab
+ ivda
.vda_name
;
5844 nn
+= printf ("(%s%-*s",
5846 12 - (int) strlen (name
),
5852 printf ("%*c", 18 - nn
, ' ');
5870 printf (_("\nNo version information found in this file.\n"));
5876 get_symbol_binding (unsigned int binding
)
5878 static char buff
[32];
5882 case STB_LOCAL
: return "LOCAL";
5883 case STB_GLOBAL
: return "GLOBAL";
5884 case STB_WEAK
: return "WEAK";
5886 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
5887 sprintf (buff
, _("<processor specific>: %d"), binding
);
5888 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
5889 sprintf (buff
, _("<OS specific>: %d"), binding
);
5891 sprintf (buff
, _("<unknown>: %d"), binding
);
5897 get_symbol_type (unsigned int type
)
5899 static char buff
[32];
5903 case STT_NOTYPE
: return "NOTYPE";
5904 case STT_OBJECT
: return "OBJECT";
5905 case STT_FUNC
: return "FUNC";
5906 case STT_SECTION
: return "SECTION";
5907 case STT_FILE
: return "FILE";
5908 case STT_COMMON
: return "COMMON";
5909 case STT_TLS
: return "TLS";
5911 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
5913 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
5914 return "THUMB_FUNC";
5916 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
5919 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
5920 return "PARISC_MILLI";
5922 sprintf (buff
, _("<processor specific>: %d"), type
);
5924 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
5926 if (elf_header
.e_machine
== EM_PARISC
)
5928 if (type
== STT_HP_OPAQUE
)
5930 if (type
== STT_HP_STUB
)
5934 sprintf (buff
, _("<OS specific>: %d"), type
);
5937 sprintf (buff
, _("<unknown>: %d"), type
);
5943 get_symbol_visibility (unsigned int visibility
)
5947 case STV_DEFAULT
: return "DEFAULT";
5948 case STV_INTERNAL
: return "INTERNAL";
5949 case STV_HIDDEN
: return "HIDDEN";
5950 case STV_PROTECTED
: return "PROTECTED";
5956 get_symbol_index_type (unsigned int type
)
5958 static char buff
[32];
5962 case SHN_UNDEF
: return "UND";
5963 case SHN_ABS
: return "ABS";
5964 case SHN_COMMON
: return "COM";
5966 if (type
== SHN_IA_64_ANSI_COMMON
5967 && elf_header
.e_machine
== EM_IA_64
5968 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
5970 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
5971 sprintf (buff
, "PRC[0x%04x]", type
);
5972 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
5973 sprintf (buff
, "OS [0x%04x]", type
);
5974 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
5975 sprintf (buff
, "RSV[0x%04x]", type
);
5977 sprintf (buff
, "%3d", type
);
5985 get_dynamic_data (FILE *file
, unsigned int number
)
5987 unsigned char *e_data
;
5990 e_data
= malloc (number
* 4);
5994 error (_("Out of memory\n"));
5998 if (fread (e_data
, 4, number
, file
) != number
)
6000 error (_("Unable to read in dynamic data\n"));
6004 i_data
= malloc (number
* sizeof (*i_data
));
6008 error (_("Out of memory\n"));
6014 i_data
[number
] = byte_get (e_data
+ number
* 4, 4);
6021 /* Dump the symbol table. */
6023 process_symbol_table (FILE *file
)
6025 Elf_Internal_Shdr
*section
;
6026 unsigned char nb
[4];
6027 unsigned char nc
[4];
6030 int *buckets
= NULL
;
6033 if (! do_syms
&& !do_histogram
)
6036 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
6040 (archive_file_offset
6041 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
6042 sizeof nb
+ sizeof nc
)),
6045 error (_("Unable to seek to start of dynamic information"));
6049 if (fread (nb
, sizeof (nb
), 1, file
) != 1)
6051 error (_("Failed to read in number of buckets\n"));
6055 if (fread (nc
, sizeof (nc
), 1, file
) != 1)
6057 error (_("Failed to read in number of chains\n"));
6061 nbuckets
= byte_get (nb
, 4);
6062 nchains
= byte_get (nc
, 4);
6064 buckets
= get_dynamic_data (file
, nbuckets
);
6065 chains
= get_dynamic_data (file
, nchains
);
6067 if (buckets
== NULL
|| chains
== NULL
)
6072 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
6077 printf (_("\nSymbol table for image:\n"));
6079 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6081 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6083 for (hn
= 0; hn
< nbuckets
; hn
++)
6088 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
6090 Elf_Internal_Sym
*psym
;
6092 psym
= dynamic_symbols
+ si
;
6094 printf (" %3d %3d: ", si
, hn
);
6095 print_vma (psym
->st_value
, LONG_HEX
);
6097 print_vma (psym
->st_size
, DEC_5
);
6099 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6100 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6101 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6102 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
6103 if (VALID_DYNAMIC_NAME (psym
->st_name
))
6104 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
6106 printf (" <corrupt: %14ld>", psym
->st_name
);
6111 else if (do_syms
&& !do_using_dynamic
)
6115 for (i
= 0, section
= section_headers
;
6116 i
< elf_header
.e_shnum
;
6121 Elf_Internal_Sym
*symtab
;
6122 Elf_Internal_Sym
*psym
;
6125 if ( section
->sh_type
!= SHT_SYMTAB
6126 && section
->sh_type
!= SHT_DYNSYM
)
6129 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
6130 SECTION_NAME (section
),
6131 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
6133 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6135 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6137 symtab
= GET_ELF_SYMBOLS (file
, section
);
6141 if (section
->sh_link
== elf_header
.e_shstrndx
)
6142 strtab
= string_table
;
6145 Elf_Internal_Shdr
*string_sec
;
6147 string_sec
= SECTION_HEADER (section
->sh_link
);
6149 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
6150 string_sec
->sh_size
, _("string table"));
6153 for (si
= 0, psym
= symtab
;
6154 si
< section
->sh_size
/ section
->sh_entsize
;
6157 printf ("%6d: ", si
);
6158 print_vma (psym
->st_value
, LONG_HEX
);
6160 print_vma (psym
->st_size
, DEC_5
);
6161 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6162 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6163 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6164 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
6165 print_symbol (25, strtab
+ psym
->st_name
);
6167 if (section
->sh_type
== SHT_DYNSYM
&&
6168 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
6170 unsigned char data
[2];
6171 unsigned short vers_data
;
6172 unsigned long offset
;
6176 offset
= offset_from_vma
6177 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6178 sizeof data
+ si
* sizeof (vers_data
));
6180 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
6181 sizeof (data
), _("version data"));
6183 vers_data
= byte_get (data
, 2);
6185 is_nobits
= (SECTION_HEADER (psym
->st_shndx
)->sh_type
6188 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
6190 if ((vers_data
& 0x8000) || vers_data
> 1)
6192 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
6193 && (is_nobits
|| ! check_def
))
6195 Elf_External_Verneed evn
;
6196 Elf_Internal_Verneed ivn
;
6197 Elf_Internal_Vernaux ivna
;
6199 /* We must test both. */
6200 offset
= offset_from_vma
6201 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6206 unsigned long vna_off
;
6208 get_data (&evn
, file
, offset
, sizeof (evn
),
6211 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6212 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6214 vna_off
= offset
+ ivn
.vn_aux
;
6218 Elf_External_Vernaux evna
;
6220 get_data (&evna
, file
, vna_off
,
6222 _("version need aux (3)"));
6224 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6225 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6226 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6228 vna_off
+= ivna
.vna_next
;
6230 while (ivna
.vna_other
!= vers_data
6231 && ivna
.vna_next
!= 0);
6233 if (ivna
.vna_other
== vers_data
)
6236 offset
+= ivn
.vn_next
;
6238 while (ivn
.vn_next
!= 0);
6240 if (ivna
.vna_other
== vers_data
)
6243 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
6246 else if (! is_nobits
)
6247 error (_("bad dynamic symbol"));
6254 if (vers_data
!= 0x8001
6255 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6257 Elf_Internal_Verdef ivd
;
6258 Elf_Internal_Verdaux ivda
;
6259 Elf_External_Verdaux evda
;
6260 unsigned long offset
;
6262 offset
= offset_from_vma
6264 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6265 sizeof (Elf_External_Verdef
));
6269 Elf_External_Verdef evd
;
6271 get_data (&evd
, file
, offset
, sizeof (evd
),
6274 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6275 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6276 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6278 offset
+= ivd
.vd_next
;
6280 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
6281 && ivd
.vd_next
!= 0);
6283 offset
-= ivd
.vd_next
;
6284 offset
+= ivd
.vd_aux
;
6286 get_data (&evda
, file
, offset
, sizeof (evda
),
6287 _("version def aux"));
6289 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6291 if (psym
->st_name
!= ivda
.vda_name
)
6292 printf ((vers_data
& 0x8000)
6294 strtab
+ ivda
.vda_name
);
6304 if (strtab
!= string_table
)
6310 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
6312 if (do_histogram
&& buckets
!= NULL
)
6319 int nzero_counts
= 0;
6322 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
6324 printf (_(" Length Number %% of total Coverage\n"));
6326 lengths
= calloc (nbuckets
, sizeof (int));
6327 if (lengths
== NULL
)
6329 error (_("Out of memory"));
6332 for (hn
= 0; hn
< nbuckets
; ++hn
)
6337 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
6340 if (maxlength
< ++lengths
[hn
])
6345 counts
= calloc (maxlength
+ 1, sizeof (int));
6348 error (_("Out of memory"));
6352 for (hn
= 0; hn
< nbuckets
; ++hn
)
6353 ++counts
[lengths
[hn
]];
6357 printf (" 0 %-10d (%5.1f%%)\n",
6358 counts
[0], (counts
[0] * 100.0) / nbuckets
);
6359 for (si
= 1; si
<= maxlength
; ++si
)
6361 nzero_counts
+= counts
[si
] * si
;
6362 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
6363 si
, counts
[si
], (counts
[si
] * 100.0) / nbuckets
,
6364 (nzero_counts
* 100.0) / nsyms
);
6372 if (buckets
!= NULL
)
6382 process_syminfo (FILE *file ATTRIBUTE_UNUSED
)
6386 if (dynamic_syminfo
== NULL
6388 /* No syminfo, this is ok. */
6391 /* There better should be a dynamic symbol section. */
6392 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
6396 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
6397 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
6399 printf (_(" Num: Name BoundTo Flags\n"));
6400 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
6402 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
6404 printf ("%4d: ", i
);
6405 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
6406 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
6408 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
6411 switch (dynamic_syminfo
[i
].si_boundto
)
6413 case SYMINFO_BT_SELF
:
6414 fputs ("SELF ", stdout
);
6416 case SYMINFO_BT_PARENT
:
6417 fputs ("PARENT ", stdout
);
6420 if (dynamic_syminfo
[i
].si_boundto
> 0
6421 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
6422 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
6424 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
6428 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
6432 if (flags
& SYMINFO_FLG_DIRECT
)
6434 if (flags
& SYMINFO_FLG_PASSTHRU
)
6435 printf (" PASSTHRU");
6436 if (flags
& SYMINFO_FLG_COPY
)
6438 if (flags
& SYMINFO_FLG_LAZYLOAD
)
6439 printf (" LAZYLOAD");
6447 #ifdef SUPPORT_DISASSEMBLY
6449 disassemble_section (Elf_Internal_Shdr
*section
, FILE *file
)
6451 printf (_("\nAssembly dump of section %s\n"),
6452 SECTION_NAME (section
));
6454 /* XXX -- to be done --- XXX */
6461 dump_section (Elf_Internal_Shdr
*section
, FILE *file
)
6463 bfd_size_type bytes
;
6465 unsigned char *data
;
6466 unsigned char *start
;
6468 bytes
= section
->sh_size
;
6470 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
6472 printf (_("\nSection '%s' has no data to dump.\n"),
6473 SECTION_NAME (section
));
6477 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
6479 addr
= section
->sh_addr
;
6481 start
= get_data (NULL
, file
, section
->sh_offset
, bytes
, _("section data"));
6493 lbytes
= (bytes
> 16 ? 16 : bytes
);
6495 printf (" 0x%8.8lx ", (unsigned long) addr
);
6497 switch (elf_header
.e_ident
[EI_DATA
])
6501 for (j
= 15; j
>= 0; j
--)
6504 printf ("%2.2x", data
[j
]);
6514 for (j
= 0; j
< 16; j
++)
6517 printf ("%2.2x", data
[j
]);
6527 for (j
= 0; j
< lbytes
; j
++)
6530 if (k
>= ' ' && k
< 0x7f)
6549 static unsigned long int
6550 read_leb128 (unsigned char *data
, int *length_return
, int sign
)
6552 unsigned long int result
= 0;
6553 unsigned int num_read
= 0;
6562 result
|= (byte
& 0x7f) << shift
;
6567 while (byte
& 0x80);
6569 if (length_return
!= NULL
)
6570 *length_return
= num_read
;
6572 if (sign
&& (shift
< 32) && (byte
& 0x40))
6573 result
|= -1 << shift
;
6578 typedef struct State_Machine_Registers
6580 unsigned long address
;
6583 unsigned int column
;
6587 /* This variable hold the number of the last entry seen
6588 in the File Table. */
6589 unsigned int last_file_entry
;
6592 static SMR state_machine_regs
;
6595 reset_state_machine (int is_stmt
)
6597 state_machine_regs
.address
= 0;
6598 state_machine_regs
.file
= 1;
6599 state_machine_regs
.line
= 1;
6600 state_machine_regs
.column
= 0;
6601 state_machine_regs
.is_stmt
= is_stmt
;
6602 state_machine_regs
.basic_block
= 0;
6603 state_machine_regs
.end_sequence
= 0;
6604 state_machine_regs
.last_file_entry
= 0;
6607 /* Handled an extend line op. Returns true if this is the end
6610 process_extended_line_op (unsigned char *data
, int is_stmt
, int pointer_size
)
6612 unsigned char op_code
;
6615 unsigned char *name
;
6618 len
= read_leb128 (data
, & bytes_read
, 0);
6623 warn (_("badly formed extended line op encountered!\n"));
6630 printf (_(" Extended opcode %d: "), op_code
);
6634 case DW_LNE_end_sequence
:
6635 printf (_("End of Sequence\n\n"));
6636 reset_state_machine (is_stmt
);
6639 case DW_LNE_set_address
:
6640 adr
= byte_get (data
, pointer_size
);
6641 printf (_("set Address to 0x%lx\n"), adr
);
6642 state_machine_regs
.address
= adr
;
6645 case DW_LNE_define_file
:
6646 printf (_(" define new File Table entry\n"));
6647 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6649 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
6651 data
+= strlen ((char *) data
) + 1;
6652 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6654 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6656 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6657 printf (_("%s\n\n"), name
);
6661 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
6668 /* Finds section NAME inside FILE and returns a
6669 pointer to it, or NULL upon failure. */
6671 static Elf_Internal_Shdr
*
6672 find_section (const char * name
)
6674 Elf_Internal_Shdr
*sec
;
6677 for (i
= elf_header
.e_shnum
, sec
= section_headers
+ i
- 1;
6679 if (strcmp (SECTION_NAME (sec
), name
) == 0)
6682 if (i
&& sec
&& sec
->sh_size
!= 0)
6688 /* Size of pointers in the .debug_line section. This information is not
6689 really present in that section. It's obtained before dumping the debug
6690 sections by doing some pre-scan of the .debug_info section. */
6691 static unsigned int * debug_line_pointer_sizes
= NULL
;
6692 static unsigned int num_debug_line_pointer_sizes
= 0;
6694 /* Locate and scan the .debug_info section in the file and record the pointer
6695 sizes for the compilation units in it. Usually an executable will have
6696 just one pointer size, but this is not guaranteed, and so we try not to
6697 make any assumptions. Returns zero upon failure, or the number of
6698 compilation units upon success. */
6701 get_debug_line_pointer_sizes (FILE * file
)
6703 Elf_Internal_Shdr
* section
;
6704 unsigned char * start
;
6705 unsigned char * end
;
6706 unsigned char * begin
;
6707 unsigned long length
;
6708 unsigned int num_units
;
6711 section
= find_section (".debug_info");
6712 if (section
== NULL
)
6715 length
= section
->sh_size
;
6716 start
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
6717 _("extracting pointer sizes from .debug_info section"));
6721 end
= start
+ section
->sh_size
;
6722 /* First scan the section to get the number of comp units. */
6723 for (begin
= start
, num_units
= 0; begin
< end
; num_units
++)
6725 /* Read the first 4 bytes. For a 32-bit DWARF section, this will
6726 be the length. For a 64-bit DWARF section, it'll be the escape
6727 code 0xffffffff followed by an 8 byte length. */
6728 length
= byte_get (begin
, 4);
6730 if (length
== 0xffffffff)
6732 length
= byte_get (begin
+ 4, 8);
6733 begin
+= length
+ 12;
6736 begin
+= length
+ 4;
6741 error (_("No comp units in .debug_info section ?"));
6746 /* Then allocate an array to hold the pointer sizes. */
6747 debug_line_pointer_sizes
= malloc (num_units
* sizeof * debug_line_pointer_sizes
);
6748 if (debug_line_pointer_sizes
== NULL
)
6750 error (_("Not enough memory for a pointer size array of %u entries"),
6756 /* Populate the array. */
6757 for (begin
= start
, unit
= 0; begin
< end
; unit
++)
6759 length
= byte_get (begin
, 4);
6760 if (length
== 0xffffffff)
6762 /* For 64-bit DWARF, the 1-byte address_size field is 22 bytes
6763 from the start of the section. This is computed as follows:
6765 unit_length: 12 bytes
6767 debug_abbrev_offset: 8 bytes
6768 -----------------------------
6771 debug_line_pointer_sizes
[unit
] = byte_get (begin
+ 22, 1);
6772 length
= byte_get (begin
+ 4, 8);
6773 begin
+= length
+ 12;
6777 /* For 32-bit DWARF, the 1-byte address_size field is 10 bytes from
6778 the start of the section:
6780 unit_length: 4 bytes
6782 debug_abbrev_offset: 4 bytes
6783 -----------------------------
6786 debug_line_pointer_sizes
[unit
] = byte_get (begin
+ 10, 1);
6787 begin
+= length
+ 4;
6792 num_debug_line_pointer_sizes
= num_units
;
6797 display_debug_lines (Elf_Internal_Shdr
*section
,
6798 unsigned char *start
, FILE *file
)
6800 unsigned char *hdrptr
;
6801 DWARF2_Internal_LineInfo info
;
6802 unsigned char *standard_opcodes
;
6803 unsigned char *data
= start
;
6804 unsigned char *end
= start
+ section
->sh_size
;
6805 unsigned char *end_of_sequence
;
6808 int initial_length_size
;
6809 unsigned int comp_unit
= 0;
6811 printf (_("\nDump of debug contents of section %s:\n\n"),
6812 SECTION_NAME (section
));
6814 if (num_debug_line_pointer_sizes
== 0)
6815 get_debug_line_pointer_sizes (file
);
6819 unsigned int pointer_size
;
6823 /* Check the length of the block. */
6824 info
.li_length
= byte_get (hdrptr
, 4);
6827 if (info
.li_length
== 0xffffffff)
6829 /* This section is 64-bit DWARF 3. */
6830 info
.li_length
= byte_get (hdrptr
, 8);
6833 initial_length_size
= 12;
6838 initial_length_size
= 4;
6841 if (info
.li_length
+ initial_length_size
> section
->sh_size
)
6844 (_("The line info appears to be corrupt - the section is too small\n"));
6848 /* Check its version number. */
6849 info
.li_version
= byte_get (hdrptr
, 2);
6851 if (info
.li_version
!= 2 && info
.li_version
!= 3)
6853 warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
6857 info
.li_prologue_length
= byte_get (hdrptr
, offset_size
);
6858 hdrptr
+= offset_size
;
6859 info
.li_min_insn_length
= byte_get (hdrptr
, 1);
6861 info
.li_default_is_stmt
= byte_get (hdrptr
, 1);
6863 info
.li_line_base
= byte_get (hdrptr
, 1);
6865 info
.li_line_range
= byte_get (hdrptr
, 1);
6867 info
.li_opcode_base
= byte_get (hdrptr
, 1);
6870 /* Sign extend the line base field. */
6871 info
.li_line_base
<<= 24;
6872 info
.li_line_base
>>= 24;
6874 /* Get the pointer size from the comp unit associated
6875 with this block of line number information. */
6876 if (comp_unit
>= num_debug_line_pointer_sizes
)
6878 error (_("Not enough comp units for .debug_lines section\n"));
6883 pointer_size
= debug_line_pointer_sizes
[comp_unit
];
6887 printf (_(" Length: %ld\n"), info
.li_length
);
6888 printf (_(" DWARF Version: %d\n"), info
.li_version
);
6889 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
6890 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
6891 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
6892 printf (_(" Line Base: %d\n"), info
.li_line_base
);
6893 printf (_(" Line Range: %d\n"), info
.li_line_range
);
6894 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
6895 printf (_(" (Pointer size: %u)\n"), pointer_size
);
6897 end_of_sequence
= data
+ info
.li_length
+ initial_length_size
;
6899 reset_state_machine (info
.li_default_is_stmt
);
6901 /* Display the contents of the Opcodes table. */
6902 standard_opcodes
= hdrptr
;
6904 printf (_("\n Opcodes:\n"));
6906 for (i
= 1; i
< info
.li_opcode_base
; i
++)
6907 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
6909 /* Display the contents of the Directory table. */
6910 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
6913 printf (_("\n The Directory Table is empty.\n"));
6916 printf (_("\n The Directory Table:\n"));
6920 printf (_(" %s\n"), data
);
6922 data
+= strlen ((char *) data
) + 1;
6926 /* Skip the NUL at the end of the table. */
6929 /* Display the contents of the File Name table. */
6931 printf (_("\n The File Name Table is empty.\n"));
6934 printf (_("\n The File Name Table:\n"));
6935 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6939 unsigned char *name
;
6942 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
6945 data
+= strlen ((char *) data
) + 1;
6947 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6949 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6951 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6953 printf (_("%s\n"), name
);
6957 /* Skip the NUL at the end of the table. */
6960 /* Now display the statements. */
6961 printf (_("\n Line Number Statements:\n"));
6964 while (data
< end_of_sequence
)
6966 unsigned char op_code
;
6972 if (op_code
>= info
.li_opcode_base
)
6974 op_code
-= info
.li_opcode_base
;
6975 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
6976 state_machine_regs
.address
+= adv
;
6977 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
6978 op_code
, adv
, state_machine_regs
.address
);
6979 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
6980 state_machine_regs
.line
+= adv
;
6981 printf (_(" and Line by %d to %d\n"),
6982 adv
, state_machine_regs
.line
);
6984 else switch (op_code
)
6986 case DW_LNS_extended_op
:
6987 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
6992 printf (_(" Copy\n"));
6995 case DW_LNS_advance_pc
:
6996 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
6998 state_machine_regs
.address
+= adv
;
6999 printf (_(" Advance PC by %d to %lx\n"), adv
,
7000 state_machine_regs
.address
);
7003 case DW_LNS_advance_line
:
7004 adv
= read_leb128 (data
, & bytes_read
, 1);
7006 state_machine_regs
.line
+= adv
;
7007 printf (_(" Advance Line by %d to %d\n"), adv
,
7008 state_machine_regs
.line
);
7011 case DW_LNS_set_file
:
7012 adv
= read_leb128 (data
, & bytes_read
, 0);
7014 printf (_(" Set File Name to entry %d in the File Name Table\n"),
7016 state_machine_regs
.file
= adv
;
7019 case DW_LNS_set_column
:
7020 adv
= read_leb128 (data
, & bytes_read
, 0);
7022 printf (_(" Set column to %d\n"), adv
);
7023 state_machine_regs
.column
= adv
;
7026 case DW_LNS_negate_stmt
:
7027 adv
= state_machine_regs
.is_stmt
;
7029 printf (_(" Set is_stmt to %d\n"), adv
);
7030 state_machine_regs
.is_stmt
= adv
;
7033 case DW_LNS_set_basic_block
:
7034 printf (_(" Set basic block\n"));
7035 state_machine_regs
.basic_block
= 1;
7038 case DW_LNS_const_add_pc
:
7039 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
7040 * info
.li_min_insn_length
);
7041 state_machine_regs
.address
+= adv
;
7042 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
7043 state_machine_regs
.address
);
7046 case DW_LNS_fixed_advance_pc
:
7047 adv
= byte_get (data
, 2);
7049 state_machine_regs
.address
+= adv
;
7050 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
7051 adv
, state_machine_regs
.address
);
7054 case DW_LNS_set_prologue_end
:
7055 printf (_(" Set prologue_end to true\n"));
7058 case DW_LNS_set_epilogue_begin
:
7059 printf (_(" Set epilogue_begin to true\n"));
7062 case DW_LNS_set_isa
:
7063 adv
= read_leb128 (data
, & bytes_read
, 0);
7065 printf (_(" Set ISA to %d\n"), adv
);
7069 printf (_(" Unknown opcode %d with operands: "), op_code
);
7072 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
7074 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
7075 i
== 1 ? "" : ", ");
7090 display_debug_pubnames (Elf_Internal_Shdr
*section
,
7091 unsigned char *start
,
7092 FILE *file ATTRIBUTE_UNUSED
)
7094 DWARF2_Internal_PubNames pubnames
;
7097 end
= start
+ section
->sh_size
;
7099 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
7103 unsigned char *data
;
7104 unsigned long offset
;
7105 int offset_size
, initial_length_size
;
7109 pubnames
.pn_length
= byte_get (data
, 4);
7111 if (pubnames
.pn_length
== 0xffffffff)
7113 pubnames
.pn_length
= byte_get (data
, 8);
7116 initial_length_size
= 12;
7121 initial_length_size
= 4;
7124 pubnames
.pn_version
= byte_get (data
, 2);
7126 pubnames
.pn_offset
= byte_get (data
, offset_size
);
7127 data
+= offset_size
;
7128 pubnames
.pn_size
= byte_get (data
, offset_size
);
7129 data
+= offset_size
;
7131 start
+= pubnames
.pn_length
+ initial_length_size
;
7133 if (pubnames
.pn_version
!= 2 && pubnames
.pn_version
!= 3)
7135 static int warned
= 0;
7139 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
7146 printf (_(" Length: %ld\n"),
7147 pubnames
.pn_length
);
7148 printf (_(" Version: %d\n"),
7149 pubnames
.pn_version
);
7150 printf (_(" Offset into .debug_info section: %ld\n"),
7151 pubnames
.pn_offset
);
7152 printf (_(" Size of area in .debug_info section: %ld\n"),
7155 printf (_("\n Offset\tName\n"));
7159 offset
= byte_get (data
, offset_size
);
7163 data
+= offset_size
;
7164 printf (" %-6ld\t\t%s\n", offset
, data
);
7165 data
+= strlen ((char *) data
) + 1;
7168 while (offset
!= 0);
7176 get_TAG_name (unsigned long tag
)
7180 case DW_TAG_padding
: return "DW_TAG_padding";
7181 case DW_TAG_array_type
: return "DW_TAG_array_type";
7182 case DW_TAG_class_type
: return "DW_TAG_class_type";
7183 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
7184 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
7185 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
7186 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
7187 case DW_TAG_label
: return "DW_TAG_label";
7188 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
7189 case DW_TAG_member
: return "DW_TAG_member";
7190 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
7191 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
7192 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
7193 case DW_TAG_string_type
: return "DW_TAG_string_type";
7194 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
7195 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
7196 case DW_TAG_typedef
: return "DW_TAG_typedef";
7197 case DW_TAG_union_type
: return "DW_TAG_union_type";
7198 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
7199 case DW_TAG_variant
: return "DW_TAG_variant";
7200 case DW_TAG_common_block
: return "DW_TAG_common_block";
7201 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
7202 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
7203 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
7204 case DW_TAG_module
: return "DW_TAG_module";
7205 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
7206 case DW_TAG_set_type
: return "DW_TAG_set_type";
7207 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
7208 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
7209 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
7210 case DW_TAG_base_type
: return "DW_TAG_base_type";
7211 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
7212 case DW_TAG_const_type
: return "DW_TAG_const_type";
7213 case DW_TAG_constant
: return "DW_TAG_constant";
7214 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
7215 case DW_TAG_file_type
: return "DW_TAG_file_type";
7216 case DW_TAG_friend
: return "DW_TAG_friend";
7217 case DW_TAG_namelist
: return "DW_TAG_namelist";
7218 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
7219 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
7220 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
7221 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
7222 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
7223 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
7224 case DW_TAG_try_block
: return "DW_TAG_try_block";
7225 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
7226 case DW_TAG_variable
: return "DW_TAG_variable";
7227 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
7228 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
7229 case DW_TAG_format_label
: return "DW_TAG_format_label";
7230 case DW_TAG_function_template
: return "DW_TAG_function_template";
7231 case DW_TAG_class_template
: return "DW_TAG_class_template";
7232 /* DWARF 2.1 values. */
7233 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
7234 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
7235 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
7236 case DW_TAG_namespace
: return "DW_TAG_namespace";
7237 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
7238 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
7239 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
7240 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
7242 case DW_TAG_upc_shared_type
: return "DW_TAG_upc_shared_type";
7243 case DW_TAG_upc_strict_type
: return "DW_TAG_upc_strict_type";
7244 case DW_TAG_upc_relaxed_type
: return "DW_TAG_upc_relaxed_type";
7247 static char buffer
[100];
7249 sprintf (buffer
, _("Unknown TAG value: %lx"), tag
);
7256 get_AT_name (unsigned long attribute
)
7260 case DW_AT_sibling
: return "DW_AT_sibling";
7261 case DW_AT_location
: return "DW_AT_location";
7262 case DW_AT_name
: return "DW_AT_name";
7263 case DW_AT_ordering
: return "DW_AT_ordering";
7264 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
7265 case DW_AT_byte_size
: return "DW_AT_byte_size";
7266 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
7267 case DW_AT_bit_size
: return "DW_AT_bit_size";
7268 case DW_AT_element_list
: return "DW_AT_element_list";
7269 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
7270 case DW_AT_low_pc
: return "DW_AT_low_pc";
7271 case DW_AT_high_pc
: return "DW_AT_high_pc";
7272 case DW_AT_language
: return "DW_AT_language";
7273 case DW_AT_member
: return "DW_AT_member";
7274 case DW_AT_discr
: return "DW_AT_discr";
7275 case DW_AT_discr_value
: return "DW_AT_discr_value";
7276 case DW_AT_visibility
: return "DW_AT_visibility";
7277 case DW_AT_import
: return "DW_AT_import";
7278 case DW_AT_string_length
: return "DW_AT_string_length";
7279 case DW_AT_common_reference
: return "DW_AT_common_reference";
7280 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
7281 case DW_AT_const_value
: return "DW_AT_const_value";
7282 case DW_AT_containing_type
: return "DW_AT_containing_type";
7283 case DW_AT_default_value
: return "DW_AT_default_value";
7284 case DW_AT_inline
: return "DW_AT_inline";
7285 case DW_AT_is_optional
: return "DW_AT_is_optional";
7286 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
7287 case DW_AT_producer
: return "DW_AT_producer";
7288 case DW_AT_prototyped
: return "DW_AT_prototyped";
7289 case DW_AT_return_addr
: return "DW_AT_return_addr";
7290 case DW_AT_start_scope
: return "DW_AT_start_scope";
7291 case DW_AT_stride_size
: return "DW_AT_stride_size";
7292 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
7293 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
7294 case DW_AT_accessibility
: return "DW_AT_accessibility";
7295 case DW_AT_address_class
: return "DW_AT_address_class";
7296 case DW_AT_artificial
: return "DW_AT_artificial";
7297 case DW_AT_base_types
: return "DW_AT_base_types";
7298 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
7299 case DW_AT_count
: return "DW_AT_count";
7300 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
7301 case DW_AT_decl_column
: return "DW_AT_decl_column";
7302 case DW_AT_decl_file
: return "DW_AT_decl_file";
7303 case DW_AT_decl_line
: return "DW_AT_decl_line";
7304 case DW_AT_declaration
: return "DW_AT_declaration";
7305 case DW_AT_discr_list
: return "DW_AT_discr_list";
7306 case DW_AT_encoding
: return "DW_AT_encoding";
7307 case DW_AT_external
: return "DW_AT_external";
7308 case DW_AT_frame_base
: return "DW_AT_frame_base";
7309 case DW_AT_friend
: return "DW_AT_friend";
7310 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
7311 case DW_AT_macro_info
: return "DW_AT_macro_info";
7312 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
7313 case DW_AT_priority
: return "DW_AT_priority";
7314 case DW_AT_segment
: return "DW_AT_segment";
7315 case DW_AT_specification
: return "DW_AT_specification";
7316 case DW_AT_static_link
: return "DW_AT_static_link";
7317 case DW_AT_type
: return "DW_AT_type";
7318 case DW_AT_use_location
: return "DW_AT_use_location";
7319 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
7320 case DW_AT_virtuality
: return "DW_AT_virtuality";
7321 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
7322 /* DWARF 2.1 values. */
7323 case DW_AT_allocated
: return "DW_AT_allocated";
7324 case DW_AT_associated
: return "DW_AT_associated";
7325 case DW_AT_data_location
: return "DW_AT_data_location";
7326 case DW_AT_stride
: return "DW_AT_stride";
7327 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
7328 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
7329 case DW_AT_extension
: return "DW_AT_extension";
7330 case DW_AT_ranges
: return "DW_AT_ranges";
7331 case DW_AT_trampoline
: return "DW_AT_trampoline";
7332 case DW_AT_call_column
: return "DW_AT_call_column";
7333 case DW_AT_call_file
: return "DW_AT_call_file";
7334 case DW_AT_call_line
: return "DW_AT_call_line";
7335 /* SGI/MIPS extensions. */
7336 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
7337 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
7338 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
7339 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
7340 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
7341 case DW_AT_MIPS_software_pipeline_depth
:
7342 return "DW_AT_MIPS_software_pipeline_depth";
7343 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
7344 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
7345 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
7346 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
7347 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
7348 /* GNU extensions. */
7349 case DW_AT_sf_names
: return "DW_AT_sf_names";
7350 case DW_AT_src_info
: return "DW_AT_src_info";
7351 case DW_AT_mac_info
: return "DW_AT_mac_info";
7352 case DW_AT_src_coords
: return "DW_AT_src_coords";
7353 case DW_AT_body_begin
: return "DW_AT_body_begin";
7354 case DW_AT_body_end
: return "DW_AT_body_end";
7355 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
7356 /* UPC extension. */
7357 case DW_AT_upc_threads_scaled
: return "DW_AT_upc_threads_scaled";
7360 static char buffer
[100];
7362 sprintf (buffer
, _("Unknown AT value: %lx"), attribute
);
7369 get_FORM_name (unsigned long form
)
7373 case DW_FORM_addr
: return "DW_FORM_addr";
7374 case DW_FORM_block2
: return "DW_FORM_block2";
7375 case DW_FORM_block4
: return "DW_FORM_block4";
7376 case DW_FORM_data2
: return "DW_FORM_data2";
7377 case DW_FORM_data4
: return "DW_FORM_data4";
7378 case DW_FORM_data8
: return "DW_FORM_data8";
7379 case DW_FORM_string
: return "DW_FORM_string";
7380 case DW_FORM_block
: return "DW_FORM_block";
7381 case DW_FORM_block1
: return "DW_FORM_block1";
7382 case DW_FORM_data1
: return "DW_FORM_data1";
7383 case DW_FORM_flag
: return "DW_FORM_flag";
7384 case DW_FORM_sdata
: return "DW_FORM_sdata";
7385 case DW_FORM_strp
: return "DW_FORM_strp";
7386 case DW_FORM_udata
: return "DW_FORM_udata";
7387 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
7388 case DW_FORM_ref1
: return "DW_FORM_ref1";
7389 case DW_FORM_ref2
: return "DW_FORM_ref2";
7390 case DW_FORM_ref4
: return "DW_FORM_ref4";
7391 case DW_FORM_ref8
: return "DW_FORM_ref8";
7392 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
7393 case DW_FORM_indirect
: return "DW_FORM_indirect";
7396 static char buffer
[100];
7398 sprintf (buffer
, _("Unknown FORM value: %lx"), form
);
7404 /* FIXME: There are better and more efficient ways to handle
7405 these structures. For now though, I just want something that
7406 is simple to implement. */
7407 typedef struct abbrev_attr
7409 unsigned long attribute
;
7411 struct abbrev_attr
*next
;
7415 typedef struct abbrev_entry
7417 unsigned long entry
;
7420 struct abbrev_attr
*first_attr
;
7421 struct abbrev_attr
*last_attr
;
7422 struct abbrev_entry
*next
;
7426 static abbrev_entry
*first_abbrev
= NULL
;
7427 static abbrev_entry
*last_abbrev
= NULL
;
7432 abbrev_entry
*abbrev
;
7434 for (abbrev
= first_abbrev
; abbrev
;)
7436 abbrev_entry
*next
= abbrev
->next
;
7439 for (attr
= abbrev
->first_attr
; attr
;)
7441 abbrev_attr
*next
= attr
->next
;
7451 last_abbrev
= first_abbrev
= NULL
;
7455 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
7457 abbrev_entry
*entry
;
7459 entry
= malloc (sizeof (*entry
));
7465 entry
->entry
= number
;
7467 entry
->children
= children
;
7468 entry
->first_attr
= NULL
;
7469 entry
->last_attr
= NULL
;
7472 if (first_abbrev
== NULL
)
7473 first_abbrev
= entry
;
7475 last_abbrev
->next
= entry
;
7477 last_abbrev
= entry
;
7481 add_abbrev_attr (unsigned long attribute
, unsigned long form
)
7485 attr
= malloc (sizeof (*attr
));
7491 attr
->attribute
= attribute
;
7495 if (last_abbrev
->first_attr
== NULL
)
7496 last_abbrev
->first_attr
= attr
;
7498 last_abbrev
->last_attr
->next
= attr
;
7500 last_abbrev
->last_attr
= attr
;
7503 /* Processes the (partial) contents of a .debug_abbrev section.
7504 Returns NULL if the end of the section was encountered.
7505 Returns the address after the last byte read if the end of
7506 an abbreviation set was found. */
7508 static unsigned char *
7509 process_abbrev_section (unsigned char *start
, unsigned char *end
)
7511 if (first_abbrev
!= NULL
)
7517 unsigned long entry
;
7519 unsigned long attribute
;
7522 entry
= read_leb128 (start
, & bytes_read
, 0);
7523 start
+= bytes_read
;
7525 /* A single zero is supposed to end the section according
7526 to the standard. If there's more, then signal that to
7529 return start
== end
? NULL
: start
;
7531 tag
= read_leb128 (start
, & bytes_read
, 0);
7532 start
+= bytes_read
;
7534 children
= *start
++;
7536 add_abbrev (entry
, tag
, children
);
7542 attribute
= read_leb128 (start
, & bytes_read
, 0);
7543 start
+= bytes_read
;
7545 form
= read_leb128 (start
, & bytes_read
, 0);
7546 start
+= bytes_read
;
7549 add_abbrev_attr (attribute
, form
);
7551 while (attribute
!= 0);
7559 display_debug_macinfo (Elf_Internal_Shdr
*section
,
7560 unsigned char *start
,
7561 FILE *file ATTRIBUTE_UNUSED
)
7563 unsigned char *end
= start
+ section
->sh_size
;
7564 unsigned char *curr
= start
;
7565 unsigned int bytes_read
;
7566 enum dwarf_macinfo_record_type op
;
7568 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
7572 unsigned int lineno
;
7580 case DW_MACINFO_start_file
:
7582 unsigned int filenum
;
7584 lineno
= read_leb128 (curr
, & bytes_read
, 0);
7586 filenum
= read_leb128 (curr
, & bytes_read
, 0);
7589 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"), lineno
, filenum
);
7593 case DW_MACINFO_end_file
:
7594 printf (_(" DW_MACINFO_end_file\n"));
7597 case DW_MACINFO_define
:
7598 lineno
= read_leb128 (curr
, & bytes_read
, 0);
7601 curr
+= strlen (string
) + 1;
7602 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"), lineno
, string
);
7605 case DW_MACINFO_undef
:
7606 lineno
= read_leb128 (curr
, & bytes_read
, 0);
7609 curr
+= strlen (string
) + 1;
7610 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"), lineno
, string
);
7613 case DW_MACINFO_vendor_ext
:
7615 unsigned int constant
;
7617 constant
= read_leb128 (curr
, & bytes_read
, 0);
7620 curr
+= strlen (string
) + 1;
7621 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"), constant
, string
);
7632 display_debug_abbrev (Elf_Internal_Shdr
*section
,
7633 unsigned char *start
,
7634 FILE *file ATTRIBUTE_UNUSED
)
7636 abbrev_entry
*entry
;
7637 unsigned char *end
= start
+ section
->sh_size
;
7639 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
7643 start
= process_abbrev_section (start
, end
);
7645 if (first_abbrev
== NULL
)
7648 printf (_(" Number TAG\n"));
7650 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
7654 printf (_(" %ld %s [%s]\n"),
7656 get_TAG_name (entry
->tag
),
7657 entry
->children
? _("has children") : _("no children"));
7659 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
7661 printf (_(" %-18s %s\n"),
7662 get_AT_name (attr
->attribute
),
7663 get_FORM_name (attr
->form
));
7677 static unsigned char *
7678 display_block (unsigned char *data
, unsigned long length
)
7680 printf (_(" %lu byte block: "), length
);
7683 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
7689 decode_location_expression (unsigned char * data
,
7690 unsigned int pointer_size
,
7691 unsigned long length
)
7695 unsigned long uvalue
;
7696 unsigned char *end
= data
+ length
;
7705 printf ("DW_OP_addr: %lx",
7706 (unsigned long) byte_get (data
, pointer_size
));
7707 data
+= pointer_size
;
7710 printf ("DW_OP_deref");
7713 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
7716 printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data
++, 1));
7719 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
7723 printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data
, 2));
7727 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
7731 printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data
, 4));
7735 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
7736 (unsigned long) byte_get (data
+ 4, 4));
7740 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
7741 (long) byte_get (data
+ 4, 4));
7745 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
7749 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
7753 printf ("DW_OP_dup");
7756 printf ("DW_OP_drop");
7759 printf ("DW_OP_over");
7762 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
7765 printf ("DW_OP_swap");
7768 printf ("DW_OP_rot");
7771 printf ("DW_OP_xderef");
7774 printf ("DW_OP_abs");
7777 printf ("DW_OP_and");
7780 printf ("DW_OP_div");
7783 printf ("DW_OP_minus");
7786 printf ("DW_OP_mod");
7789 printf ("DW_OP_mul");
7792 printf ("DW_OP_neg");
7795 printf ("DW_OP_not");
7798 printf ("DW_OP_or");
7801 printf ("DW_OP_plus");
7803 case DW_OP_plus_uconst
:
7804 printf ("DW_OP_plus_uconst: %lu",
7805 read_leb128 (data
, &bytes_read
, 0));
7809 printf ("DW_OP_shl");
7812 printf ("DW_OP_shr");
7815 printf ("DW_OP_shra");
7818 printf ("DW_OP_xor");
7821 printf ("DW_OP_bra: %ld", (long) byte_get_signed (data
, 2));
7825 printf ("DW_OP_eq");
7828 printf ("DW_OP_ge");
7831 printf ("DW_OP_gt");
7834 printf ("DW_OP_le");
7837 printf ("DW_OP_lt");
7840 printf ("DW_OP_ne");
7843 printf ("DW_OP_skip: %ld", (long) byte_get_signed (data
, 2));
7879 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
7914 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
7949 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
7950 read_leb128 (data
, &bytes_read
, 1));
7955 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
7959 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
7963 uvalue
= read_leb128 (data
, &bytes_read
, 0);
7965 printf ("DW_OP_bregx: %lu %ld", uvalue
,
7966 read_leb128 (data
, &bytes_read
, 1));
7970 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
7973 case DW_OP_deref_size
:
7974 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
7976 case DW_OP_xderef_size
:
7977 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
7980 printf ("DW_OP_nop");
7983 /* DWARF 3 extensions. */
7984 case DW_OP_push_object_address
:
7985 printf ("DW_OP_push_object_address");
7988 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2));
7992 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4));
7995 case DW_OP_call_ref
:
7996 printf ("DW_OP_call_ref");
7999 /* GNU extensions. */
8000 case DW_OP_GNU_push_tls_address
:
8001 printf ("DW_OP_GNU_push_tls_address");
8005 if (op
>= DW_OP_lo_user
8006 && op
<= DW_OP_hi_user
)
8007 printf (_("(User defined location op)"));
8009 printf (_("(Unknown location op)"));
8010 /* No way to tell where the next op is, so just bail. */
8014 /* Separate the ops. */
8020 static const char *debug_loc_contents
;
8021 static bfd_vma debug_loc_size
;
8024 load_debug_loc (FILE *file
)
8026 Elf_Internal_Shdr
*sec
;
8028 /* If it is already loaded, do nothing. */
8029 if (debug_loc_contents
!= NULL
)
8032 /* Locate the .debug_loc section. */
8033 sec
= find_section (".debug_loc");
8037 debug_loc_size
= sec
->sh_size
;
8039 debug_loc_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
8040 _("debug_loc section data"));
8044 free_debug_loc (void)
8046 if (debug_loc_contents
== NULL
)
8049 free ((char *) debug_loc_contents
);
8050 debug_loc_contents
= NULL
;
8056 display_debug_loc (Elf_Internal_Shdr
*section
,
8057 unsigned char *start
, FILE *file
)
8059 unsigned char *section_end
;
8060 unsigned long bytes
;
8061 unsigned char *section_begin
= start
;
8063 unsigned int comp_unit
= 0;
8065 addr
= section
->sh_addr
;
8066 bytes
= section
->sh_size
;
8067 section_end
= start
+ bytes
;
8071 printf (_("\nThe .debug_loc section is empty.\n"));
8075 if (num_debug_line_pointer_sizes
== 0)
8076 get_debug_line_pointer_sizes (file
);
8078 printf (_("Contents of the .debug_loc section:\n\n"));
8079 printf (_("\n Offset Begin End Expression\n"));
8081 while (start
< section_end
)
8083 unsigned long begin
;
8085 unsigned short length
;
8086 unsigned long offset
;
8087 unsigned int pointer_size
;
8089 offset
= start
- section_begin
;
8091 /* Get the pointer size from the comp unit associated
8092 with this block of location information. */
8093 if (comp_unit
>= num_debug_line_pointer_sizes
)
8095 error (_("Not enough comp units for .debug_loc section\n"));
8100 pointer_size
= debug_line_pointer_sizes
[comp_unit
];
8106 begin
= byte_get (start
, pointer_size
);
8107 start
+= pointer_size
;
8108 end
= byte_get (start
, pointer_size
);
8109 start
+= pointer_size
;
8111 if (begin
== 0 && end
== 0)
8114 /* For now, skip any base address specifiers. */
8115 if (begin
== 0xffffffff)
8121 length
= byte_get (start
, 2);
8124 printf (" %8.8lx %8.8lx %8.8lx (", offset
, begin
, end
);
8125 decode_location_expression (start
, pointer_size
, length
);
8135 static const char *debug_str_contents
;
8136 static bfd_vma debug_str_size
;
8139 load_debug_str (FILE *file
)
8141 Elf_Internal_Shdr
*sec
;
8143 /* If it is already loaded, do nothing. */
8144 if (debug_str_contents
!= NULL
)
8147 /* Locate the .debug_str section. */
8148 sec
= find_section (".debug_str");
8152 debug_str_size
= sec
->sh_size
;
8154 debug_str_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
8155 _("debug_str section data"));
8159 free_debug_str (void)
8161 if (debug_str_contents
== NULL
)
8164 free ((char *) debug_str_contents
);
8165 debug_str_contents
= NULL
;
8170 fetch_indirect_string (unsigned long offset
)
8172 if (debug_str_contents
== NULL
)
8173 return _("<no .debug_str section>");
8175 if (offset
> debug_str_size
)
8176 return _("<offset is too big>");
8178 return debug_str_contents
+ offset
;
8182 display_debug_str (Elf_Internal_Shdr
*section
,
8183 unsigned char *start
,
8184 FILE *file ATTRIBUTE_UNUSED
)
8186 unsigned long bytes
;
8189 addr
= section
->sh_addr
;
8190 bytes
= section
->sh_size
;
8194 printf (_("\nThe .debug_str section is empty.\n"));
8198 printf (_("Contents of the .debug_str section:\n\n"));
8206 lbytes
= (bytes
> 16 ? 16 : bytes
);
8208 printf (" 0x%8.8lx ", (unsigned long) addr
);
8210 for (j
= 0; j
< 16; j
++)
8213 printf ("%2.2x", start
[j
]);
8221 for (j
= 0; j
< lbytes
; j
++)
8224 if (k
>= ' ' && k
< 0x80)
8240 static unsigned char *
8241 read_and_display_attr_value (unsigned long attribute
,
8243 unsigned char *data
,
8244 unsigned long cu_offset
,
8245 unsigned long pointer_size
,
8246 unsigned long offset_size
,
8249 unsigned long uvalue
= 0;
8250 unsigned char *block_start
= NULL
;
8258 case DW_FORM_ref_addr
:
8259 if (dwarf_version
== 2)
8261 uvalue
= byte_get (data
, pointer_size
);
8262 data
+= pointer_size
;
8264 else if (dwarf_version
== 3)
8266 uvalue
= byte_get (data
, offset_size
);
8267 data
+= offset_size
;
8271 error (_("Internal error: DWARF version is not 2 or 3.\n"));
8276 uvalue
= byte_get (data
, pointer_size
);
8277 data
+= pointer_size
;
8281 uvalue
= byte_get (data
, offset_size
);
8282 data
+= offset_size
;
8288 uvalue
= byte_get (data
++, 1);
8293 uvalue
= byte_get (data
, 2);
8299 uvalue
= byte_get (data
, 4);
8304 uvalue
= read_leb128 (data
, & bytes_read
, 1);
8308 case DW_FORM_ref_udata
:
8310 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8314 case DW_FORM_indirect
:
8315 form
= read_leb128 (data
, & bytes_read
, 0);
8317 printf (" %s", get_FORM_name (form
));
8318 return read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
8319 pointer_size
, offset_size
,
8325 case DW_FORM_ref_addr
:
8326 printf (" <#%lx>", uvalue
);
8332 case DW_FORM_ref_udata
:
8333 printf (" <%lx>", uvalue
+ cu_offset
);
8337 printf (" %#lx", uvalue
);
8346 printf (" %ld", uvalue
);
8351 uvalue
= byte_get (data
, 4);
8352 printf (" %lx", uvalue
);
8353 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
8357 case DW_FORM_string
:
8358 printf (" %s", data
);
8359 data
+= strlen ((char *) data
) + 1;
8363 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8364 block_start
= data
+ bytes_read
;
8365 data
= display_block (block_start
, uvalue
);
8368 case DW_FORM_block1
:
8369 uvalue
= byte_get (data
, 1);
8370 block_start
= data
+ 1;
8371 data
= display_block (block_start
, uvalue
);
8374 case DW_FORM_block2
:
8375 uvalue
= byte_get (data
, 2);
8376 block_start
= data
+ 2;
8377 data
= display_block (block_start
, uvalue
);
8380 case DW_FORM_block4
:
8381 uvalue
= byte_get (data
, 4);
8382 block_start
= data
+ 4;
8383 data
= display_block (block_start
, uvalue
);
8387 printf (_(" (indirect string, offset: 0x%lx): %s"),
8388 uvalue
, fetch_indirect_string (uvalue
));
8391 case DW_FORM_indirect
:
8392 /* Handled above. */
8396 warn (_("Unrecognized form: %d\n"), form
);
8400 /* For some attributes we can display further information. */
8409 case DW_INL_not_inlined
:
8410 printf (_("(not inlined)"));
8412 case DW_INL_inlined
:
8413 printf (_("(inlined)"));
8415 case DW_INL_declared_not_inlined
:
8416 printf (_("(declared as inline but ignored)"));
8418 case DW_INL_declared_inlined
:
8419 printf (_("(declared as inline and inlined)"));
8422 printf (_(" (Unknown inline attribute value: %lx)"), uvalue
);
8427 case DW_AT_language
:
8430 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
8431 case DW_LANG_C89
: printf ("(ANSI C)"); break;
8432 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
8433 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
8434 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
8435 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
8436 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
8437 case DW_LANG_Ada83
: printf ("(Ada)"); break;
8438 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
8439 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
8440 /* DWARF 2.1 values. */
8441 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
8442 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
8443 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
8444 /* MIPS extension. */
8445 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
8446 /* UPC extension. */
8447 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
8449 printf ("(Unknown: %lx)", uvalue
);
8454 case DW_AT_encoding
:
8457 case DW_ATE_void
: printf ("(void)"); break;
8458 case DW_ATE_address
: printf ("(machine address)"); break;
8459 case DW_ATE_boolean
: printf ("(boolean)"); break;
8460 case DW_ATE_complex_float
: printf ("(complex float)"); break;
8461 case DW_ATE_float
: printf ("(float)"); break;
8462 case DW_ATE_signed
: printf ("(signed)"); break;
8463 case DW_ATE_signed_char
: printf ("(signed char)"); break;
8464 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
8465 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
8466 /* DWARF 2.1 value. */
8467 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
8469 if (uvalue
>= DW_ATE_lo_user
8470 && uvalue
<= DW_ATE_hi_user
)
8471 printf ("(user defined type)");
8473 printf ("(unknown type)");
8478 case DW_AT_accessibility
:
8481 case DW_ACCESS_public
: printf ("(public)"); break;
8482 case DW_ACCESS_protected
: printf ("(protected)"); break;
8483 case DW_ACCESS_private
: printf ("(private)"); break;
8485 printf ("(unknown accessibility)");
8490 case DW_AT_visibility
:
8493 case DW_VIS_local
: printf ("(local)"); break;
8494 case DW_VIS_exported
: printf ("(exported)"); break;
8495 case DW_VIS_qualified
: printf ("(qualified)"); break;
8496 default: printf ("(unknown visibility)"); break;
8500 case DW_AT_virtuality
:
8503 case DW_VIRTUALITY_none
: printf ("(none)"); break;
8504 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
8505 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
8506 default: printf ("(unknown virtuality)"); break;
8510 case DW_AT_identifier_case
:
8513 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
8514 case DW_ID_up_case
: printf ("(up_case)"); break;
8515 case DW_ID_down_case
: printf ("(down_case)"); break;
8516 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
8517 default: printf ("(unknown case)"); break;
8521 case DW_AT_calling_convention
:
8524 case DW_CC_normal
: printf ("(normal)"); break;
8525 case DW_CC_program
: printf ("(program)"); break;
8526 case DW_CC_nocall
: printf ("(nocall)"); break;
8528 if (uvalue
>= DW_CC_lo_user
8529 && uvalue
<= DW_CC_hi_user
)
8530 printf ("(user defined)");
8532 printf ("(unknown convention)");
8536 case DW_AT_ordering
:
8539 case -1: printf ("(undefined)"); break;
8540 case 0: printf ("(row major)"); break;
8541 case 1: printf ("(column major)"); break;
8545 case DW_AT_frame_base
:
8546 case DW_AT_location
:
8547 case DW_AT_data_member_location
:
8548 case DW_AT_vtable_elem_location
:
8549 case DW_AT_allocated
:
8550 case DW_AT_associated
:
8551 case DW_AT_data_location
:
8553 case DW_AT_upper_bound
:
8554 case DW_AT_lower_bound
:
8558 decode_location_expression (block_start
, pointer_size
, uvalue
);
8561 else if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8564 printf ("location list");
8576 static unsigned char *
8577 read_and_display_attr (unsigned long attribute
,
8579 unsigned char *data
,
8580 unsigned long cu_offset
,
8581 unsigned long pointer_size
,
8582 unsigned long offset_size
,
8585 printf (" %-18s:", get_AT_name (attribute
));
8586 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
8587 pointer_size
, offset_size
, dwarf_version
);
8592 /* Apply addends of RELA relocations. */
8595 debug_apply_rela_addends (FILE *file
,
8596 Elf_Internal_Shdr
*section
,
8598 unsigned char *sec_data
,
8599 unsigned char *start
,
8602 Elf_Internal_Shdr
*relsec
;
8604 if (end
- start
< reloc_size
)
8607 for (relsec
= section_headers
;
8608 relsec
< section_headers
+ elf_header
.e_shnum
;
8611 unsigned long nrelas
;
8612 Elf_Internal_Rela
*rela
, *rp
;
8613 Elf_Internal_Shdr
*symsec
;
8614 Elf_Internal_Sym
*symtab
;
8615 Elf_Internal_Sym
*sym
;
8617 if (relsec
->sh_type
!= SHT_RELA
8618 || SECTION_HEADER (relsec
->sh_info
) != section
8619 || relsec
->sh_size
== 0)
8622 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8626 symsec
= SECTION_HEADER (relsec
->sh_link
);
8627 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
8629 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8633 if (rp
->r_offset
>= (bfd_vma
) (start
- sec_data
)
8634 && rp
->r_offset
< (bfd_vma
) (end
- sec_data
) - reloc_size
)
8635 loc
= sec_data
+ rp
->r_offset
;
8641 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
8643 if (ELF32_R_SYM (rp
->r_info
) != 0
8644 && ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
8646 warn (_("Skipping unexpected symbol type %u\n"),
8647 ELF32_ST_TYPE (sym
->st_info
));
8653 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
8655 if (ELF64_R_SYM (rp
->r_info
) != 0
8656 && ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
8658 warn (_("Skipping unexpected symbol type %u\n"),
8659 ELF64_ST_TYPE (sym
->st_info
));
8664 byte_put (loc
, rp
->r_addend
, reloc_size
);
8675 display_debug_info (Elf_Internal_Shdr
*section
,
8676 unsigned char *start
,
8679 unsigned char *end
= start
+ section
->sh_size
;
8680 unsigned char *section_begin
= start
;
8682 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
8684 load_debug_str (file
);
8685 load_debug_loc (file
);
8689 DWARF2_Internal_CompUnit compunit
;
8690 unsigned char *hdrptr
;
8691 unsigned char *cu_abbrev_offset_ptr
;
8692 unsigned char *tags
;
8694 unsigned long cu_offset
;
8696 int initial_length_size
;
8700 compunit
.cu_length
= byte_get (hdrptr
, 4);
8703 if (compunit
.cu_length
== 0xffffffff)
8705 compunit
.cu_length
= byte_get (hdrptr
, 8);
8708 initial_length_size
= 12;
8713 initial_length_size
= 4;
8716 compunit
.cu_version
= byte_get (hdrptr
, 2);
8719 cu_offset
= start
- section_begin
;
8720 start
+= compunit
.cu_length
+ initial_length_size
;
8722 if (elf_header
.e_type
== ET_REL
8723 && !debug_apply_rela_addends (file
, section
, offset_size
,
8724 section_begin
, hdrptr
, start
))
8727 cu_abbrev_offset_ptr
= hdrptr
;
8728 compunit
.cu_abbrev_offset
= byte_get (hdrptr
, offset_size
);
8729 hdrptr
+= offset_size
;
8731 compunit
.cu_pointer_size
= byte_get (hdrptr
, 1);
8736 printf (_(" Compilation Unit @ %lx:\n"), cu_offset
);
8737 printf (_(" Length: %ld\n"), compunit
.cu_length
);
8738 printf (_(" Version: %d\n"), compunit
.cu_version
);
8739 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
8740 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
8742 if (compunit
.cu_version
!= 2 && compunit
.cu_version
!= 3)
8744 warn (_("Only version 2 and 3 DWARF debug information is currently supported.\n"));
8750 /* Read in the abbrevs used by this compilation unit. */
8752 Elf_Internal_Shdr
*sec
;
8753 unsigned char *begin
;
8755 /* Locate the .debug_abbrev section and process it. */
8756 sec
= find_section (".debug_abbrev");
8759 warn (_("Unable to locate .debug_abbrev section!\n"));
8763 begin
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
8764 _("debug_abbrev section data"));
8768 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
8769 begin
+ sec
->sh_size
);
8775 while (tags
< start
)
8778 unsigned long abbrev_number
;
8779 abbrev_entry
*entry
;
8782 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
8785 /* A null DIE marks the end of a list of children. */
8786 if (abbrev_number
== 0)
8792 /* Scan through the abbreviation list until we reach the
8794 for (entry
= first_abbrev
;
8795 entry
&& entry
->entry
!= abbrev_number
;
8796 entry
= entry
->next
)
8801 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
8806 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
8808 (unsigned long) (tags
- section_begin
- bytes_read
),
8810 get_TAG_name (entry
->tag
));
8812 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
8813 tags
= read_and_display_attr (attr
->attribute
,
8816 compunit
.cu_pointer_size
,
8818 compunit
.cu_version
);
8820 if (entry
->children
)
8834 display_debug_aranges (Elf_Internal_Shdr
*section
,
8835 unsigned char *start
,
8836 FILE *file ATTRIBUTE_UNUSED
)
8838 unsigned char *end
= start
+ section
->sh_size
;
8840 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
8844 unsigned char *hdrptr
;
8845 DWARF2_Internal_ARange arange
;
8846 unsigned char *ranges
;
8847 unsigned long length
;
8848 unsigned long address
;
8851 int initial_length_size
;
8855 arange
.ar_length
= byte_get (hdrptr
, 4);
8858 if (arange
.ar_length
== 0xffffffff)
8860 arange
.ar_length
= byte_get (hdrptr
, 8);
8863 initial_length_size
= 12;
8868 initial_length_size
= 4;
8871 arange
.ar_version
= byte_get (hdrptr
, 2);
8874 arange
.ar_info_offset
= byte_get (hdrptr
, offset_size
);
8875 hdrptr
+= offset_size
;
8877 arange
.ar_pointer_size
= byte_get (hdrptr
, 1);
8880 arange
.ar_segment_size
= byte_get (hdrptr
, 1);
8883 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
8885 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
8889 printf (_(" Length: %ld\n"), arange
.ar_length
);
8890 printf (_(" Version: %d\n"), arange
.ar_version
);
8891 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
8892 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
8893 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
8895 printf (_("\n Address Length\n"));
8899 /* Must pad to an alignment boundary that is twice the pointer size. */
8900 excess
= (hdrptr
- start
) % (2 * arange
.ar_pointer_size
);
8902 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
8906 address
= byte_get (ranges
, arange
.ar_pointer_size
);
8908 ranges
+= arange
.ar_pointer_size
;
8910 length
= byte_get (ranges
, arange
.ar_pointer_size
);
8912 ranges
+= arange
.ar_pointer_size
;
8914 /* A pair of zeros marks the end of the list. */
8915 if (address
== 0 && length
== 0)
8918 printf (" %8.8lx %lu\n", address
, length
);
8921 start
+= arange
.ar_length
+ initial_length_size
;
8929 typedef struct Frame_Chunk
8931 struct Frame_Chunk
*next
;
8932 unsigned char *chunk_start
;
8934 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
8935 short int *col_type
;
8938 unsigned int code_factor
;
8940 unsigned long pc_begin
;
8941 unsigned long pc_range
;
8945 unsigned char fde_encoding
;
8946 unsigned char cfa_exp
;
8950 /* A marker for a col_type that means this column was never referenced
8951 in the frame info. */
8952 #define DW_CFA_unreferenced (-1)
8955 frame_need_space (Frame_Chunk
*fc
, int reg
)
8957 int prev
= fc
->ncols
;
8959 if (reg
< fc
->ncols
)
8962 fc
->ncols
= reg
+ 1;
8963 fc
->col_type
= xrealloc (fc
->col_type
, fc
->ncols
* sizeof (short int));
8964 fc
->col_offset
= xrealloc (fc
->col_offset
, fc
->ncols
* sizeof (int));
8966 while (prev
< fc
->ncols
)
8968 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
8969 fc
->col_offset
[prev
] = 0;
8975 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, int *max_regs
)
8980 if (*max_regs
< fc
->ncols
)
8981 *max_regs
= fc
->ncols
;
8983 if (*need_col_headers
)
8985 *need_col_headers
= 0;
8987 printf (" LOC CFA ");
8989 for (r
= 0; r
< *max_regs
; r
++)
8990 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8995 printf ("r%-4d", r
);
9001 printf ("%08lx ", fc
->pc_begin
);
9003 strcpy (tmp
, "exp");
9005 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
9006 printf ("%-8s ", tmp
);
9008 for (r
= 0; r
< fc
->ncols
; r
++)
9010 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
9012 switch (fc
->col_type
[r
])
9014 case DW_CFA_undefined
:
9017 case DW_CFA_same_value
:
9021 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
9023 case DW_CFA_register
:
9024 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
9026 case DW_CFA_expression
:
9027 strcpy (tmp
, "exp");
9030 strcpy (tmp
, "n/a");
9033 printf ("%-5s", tmp
);
9040 size_of_encoded_value (int encoding
)
9042 switch (encoding
& 0x7)
9045 case 0: return is_32bit_elf
? 4 : 8;
9053 get_encoded_value (unsigned char *data
, int encoding
)
9055 int size
= size_of_encoded_value (encoding
);
9056 if (encoding
& DW_EH_PE_signed
)
9057 return byte_get_signed (data
, size
);
9059 return byte_get (data
, size
);
9062 #define GET(N) byte_get (start, N); start += N
9063 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
9064 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
9067 display_debug_frames (Elf_Internal_Shdr
*section
,
9068 unsigned char *start
,
9069 FILE *file ATTRIBUTE_UNUSED
)
9071 unsigned char *end
= start
+ section
->sh_size
;
9072 unsigned char *section_start
= start
;
9073 Frame_Chunk
*chunks
= 0;
9074 Frame_Chunk
*remembered_state
= 0;
9076 int is_eh
= (strcmp (SECTION_NAME (section
), ".eh_frame") == 0);
9079 int addr_size
= is_32bit_elf
? 4 : 8;
9081 printf (_("The section %s contains:\n"), SECTION_NAME (section
));
9085 unsigned char *saved_start
;
9086 unsigned char *block_end
;
9087 unsigned long length
;
9088 unsigned long cie_id
;
9091 int need_col_headers
= 1;
9092 unsigned char *augmentation_data
= NULL
;
9093 unsigned long augmentation_data_len
= 0;
9094 int encoded_ptr_size
= addr_size
;
9096 int initial_length_size
;
9098 saved_start
= start
;
9099 length
= byte_get (start
, 4); start
+= 4;
9103 printf ("\n%08lx ZERO terminator\n\n",
9104 (unsigned long)(saved_start
- section_start
));
9108 if (length
== 0xffffffff)
9110 length
= byte_get (start
, 8);
9113 initial_length_size
= 12;
9118 initial_length_size
= 4;
9121 block_end
= saved_start
+ length
+ initial_length_size
;
9122 cie_id
= byte_get (start
, offset_size
); start
+= offset_size
;
9124 if (elf_header
.e_type
== ET_REL
9125 && !debug_apply_rela_addends (file
, section
, offset_size
,
9126 section_start
, start
, block_end
))
9129 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
9133 fc
= xmalloc (sizeof (Frame_Chunk
));
9134 memset (fc
, 0, sizeof (Frame_Chunk
));
9138 fc
->chunk_start
= saved_start
;
9140 fc
->col_type
= xmalloc (sizeof (short int));
9141 fc
->col_offset
= xmalloc (sizeof (int));
9142 frame_need_space (fc
, max_regs
-1);
9146 fc
->augmentation
= start
;
9147 start
= strchr (start
, '\0') + 1;
9149 if (fc
->augmentation
[0] == 'z')
9151 fc
->code_factor
= LEB ();
9152 fc
->data_factor
= SLEB ();
9161 augmentation_data_len
= LEB ();
9162 augmentation_data
= start
;
9163 start
+= augmentation_data_len
;
9165 else if (strcmp (fc
->augmentation
, "eh") == 0)
9168 fc
->code_factor
= LEB ();
9169 fc
->data_factor
= SLEB ();
9181 fc
->code_factor
= LEB ();
9182 fc
->data_factor
= SLEB ();
9194 if (do_debug_frames_interp
)
9195 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
9196 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
9197 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
9201 printf ("\n%08lx %08lx %08lx CIE\n",
9202 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
9203 printf (" Version: %d\n", version
);
9204 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
9205 printf (" Code alignment factor: %u\n", fc
->code_factor
);
9206 printf (" Data alignment factor: %d\n", fc
->data_factor
);
9207 printf (" Return address column: %d\n", fc
->ra
);
9209 if (augmentation_data_len
)
9212 printf (" Augmentation data: ");
9213 for (i
= 0; i
< augmentation_data_len
; ++i
)
9214 printf (" %02x", augmentation_data
[i
]);
9220 if (augmentation_data_len
)
9222 unsigned char *p
, *q
;
9223 p
= fc
->augmentation
+ 1;
9224 q
= augmentation_data
;
9231 q
+= 1 + size_of_encoded_value (*q
);
9233 fc
->fde_encoding
= *q
++;
9239 if (fc
->fde_encoding
)
9240 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
9243 frame_need_space (fc
, fc
->ra
);
9247 unsigned char *look_for
;
9248 static Frame_Chunk fde_fc
;
9251 memset (fc
, 0, sizeof (Frame_Chunk
));
9253 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
9255 for (cie
= chunks
; cie
; cie
= cie
->next
)
9256 if (cie
->chunk_start
== look_for
)
9261 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
9262 cie_id
, saved_start
);
9265 fc
->col_type
= xmalloc (sizeof (short int));
9266 fc
->col_offset
= xmalloc (sizeof (int));
9267 frame_need_space (fc
, max_regs
- 1);
9269 fc
->augmentation
= "";
9270 fc
->fde_encoding
= 0;
9274 fc
->ncols
= cie
->ncols
;
9275 fc
->col_type
= xmalloc (fc
->ncols
* sizeof (short int));
9276 fc
->col_offset
= xmalloc (fc
->ncols
* sizeof (int));
9277 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
9278 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
9279 fc
->augmentation
= cie
->augmentation
;
9280 fc
->code_factor
= cie
->code_factor
;
9281 fc
->data_factor
= cie
->data_factor
;
9282 fc
->cfa_reg
= cie
->cfa_reg
;
9283 fc
->cfa_offset
= cie
->cfa_offset
;
9285 frame_need_space (fc
, max_regs
-1);
9286 fc
->fde_encoding
= cie
->fde_encoding
;
9289 if (fc
->fde_encoding
)
9290 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
9292 fc
->pc_begin
= get_encoded_value (start
, fc
->fde_encoding
);
9293 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
9294 /* Don't adjust for ET_REL since there's invariably a pcrel
9295 reloc here, which we haven't applied. */
9296 && elf_header
.e_type
!= ET_REL
)
9297 fc
->pc_begin
+= section
->sh_addr
+ (start
- section_start
);
9298 start
+= encoded_ptr_size
;
9299 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
9300 start
+= encoded_ptr_size
;
9302 if (cie
->augmentation
[0] == 'z')
9304 augmentation_data_len
= LEB ();
9305 augmentation_data
= start
;
9306 start
+= augmentation_data_len
;
9309 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
9310 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
9311 (unsigned long)(cie
->chunk_start
- section_start
),
9312 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
9313 if (! do_debug_frames_interp
&& augmentation_data_len
)
9316 printf (" Augmentation data: ");
9317 for (i
= 0; i
< augmentation_data_len
; ++i
)
9318 printf (" %02x", augmentation_data
[i
]);
9324 /* At this point, fc is the current chunk, cie (if any) is set, and we're
9325 about to interpret instructions for the chunk. */
9326 /* ??? At present we need to do this always, since this sizes the
9327 fc->col_type and fc->col_offset arrays, which we write into always.
9328 We should probably split the interpreted and non-interpreted bits
9329 into two different routines, since there's so much that doesn't
9330 really overlap between them. */
9331 if (1 || do_debug_frames_interp
)
9333 /* Start by making a pass over the chunk, allocating storage
9334 and taking note of what registers are used. */
9335 unsigned char *tmp
= start
;
9337 while (start
< block_end
)
9340 unsigned long reg
, tmp
;
9347 /* Warning: if you add any more cases to this switch, be
9348 sure to add them to the corresponding switch below. */
9351 case DW_CFA_advance_loc
:
9355 frame_need_space (fc
, opa
);
9356 fc
->col_type
[opa
] = DW_CFA_undefined
;
9358 case DW_CFA_restore
:
9359 frame_need_space (fc
, opa
);
9360 fc
->col_type
[opa
] = DW_CFA_undefined
;
9362 case DW_CFA_set_loc
:
9363 start
+= encoded_ptr_size
;
9365 case DW_CFA_advance_loc1
:
9368 case DW_CFA_advance_loc2
:
9371 case DW_CFA_advance_loc4
:
9374 case DW_CFA_offset_extended
:
9375 reg
= LEB (); LEB ();
9376 frame_need_space (fc
, reg
);
9377 fc
->col_type
[reg
] = DW_CFA_undefined
;
9379 case DW_CFA_restore_extended
:
9381 frame_need_space (fc
, reg
);
9382 fc
->col_type
[reg
] = DW_CFA_undefined
;
9384 case DW_CFA_undefined
:
9386 frame_need_space (fc
, reg
);
9387 fc
->col_type
[reg
] = DW_CFA_undefined
;
9389 case DW_CFA_same_value
:
9391 frame_need_space (fc
, reg
);
9392 fc
->col_type
[reg
] = DW_CFA_undefined
;
9394 case DW_CFA_register
:
9395 reg
= LEB (); LEB ();
9396 frame_need_space (fc
, reg
);
9397 fc
->col_type
[reg
] = DW_CFA_undefined
;
9399 case DW_CFA_def_cfa
:
9402 case DW_CFA_def_cfa_register
:
9405 case DW_CFA_def_cfa_offset
:
9408 case DW_CFA_def_cfa_expression
:
9412 case DW_CFA_expression
:
9416 frame_need_space (fc
, reg
);
9417 fc
->col_type
[reg
] = DW_CFA_undefined
;
9419 case DW_CFA_offset_extended_sf
:
9420 reg
= LEB (); SLEB ();
9421 frame_need_space (fc
, reg
);
9422 fc
->col_type
[reg
] = DW_CFA_undefined
;
9424 case DW_CFA_def_cfa_sf
:
9427 case DW_CFA_def_cfa_offset_sf
:
9430 case DW_CFA_MIPS_advance_loc8
:
9433 case DW_CFA_GNU_args_size
:
9436 case DW_CFA_GNU_negative_offset_extended
:
9437 reg
= LEB (); LEB ();
9438 frame_need_space (fc
, reg
);
9439 fc
->col_type
[reg
] = DW_CFA_undefined
;
9448 /* Now we know what registers are used, make a second pass over
9449 the chunk, this time actually printing out the info. */
9451 while (start
< block_end
)
9454 unsigned long ul
, reg
, roffs
;
9463 /* Warning: if you add any more cases to this switch, be
9464 sure to add them to the corresponding switch above. */
9467 case DW_CFA_advance_loc
:
9468 if (do_debug_frames_interp
)
9469 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9471 printf (" DW_CFA_advance_loc: %d to %08lx\n",
9472 opa
* fc
->code_factor
,
9473 fc
->pc_begin
+ opa
* fc
->code_factor
);
9474 fc
->pc_begin
+= opa
* fc
->code_factor
;
9479 if (! do_debug_frames_interp
)
9480 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
9481 opa
, roffs
* fc
->data_factor
);
9482 fc
->col_type
[opa
] = DW_CFA_offset
;
9483 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
9486 case DW_CFA_restore
:
9487 if (! do_debug_frames_interp
)
9488 printf (" DW_CFA_restore: r%d\n", opa
);
9489 fc
->col_type
[opa
] = cie
->col_type
[opa
];
9490 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
9493 case DW_CFA_set_loc
:
9494 vma
= get_encoded_value (start
, fc
->fde_encoding
);
9495 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
9496 && elf_header
.e_type
!= ET_REL
)
9497 vma
+= section
->sh_addr
+ (start
- section_start
);
9498 start
+= encoded_ptr_size
;
9499 if (do_debug_frames_interp
)
9500 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9502 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
9506 case DW_CFA_advance_loc1
:
9507 ofs
= byte_get (start
, 1); start
+= 1;
9508 if (do_debug_frames_interp
)
9509 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9511 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
9512 ofs
* fc
->code_factor
,
9513 fc
->pc_begin
+ ofs
* fc
->code_factor
);
9514 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9517 case DW_CFA_advance_loc2
:
9518 ofs
= byte_get (start
, 2); start
+= 2;
9519 if (do_debug_frames_interp
)
9520 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9522 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
9523 ofs
* fc
->code_factor
,
9524 fc
->pc_begin
+ ofs
* fc
->code_factor
);
9525 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9528 case DW_CFA_advance_loc4
:
9529 ofs
= byte_get (start
, 4); start
+= 4;
9530 if (do_debug_frames_interp
)
9531 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9533 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
9534 ofs
* fc
->code_factor
,
9535 fc
->pc_begin
+ ofs
* fc
->code_factor
);
9536 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9539 case DW_CFA_offset_extended
:
9542 if (! do_debug_frames_interp
)
9543 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
9544 reg
, roffs
* fc
->data_factor
);
9545 fc
->col_type
[reg
] = DW_CFA_offset
;
9546 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
9549 case DW_CFA_restore_extended
:
9551 if (! do_debug_frames_interp
)
9552 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
9553 fc
->col_type
[reg
] = cie
->col_type
[reg
];
9554 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
9557 case DW_CFA_undefined
:
9559 if (! do_debug_frames_interp
)
9560 printf (" DW_CFA_undefined: r%ld\n", reg
);
9561 fc
->col_type
[reg
] = DW_CFA_undefined
;
9562 fc
->col_offset
[reg
] = 0;
9565 case DW_CFA_same_value
:
9567 if (! do_debug_frames_interp
)
9568 printf (" DW_CFA_same_value: r%ld\n", reg
);
9569 fc
->col_type
[reg
] = DW_CFA_same_value
;
9570 fc
->col_offset
[reg
] = 0;
9573 case DW_CFA_register
:
9576 if (! do_debug_frames_interp
)
9577 printf (" DW_CFA_register: r%ld in r%ld\n", reg
, roffs
);
9578 fc
->col_type
[reg
] = DW_CFA_register
;
9579 fc
->col_offset
[reg
] = roffs
;
9582 case DW_CFA_remember_state
:
9583 if (! do_debug_frames_interp
)
9584 printf (" DW_CFA_remember_state\n");
9585 rs
= xmalloc (sizeof (Frame_Chunk
));
9586 rs
->ncols
= fc
->ncols
;
9587 rs
->col_type
= xmalloc (rs
->ncols
* sizeof (short int));
9588 rs
->col_offset
= xmalloc (rs
->ncols
* sizeof (int));
9589 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
9590 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
9591 rs
->next
= remembered_state
;
9592 remembered_state
= rs
;
9595 case DW_CFA_restore_state
:
9596 if (! do_debug_frames_interp
)
9597 printf (" DW_CFA_restore_state\n");
9598 rs
= remembered_state
;
9601 remembered_state
= rs
->next
;
9602 frame_need_space (fc
, rs
->ncols
-1);
9603 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
9604 memcpy (fc
->col_offset
, rs
->col_offset
,
9605 rs
->ncols
* sizeof (int));
9606 free (rs
->col_type
);
9607 free (rs
->col_offset
);
9610 else if (do_debug_frames_interp
)
9611 printf ("Mismatched DW_CFA_restore_state\n");
9614 case DW_CFA_def_cfa
:
9615 fc
->cfa_reg
= LEB ();
9616 fc
->cfa_offset
= LEB ();
9618 if (! do_debug_frames_interp
)
9619 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
9620 fc
->cfa_reg
, fc
->cfa_offset
);
9623 case DW_CFA_def_cfa_register
:
9624 fc
->cfa_reg
= LEB ();
9626 if (! do_debug_frames_interp
)
9627 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
9630 case DW_CFA_def_cfa_offset
:
9631 fc
->cfa_offset
= LEB ();
9632 if (! do_debug_frames_interp
)
9633 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
9637 if (! do_debug_frames_interp
)
9638 printf (" DW_CFA_nop\n");
9641 case DW_CFA_def_cfa_expression
:
9643 if (! do_debug_frames_interp
)
9645 printf (" DW_CFA_def_cfa_expression (");
9646 decode_location_expression (start
, addr_size
, ul
);
9653 case DW_CFA_expression
:
9656 if (! do_debug_frames_interp
)
9658 printf (" DW_CFA_expression: r%ld (", reg
);
9659 decode_location_expression (start
, addr_size
, ul
);
9662 fc
->col_type
[reg
] = DW_CFA_expression
;
9666 case DW_CFA_offset_extended_sf
:
9669 frame_need_space (fc
, reg
);
9670 if (! do_debug_frames_interp
)
9671 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
9672 reg
, l
* fc
->data_factor
);
9673 fc
->col_type
[reg
] = DW_CFA_offset
;
9674 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9677 case DW_CFA_def_cfa_sf
:
9678 fc
->cfa_reg
= LEB ();
9679 fc
->cfa_offset
= SLEB ();
9681 if (! do_debug_frames_interp
)
9682 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
9683 fc
->cfa_reg
, fc
->cfa_offset
);
9686 case DW_CFA_def_cfa_offset_sf
:
9687 fc
->cfa_offset
= SLEB ();
9688 if (! do_debug_frames_interp
)
9689 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
9692 case DW_CFA_MIPS_advance_loc8
:
9693 ofs
= byte_get (start
, 8); start
+= 8;
9694 if (do_debug_frames_interp
)
9695 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9697 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
9698 ofs
* fc
->code_factor
,
9699 fc
->pc_begin
+ ofs
* fc
->code_factor
);
9700 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9703 case DW_CFA_GNU_window_save
:
9704 if (! do_debug_frames_interp
)
9705 printf (" DW_CFA_GNU_window_save\n");
9708 case DW_CFA_GNU_args_size
:
9710 if (! do_debug_frames_interp
)
9711 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
9714 case DW_CFA_GNU_negative_offset_extended
:
9717 frame_need_space (fc
, reg
);
9718 if (! do_debug_frames_interp
)
9719 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
9720 reg
, l
* fc
->data_factor
);
9721 fc
->col_type
[reg
] = DW_CFA_offset
;
9722 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9726 fprintf (stderr
, "unsupported or unknown DW_CFA_%d\n", op
);
9731 if (do_debug_frames_interp
)
9732 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9747 display_debug_not_supported (Elf_Internal_Shdr
*section
,
9748 unsigned char *start ATTRIBUTE_UNUSED
,
9749 FILE *file ATTRIBUTE_UNUSED
)
9751 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
9752 SECTION_NAME (section
));
9757 /* A structure containing the name of a debug section
9758 and a pointer to a function that can decode it. */
9761 const char *const name
;
9762 int (*display
) (Elf_Internal_Shdr
*, unsigned char *, FILE *);
9766 { ".debug_abbrev", display_debug_abbrev
},
9767 { ".debug_aranges", display_debug_aranges
},
9768 { ".debug_frame", display_debug_frames
},
9769 { ".debug_info", display_debug_info
},
9770 { ".debug_line", display_debug_lines
},
9771 { ".debug_pubnames", display_debug_pubnames
},
9772 { ".eh_frame", display_debug_frames
},
9773 { ".debug_macinfo", display_debug_macinfo
},
9774 { ".debug_str", display_debug_str
},
9775 { ".debug_loc", display_debug_loc
},
9776 { ".debug_pubtypes", display_debug_pubnames
},
9777 { ".debug_ranges", display_debug_not_supported
},
9778 { ".debug_static_func", display_debug_not_supported
},
9779 { ".debug_static_vars", display_debug_not_supported
},
9780 { ".debug_types", display_debug_not_supported
},
9781 { ".debug_weaknames", display_debug_not_supported
}
9785 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
9787 char *name
= SECTION_NAME (section
);
9788 bfd_size_type length
;
9789 unsigned char *start
;
9792 length
= section
->sh_size
;
9795 printf (_("\nSection '%s' has no debugging data.\n"), name
);
9799 start
= get_data (NULL
, file
, section
->sh_offset
, length
,
9800 _("debug section data"));
9804 /* See if we know how to display the contents of this section. */
9805 if (strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
9806 name
= ".debug_info";
9808 for (i
= NUM_ELEM (debug_displays
); i
--;)
9809 if (strcmp (debug_displays
[i
].name
, name
) == 0)
9811 debug_displays
[i
].display (section
, start
, file
);
9816 printf (_("Unrecognized debug section: %s\n"), name
);
9820 /* If we loaded in the abbrev section at some point,
9821 we must release it here. */
9828 process_section_contents (FILE *file
)
9830 Elf_Internal_Shdr
*section
;
9836 for (i
= 0, section
= section_headers
;
9837 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
9840 #ifdef SUPPORT_DISASSEMBLY
9841 if (dump_sects
[i
] & DISASS_DUMP
)
9842 disassemble_section (section
, file
);
9844 if (dump_sects
[i
] & HEX_DUMP
)
9845 dump_section (section
, file
);
9847 if (dump_sects
[i
] & DEBUG_DUMP
)
9848 display_debug_section (section
, file
);
9851 if (i
< num_dump_sects
)
9852 warn (_("Some sections were not dumped because they do not exist!\n"));
9858 process_mips_fpe_exception (int mask
)
9863 if (mask
& OEX_FPU_INEX
)
9864 fputs ("INEX", stdout
), first
= 0;
9865 if (mask
& OEX_FPU_UFLO
)
9866 printf ("%sUFLO", first
? "" : "|"), first
= 0;
9867 if (mask
& OEX_FPU_OFLO
)
9868 printf ("%sOFLO", first
? "" : "|"), first
= 0;
9869 if (mask
& OEX_FPU_DIV0
)
9870 printf ("%sDIV0", first
? "" : "|"), first
= 0;
9871 if (mask
& OEX_FPU_INVAL
)
9872 printf ("%sINVAL", first
? "" : "|");
9875 fputs ("0", stdout
);
9879 process_mips_specific (FILE *file
)
9881 Elf_Internal_Dyn
*entry
;
9882 size_t liblist_offset
= 0;
9883 size_t liblistno
= 0;
9884 size_t conflictsno
= 0;
9885 size_t options_offset
= 0;
9886 size_t conflicts_offset
= 0;
9888 /* We have a lot of special sections. Thanks SGI! */
9889 if (dynamic_section
== NULL
)
9890 /* No information available. */
9893 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
9894 switch (entry
->d_tag
)
9896 case DT_MIPS_LIBLIST
:
9898 = offset_from_vma (file
, entry
->d_un
.d_val
,
9899 liblistno
* sizeof (Elf32_External_Lib
));
9901 case DT_MIPS_LIBLISTNO
:
9902 liblistno
= entry
->d_un
.d_val
;
9904 case DT_MIPS_OPTIONS
:
9905 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9907 case DT_MIPS_CONFLICT
:
9909 = offset_from_vma (file
, entry
->d_un
.d_val
,
9910 conflictsno
* sizeof (Elf32_External_Conflict
));
9912 case DT_MIPS_CONFLICTNO
:
9913 conflictsno
= entry
->d_un
.d_val
;
9919 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
9921 Elf32_External_Lib
*elib
;
9924 elib
= get_data (NULL
, file
, liblist_offset
,
9925 liblistno
* sizeof (Elf32_External_Lib
),
9929 printf ("\nSection '.liblist' contains %lu entries:\n",
9930 (unsigned long) liblistno
);
9931 fputs (" Library Time Stamp Checksum Version Flags\n",
9934 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
9941 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9942 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9943 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9944 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9945 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9947 tmp
= gmtime (&time
);
9948 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
9949 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9950 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9952 printf ("%3lu: ", (unsigned long) cnt
);
9953 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
9954 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
9956 printf ("<corrupt: %9ld>", liblist
.l_name
);
9957 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
9960 if (liblist
.l_flags
== 0)
9971 { " EXACT_MATCH", LL_EXACT_MATCH
},
9972 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
9973 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
9974 { " EXPORTS", LL_EXPORTS
},
9975 { " DELAY_LOAD", LL_DELAY_LOAD
},
9976 { " DELTA", LL_DELTA
}
9978 int flags
= liblist
.l_flags
;
9982 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
9984 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
9986 fputs (l_flags_vals
[fcnt
].name
, stdout
);
9987 flags
^= l_flags_vals
[fcnt
].bit
;
9990 printf (" %#x", (unsigned int) flags
);
10000 if (options_offset
!= 0)
10002 Elf_External_Options
*eopt
;
10003 Elf_Internal_Shdr
*sect
= section_headers
;
10004 Elf_Internal_Options
*iopt
;
10005 Elf_Internal_Options
*option
;
10009 /* Find the section header so that we get the size. */
10010 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
10013 eopt
= get_data (NULL
, file
, options_offset
, sect
->sh_size
,
10017 iopt
= malloc ((sect
->sh_size
/ sizeof (eopt
)) * sizeof (*iopt
));
10020 error (_("Out of memory"));
10027 while (offset
< sect
->sh_size
)
10029 Elf_External_Options
*eoption
;
10031 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
10033 option
->kind
= BYTE_GET (eoption
->kind
);
10034 option
->size
= BYTE_GET (eoption
->size
);
10035 option
->section
= BYTE_GET (eoption
->section
);
10036 option
->info
= BYTE_GET (eoption
->info
);
10038 offset
+= option
->size
;
10044 printf (_("\nSection '%s' contains %d entries:\n"),
10045 SECTION_NAME (sect
), cnt
);
10053 switch (option
->kind
)
10056 /* This shouldn't happen. */
10057 printf (" NULL %d %lx", option
->section
, option
->info
);
10060 printf (" REGINFO ");
10061 if (elf_header
.e_machine
== EM_MIPS
)
10064 Elf32_External_RegInfo
*ereg
;
10065 Elf32_RegInfo reginfo
;
10067 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
10068 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
10069 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
10070 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
10071 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
10072 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
10073 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
10075 printf ("GPR %08lx GP 0x%lx\n",
10076 reginfo
.ri_gprmask
,
10077 (unsigned long) reginfo
.ri_gp_value
);
10078 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
10079 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
10080 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
10085 Elf64_External_RegInfo
*ereg
;
10086 Elf64_Internal_RegInfo reginfo
;
10088 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
10089 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
10090 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
10091 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
10092 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
10093 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
10094 reginfo
.ri_gp_value
= BYTE_GET8 (ereg
->ri_gp_value
);
10096 printf ("GPR %08lx GP 0x",
10097 reginfo
.ri_gprmask
);
10098 printf_vma (reginfo
.ri_gp_value
);
10101 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
10102 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
10103 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
10107 case ODK_EXCEPTIONS
:
10108 fputs (" EXCEPTIONS fpe_min(", stdout
);
10109 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
10110 fputs (") fpe_max(", stdout
);
10111 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
10112 fputs (")", stdout
);
10114 if (option
->info
& OEX_PAGE0
)
10115 fputs (" PAGE0", stdout
);
10116 if (option
->info
& OEX_SMM
)
10117 fputs (" SMM", stdout
);
10118 if (option
->info
& OEX_FPDBUG
)
10119 fputs (" FPDBUG", stdout
);
10120 if (option
->info
& OEX_DISMISS
)
10121 fputs (" DISMISS", stdout
);
10124 fputs (" PAD ", stdout
);
10125 if (option
->info
& OPAD_PREFIX
)
10126 fputs (" PREFIX", stdout
);
10127 if (option
->info
& OPAD_POSTFIX
)
10128 fputs (" POSTFIX", stdout
);
10129 if (option
->info
& OPAD_SYMBOL
)
10130 fputs (" SYMBOL", stdout
);
10133 fputs (" HWPATCH ", stdout
);
10134 if (option
->info
& OHW_R4KEOP
)
10135 fputs (" R4KEOP", stdout
);
10136 if (option
->info
& OHW_R8KPFETCH
)
10137 fputs (" R8KPFETCH", stdout
);
10138 if (option
->info
& OHW_R5KEOP
)
10139 fputs (" R5KEOP", stdout
);
10140 if (option
->info
& OHW_R5KCVTL
)
10141 fputs (" R5KCVTL", stdout
);
10144 fputs (" FILL ", stdout
);
10145 /* XXX Print content of info word? */
10148 fputs (" TAGS ", stdout
);
10149 /* XXX Print content of info word? */
10152 fputs (" HWAND ", stdout
);
10153 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
10154 fputs (" R4KEOP_CHECKED", stdout
);
10155 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
10156 fputs (" R4KEOP_CLEAN", stdout
);
10159 fputs (" HWOR ", stdout
);
10160 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
10161 fputs (" R4KEOP_CHECKED", stdout
);
10162 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
10163 fputs (" R4KEOP_CLEAN", stdout
);
10166 printf (" GP_GROUP %#06lx self-contained %#06lx",
10167 option
->info
& OGP_GROUP
,
10168 (option
->info
& OGP_SELF
) >> 16);
10171 printf (" IDENT %#06lx self-contained %#06lx",
10172 option
->info
& OGP_GROUP
,
10173 (option
->info
& OGP_SELF
) >> 16);
10176 /* This shouldn't happen. */
10177 printf (" %3d ??? %d %lx",
10178 option
->kind
, option
->section
, option
->info
);
10182 len
= sizeof (*eopt
);
10183 while (len
< option
->size
)
10184 if (((char *) option
)[len
] >= ' '
10185 && ((char *) option
)[len
] < 0x7f)
10186 printf ("%c", ((char *) option
)[len
++]);
10188 printf ("\\%03o", ((char *) option
)[len
++]);
10190 fputs ("\n", stdout
);
10198 if (conflicts_offset
!= 0 && conflictsno
!= 0)
10200 Elf32_Conflict
*iconf
;
10203 if (dynamic_symbols
== NULL
)
10205 error (_("conflict list found without a dynamic symbol table"));
10209 iconf
= malloc (conflictsno
* sizeof (*iconf
));
10212 error (_("Out of memory"));
10218 Elf32_External_Conflict
*econf32
;
10220 econf32
= get_data (NULL
, file
, conflicts_offset
,
10221 conflictsno
* sizeof (*econf32
), _("conflict"));
10225 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10226 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
10232 Elf64_External_Conflict
*econf64
;
10234 econf64
= get_data (NULL
, file
, conflicts_offset
,
10235 conflictsno
* sizeof (*econf64
), _("conflict"));
10239 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10240 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
10245 printf (_("\nSection '.conflict' contains %lu entries:\n"),
10246 (unsigned long) conflictsno
);
10247 puts (_(" Num: Index Value Name"));
10249 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10251 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
10253 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
10254 print_vma (psym
->st_value
, FULL_HEX
);
10256 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10257 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10259 printf ("<corrupt: %14ld>", psym
->st_name
);
10270 process_gnu_liblist (FILE *file
)
10272 Elf_Internal_Shdr
*section
, *string_sec
;
10273 Elf32_External_Lib
*elib
;
10281 for (i
= 0, section
= section_headers
;
10282 i
< elf_header
.e_shnum
;
10285 switch (section
->sh_type
)
10287 case SHT_GNU_LIBLIST
:
10288 elib
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
10293 string_sec
= SECTION_HEADER (section
->sh_link
);
10295 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
10296 string_sec
->sh_size
, _("liblist string table"));
10299 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
10305 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
10306 SECTION_NAME (section
),
10307 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
10309 puts (" Library Time Stamp Checksum Version Flags");
10311 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
10319 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
10320 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
10321 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
10322 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
10323 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
10325 tmp
= gmtime (&time
);
10326 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
10327 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10328 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10330 printf ("%3lu: ", (unsigned long) cnt
);
10332 printf ("%-20s", strtab
+ liblist
.l_name
);
10334 printf ("%-20.20s", strtab
+ liblist
.l_name
);
10335 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
10336 liblist
.l_version
, liblist
.l_flags
);
10346 static const char *
10347 get_note_type (unsigned e_type
)
10349 static char buff
[64];
10353 case NT_AUXV
: return _("NT_AUXV (auxiliary vector)");
10354 case NT_PRSTATUS
: return _("NT_PRSTATUS (prstatus structure)");
10355 case NT_FPREGSET
: return _("NT_FPREGSET (floating point registers)");
10356 case NT_PRPSINFO
: return _("NT_PRPSINFO (prpsinfo structure)");
10357 case NT_TASKSTRUCT
: return _("NT_TASKSTRUCT (task structure)");
10358 case NT_PRXFPREG
: return _("NT_PRXFPREG (user_xfpregs structure)");
10359 case NT_PSTATUS
: return _("NT_PSTATUS (pstatus structure)");
10360 case NT_FPREGS
: return _("NT_FPREGS (floating point registers)");
10361 case NT_PSINFO
: return _("NT_PSINFO (psinfo structure)");
10362 case NT_LWPSTATUS
: return _("NT_LWPSTATUS (lwpstatus_t structure)");
10363 case NT_LWPSINFO
: return _("NT_LWPSINFO (lwpsinfo_t structure)");
10364 case NT_WIN32PSTATUS
: return _("NT_WIN32PSTATUS (win32_pstatus structure)");
10366 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
10371 static const char *
10372 get_netbsd_elfcore_note_type (unsigned e_type
)
10374 static char buff
[64];
10376 if (e_type
== NT_NETBSDCORE_PROCINFO
)
10378 /* NetBSD core "procinfo" structure. */
10379 return _("NetBSD procinfo structure");
10382 /* As of Jan 2002 there are no other machine-independent notes
10383 defined for NetBSD core files. If the note type is less
10384 than the start of the machine-dependent note types, we don't
10387 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
10389 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
10393 switch (elf_header
.e_machine
)
10395 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
10396 and PT_GETFPREGS == mach+2. */
10401 case EM_SPARC32PLUS
:
10405 case NT_NETBSDCORE_FIRSTMACH
+0:
10406 return _("PT_GETREGS (reg structure)");
10407 case NT_NETBSDCORE_FIRSTMACH
+2:
10408 return _("PT_GETFPREGS (fpreg structure)");
10414 /* On all other arch's, PT_GETREGS == mach+1 and
10415 PT_GETFPREGS == mach+3. */
10419 case NT_NETBSDCORE_FIRSTMACH
+1:
10420 return _("PT_GETREGS (reg structure)");
10421 case NT_NETBSDCORE_FIRSTMACH
+3:
10422 return _("PT_GETFPREGS (fpreg structure)");
10428 sprintf (buff
, _("PT_FIRSTMACH+%d"), e_type
- NT_NETBSDCORE_FIRSTMACH
);
10432 /* Note that by the ELF standard, the name field is already null byte
10433 terminated, and namesz includes the terminating null byte.
10434 I.E. the value of namesz for the name "FSF" is 4.
10436 If the value of namesz is zero, there is no name present. */
10438 process_note (Elf_Internal_Note
*pnote
)
10442 if (pnote
->namesz
== 0)
10444 /* If there is no note name, then use the default set of
10445 note type strings. */
10446 nt
= get_note_type (pnote
->type
);
10448 else if (strncmp (pnote
->namedata
, "NetBSD-CORE", 11) == 0)
10450 /* NetBSD-specific core file notes. */
10451 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
10455 /* Don't recognize this note name; just use the default set of
10456 note type strings. */
10457 nt
= get_note_type (pnote
->type
);
10460 printf (" %s\t\t0x%08lx\t%s\n",
10461 pnote
->namesz
? pnote
->namedata
: "(NONE)",
10462 pnote
->descsz
, nt
);
10468 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
10470 Elf_External_Note
*pnotes
;
10471 Elf_External_Note
*external
;
10477 pnotes
= get_data (NULL
, file
, offset
, length
, _("notes"));
10483 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
10484 (unsigned long) offset
, (unsigned long) length
);
10485 printf (_(" Owner\t\tData size\tDescription\n"));
10487 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
10489 Elf_External_Note
*next
;
10490 Elf_Internal_Note inote
;
10493 inote
.type
= BYTE_GET (external
->type
);
10494 inote
.namesz
= BYTE_GET (external
->namesz
);
10495 inote
.namedata
= external
->name
;
10496 inote
.descsz
= BYTE_GET (external
->descsz
);
10497 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
10498 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
10500 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
10502 if (((char *) next
) > (((char *) pnotes
) + length
))
10504 warn (_("corrupt note found at offset %x into core notes\n"),
10505 ((char *) external
) - ((char *) pnotes
));
10506 warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
10507 inote
.type
, inote
.namesz
, inote
.descsz
);
10513 /* Verify that name is null terminated. It appears that at least
10514 one version of Linux (RedHat 6.0) generates corefiles that don't
10515 comply with the ELF spec by failing to include the null byte in
10517 if (inote
.namedata
[inote
.namesz
] != '\0')
10519 temp
= malloc (inote
.namesz
+ 1);
10523 error (_("Out of memory\n"));
10528 strncpy (temp
, inote
.namedata
, inote
.namesz
);
10529 temp
[inote
.namesz
] = 0;
10531 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
10532 inote
.namedata
= temp
;
10535 res
&= process_note (& inote
);
10550 process_corefile_note_segments (FILE *file
)
10552 Elf_Internal_Phdr
*segment
;
10556 if (! get_program_headers (file
))
10559 for (i
= 0, segment
= program_headers
;
10560 i
< elf_header
.e_phnum
;
10563 if (segment
->p_type
== PT_NOTE
)
10564 res
&= process_corefile_note_segment (file
,
10565 (bfd_vma
) segment
->p_offset
,
10566 (bfd_vma
) segment
->p_filesz
);
10573 process_corefile_contents (FILE *file
)
10575 /* If we have not been asked to display the notes then do nothing. */
10579 /* If file is not a core file then exit. */
10580 if (elf_header
.e_type
!= ET_CORE
)
10583 /* No program headers means no NOTE segment. */
10584 if (elf_header
.e_phnum
== 0)
10586 printf (_("No note segments present in the core file.\n"));
10590 return process_corefile_note_segments (file
);
10594 process_arch_specific (FILE *file
)
10599 switch (elf_header
.e_machine
)
10602 case EM_MIPS_RS3_LE
:
10603 return process_mips_specific (file
);
10612 get_file_header (FILE *file
)
10614 /* Read in the identity array. */
10615 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
10618 /* Determine how to read the rest of the header. */
10619 switch (elf_header
.e_ident
[EI_DATA
])
10621 default: /* fall through */
10622 case ELFDATANONE
: /* fall through */
10624 byte_get
= byte_get_little_endian
;
10625 byte_put
= byte_put_little_endian
;
10628 byte_get
= byte_get_big_endian
;
10629 byte_put
= byte_put_big_endian
;
10633 /* For now we only support 32 bit and 64 bit ELF files. */
10634 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
10636 /* Read in the rest of the header. */
10639 Elf32_External_Ehdr ehdr32
;
10641 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
10644 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
10645 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
10646 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
10647 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
10648 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
10649 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
10650 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
10651 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
10652 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
10653 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
10654 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
10655 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
10656 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
10660 Elf64_External_Ehdr ehdr64
;
10662 /* If we have been compiled with sizeof (bfd_vma) == 4, then
10663 we will not be able to cope with the 64bit data found in
10664 64 ELF files. Detect this now and abort before we start
10665 overwriting things. */
10666 if (sizeof (bfd_vma
) < 8)
10668 error (_("This instance of readelf has been built without support for a\n\
10669 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10673 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
10676 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
10677 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
10678 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
10679 elf_header
.e_entry
= BYTE_GET8 (ehdr64
.e_entry
);
10680 elf_header
.e_phoff
= BYTE_GET8 (ehdr64
.e_phoff
);
10681 elf_header
.e_shoff
= BYTE_GET8 (ehdr64
.e_shoff
);
10682 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
10683 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
10684 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
10685 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
10686 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
10687 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
10688 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
10691 if (elf_header
.e_shoff
)
10693 /* There may be some extensions in the first section header. Don't
10694 bomb if we can't read it. */
10696 get_32bit_section_headers (file
, 1);
10698 get_64bit_section_headers (file
, 1);
10704 /* Process one ELF object file according to the command line options.
10705 This file may actually be stored in an archive. The file is
10706 positioned at the start of the ELF object. */
10709 process_object (char *file_name
, FILE *file
)
10713 if (! get_file_header (file
))
10715 error (_("%s: Failed to read file header\n"), file_name
);
10719 /* Initialise per file variables. */
10720 for (i
= NUM_ELEM (version_info
); i
--;)
10721 version_info
[i
] = 0;
10723 for (i
= NUM_ELEM (dynamic_info
); i
--;)
10724 dynamic_info
[i
] = 0;
10726 /* Process the file. */
10728 printf (_("\nFile: %s\n"), file_name
);
10730 if (! process_file_header ())
10733 if (! process_section_headers (file
)
10734 || ! process_section_groups (file
))
10736 /* Without loaded section headers and section groups we
10737 cannot process lots of things. */
10738 do_unwind
= do_version
= do_dump
= do_arch
= 0;
10740 if (! do_using_dynamic
)
10741 do_syms
= do_reloc
= 0;
10744 if (process_program_headers (file
))
10745 process_dynamic_section (file
);
10747 process_relocs (file
);
10749 process_unwind (file
);
10751 process_symbol_table (file
);
10753 process_syminfo (file
);
10755 process_version_sections (file
);
10757 process_section_contents (file
);
10759 process_corefile_contents (file
);
10761 process_gnu_liblist (file
);
10763 process_arch_specific (file
);
10765 if (program_headers
)
10767 free (program_headers
);
10768 program_headers
= NULL
;
10771 if (section_headers
)
10773 free (section_headers
);
10774 section_headers
= NULL
;
10779 free (string_table
);
10780 string_table
= NULL
;
10781 string_table_length
= 0;
10784 if (dynamic_strings
)
10786 free (dynamic_strings
);
10787 dynamic_strings
= NULL
;
10788 dynamic_strings_length
= 0;
10791 if (dynamic_symbols
)
10793 free (dynamic_symbols
);
10794 dynamic_symbols
= NULL
;
10795 num_dynamic_syms
= 0;
10798 if (dynamic_syminfo
)
10800 free (dynamic_syminfo
);
10801 dynamic_syminfo
= NULL
;
10804 if (section_headers_groups
)
10806 free (section_headers_groups
);
10807 section_headers_groups
= NULL
;
10810 if (section_groups
)
10812 struct group_list
*g
, *next
;
10814 for (i
= 0; i
< group_count
; i
++)
10816 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
10823 free (section_groups
);
10824 section_groups
= NULL
;
10830 /* Process an ELF archive. The file is positioned just after the
10834 process_archive (char *file_name
, FILE *file
)
10836 struct ar_hdr arhdr
;
10838 unsigned long size
;
10839 char *longnames
= NULL
;
10840 unsigned long longnames_size
= 0;
10841 size_t file_name_size
;
10846 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10847 if (got
!= sizeof arhdr
)
10852 error (_("%s: failed to read archive header\n"), file_name
);
10856 if (memcmp (arhdr
.ar_name
, "/ ", 16) == 0)
10858 /* This is the archive symbol table. Skip it.
10859 FIXME: We should have an option to dump it. */
10860 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10861 if (fseek (file
, size
+ (size
& 1), SEEK_CUR
) != 0)
10863 error (_("%s: failed to skip archive symbol table\n"), file_name
);
10867 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10868 if (got
!= sizeof arhdr
)
10873 error (_("%s: failed to read archive header\n"), file_name
);
10878 if (memcmp (arhdr
.ar_name
, "// ", 16) == 0)
10880 /* This is the archive string table holding long member
10883 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10885 longnames
= malloc (longnames_size
);
10886 if (longnames
== NULL
)
10888 error (_("Out of memory\n"));
10892 if (fread (longnames
, longnames_size
, 1, file
) != 1)
10895 error(_("%s: failed to read string table\n"), file_name
);
10899 if ((longnames_size
& 1) != 0)
10902 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10903 if (got
!= sizeof arhdr
)
10910 error (_("%s: failed to read archive header\n"), file_name
);
10915 file_name_size
= strlen (file_name
);
10924 if (arhdr
.ar_name
[0] == '/')
10928 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
10929 if (off
>= longnames_size
)
10931 error (_("%s: invalid archive string table offset %lu\n"), off
);
10936 name
= longnames
+ off
;
10937 nameend
= memchr (name
, '/', longnames_size
- off
);
10941 name
= arhdr
.ar_name
;
10942 nameend
= memchr (name
, '/', 16);
10945 if (nameend
== NULL
)
10947 error (_("%s: bad archive file name\n"));
10952 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
10953 if (namealc
== NULL
)
10955 error (_("Out of memory\n"));
10960 memcpy (namealc
, file_name
, file_name_size
);
10961 namealc
[file_name_size
] = '(';
10962 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
10963 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
10964 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
10966 archive_file_offset
= ftell (file
);
10967 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10969 ret
|= process_object (namealc
, file
);
10974 (archive_file_offset
10975 + archive_file_size
10976 + (archive_file_size
& 1)),
10979 error (_("%s: failed to seek to next archive header\n"), file_name
);
10984 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10985 if (got
!= sizeof arhdr
)
10990 error (_("%s: failed to read archive header\n"), file_name
);
10996 if (longnames
!= 0)
11003 process_file (char *file_name
)
11006 struct stat statbuf
;
11007 char armag
[SARMAG
];
11010 if (stat (file_name
, &statbuf
) < 0)
11012 if (errno
== ENOENT
)
11013 error (_("'%s': No such file\n"), file_name
);
11015 error (_("Could not locate '%s'. System error message: %s\n"),
11016 file_name
, strerror (errno
));
11020 if (! S_ISREG (statbuf
.st_mode
))
11022 error (_("'%s' is not an ordinary file\n"), file_name
);
11026 file
= fopen (file_name
, "rb");
11029 error (_("Input file '%s' is not readable.\n"), file_name
);
11033 if (fread (armag
, SARMAG
, 1, file
) != 1)
11035 error (_("%s: Failed to read file header\n"), file_name
);
11040 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
11041 ret
= process_archive (file_name
, file
);
11045 archive_file_size
= archive_file_offset
= 0;
11046 ret
= process_object (file_name
, file
);
11054 #ifdef SUPPORT_DISASSEMBLY
11055 /* Needed by the i386 disassembler. For extra credit, someone could
11056 fix this so that we insert symbolic addresses here, esp for GOT/PLT
11060 print_address (unsigned int addr
, FILE *outfile
)
11062 fprintf (outfile
,"0x%8.8x", addr
);
11065 /* Needed by the i386 disassembler. */
11067 db_task_printsym (unsigned int addr
)
11069 print_address (addr
, stderr
);
11074 main (int argc
, char **argv
)
11077 char *cmdline_dump_sects
= NULL
;
11078 unsigned num_cmdline_dump_sects
= 0;
11080 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
11081 setlocale (LC_MESSAGES
, "");
11083 #if defined (HAVE_SETLOCALE)
11084 setlocale (LC_CTYPE
, "");
11086 bindtextdomain (PACKAGE
, LOCALEDIR
);
11087 textdomain (PACKAGE
);
11089 parse_args (argc
, argv
);
11091 if (optind
< (argc
- 1))
11094 /* When processing more than one file remember the dump requests
11095 issued on command line to reset them after each file. */
11096 if (optind
+ 1 < argc
&& dump_sects
!= NULL
)
11098 cmdline_dump_sects
= malloc (num_dump_sects
);
11099 if (cmdline_dump_sects
== NULL
)
11100 error (_("Out of memory allocating dump request table."));
11103 memcpy (cmdline_dump_sects
, dump_sects
, num_dump_sects
);
11104 num_cmdline_dump_sects
= num_dump_sects
;
11109 while (optind
< argc
)
11111 err
|= process_file (argv
[optind
++]);
11113 /* Reset dump requests. */
11114 if (optind
< argc
&& dump_sects
!= NULL
)
11116 num_dump_sects
= num_cmdline_dump_sects
;
11117 if (num_cmdline_dump_sects
> 0)
11118 memcpy (dump_sects
, cmdline_dump_sects
, num_cmdline_dump_sects
);
11122 if (dump_sects
!= NULL
)
11124 if (cmdline_dump_sects
!= NULL
)
11125 free (cmdline_dump_sects
);