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
);
4425 if (ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
4427 warn (_("Skipping unexpected symbol type %u\n"),
4428 ELF32_ST_TYPE (sym
->st_info
));
4434 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4435 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4437 if (ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
4439 warn (_("Skipping unexpected symbol type %u\n"),
4440 ELF64_ST_TYPE (sym
->st_info
));
4445 if (strncmp (relname
, "R_IA64_SEGREL", 13) != 0)
4447 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4451 i
= rp
->r_offset
/ (3 * addr_size
);
4453 switch (rp
->r_offset
/addr_size
% 3)
4456 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4457 aux
->table
[i
].start
.offset
+= rp
->r_addend
;
4460 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4461 aux
->table
[i
].end
.offset
+= rp
->r_addend
;
4464 aux
->table
[i
].info
.section
= sym
->st_shndx
;
4465 aux
->table
[i
].info
.offset
+= rp
->r_addend
;
4475 aux
->table_len
= size
/ (3 * addr_size
);
4480 process_unwind (FILE *file
)
4482 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
4483 unsigned long i
, addr_size
, unwcount
= 0, unwstart
= 0;
4484 struct unw_aux_info aux
;
4489 if (elf_header
.e_machine
!= EM_IA_64
)
4491 printf (_("\nThere are no unwind sections in this file.\n"));
4495 memset (& aux
, 0, sizeof (aux
));
4497 addr_size
= is_32bit_elf
? 4 : 8;
4499 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4501 if (sec
->sh_type
== SHT_SYMTAB
)
4503 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
4504 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
4506 strsec
= SECTION_HEADER (sec
->sh_link
);
4507 aux
.strtab_size
= strsec
->sh_size
;
4508 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4509 aux
.strtab_size
, _("string table"));
4511 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4516 printf (_("\nThere are no unwind sections in this file.\n"));
4518 while (unwcount
-- > 0)
4523 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
4524 i
< elf_header
.e_shnum
; ++i
, ++sec
)
4525 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4532 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
4534 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
4536 /* We need to find which section group it is in. */
4537 struct group_list
*g
= section_headers_groups
[i
]->root
;
4539 for (; g
!= NULL
; g
= g
->next
)
4541 sec
= SECTION_HEADER (g
->section_index
);
4542 if (strcmp (SECTION_NAME (sec
),
4543 ELF_STRING_ia64_unwind_info
) == 0)
4548 i
= elf_header
.e_shnum
;
4550 else if (strncmp (SECTION_NAME (unwsec
),
4551 ELF_STRING_ia64_unwind_once
, len
) == 0)
4553 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO */
4554 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
4555 suffix
= SECTION_NAME (unwsec
) + len
;
4556 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4558 if (strncmp (SECTION_NAME (sec
),
4559 ELF_STRING_ia64_unwind_info_once
, len2
) == 0
4560 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
4565 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
4566 .IA_64.unwind or BAR -> .IA_64.unwind_info */
4567 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
4568 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
4570 if (strncmp (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
,
4572 suffix
= SECTION_NAME (unwsec
) + len
;
4573 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4575 if (strncmp (SECTION_NAME (sec
),
4576 ELF_STRING_ia64_unwind_info
, len2
) == 0
4577 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
4581 if (i
== elf_header
.e_shnum
)
4583 printf (_("\nCould not find unwind info section for "));
4585 if (string_table
== NULL
)
4586 printf ("%d", unwsec
->sh_name
);
4588 printf (_("'%s'"), SECTION_NAME (unwsec
));
4592 aux
.info_size
= sec
->sh_size
;
4593 aux
.info_addr
= sec
->sh_addr
;
4594 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, aux
.info_size
,
4597 printf (_("\nUnwind section "));
4599 if (string_table
== NULL
)
4600 printf ("%d", unwsec
->sh_name
);
4602 printf (_("'%s'"), SECTION_NAME (unwsec
));
4604 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4605 (unsigned long) unwsec
->sh_offset
,
4606 (unsigned long) (unwsec
->sh_size
/ (3 * addr_size
)));
4608 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
4610 if (aux
.table_len
> 0)
4611 dump_ia64_unwind (& aux
);
4614 free ((char *) aux
.table
);
4616 free ((char *) aux
.info
);
4625 free ((char *) aux
.strtab
);
4631 dynamic_section_mips_val (Elf_Internal_Dyn
*entry
)
4633 switch (entry
->d_tag
)
4636 if (entry
->d_un
.d_val
== 0)
4640 static const char * opts
[] =
4642 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
4643 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
4644 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
4645 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
4650 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++cnt
)
4651 if (entry
->d_un
.d_val
& (1 << cnt
))
4653 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
4660 case DT_MIPS_IVERSION
:
4661 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
4662 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
4664 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
4667 case DT_MIPS_TIME_STAMP
:
4672 time_t time
= entry
->d_un
.d_val
;
4673 tmp
= gmtime (&time
);
4674 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
4675 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
4676 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
4677 printf ("Time Stamp: %s\n", timebuf
);
4681 case DT_MIPS_RLD_VERSION
:
4682 case DT_MIPS_LOCAL_GOTNO
:
4683 case DT_MIPS_CONFLICTNO
:
4684 case DT_MIPS_LIBLISTNO
:
4685 case DT_MIPS_SYMTABNO
:
4686 case DT_MIPS_UNREFEXTNO
:
4687 case DT_MIPS_HIPAGENO
:
4688 case DT_MIPS_DELTA_CLASS_NO
:
4689 case DT_MIPS_DELTA_INSTANCE_NO
:
4690 case DT_MIPS_DELTA_RELOC_NO
:
4691 case DT_MIPS_DELTA_SYM_NO
:
4692 case DT_MIPS_DELTA_CLASSSYM_NO
:
4693 case DT_MIPS_COMPACT_SIZE
:
4694 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
4698 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
4704 dynamic_section_parisc_val (Elf_Internal_Dyn
*entry
)
4706 switch (entry
->d_tag
)
4708 case DT_HP_DLD_FLAGS
:
4717 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
4718 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
4719 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
4720 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
4721 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
4722 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
4723 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
4724 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
4725 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
4726 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
4727 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
4731 bfd_vma val
= entry
->d_un
.d_val
;
4733 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
4734 if (val
& flags
[cnt
].bit
)
4738 fputs (flags
[cnt
].str
, stdout
);
4740 val
^= flags
[cnt
].bit
;
4743 if (val
!= 0 || first
)
4747 print_vma (val
, HEX
);
4753 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
4760 dynamic_section_ia64_val (Elf_Internal_Dyn
*entry
)
4762 switch (entry
->d_tag
)
4764 case DT_IA_64_PLT_RESERVE
:
4765 /* First 3 slots reserved. */
4766 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
4768 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
4772 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
4779 get_32bit_dynamic_section (FILE *file
)
4781 Elf32_External_Dyn
*edyn
, *ext
;
4782 Elf_Internal_Dyn
*entry
;
4784 edyn
= get_data (NULL
, file
, dynamic_addr
, dynamic_size
,
4785 _("dynamic section"));
4789 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
4790 might not have the luxury of section headers. Look for the DT_NULL
4791 terminator to determine the number of entries. */
4792 for (ext
= edyn
, dynamic_nent
= 0;
4793 (char *) ext
< (char *) edyn
+ dynamic_size
;
4797 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
4801 dynamic_section
= malloc (dynamic_nent
* sizeof (*entry
));
4802 if (dynamic_section
== NULL
)
4804 error (_("Out of memory\n"));
4809 for (ext
= edyn
, entry
= dynamic_section
;
4810 entry
< dynamic_section
+ dynamic_nent
;
4813 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
4814 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
4823 get_64bit_dynamic_section (FILE *file
)
4825 Elf64_External_Dyn
*edyn
, *ext
;
4826 Elf_Internal_Dyn
*entry
;
4828 edyn
= get_data (NULL
, file
, dynamic_addr
, dynamic_size
,
4829 _("dynamic section"));
4833 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
4834 might not have the luxury of section headers. Look for the DT_NULL
4835 terminator to determine the number of entries. */
4836 for (ext
= edyn
, dynamic_nent
= 0;
4837 (char *) ext
< (char *) edyn
+ dynamic_size
;
4841 if (BYTE_GET8 (ext
->d_tag
) == DT_NULL
)
4845 dynamic_section
= malloc (dynamic_nent
* sizeof (*entry
));
4846 if (dynamic_section
== NULL
)
4848 error (_("Out of memory\n"));
4853 for (ext
= edyn
, entry
= dynamic_section
;
4854 entry
< dynamic_section
+ dynamic_nent
;
4857 entry
->d_tag
= BYTE_GET8 (ext
->d_tag
);
4858 entry
->d_un
.d_val
= BYTE_GET8 (ext
->d_un
.d_val
);
4867 get_dynamic_flags (bfd_vma flags
)
4869 static char buff
[128];
4877 flag
= flags
& - flags
;
4885 case DF_ORIGIN
: strcpy (p
, "ORIGIN"); break;
4886 case DF_SYMBOLIC
: strcpy (p
, "SYMBOLIC"); break;
4887 case DF_TEXTREL
: strcpy (p
, "TEXTREL"); break;
4888 case DF_BIND_NOW
: strcpy (p
, "BIND_NOW"); break;
4889 case DF_STATIC_TLS
: strcpy (p
, "STATIC_TLS"); break;
4890 default: strcpy (p
, "unknown"); break;
4893 p
= strchr (p
, '\0');
4898 /* Parse and display the contents of the dynamic section. */
4901 process_dynamic_section (FILE *file
)
4903 Elf_Internal_Dyn
*entry
;
4905 if (dynamic_size
== 0)
4908 printf (_("\nThere is no dynamic section in this file.\n"));
4915 if (! get_32bit_dynamic_section (file
))
4918 else if (! get_64bit_dynamic_section (file
))
4921 /* Find the appropriate symbol table. */
4922 if (dynamic_symbols
== NULL
)
4924 for (entry
= dynamic_section
;
4925 entry
< dynamic_section
+ dynamic_nent
;
4928 Elf_Internal_Shdr section
;
4930 if (entry
->d_tag
!= DT_SYMTAB
)
4933 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
4935 /* Since we do not know how big the symbol table is,
4936 we default to reading in the entire file (!) and
4937 processing that. This is overkill, I know, but it
4939 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
4941 if (archive_file_offset
!= 0)
4942 section
.sh_size
= archive_file_size
- section
.sh_offset
;
4945 if (fseek (file
, 0, SEEK_END
))
4946 error (_("Unable to seek to end of file!"));
4948 section
.sh_size
= ftell (file
) - section
.sh_offset
;
4952 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
4954 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
4956 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
4957 if (num_dynamic_syms
< 1)
4959 error (_("Unable to determine the number of symbols to load\n"));
4963 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
4967 /* Similarly find a string table. */
4968 if (dynamic_strings
== NULL
)
4970 for (entry
= dynamic_section
;
4971 entry
< dynamic_section
+ dynamic_nent
;
4974 unsigned long offset
;
4977 if (entry
->d_tag
!= DT_STRTAB
)
4980 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
4982 /* Since we do not know how big the string table is,
4983 we default to reading in the entire file (!) and
4984 processing that. This is overkill, I know, but it
4987 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
4989 if (archive_file_offset
!= 0)
4990 str_tab_len
= archive_file_size
- offset
;
4993 if (fseek (file
, 0, SEEK_END
))
4994 error (_("Unable to seek to end of file\n"));
4995 str_tab_len
= ftell (file
) - offset
;
4998 if (str_tab_len
< 1)
5001 (_("Unable to determine the length of the dynamic string table\n"));
5005 dynamic_strings
= get_data (NULL
, file
, offset
, str_tab_len
,
5006 _("dynamic string table"));
5007 dynamic_strings_length
= str_tab_len
;
5012 /* And find the syminfo section if available. */
5013 if (dynamic_syminfo
== NULL
)
5015 unsigned long syminsz
= 0;
5017 for (entry
= dynamic_section
;
5018 entry
< dynamic_section
+ dynamic_nent
;
5021 if (entry
->d_tag
== DT_SYMINENT
)
5023 /* Note: these braces are necessary to avoid a syntax
5024 error from the SunOS4 C compiler. */
5025 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
5027 else if (entry
->d_tag
== DT_SYMINSZ
)
5028 syminsz
= entry
->d_un
.d_val
;
5029 else if (entry
->d_tag
== DT_SYMINFO
)
5030 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
5034 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
5036 Elf_External_Syminfo
*extsyminfo
, *extsym
;
5037 Elf_Internal_Syminfo
*syminfo
;
5039 /* There is a syminfo section. Read the data. */
5040 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, syminsz
,
5041 _("symbol information"));
5045 dynamic_syminfo
= malloc (syminsz
);
5046 if (dynamic_syminfo
== NULL
)
5048 error (_("Out of memory\n"));
5052 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
5053 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
5054 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
5055 ++syminfo
, ++extsym
)
5057 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
5058 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
5065 if (do_dynamic
&& dynamic_addr
)
5066 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
5067 dynamic_addr
, dynamic_nent
);
5069 printf (_(" Tag Type Name/Value\n"));
5071 for (entry
= dynamic_section
;
5072 entry
< dynamic_section
+ dynamic_nent
;
5080 print_vma (entry
->d_tag
, FULL_HEX
);
5081 dtype
= get_dynamic_type (entry
->d_tag
);
5082 printf (" (%s)%*s", dtype
,
5083 ((is_32bit_elf
? 27 : 19)
5084 - (int) strlen (dtype
)),
5088 switch (entry
->d_tag
)
5092 puts (get_dynamic_flags (entry
->d_un
.d_val
));
5102 switch (entry
->d_tag
)
5105 printf (_("Auxiliary library"));
5109 printf (_("Filter library"));
5113 printf (_("Configuration file"));
5117 printf (_("Dependency audit library"));
5121 printf (_("Audit library"));
5125 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5126 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5130 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5139 printf (_("Flags:"));
5141 if (entry
->d_un
.d_val
== 0)
5142 printf (_(" None\n"));
5145 unsigned long int val
= entry
->d_un
.d_val
;
5147 if (val
& DTF_1_PARINIT
)
5149 printf (" PARINIT");
5150 val
^= DTF_1_PARINIT
;
5152 if (val
& DTF_1_CONFEXP
)
5154 printf (" CONFEXP");
5155 val
^= DTF_1_CONFEXP
;
5158 printf (" %lx", val
);
5167 printf (_("Flags:"));
5169 if (entry
->d_un
.d_val
== 0)
5170 printf (_(" None\n"));
5173 unsigned long int val
= entry
->d_un
.d_val
;
5175 if (val
& DF_P1_LAZYLOAD
)
5177 printf (" LAZYLOAD");
5178 val
^= DF_P1_LAZYLOAD
;
5180 if (val
& DF_P1_GROUPPERM
)
5182 printf (" GROUPPERM");
5183 val
^= DF_P1_GROUPPERM
;
5186 printf (" %lx", val
);
5195 printf (_("Flags:"));
5196 if (entry
->d_un
.d_val
== 0)
5197 printf (_(" None\n"));
5200 unsigned long int val
= entry
->d_un
.d_val
;
5207 if (val
& DF_1_GLOBAL
)
5212 if (val
& DF_1_GROUP
)
5217 if (val
& DF_1_NODELETE
)
5219 printf (" NODELETE");
5220 val
^= DF_1_NODELETE
;
5222 if (val
& DF_1_LOADFLTR
)
5224 printf (" LOADFLTR");
5225 val
^= DF_1_LOADFLTR
;
5227 if (val
& DF_1_INITFIRST
)
5229 printf (" INITFIRST");
5230 val
^= DF_1_INITFIRST
;
5232 if (val
& DF_1_NOOPEN
)
5237 if (val
& DF_1_ORIGIN
)
5242 if (val
& DF_1_DIRECT
)
5247 if (val
& DF_1_TRANS
)
5252 if (val
& DF_1_INTERPOSE
)
5254 printf (" INTERPOSE");
5255 val
^= DF_1_INTERPOSE
;
5257 if (val
& DF_1_NODEFLIB
)
5259 printf (" NODEFLIB");
5260 val
^= DF_1_NODEFLIB
;
5262 if (val
& DF_1_NODUMP
)
5267 if (val
& DF_1_CONLFAT
)
5269 printf (" CONLFAT");
5270 val
^= DF_1_CONLFAT
;
5273 printf (" %lx", val
);
5280 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5282 puts (get_dynamic_type (entry
->d_un
.d_val
));
5302 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5308 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5309 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
5315 switch (entry
->d_tag
)
5318 printf (_("Shared library: [%s]"), name
);
5320 if (strcmp (name
, program_interpreter
) == 0)
5321 printf (_(" program interpreter"));
5325 printf (_("Library soname: [%s]"), name
);
5329 printf (_("Library rpath: [%s]"), name
);
5333 printf (_("Library runpath: [%s]"), name
);
5337 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5342 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5355 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5359 case DT_INIT_ARRAYSZ
:
5360 case DT_FINI_ARRAYSZ
:
5361 case DT_GNU_CONFLICTSZ
:
5362 case DT_GNU_LIBLISTSZ
:
5365 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5366 printf (" (bytes)\n");
5376 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5389 if (entry
->d_tag
== DT_USED
5390 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5392 char *name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
5396 printf (_("Not needed object: [%s]\n"), name
);
5401 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5407 /* The value of this entry is ignored. */
5412 case DT_GNU_PRELINKED
:
5416 time_t time
= entry
->d_un
.d_val
;
5418 tmp
= gmtime (&time
);
5419 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
5420 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5421 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5427 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
5428 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
5433 switch (elf_header
.e_machine
)
5436 case EM_MIPS_RS3_LE
:
5437 dynamic_section_mips_val (entry
);
5440 dynamic_section_parisc_val (entry
);
5443 dynamic_section_ia64_val (entry
);
5446 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5458 get_ver_flags (unsigned int flags
)
5460 static char buff
[32];
5467 if (flags
& VER_FLG_BASE
)
5468 strcat (buff
, "BASE ");
5470 if (flags
& VER_FLG_WEAK
)
5472 if (flags
& VER_FLG_BASE
)
5473 strcat (buff
, "| ");
5475 strcat (buff
, "WEAK ");
5478 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
5479 strcat (buff
, "| <unknown>");
5484 /* Display the contents of the version sections. */
5486 process_version_sections (FILE *file
)
5488 Elf_Internal_Shdr
*section
;
5495 for (i
= 0, section
= section_headers
;
5496 i
< elf_header
.e_shnum
;
5499 switch (section
->sh_type
)
5501 case SHT_GNU_verdef
:
5503 Elf_External_Verdef
*edefs
;
5510 (_("\nVersion definition section '%s' contains %ld entries:\n"),
5511 SECTION_NAME (section
), section
->sh_info
);
5513 printf (_(" Addr: 0x"));
5514 printf_vma (section
->sh_addr
);
5515 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5516 (unsigned long) section
->sh_offset
, section
->sh_link
,
5517 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
5519 edefs
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
5520 _("version definition section"));
5524 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
5527 Elf_External_Verdef
*edef
;
5528 Elf_Internal_Verdef ent
;
5529 Elf_External_Verdaux
*eaux
;
5530 Elf_Internal_Verdaux aux
;
5534 vstart
= ((char *) edefs
) + idx
;
5536 edef
= (Elf_External_Verdef
*) vstart
;
5538 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
5539 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
5540 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
5541 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
5542 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
5543 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
5544 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
5546 printf (_(" %#06x: Rev: %d Flags: %s"),
5547 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
5549 printf (_(" Index: %d Cnt: %d "),
5550 ent
.vd_ndx
, ent
.vd_cnt
);
5552 vstart
+= ent
.vd_aux
;
5554 eaux
= (Elf_External_Verdaux
*) vstart
;
5556 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
5557 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
5559 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
5560 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
5562 printf (_("Name index: %ld\n"), aux
.vda_name
);
5564 isum
= idx
+ ent
.vd_aux
;
5566 for (j
= 1; j
< ent
.vd_cnt
; j
++)
5568 isum
+= aux
.vda_next
;
5569 vstart
+= aux
.vda_next
;
5571 eaux
= (Elf_External_Verdaux
*) vstart
;
5573 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
5574 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
5576 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
5577 printf (_(" %#06x: Parent %d: %s\n"),
5578 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
5580 printf (_(" %#06x: Parent %d, name index: %ld\n"),
5581 isum
, j
, aux
.vda_name
);
5591 case SHT_GNU_verneed
:
5593 Elf_External_Verneed
*eneed
;
5599 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
5600 SECTION_NAME (section
), section
->sh_info
);
5602 printf (_(" Addr: 0x"));
5603 printf_vma (section
->sh_addr
);
5604 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
5605 (unsigned long) section
->sh_offset
, section
->sh_link
,
5606 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
5608 eneed
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
5609 _("version need section"));
5613 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
5615 Elf_External_Verneed
*entry
;
5616 Elf_Internal_Verneed ent
;
5621 vstart
= ((char *) eneed
) + idx
;
5623 entry
= (Elf_External_Verneed
*) vstart
;
5625 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
5626 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
5627 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
5628 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
5629 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
5631 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
5633 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
5634 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
5636 printf (_(" File: %lx"), ent
.vn_file
);
5638 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
5640 vstart
+= ent
.vn_aux
;
5642 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
5644 Elf_External_Vernaux
*eaux
;
5645 Elf_Internal_Vernaux aux
;
5647 eaux
= (Elf_External_Vernaux
*) vstart
;
5649 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
5650 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
5651 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
5652 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
5653 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
5655 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
5656 printf (_(" %#06x: Name: %s"),
5657 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
5659 printf (_(" %#06x: Name index: %lx"),
5660 isum
, aux
.vna_name
);
5662 printf (_(" Flags: %s Version: %d\n"),
5663 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
5665 isum
+= aux
.vna_next
;
5666 vstart
+= aux
.vna_next
;
5676 case SHT_GNU_versym
:
5678 Elf_Internal_Shdr
*link_section
;
5681 unsigned char *edata
;
5682 unsigned short *data
;
5684 Elf_Internal_Sym
*symbols
;
5685 Elf_Internal_Shdr
*string_sec
;
5688 link_section
= SECTION_HEADER (section
->sh_link
);
5689 total
= section
->sh_size
/ section
->sh_entsize
;
5693 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
5695 string_sec
= SECTION_HEADER (link_section
->sh_link
);
5697 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
5698 string_sec
->sh_size
, _("version string table"));
5702 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
5703 SECTION_NAME (section
), total
);
5705 printf (_(" Addr: "));
5706 printf_vma (section
->sh_addr
);
5707 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5708 (unsigned long) section
->sh_offset
, section
->sh_link
,
5709 SECTION_NAME (link_section
));
5711 off
= offset_from_vma (file
,
5712 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
5713 total
* sizeof (short));
5714 edata
= get_data (NULL
, file
, off
, total
* sizeof (short),
5715 _("version symbol data"));
5722 data
= malloc (total
* sizeof (short));
5724 for (cnt
= total
; cnt
--;)
5725 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
5730 for (cnt
= 0; cnt
< total
; cnt
+= 4)
5733 int check_def
, check_need
;
5736 printf (" %03x:", cnt
);
5738 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
5739 switch (data
[cnt
+ j
])
5742 fputs (_(" 0 (*local*) "), stdout
);
5746 fputs (_(" 1 (*global*) "), stdout
);
5750 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
5751 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
5755 if (SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
5758 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
5765 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
5767 Elf_Internal_Verneed ivn
;
5768 unsigned long offset
;
5770 offset
= offset_from_vma
5771 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
5772 sizeof (Elf_External_Verneed
));
5776 Elf_Internal_Vernaux ivna
;
5777 Elf_External_Verneed evn
;
5778 Elf_External_Vernaux evna
;
5779 unsigned long a_off
;
5781 get_data (&evn
, file
, offset
, sizeof (evn
),
5784 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
5785 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
5787 a_off
= offset
+ ivn
.vn_aux
;
5791 get_data (&evna
, file
, a_off
, sizeof (evna
),
5792 _("version need aux (2)"));
5794 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
5795 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
5797 a_off
+= ivna
.vna_next
;
5799 while (ivna
.vna_other
!= data
[cnt
+ j
]
5800 && ivna
.vna_next
!= 0);
5802 if (ivna
.vna_other
== data
[cnt
+ j
])
5804 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
5806 name
= strtab
+ ivna
.vna_name
;
5807 nn
+= printf ("(%s%-*s",
5809 12 - (int) strlen (name
),
5815 offset
+= ivn
.vn_next
;
5817 while (ivn
.vn_next
);
5820 if (check_def
&& data
[cnt
+ j
] != 0x8001
5821 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
5823 Elf_Internal_Verdef ivd
;
5824 Elf_External_Verdef evd
;
5825 unsigned long offset
;
5827 offset
= offset_from_vma
5828 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
5833 get_data (&evd
, file
, offset
, sizeof (evd
),
5836 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
5837 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
5839 offset
+= ivd
.vd_next
;
5841 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
5842 && ivd
.vd_next
!= 0);
5844 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
5846 Elf_External_Verdaux evda
;
5847 Elf_Internal_Verdaux ivda
;
5849 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
5851 get_data (&evda
, file
,
5852 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
5853 sizeof (evda
), _("version def aux"));
5855 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
5857 name
= strtab
+ ivda
.vda_name
;
5858 nn
+= printf ("(%s%-*s",
5860 12 - (int) strlen (name
),
5866 printf ("%*c", 18 - nn
, ' ');
5884 printf (_("\nNo version information found in this file.\n"));
5890 get_symbol_binding (unsigned int binding
)
5892 static char buff
[32];
5896 case STB_LOCAL
: return "LOCAL";
5897 case STB_GLOBAL
: return "GLOBAL";
5898 case STB_WEAK
: return "WEAK";
5900 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
5901 sprintf (buff
, _("<processor specific>: %d"), binding
);
5902 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
5903 sprintf (buff
, _("<OS specific>: %d"), binding
);
5905 sprintf (buff
, _("<unknown>: %d"), binding
);
5911 get_symbol_type (unsigned int type
)
5913 static char buff
[32];
5917 case STT_NOTYPE
: return "NOTYPE";
5918 case STT_OBJECT
: return "OBJECT";
5919 case STT_FUNC
: return "FUNC";
5920 case STT_SECTION
: return "SECTION";
5921 case STT_FILE
: return "FILE";
5922 case STT_COMMON
: return "COMMON";
5923 case STT_TLS
: return "TLS";
5925 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
5927 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
5928 return "THUMB_FUNC";
5930 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
5933 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
5934 return "PARISC_MILLI";
5936 sprintf (buff
, _("<processor specific>: %d"), type
);
5938 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
5940 if (elf_header
.e_machine
== EM_PARISC
)
5942 if (type
== STT_HP_OPAQUE
)
5944 if (type
== STT_HP_STUB
)
5948 sprintf (buff
, _("<OS specific>: %d"), type
);
5951 sprintf (buff
, _("<unknown>: %d"), type
);
5957 get_symbol_visibility (unsigned int visibility
)
5961 case STV_DEFAULT
: return "DEFAULT";
5962 case STV_INTERNAL
: return "INTERNAL";
5963 case STV_HIDDEN
: return "HIDDEN";
5964 case STV_PROTECTED
: return "PROTECTED";
5970 get_symbol_index_type (unsigned int type
)
5972 static char buff
[32];
5976 case SHN_UNDEF
: return "UND";
5977 case SHN_ABS
: return "ABS";
5978 case SHN_COMMON
: return "COM";
5980 if (type
== SHN_IA_64_ANSI_COMMON
5981 && elf_header
.e_machine
== EM_IA_64
5982 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
5984 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
5985 sprintf (buff
, "PRC[0x%04x]", type
);
5986 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
5987 sprintf (buff
, "OS [0x%04x]", type
);
5988 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
5989 sprintf (buff
, "RSV[0x%04x]", type
);
5991 sprintf (buff
, "%3d", type
);
5999 get_dynamic_data (FILE *file
, unsigned int number
)
6001 unsigned char *e_data
;
6004 e_data
= malloc (number
* 4);
6008 error (_("Out of memory\n"));
6012 if (fread (e_data
, 4, number
, file
) != number
)
6014 error (_("Unable to read in dynamic data\n"));
6018 i_data
= malloc (number
* sizeof (*i_data
));
6022 error (_("Out of memory\n"));
6028 i_data
[number
] = byte_get (e_data
+ number
* 4, 4);
6035 /* Dump the symbol table. */
6037 process_symbol_table (FILE *file
)
6039 Elf_Internal_Shdr
*section
;
6040 unsigned char nb
[4];
6041 unsigned char nc
[4];
6044 int *buckets
= NULL
;
6047 if (! do_syms
&& !do_histogram
)
6050 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
6054 (archive_file_offset
6055 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
6056 sizeof nb
+ sizeof nc
)),
6059 error (_("Unable to seek to start of dynamic information"));
6063 if (fread (nb
, sizeof (nb
), 1, file
) != 1)
6065 error (_("Failed to read in number of buckets\n"));
6069 if (fread (nc
, sizeof (nc
), 1, file
) != 1)
6071 error (_("Failed to read in number of chains\n"));
6075 nbuckets
= byte_get (nb
, 4);
6076 nchains
= byte_get (nc
, 4);
6078 buckets
= get_dynamic_data (file
, nbuckets
);
6079 chains
= get_dynamic_data (file
, nchains
);
6081 if (buckets
== NULL
|| chains
== NULL
)
6086 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
6091 printf (_("\nSymbol table for image:\n"));
6093 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6095 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6097 for (hn
= 0; hn
< nbuckets
; hn
++)
6102 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
6104 Elf_Internal_Sym
*psym
;
6106 psym
= dynamic_symbols
+ si
;
6108 printf (" %3d %3d: ", si
, hn
);
6109 print_vma (psym
->st_value
, LONG_HEX
);
6111 print_vma (psym
->st_size
, DEC_5
);
6113 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6114 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6115 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6116 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
6117 if (VALID_DYNAMIC_NAME (psym
->st_name
))
6118 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
6120 printf (" <corrupt: %14ld>", psym
->st_name
);
6125 else if (do_syms
&& !do_using_dynamic
)
6129 for (i
= 0, section
= section_headers
;
6130 i
< elf_header
.e_shnum
;
6135 Elf_Internal_Sym
*symtab
;
6136 Elf_Internal_Sym
*psym
;
6139 if ( section
->sh_type
!= SHT_SYMTAB
6140 && section
->sh_type
!= SHT_DYNSYM
)
6143 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
6144 SECTION_NAME (section
),
6145 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
6147 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6149 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6151 symtab
= GET_ELF_SYMBOLS (file
, section
);
6155 if (section
->sh_link
== elf_header
.e_shstrndx
)
6156 strtab
= string_table
;
6159 Elf_Internal_Shdr
*string_sec
;
6161 string_sec
= SECTION_HEADER (section
->sh_link
);
6163 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
6164 string_sec
->sh_size
, _("string table"));
6167 for (si
= 0, psym
= symtab
;
6168 si
< section
->sh_size
/ section
->sh_entsize
;
6171 printf ("%6d: ", si
);
6172 print_vma (psym
->st_value
, LONG_HEX
);
6174 print_vma (psym
->st_size
, DEC_5
);
6175 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6176 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6177 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6178 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
6179 print_symbol (25, strtab
+ psym
->st_name
);
6181 if (section
->sh_type
== SHT_DYNSYM
&&
6182 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
6184 unsigned char data
[2];
6185 unsigned short vers_data
;
6186 unsigned long offset
;
6190 offset
= offset_from_vma
6191 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6192 sizeof data
+ si
* sizeof (vers_data
));
6194 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
6195 sizeof (data
), _("version data"));
6197 vers_data
= byte_get (data
, 2);
6199 is_nobits
= (SECTION_HEADER (psym
->st_shndx
)->sh_type
6202 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
6204 if ((vers_data
& 0x8000) || vers_data
> 1)
6206 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
6207 && (is_nobits
|| ! check_def
))
6209 Elf_External_Verneed evn
;
6210 Elf_Internal_Verneed ivn
;
6211 Elf_Internal_Vernaux ivna
;
6213 /* We must test both. */
6214 offset
= offset_from_vma
6215 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6220 unsigned long vna_off
;
6222 get_data (&evn
, file
, offset
, sizeof (evn
),
6225 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6226 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6228 vna_off
= offset
+ ivn
.vn_aux
;
6232 Elf_External_Vernaux evna
;
6234 get_data (&evna
, file
, vna_off
,
6236 _("version need aux (3)"));
6238 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6239 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6240 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6242 vna_off
+= ivna
.vna_next
;
6244 while (ivna
.vna_other
!= vers_data
6245 && ivna
.vna_next
!= 0);
6247 if (ivna
.vna_other
== vers_data
)
6250 offset
+= ivn
.vn_next
;
6252 while (ivn
.vn_next
!= 0);
6254 if (ivna
.vna_other
== vers_data
)
6257 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
6260 else if (! is_nobits
)
6261 error (_("bad dynamic symbol"));
6268 if (vers_data
!= 0x8001
6269 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6271 Elf_Internal_Verdef ivd
;
6272 Elf_Internal_Verdaux ivda
;
6273 Elf_External_Verdaux evda
;
6274 unsigned long offset
;
6276 offset
= offset_from_vma
6278 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6279 sizeof (Elf_External_Verdef
));
6283 Elf_External_Verdef evd
;
6285 get_data (&evd
, file
, offset
, sizeof (evd
),
6288 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6289 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6290 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6292 offset
+= ivd
.vd_next
;
6294 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
6295 && ivd
.vd_next
!= 0);
6297 offset
-= ivd
.vd_next
;
6298 offset
+= ivd
.vd_aux
;
6300 get_data (&evda
, file
, offset
, sizeof (evda
),
6301 _("version def aux"));
6303 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6305 if (psym
->st_name
!= ivda
.vda_name
)
6306 printf ((vers_data
& 0x8000)
6308 strtab
+ ivda
.vda_name
);
6318 if (strtab
!= string_table
)
6324 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
6326 if (do_histogram
&& buckets
!= NULL
)
6333 int nzero_counts
= 0;
6336 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
6338 printf (_(" Length Number %% of total Coverage\n"));
6340 lengths
= calloc (nbuckets
, sizeof (int));
6341 if (lengths
== NULL
)
6343 error (_("Out of memory"));
6346 for (hn
= 0; hn
< nbuckets
; ++hn
)
6351 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
6354 if (maxlength
< ++lengths
[hn
])
6359 counts
= calloc (maxlength
+ 1, sizeof (int));
6362 error (_("Out of memory"));
6366 for (hn
= 0; hn
< nbuckets
; ++hn
)
6367 ++counts
[lengths
[hn
]];
6371 printf (" 0 %-10d (%5.1f%%)\n",
6372 counts
[0], (counts
[0] * 100.0) / nbuckets
);
6373 for (si
= 1; si
<= maxlength
; ++si
)
6375 nzero_counts
+= counts
[si
] * si
;
6376 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
6377 si
, counts
[si
], (counts
[si
] * 100.0) / nbuckets
,
6378 (nzero_counts
* 100.0) / nsyms
);
6386 if (buckets
!= NULL
)
6396 process_syminfo (FILE *file ATTRIBUTE_UNUSED
)
6400 if (dynamic_syminfo
== NULL
6402 /* No syminfo, this is ok. */
6405 /* There better should be a dynamic symbol section. */
6406 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
6410 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
6411 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
6413 printf (_(" Num: Name BoundTo Flags\n"));
6414 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
6416 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
6418 printf ("%4d: ", i
);
6419 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
6420 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
6422 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
6425 switch (dynamic_syminfo
[i
].si_boundto
)
6427 case SYMINFO_BT_SELF
:
6428 fputs ("SELF ", stdout
);
6430 case SYMINFO_BT_PARENT
:
6431 fputs ("PARENT ", stdout
);
6434 if (dynamic_syminfo
[i
].si_boundto
> 0
6435 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
6436 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
6438 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
6442 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
6446 if (flags
& SYMINFO_FLG_DIRECT
)
6448 if (flags
& SYMINFO_FLG_PASSTHRU
)
6449 printf (" PASSTHRU");
6450 if (flags
& SYMINFO_FLG_COPY
)
6452 if (flags
& SYMINFO_FLG_LAZYLOAD
)
6453 printf (" LAZYLOAD");
6461 #ifdef SUPPORT_DISASSEMBLY
6463 disassemble_section (Elf_Internal_Shdr
*section
, FILE *file
)
6465 printf (_("\nAssembly dump of section %s\n"),
6466 SECTION_NAME (section
));
6468 /* XXX -- to be done --- XXX */
6475 dump_section (Elf_Internal_Shdr
*section
, FILE *file
)
6477 bfd_size_type bytes
;
6479 unsigned char *data
;
6480 unsigned char *start
;
6482 bytes
= section
->sh_size
;
6484 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
6486 printf (_("\nSection '%s' has no data to dump.\n"),
6487 SECTION_NAME (section
));
6491 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
6493 addr
= section
->sh_addr
;
6495 start
= get_data (NULL
, file
, section
->sh_offset
, bytes
, _("section data"));
6507 lbytes
= (bytes
> 16 ? 16 : bytes
);
6509 printf (" 0x%8.8lx ", (unsigned long) addr
);
6511 switch (elf_header
.e_ident
[EI_DATA
])
6515 for (j
= 15; j
>= 0; j
--)
6518 printf ("%2.2x", data
[j
]);
6528 for (j
= 0; j
< 16; j
++)
6531 printf ("%2.2x", data
[j
]);
6541 for (j
= 0; j
< lbytes
; j
++)
6544 if (k
>= ' ' && k
< 0x7f)
6563 static unsigned long int
6564 read_leb128 (unsigned char *data
, int *length_return
, int sign
)
6566 unsigned long int result
= 0;
6567 unsigned int num_read
= 0;
6576 result
|= (byte
& 0x7f) << shift
;
6581 while (byte
& 0x80);
6583 if (length_return
!= NULL
)
6584 *length_return
= num_read
;
6586 if (sign
&& (shift
< 32) && (byte
& 0x40))
6587 result
|= -1 << shift
;
6592 typedef struct State_Machine_Registers
6594 unsigned long address
;
6597 unsigned int column
;
6601 /* This variable hold the number of the last entry seen
6602 in the File Table. */
6603 unsigned int last_file_entry
;
6606 static SMR state_machine_regs
;
6609 reset_state_machine (int is_stmt
)
6611 state_machine_regs
.address
= 0;
6612 state_machine_regs
.file
= 1;
6613 state_machine_regs
.line
= 1;
6614 state_machine_regs
.column
= 0;
6615 state_machine_regs
.is_stmt
= is_stmt
;
6616 state_machine_regs
.basic_block
= 0;
6617 state_machine_regs
.end_sequence
= 0;
6618 state_machine_regs
.last_file_entry
= 0;
6621 /* Handled an extend line op. Returns true if this is the end
6624 process_extended_line_op (unsigned char *data
, int is_stmt
, int pointer_size
)
6626 unsigned char op_code
;
6629 unsigned char *name
;
6632 len
= read_leb128 (data
, & bytes_read
, 0);
6637 warn (_("badly formed extended line op encountered!\n"));
6644 printf (_(" Extended opcode %d: "), op_code
);
6648 case DW_LNE_end_sequence
:
6649 printf (_("End of Sequence\n\n"));
6650 reset_state_machine (is_stmt
);
6653 case DW_LNE_set_address
:
6654 adr
= byte_get (data
, pointer_size
);
6655 printf (_("set Address to 0x%lx\n"), adr
);
6656 state_machine_regs
.address
= adr
;
6659 case DW_LNE_define_file
:
6660 printf (_(" define new File Table entry\n"));
6661 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6663 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
6665 data
+= strlen ((char *) data
) + 1;
6666 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6668 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6670 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6671 printf (_("%s\n\n"), name
);
6675 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
6682 /* Finds section NAME inside FILE and returns a
6683 pointer to it, or NULL upon failure. */
6685 static Elf_Internal_Shdr
*
6686 find_section (const char * name
)
6688 Elf_Internal_Shdr
*sec
;
6691 for (i
= elf_header
.e_shnum
, sec
= section_headers
+ i
- 1;
6693 if (strcmp (SECTION_NAME (sec
), name
) == 0)
6696 if (i
&& sec
&& sec
->sh_size
!= 0)
6702 /* Size of pointers in the .debug_line section. This information is not
6703 really present in that section. It's obtained before dumping the debug
6704 sections by doing some pre-scan of the .debug_info section. */
6705 static unsigned int * debug_line_pointer_sizes
= NULL
;
6706 static unsigned int num_debug_line_pointer_sizes
= 0;
6708 /* Locate and scan the .debug_info section in the file and record the pointer
6709 sizes for the compilation units in it. Usually an executable will have
6710 just one pointer size, but this is not guaranteed, and so we try not to
6711 make any assumptions. Returns zero upon failure, or the number of
6712 compilation units upon success. */
6715 get_debug_line_pointer_sizes (FILE * file
)
6717 Elf_Internal_Shdr
* section
;
6718 unsigned char * start
;
6719 unsigned char * end
;
6720 unsigned char * begin
;
6721 unsigned long length
;
6722 unsigned int num_units
;
6725 section
= find_section (".debug_info");
6726 if (section
== NULL
)
6729 length
= section
->sh_size
;
6730 start
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
6731 _("extracting pointer sizes from .debug_info section"));
6735 end
= start
+ section
->sh_size
;
6736 /* First scan the section to get the number of comp units. */
6737 for (begin
= start
, num_units
= 0; begin
< end
; num_units
++)
6739 /* Read the first 4 bytes. For a 32-bit DWARF section, this will
6740 be the length. For a 64-bit DWARF section, it'll be the escape
6741 code 0xffffffff followed by an 8 byte length. */
6742 length
= byte_get (begin
, 4);
6744 if (length
== 0xffffffff)
6746 length
= byte_get (begin
+ 4, 8);
6747 begin
+= length
+ 12;
6750 begin
+= length
+ 4;
6755 error (_("No comp units in .debug_info section ?"));
6760 /* Then allocate an array to hold the pointer sizes. */
6761 debug_line_pointer_sizes
= malloc (num_units
* sizeof * debug_line_pointer_sizes
);
6762 if (debug_line_pointer_sizes
== NULL
)
6764 error (_("Not enough memory for a pointer size array of %u entries"),
6770 /* Populate the array. */
6771 for (begin
= start
, unit
= 0; begin
< end
; unit
++)
6773 length
= byte_get (begin
, 4);
6774 if (length
== 0xffffffff)
6776 /* For 64-bit DWARF, the 1-byte address_size field is 22 bytes
6777 from the start of the section. This is computed as follows:
6779 unit_length: 12 bytes
6781 debug_abbrev_offset: 8 bytes
6782 -----------------------------
6785 debug_line_pointer_sizes
[unit
] = byte_get (begin
+ 22, 1);
6786 length
= byte_get (begin
+ 4, 8);
6787 begin
+= length
+ 12;
6791 /* For 32-bit DWARF, the 1-byte address_size field is 10 bytes from
6792 the start of the section:
6794 unit_length: 4 bytes
6796 debug_abbrev_offset: 4 bytes
6797 -----------------------------
6800 debug_line_pointer_sizes
[unit
] = byte_get (begin
+ 10, 1);
6801 begin
+= length
+ 4;
6806 num_debug_line_pointer_sizes
= num_units
;
6811 display_debug_lines (Elf_Internal_Shdr
*section
,
6812 unsigned char *start
, FILE *file
)
6814 unsigned char *hdrptr
;
6815 DWARF2_Internal_LineInfo info
;
6816 unsigned char *standard_opcodes
;
6817 unsigned char *data
= start
;
6818 unsigned char *end
= start
+ section
->sh_size
;
6819 unsigned char *end_of_sequence
;
6822 int initial_length_size
;
6823 unsigned int comp_unit
= 0;
6825 printf (_("\nDump of debug contents of section %s:\n\n"),
6826 SECTION_NAME (section
));
6828 if (num_debug_line_pointer_sizes
== 0)
6829 get_debug_line_pointer_sizes (file
);
6833 unsigned int pointer_size
;
6837 /* Check the length of the block. */
6838 info
.li_length
= byte_get (hdrptr
, 4);
6841 if (info
.li_length
== 0xffffffff)
6843 /* This section is 64-bit DWARF 3. */
6844 info
.li_length
= byte_get (hdrptr
, 8);
6847 initial_length_size
= 12;
6852 initial_length_size
= 4;
6855 if (info
.li_length
+ initial_length_size
> section
->sh_size
)
6858 (_("The line info appears to be corrupt - the section is too small\n"));
6862 /* Check its version number. */
6863 info
.li_version
= byte_get (hdrptr
, 2);
6865 if (info
.li_version
!= 2 && info
.li_version
!= 3)
6867 warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
6871 info
.li_prologue_length
= byte_get (hdrptr
, offset_size
);
6872 hdrptr
+= offset_size
;
6873 info
.li_min_insn_length
= byte_get (hdrptr
, 1);
6875 info
.li_default_is_stmt
= byte_get (hdrptr
, 1);
6877 info
.li_line_base
= byte_get (hdrptr
, 1);
6879 info
.li_line_range
= byte_get (hdrptr
, 1);
6881 info
.li_opcode_base
= byte_get (hdrptr
, 1);
6884 /* Sign extend the line base field. */
6885 info
.li_line_base
<<= 24;
6886 info
.li_line_base
>>= 24;
6888 /* Get the pointer size from the comp unit associated
6889 with this block of line number information. */
6890 if (comp_unit
>= num_debug_line_pointer_sizes
)
6892 error (_("Not enough comp units for .debug_lines section\n"));
6897 pointer_size
= debug_line_pointer_sizes
[comp_unit
];
6901 printf (_(" Length: %ld\n"), info
.li_length
);
6902 printf (_(" DWARF Version: %d\n"), info
.li_version
);
6903 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
6904 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
6905 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
6906 printf (_(" Line Base: %d\n"), info
.li_line_base
);
6907 printf (_(" Line Range: %d\n"), info
.li_line_range
);
6908 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
6909 printf (_(" (Pointer size: %u)\n"), pointer_size
);
6911 end_of_sequence
= data
+ info
.li_length
+ initial_length_size
;
6913 reset_state_machine (info
.li_default_is_stmt
);
6915 /* Display the contents of the Opcodes table. */
6916 standard_opcodes
= hdrptr
;
6918 printf (_("\n Opcodes:\n"));
6920 for (i
= 1; i
< info
.li_opcode_base
; i
++)
6921 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
6923 /* Display the contents of the Directory table. */
6924 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
6927 printf (_("\n The Directory Table is empty.\n"));
6930 printf (_("\n The Directory Table:\n"));
6934 printf (_(" %s\n"), data
);
6936 data
+= strlen ((char *) data
) + 1;
6940 /* Skip the NUL at the end of the table. */
6943 /* Display the contents of the File Name table. */
6945 printf (_("\n The File Name Table is empty.\n"));
6948 printf (_("\n The File Name Table:\n"));
6949 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6953 unsigned char *name
;
6956 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
6959 data
+= strlen ((char *) data
) + 1;
6961 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6963 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6965 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6967 printf (_("%s\n"), name
);
6971 /* Skip the NUL at the end of the table. */
6974 /* Now display the statements. */
6975 printf (_("\n Line Number Statements:\n"));
6978 while (data
< end_of_sequence
)
6980 unsigned char op_code
;
6986 if (op_code
>= info
.li_opcode_base
)
6988 op_code
-= info
.li_opcode_base
;
6989 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
6990 state_machine_regs
.address
+= adv
;
6991 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
6992 op_code
, adv
, state_machine_regs
.address
);
6993 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
6994 state_machine_regs
.line
+= adv
;
6995 printf (_(" and Line by %d to %d\n"),
6996 adv
, state_machine_regs
.line
);
6998 else switch (op_code
)
7000 case DW_LNS_extended_op
:
7001 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
7006 printf (_(" Copy\n"));
7009 case DW_LNS_advance_pc
:
7010 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
7012 state_machine_regs
.address
+= adv
;
7013 printf (_(" Advance PC by %d to %lx\n"), adv
,
7014 state_machine_regs
.address
);
7017 case DW_LNS_advance_line
:
7018 adv
= read_leb128 (data
, & bytes_read
, 1);
7020 state_machine_regs
.line
+= adv
;
7021 printf (_(" Advance Line by %d to %d\n"), adv
,
7022 state_machine_regs
.line
);
7025 case DW_LNS_set_file
:
7026 adv
= read_leb128 (data
, & bytes_read
, 0);
7028 printf (_(" Set File Name to entry %d in the File Name Table\n"),
7030 state_machine_regs
.file
= adv
;
7033 case DW_LNS_set_column
:
7034 adv
= read_leb128 (data
, & bytes_read
, 0);
7036 printf (_(" Set column to %d\n"), adv
);
7037 state_machine_regs
.column
= adv
;
7040 case DW_LNS_negate_stmt
:
7041 adv
= state_machine_regs
.is_stmt
;
7043 printf (_(" Set is_stmt to %d\n"), adv
);
7044 state_machine_regs
.is_stmt
= adv
;
7047 case DW_LNS_set_basic_block
:
7048 printf (_(" Set basic block\n"));
7049 state_machine_regs
.basic_block
= 1;
7052 case DW_LNS_const_add_pc
:
7053 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
7054 * info
.li_min_insn_length
);
7055 state_machine_regs
.address
+= adv
;
7056 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
7057 state_machine_regs
.address
);
7060 case DW_LNS_fixed_advance_pc
:
7061 adv
= byte_get (data
, 2);
7063 state_machine_regs
.address
+= adv
;
7064 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
7065 adv
, state_machine_regs
.address
);
7068 case DW_LNS_set_prologue_end
:
7069 printf (_(" Set prologue_end to true\n"));
7072 case DW_LNS_set_epilogue_begin
:
7073 printf (_(" Set epilogue_begin to true\n"));
7076 case DW_LNS_set_isa
:
7077 adv
= read_leb128 (data
, & bytes_read
, 0);
7079 printf (_(" Set ISA to %d\n"), adv
);
7083 printf (_(" Unknown opcode %d with operands: "), op_code
);
7086 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
7088 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
7089 i
== 1 ? "" : ", ");
7104 display_debug_pubnames (Elf_Internal_Shdr
*section
,
7105 unsigned char *start
,
7106 FILE *file ATTRIBUTE_UNUSED
)
7108 DWARF2_Internal_PubNames pubnames
;
7111 end
= start
+ section
->sh_size
;
7113 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
7117 unsigned char *data
;
7118 unsigned long offset
;
7119 int offset_size
, initial_length_size
;
7123 pubnames
.pn_length
= byte_get (data
, 4);
7125 if (pubnames
.pn_length
== 0xffffffff)
7127 pubnames
.pn_length
= byte_get (data
, 8);
7130 initial_length_size
= 12;
7135 initial_length_size
= 4;
7138 pubnames
.pn_version
= byte_get (data
, 2);
7140 pubnames
.pn_offset
= byte_get (data
, offset_size
);
7141 data
+= offset_size
;
7142 pubnames
.pn_size
= byte_get (data
, offset_size
);
7143 data
+= offset_size
;
7145 start
+= pubnames
.pn_length
+ initial_length_size
;
7147 if (pubnames
.pn_version
!= 2 && pubnames
.pn_version
!= 3)
7149 static int warned
= 0;
7153 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
7160 printf (_(" Length: %ld\n"),
7161 pubnames
.pn_length
);
7162 printf (_(" Version: %d\n"),
7163 pubnames
.pn_version
);
7164 printf (_(" Offset into .debug_info section: %ld\n"),
7165 pubnames
.pn_offset
);
7166 printf (_(" Size of area in .debug_info section: %ld\n"),
7169 printf (_("\n Offset\tName\n"));
7173 offset
= byte_get (data
, offset_size
);
7177 data
+= offset_size
;
7178 printf (" %-6ld\t\t%s\n", offset
, data
);
7179 data
+= strlen ((char *) data
) + 1;
7182 while (offset
!= 0);
7190 get_TAG_name (unsigned long tag
)
7194 case DW_TAG_padding
: return "DW_TAG_padding";
7195 case DW_TAG_array_type
: return "DW_TAG_array_type";
7196 case DW_TAG_class_type
: return "DW_TAG_class_type";
7197 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
7198 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
7199 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
7200 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
7201 case DW_TAG_label
: return "DW_TAG_label";
7202 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
7203 case DW_TAG_member
: return "DW_TAG_member";
7204 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
7205 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
7206 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
7207 case DW_TAG_string_type
: return "DW_TAG_string_type";
7208 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
7209 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
7210 case DW_TAG_typedef
: return "DW_TAG_typedef";
7211 case DW_TAG_union_type
: return "DW_TAG_union_type";
7212 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
7213 case DW_TAG_variant
: return "DW_TAG_variant";
7214 case DW_TAG_common_block
: return "DW_TAG_common_block";
7215 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
7216 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
7217 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
7218 case DW_TAG_module
: return "DW_TAG_module";
7219 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
7220 case DW_TAG_set_type
: return "DW_TAG_set_type";
7221 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
7222 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
7223 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
7224 case DW_TAG_base_type
: return "DW_TAG_base_type";
7225 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
7226 case DW_TAG_const_type
: return "DW_TAG_const_type";
7227 case DW_TAG_constant
: return "DW_TAG_constant";
7228 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
7229 case DW_TAG_file_type
: return "DW_TAG_file_type";
7230 case DW_TAG_friend
: return "DW_TAG_friend";
7231 case DW_TAG_namelist
: return "DW_TAG_namelist";
7232 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
7233 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
7234 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
7235 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
7236 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
7237 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
7238 case DW_TAG_try_block
: return "DW_TAG_try_block";
7239 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
7240 case DW_TAG_variable
: return "DW_TAG_variable";
7241 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
7242 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
7243 case DW_TAG_format_label
: return "DW_TAG_format_label";
7244 case DW_TAG_function_template
: return "DW_TAG_function_template";
7245 case DW_TAG_class_template
: return "DW_TAG_class_template";
7246 /* DWARF 2.1 values. */
7247 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
7248 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
7249 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
7250 case DW_TAG_namespace
: return "DW_TAG_namespace";
7251 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
7252 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
7253 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
7254 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
7256 case DW_TAG_upc_shared_type
: return "DW_TAG_upc_shared_type";
7257 case DW_TAG_upc_strict_type
: return "DW_TAG_upc_strict_type";
7258 case DW_TAG_upc_relaxed_type
: return "DW_TAG_upc_relaxed_type";
7261 static char buffer
[100];
7263 sprintf (buffer
, _("Unknown TAG value: %lx"), tag
);
7270 get_AT_name (unsigned long attribute
)
7274 case DW_AT_sibling
: return "DW_AT_sibling";
7275 case DW_AT_location
: return "DW_AT_location";
7276 case DW_AT_name
: return "DW_AT_name";
7277 case DW_AT_ordering
: return "DW_AT_ordering";
7278 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
7279 case DW_AT_byte_size
: return "DW_AT_byte_size";
7280 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
7281 case DW_AT_bit_size
: return "DW_AT_bit_size";
7282 case DW_AT_element_list
: return "DW_AT_element_list";
7283 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
7284 case DW_AT_low_pc
: return "DW_AT_low_pc";
7285 case DW_AT_high_pc
: return "DW_AT_high_pc";
7286 case DW_AT_language
: return "DW_AT_language";
7287 case DW_AT_member
: return "DW_AT_member";
7288 case DW_AT_discr
: return "DW_AT_discr";
7289 case DW_AT_discr_value
: return "DW_AT_discr_value";
7290 case DW_AT_visibility
: return "DW_AT_visibility";
7291 case DW_AT_import
: return "DW_AT_import";
7292 case DW_AT_string_length
: return "DW_AT_string_length";
7293 case DW_AT_common_reference
: return "DW_AT_common_reference";
7294 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
7295 case DW_AT_const_value
: return "DW_AT_const_value";
7296 case DW_AT_containing_type
: return "DW_AT_containing_type";
7297 case DW_AT_default_value
: return "DW_AT_default_value";
7298 case DW_AT_inline
: return "DW_AT_inline";
7299 case DW_AT_is_optional
: return "DW_AT_is_optional";
7300 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
7301 case DW_AT_producer
: return "DW_AT_producer";
7302 case DW_AT_prototyped
: return "DW_AT_prototyped";
7303 case DW_AT_return_addr
: return "DW_AT_return_addr";
7304 case DW_AT_start_scope
: return "DW_AT_start_scope";
7305 case DW_AT_stride_size
: return "DW_AT_stride_size";
7306 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
7307 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
7308 case DW_AT_accessibility
: return "DW_AT_accessibility";
7309 case DW_AT_address_class
: return "DW_AT_address_class";
7310 case DW_AT_artificial
: return "DW_AT_artificial";
7311 case DW_AT_base_types
: return "DW_AT_base_types";
7312 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
7313 case DW_AT_count
: return "DW_AT_count";
7314 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
7315 case DW_AT_decl_column
: return "DW_AT_decl_column";
7316 case DW_AT_decl_file
: return "DW_AT_decl_file";
7317 case DW_AT_decl_line
: return "DW_AT_decl_line";
7318 case DW_AT_declaration
: return "DW_AT_declaration";
7319 case DW_AT_discr_list
: return "DW_AT_discr_list";
7320 case DW_AT_encoding
: return "DW_AT_encoding";
7321 case DW_AT_external
: return "DW_AT_external";
7322 case DW_AT_frame_base
: return "DW_AT_frame_base";
7323 case DW_AT_friend
: return "DW_AT_friend";
7324 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
7325 case DW_AT_macro_info
: return "DW_AT_macro_info";
7326 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
7327 case DW_AT_priority
: return "DW_AT_priority";
7328 case DW_AT_segment
: return "DW_AT_segment";
7329 case DW_AT_specification
: return "DW_AT_specification";
7330 case DW_AT_static_link
: return "DW_AT_static_link";
7331 case DW_AT_type
: return "DW_AT_type";
7332 case DW_AT_use_location
: return "DW_AT_use_location";
7333 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
7334 case DW_AT_virtuality
: return "DW_AT_virtuality";
7335 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
7336 /* DWARF 2.1 values. */
7337 case DW_AT_allocated
: return "DW_AT_allocated";
7338 case DW_AT_associated
: return "DW_AT_associated";
7339 case DW_AT_data_location
: return "DW_AT_data_location";
7340 case DW_AT_stride
: return "DW_AT_stride";
7341 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
7342 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
7343 case DW_AT_extension
: return "DW_AT_extension";
7344 case DW_AT_ranges
: return "DW_AT_ranges";
7345 case DW_AT_trampoline
: return "DW_AT_trampoline";
7346 case DW_AT_call_column
: return "DW_AT_call_column";
7347 case DW_AT_call_file
: return "DW_AT_call_file";
7348 case DW_AT_call_line
: return "DW_AT_call_line";
7349 /* SGI/MIPS extensions. */
7350 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
7351 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
7352 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
7353 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
7354 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
7355 case DW_AT_MIPS_software_pipeline_depth
:
7356 return "DW_AT_MIPS_software_pipeline_depth";
7357 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
7358 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
7359 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
7360 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
7361 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
7362 /* GNU extensions. */
7363 case DW_AT_sf_names
: return "DW_AT_sf_names";
7364 case DW_AT_src_info
: return "DW_AT_src_info";
7365 case DW_AT_mac_info
: return "DW_AT_mac_info";
7366 case DW_AT_src_coords
: return "DW_AT_src_coords";
7367 case DW_AT_body_begin
: return "DW_AT_body_begin";
7368 case DW_AT_body_end
: return "DW_AT_body_end";
7369 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
7370 /* UPC extension. */
7371 case DW_AT_upc_threads_scaled
: return "DW_AT_upc_threads_scaled";
7374 static char buffer
[100];
7376 sprintf (buffer
, _("Unknown AT value: %lx"), attribute
);
7383 get_FORM_name (unsigned long form
)
7387 case DW_FORM_addr
: return "DW_FORM_addr";
7388 case DW_FORM_block2
: return "DW_FORM_block2";
7389 case DW_FORM_block4
: return "DW_FORM_block4";
7390 case DW_FORM_data2
: return "DW_FORM_data2";
7391 case DW_FORM_data4
: return "DW_FORM_data4";
7392 case DW_FORM_data8
: return "DW_FORM_data8";
7393 case DW_FORM_string
: return "DW_FORM_string";
7394 case DW_FORM_block
: return "DW_FORM_block";
7395 case DW_FORM_block1
: return "DW_FORM_block1";
7396 case DW_FORM_data1
: return "DW_FORM_data1";
7397 case DW_FORM_flag
: return "DW_FORM_flag";
7398 case DW_FORM_sdata
: return "DW_FORM_sdata";
7399 case DW_FORM_strp
: return "DW_FORM_strp";
7400 case DW_FORM_udata
: return "DW_FORM_udata";
7401 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
7402 case DW_FORM_ref1
: return "DW_FORM_ref1";
7403 case DW_FORM_ref2
: return "DW_FORM_ref2";
7404 case DW_FORM_ref4
: return "DW_FORM_ref4";
7405 case DW_FORM_ref8
: return "DW_FORM_ref8";
7406 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
7407 case DW_FORM_indirect
: return "DW_FORM_indirect";
7410 static char buffer
[100];
7412 sprintf (buffer
, _("Unknown FORM value: %lx"), form
);
7418 /* FIXME: There are better and more efficient ways to handle
7419 these structures. For now though, I just want something that
7420 is simple to implement. */
7421 typedef struct abbrev_attr
7423 unsigned long attribute
;
7425 struct abbrev_attr
*next
;
7429 typedef struct abbrev_entry
7431 unsigned long entry
;
7434 struct abbrev_attr
*first_attr
;
7435 struct abbrev_attr
*last_attr
;
7436 struct abbrev_entry
*next
;
7440 static abbrev_entry
*first_abbrev
= NULL
;
7441 static abbrev_entry
*last_abbrev
= NULL
;
7446 abbrev_entry
*abbrev
;
7448 for (abbrev
= first_abbrev
; abbrev
;)
7450 abbrev_entry
*next
= abbrev
->next
;
7453 for (attr
= abbrev
->first_attr
; attr
;)
7455 abbrev_attr
*next
= attr
->next
;
7465 last_abbrev
= first_abbrev
= NULL
;
7469 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
7471 abbrev_entry
*entry
;
7473 entry
= malloc (sizeof (*entry
));
7479 entry
->entry
= number
;
7481 entry
->children
= children
;
7482 entry
->first_attr
= NULL
;
7483 entry
->last_attr
= NULL
;
7486 if (first_abbrev
== NULL
)
7487 first_abbrev
= entry
;
7489 last_abbrev
->next
= entry
;
7491 last_abbrev
= entry
;
7495 add_abbrev_attr (unsigned long attribute
, unsigned long form
)
7499 attr
= malloc (sizeof (*attr
));
7505 attr
->attribute
= attribute
;
7509 if (last_abbrev
->first_attr
== NULL
)
7510 last_abbrev
->first_attr
= attr
;
7512 last_abbrev
->last_attr
->next
= attr
;
7514 last_abbrev
->last_attr
= attr
;
7517 /* Processes the (partial) contents of a .debug_abbrev section.
7518 Returns NULL if the end of the section was encountered.
7519 Returns the address after the last byte read if the end of
7520 an abbreviation set was found. */
7522 static unsigned char *
7523 process_abbrev_section (unsigned char *start
, unsigned char *end
)
7525 if (first_abbrev
!= NULL
)
7531 unsigned long entry
;
7533 unsigned long attribute
;
7536 entry
= read_leb128 (start
, & bytes_read
, 0);
7537 start
+= bytes_read
;
7539 /* A single zero is supposed to end the section according
7540 to the standard. If there's more, then signal that to
7543 return start
== end
? NULL
: start
;
7545 tag
= read_leb128 (start
, & bytes_read
, 0);
7546 start
+= bytes_read
;
7548 children
= *start
++;
7550 add_abbrev (entry
, tag
, children
);
7556 attribute
= read_leb128 (start
, & bytes_read
, 0);
7557 start
+= bytes_read
;
7559 form
= read_leb128 (start
, & bytes_read
, 0);
7560 start
+= bytes_read
;
7563 add_abbrev_attr (attribute
, form
);
7565 while (attribute
!= 0);
7573 display_debug_macinfo (Elf_Internal_Shdr
*section
,
7574 unsigned char *start
,
7575 FILE *file ATTRIBUTE_UNUSED
)
7577 unsigned char *end
= start
+ section
->sh_size
;
7578 unsigned char *curr
= start
;
7579 unsigned int bytes_read
;
7580 enum dwarf_macinfo_record_type op
;
7582 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
7586 unsigned int lineno
;
7594 case DW_MACINFO_start_file
:
7596 unsigned int filenum
;
7598 lineno
= read_leb128 (curr
, & bytes_read
, 0);
7600 filenum
= read_leb128 (curr
, & bytes_read
, 0);
7603 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"), lineno
, filenum
);
7607 case DW_MACINFO_end_file
:
7608 printf (_(" DW_MACINFO_end_file\n"));
7611 case DW_MACINFO_define
:
7612 lineno
= read_leb128 (curr
, & bytes_read
, 0);
7615 curr
+= strlen (string
) + 1;
7616 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"), lineno
, string
);
7619 case DW_MACINFO_undef
:
7620 lineno
= read_leb128 (curr
, & bytes_read
, 0);
7623 curr
+= strlen (string
) + 1;
7624 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"), lineno
, string
);
7627 case DW_MACINFO_vendor_ext
:
7629 unsigned int constant
;
7631 constant
= read_leb128 (curr
, & bytes_read
, 0);
7634 curr
+= strlen (string
) + 1;
7635 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"), constant
, string
);
7646 display_debug_abbrev (Elf_Internal_Shdr
*section
,
7647 unsigned char *start
,
7648 FILE *file ATTRIBUTE_UNUSED
)
7650 abbrev_entry
*entry
;
7651 unsigned char *end
= start
+ section
->sh_size
;
7653 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
7657 start
= process_abbrev_section (start
, end
);
7659 if (first_abbrev
== NULL
)
7662 printf (_(" Number TAG\n"));
7664 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
7668 printf (_(" %ld %s [%s]\n"),
7670 get_TAG_name (entry
->tag
),
7671 entry
->children
? _("has children") : _("no children"));
7673 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
7675 printf (_(" %-18s %s\n"),
7676 get_AT_name (attr
->attribute
),
7677 get_FORM_name (attr
->form
));
7691 static unsigned char *
7692 display_block (unsigned char *data
, unsigned long length
)
7694 printf (_(" %lu byte block: "), length
);
7697 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
7703 decode_location_expression (unsigned char * data
,
7704 unsigned int pointer_size
,
7705 unsigned long length
)
7709 unsigned long uvalue
;
7710 unsigned char *end
= data
+ length
;
7719 printf ("DW_OP_addr: %lx",
7720 (unsigned long) byte_get (data
, pointer_size
));
7721 data
+= pointer_size
;
7724 printf ("DW_OP_deref");
7727 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
7730 printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data
++, 1));
7733 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
7737 printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data
, 2));
7741 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
7745 printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data
, 4));
7749 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
7750 (unsigned long) byte_get (data
+ 4, 4));
7754 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
7755 (long) byte_get (data
+ 4, 4));
7759 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
7763 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
7767 printf ("DW_OP_dup");
7770 printf ("DW_OP_drop");
7773 printf ("DW_OP_over");
7776 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
7779 printf ("DW_OP_swap");
7782 printf ("DW_OP_rot");
7785 printf ("DW_OP_xderef");
7788 printf ("DW_OP_abs");
7791 printf ("DW_OP_and");
7794 printf ("DW_OP_div");
7797 printf ("DW_OP_minus");
7800 printf ("DW_OP_mod");
7803 printf ("DW_OP_mul");
7806 printf ("DW_OP_neg");
7809 printf ("DW_OP_not");
7812 printf ("DW_OP_or");
7815 printf ("DW_OP_plus");
7817 case DW_OP_plus_uconst
:
7818 printf ("DW_OP_plus_uconst: %lu",
7819 read_leb128 (data
, &bytes_read
, 0));
7823 printf ("DW_OP_shl");
7826 printf ("DW_OP_shr");
7829 printf ("DW_OP_shra");
7832 printf ("DW_OP_xor");
7835 printf ("DW_OP_bra: %ld", (long) byte_get_signed (data
, 2));
7839 printf ("DW_OP_eq");
7842 printf ("DW_OP_ge");
7845 printf ("DW_OP_gt");
7848 printf ("DW_OP_le");
7851 printf ("DW_OP_lt");
7854 printf ("DW_OP_ne");
7857 printf ("DW_OP_skip: %ld", (long) byte_get_signed (data
, 2));
7893 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
7928 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
7963 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
7964 read_leb128 (data
, &bytes_read
, 1));
7969 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
7973 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
7977 uvalue
= read_leb128 (data
, &bytes_read
, 0);
7979 printf ("DW_OP_bregx: %lu %ld", uvalue
,
7980 read_leb128 (data
, &bytes_read
, 1));
7984 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
7987 case DW_OP_deref_size
:
7988 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
7990 case DW_OP_xderef_size
:
7991 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
7994 printf ("DW_OP_nop");
7997 /* DWARF 3 extensions. */
7998 case DW_OP_push_object_address
:
7999 printf ("DW_OP_push_object_address");
8002 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2));
8006 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4));
8009 case DW_OP_call_ref
:
8010 printf ("DW_OP_call_ref");
8013 /* GNU extensions. */
8014 case DW_OP_GNU_push_tls_address
:
8015 printf ("DW_OP_GNU_push_tls_address");
8019 if (op
>= DW_OP_lo_user
8020 && op
<= DW_OP_hi_user
)
8021 printf (_("(User defined location op)"));
8023 printf (_("(Unknown location op)"));
8024 /* No way to tell where the next op is, so just bail. */
8028 /* Separate the ops. */
8034 static const char *debug_loc_contents
;
8035 static bfd_vma debug_loc_size
;
8038 load_debug_loc (FILE *file
)
8040 Elf_Internal_Shdr
*sec
;
8042 /* If it is already loaded, do nothing. */
8043 if (debug_loc_contents
!= NULL
)
8046 /* Locate the .debug_loc section. */
8047 sec
= find_section (".debug_loc");
8051 debug_loc_size
= sec
->sh_size
;
8053 debug_loc_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
8054 _("debug_loc section data"));
8058 free_debug_loc (void)
8060 if (debug_loc_contents
== NULL
)
8063 free ((char *) debug_loc_contents
);
8064 debug_loc_contents
= NULL
;
8070 display_debug_loc (Elf_Internal_Shdr
*section
,
8071 unsigned char *start
, FILE *file
)
8073 unsigned char *section_end
;
8074 unsigned long bytes
;
8075 unsigned char *section_begin
= start
;
8077 unsigned int comp_unit
= 0;
8079 addr
= section
->sh_addr
;
8080 bytes
= section
->sh_size
;
8081 section_end
= start
+ bytes
;
8085 printf (_("\nThe .debug_loc section is empty.\n"));
8089 if (num_debug_line_pointer_sizes
== 0)
8090 get_debug_line_pointer_sizes (file
);
8092 printf (_("Contents of the .debug_loc section:\n\n"));
8093 printf (_("\n Offset Begin End Expression\n"));
8095 while (start
< section_end
)
8097 unsigned long begin
;
8099 unsigned short length
;
8100 unsigned long offset
;
8101 unsigned int pointer_size
;
8103 offset
= start
- section_begin
;
8105 /* Get the pointer size from the comp unit associated
8106 with this block of location information. */
8107 if (comp_unit
>= num_debug_line_pointer_sizes
)
8109 error (_("Not enough comp units for .debug_loc section\n"));
8114 pointer_size
= debug_line_pointer_sizes
[comp_unit
];
8120 begin
= byte_get (start
, pointer_size
);
8121 start
+= pointer_size
;
8122 end
= byte_get (start
, pointer_size
);
8123 start
+= pointer_size
;
8125 if (begin
== 0 && end
== 0)
8128 /* For now, skip any base address specifiers. */
8129 if (begin
== 0xffffffff)
8135 length
= byte_get (start
, 2);
8138 printf (" %8.8lx %8.8lx %8.8lx (", offset
, begin
, end
);
8139 decode_location_expression (start
, pointer_size
, length
);
8149 static const char *debug_str_contents
;
8150 static bfd_vma debug_str_size
;
8153 load_debug_str (FILE *file
)
8155 Elf_Internal_Shdr
*sec
;
8157 /* If it is already loaded, do nothing. */
8158 if (debug_str_contents
!= NULL
)
8161 /* Locate the .debug_str section. */
8162 sec
= find_section (".debug_str");
8166 debug_str_size
= sec
->sh_size
;
8168 debug_str_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
8169 _("debug_str section data"));
8173 free_debug_str (void)
8175 if (debug_str_contents
== NULL
)
8178 free ((char *) debug_str_contents
);
8179 debug_str_contents
= NULL
;
8184 fetch_indirect_string (unsigned long offset
)
8186 if (debug_str_contents
== NULL
)
8187 return _("<no .debug_str section>");
8189 if (offset
> debug_str_size
)
8190 return _("<offset is too big>");
8192 return debug_str_contents
+ offset
;
8196 display_debug_str (Elf_Internal_Shdr
*section
,
8197 unsigned char *start
,
8198 FILE *file ATTRIBUTE_UNUSED
)
8200 unsigned long bytes
;
8203 addr
= section
->sh_addr
;
8204 bytes
= section
->sh_size
;
8208 printf (_("\nThe .debug_str section is empty.\n"));
8212 printf (_("Contents of the .debug_str section:\n\n"));
8220 lbytes
= (bytes
> 16 ? 16 : bytes
);
8222 printf (" 0x%8.8lx ", (unsigned long) addr
);
8224 for (j
= 0; j
< 16; j
++)
8227 printf ("%2.2x", start
[j
]);
8235 for (j
= 0; j
< lbytes
; j
++)
8238 if (k
>= ' ' && k
< 0x80)
8254 static unsigned char *
8255 read_and_display_attr_value (unsigned long attribute
,
8257 unsigned char *data
,
8258 unsigned long cu_offset
,
8259 unsigned long pointer_size
,
8260 unsigned long offset_size
,
8263 unsigned long uvalue
= 0;
8264 unsigned char *block_start
= NULL
;
8272 case DW_FORM_ref_addr
:
8273 if (dwarf_version
== 2)
8275 uvalue
= byte_get (data
, pointer_size
);
8276 data
+= pointer_size
;
8278 else if (dwarf_version
== 3)
8280 uvalue
= byte_get (data
, offset_size
);
8281 data
+= offset_size
;
8285 error (_("Internal error: DWARF version is not 2 or 3.\n"));
8290 uvalue
= byte_get (data
, pointer_size
);
8291 data
+= pointer_size
;
8295 uvalue
= byte_get (data
, offset_size
);
8296 data
+= offset_size
;
8302 uvalue
= byte_get (data
++, 1);
8307 uvalue
= byte_get (data
, 2);
8313 uvalue
= byte_get (data
, 4);
8318 uvalue
= read_leb128 (data
, & bytes_read
, 1);
8322 case DW_FORM_ref_udata
:
8324 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8328 case DW_FORM_indirect
:
8329 form
= read_leb128 (data
, & bytes_read
, 0);
8331 printf (" %s", get_FORM_name (form
));
8332 return read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
8333 pointer_size
, offset_size
,
8339 case DW_FORM_ref_addr
:
8340 printf (" <#%lx>", uvalue
);
8346 case DW_FORM_ref_udata
:
8347 printf (" <%lx>", uvalue
+ cu_offset
);
8351 printf (" %#lx", uvalue
);
8360 printf (" %ld", uvalue
);
8365 uvalue
= byte_get (data
, 4);
8366 printf (" %lx", uvalue
);
8367 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
8371 case DW_FORM_string
:
8372 printf (" %s", data
);
8373 data
+= strlen ((char *) data
) + 1;
8377 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8378 block_start
= data
+ bytes_read
;
8379 data
= display_block (block_start
, uvalue
);
8382 case DW_FORM_block1
:
8383 uvalue
= byte_get (data
, 1);
8384 block_start
= data
+ 1;
8385 data
= display_block (block_start
, uvalue
);
8388 case DW_FORM_block2
:
8389 uvalue
= byte_get (data
, 2);
8390 block_start
= data
+ 2;
8391 data
= display_block (block_start
, uvalue
);
8394 case DW_FORM_block4
:
8395 uvalue
= byte_get (data
, 4);
8396 block_start
= data
+ 4;
8397 data
= display_block (block_start
, uvalue
);
8401 printf (_(" (indirect string, offset: 0x%lx): %s"),
8402 uvalue
, fetch_indirect_string (uvalue
));
8405 case DW_FORM_indirect
:
8406 /* Handled above. */
8410 warn (_("Unrecognized form: %d\n"), form
);
8414 /* For some attributes we can display further information. */
8423 case DW_INL_not_inlined
:
8424 printf (_("(not inlined)"));
8426 case DW_INL_inlined
:
8427 printf (_("(inlined)"));
8429 case DW_INL_declared_not_inlined
:
8430 printf (_("(declared as inline but ignored)"));
8432 case DW_INL_declared_inlined
:
8433 printf (_("(declared as inline and inlined)"));
8436 printf (_(" (Unknown inline attribute value: %lx)"), uvalue
);
8441 case DW_AT_language
:
8444 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
8445 case DW_LANG_C89
: printf ("(ANSI C)"); break;
8446 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
8447 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
8448 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
8449 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
8450 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
8451 case DW_LANG_Ada83
: printf ("(Ada)"); break;
8452 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
8453 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
8454 /* DWARF 2.1 values. */
8455 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
8456 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
8457 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
8458 /* MIPS extension. */
8459 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
8460 /* UPC extension. */
8461 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
8463 printf ("(Unknown: %lx)", uvalue
);
8468 case DW_AT_encoding
:
8471 case DW_ATE_void
: printf ("(void)"); break;
8472 case DW_ATE_address
: printf ("(machine address)"); break;
8473 case DW_ATE_boolean
: printf ("(boolean)"); break;
8474 case DW_ATE_complex_float
: printf ("(complex float)"); break;
8475 case DW_ATE_float
: printf ("(float)"); break;
8476 case DW_ATE_signed
: printf ("(signed)"); break;
8477 case DW_ATE_signed_char
: printf ("(signed char)"); break;
8478 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
8479 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
8480 /* DWARF 2.1 value. */
8481 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
8483 if (uvalue
>= DW_ATE_lo_user
8484 && uvalue
<= DW_ATE_hi_user
)
8485 printf ("(user defined type)");
8487 printf ("(unknown type)");
8492 case DW_AT_accessibility
:
8495 case DW_ACCESS_public
: printf ("(public)"); break;
8496 case DW_ACCESS_protected
: printf ("(protected)"); break;
8497 case DW_ACCESS_private
: printf ("(private)"); break;
8499 printf ("(unknown accessibility)");
8504 case DW_AT_visibility
:
8507 case DW_VIS_local
: printf ("(local)"); break;
8508 case DW_VIS_exported
: printf ("(exported)"); break;
8509 case DW_VIS_qualified
: printf ("(qualified)"); break;
8510 default: printf ("(unknown visibility)"); break;
8514 case DW_AT_virtuality
:
8517 case DW_VIRTUALITY_none
: printf ("(none)"); break;
8518 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
8519 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
8520 default: printf ("(unknown virtuality)"); break;
8524 case DW_AT_identifier_case
:
8527 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
8528 case DW_ID_up_case
: printf ("(up_case)"); break;
8529 case DW_ID_down_case
: printf ("(down_case)"); break;
8530 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
8531 default: printf ("(unknown case)"); break;
8535 case DW_AT_calling_convention
:
8538 case DW_CC_normal
: printf ("(normal)"); break;
8539 case DW_CC_program
: printf ("(program)"); break;
8540 case DW_CC_nocall
: printf ("(nocall)"); break;
8542 if (uvalue
>= DW_CC_lo_user
8543 && uvalue
<= DW_CC_hi_user
)
8544 printf ("(user defined)");
8546 printf ("(unknown convention)");
8550 case DW_AT_ordering
:
8553 case -1: printf ("(undefined)"); break;
8554 case 0: printf ("(row major)"); break;
8555 case 1: printf ("(column major)"); break;
8559 case DW_AT_frame_base
:
8560 case DW_AT_location
:
8561 case DW_AT_data_member_location
:
8562 case DW_AT_vtable_elem_location
:
8563 case DW_AT_allocated
:
8564 case DW_AT_associated
:
8565 case DW_AT_data_location
:
8567 case DW_AT_upper_bound
:
8568 case DW_AT_lower_bound
:
8572 decode_location_expression (block_start
, pointer_size
, uvalue
);
8575 else if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8578 printf ("location list");
8590 static unsigned char *
8591 read_and_display_attr (unsigned long attribute
,
8593 unsigned char *data
,
8594 unsigned long cu_offset
,
8595 unsigned long pointer_size
,
8596 unsigned long offset_size
,
8599 printf (" %-18s:", get_AT_name (attribute
));
8600 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
8601 pointer_size
, offset_size
, dwarf_version
);
8606 /* Apply addends of RELA relocations. */
8609 debug_apply_rela_addends (FILE *file
,
8610 Elf_Internal_Shdr
*section
,
8612 unsigned char *sec_data
,
8613 unsigned char *start
,
8616 Elf_Internal_Shdr
*relsec
;
8618 if (end
- start
< reloc_size
)
8621 for (relsec
= section_headers
;
8622 relsec
< section_headers
+ elf_header
.e_shnum
;
8625 unsigned long nrelas
;
8626 Elf_Internal_Rela
*rela
, *rp
;
8627 Elf_Internal_Shdr
*symsec
;
8628 Elf_Internal_Sym
*symtab
;
8629 Elf_Internal_Sym
*sym
;
8631 if (relsec
->sh_type
!= SHT_RELA
8632 || SECTION_HEADER (relsec
->sh_info
) != section
8633 || relsec
->sh_size
== 0)
8636 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8640 symsec
= SECTION_HEADER (relsec
->sh_link
);
8641 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
8643 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8647 if (rp
->r_offset
>= (bfd_vma
) (start
- sec_data
)
8648 && rp
->r_offset
< (bfd_vma
) (end
- sec_data
) - reloc_size
)
8649 loc
= sec_data
+ rp
->r_offset
;
8655 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
8657 if (ELF32_R_SYM (rp
->r_info
) != 0
8658 && ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
8660 warn (_("Skipping unexpected symbol type %u\n"),
8661 ELF32_ST_TYPE (sym
->st_info
));
8667 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
8669 if (ELF64_R_SYM (rp
->r_info
) != 0
8670 && ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
8672 warn (_("Skipping unexpected symbol type %u\n"),
8673 ELF64_ST_TYPE (sym
->st_info
));
8678 byte_put (loc
, rp
->r_addend
, reloc_size
);
8689 display_debug_info (Elf_Internal_Shdr
*section
,
8690 unsigned char *start
,
8693 unsigned char *end
= start
+ section
->sh_size
;
8694 unsigned char *section_begin
= start
;
8696 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
8698 load_debug_str (file
);
8699 load_debug_loc (file
);
8703 DWARF2_Internal_CompUnit compunit
;
8704 unsigned char *hdrptr
;
8705 unsigned char *cu_abbrev_offset_ptr
;
8706 unsigned char *tags
;
8708 unsigned long cu_offset
;
8710 int initial_length_size
;
8714 compunit
.cu_length
= byte_get (hdrptr
, 4);
8717 if (compunit
.cu_length
== 0xffffffff)
8719 compunit
.cu_length
= byte_get (hdrptr
, 8);
8722 initial_length_size
= 12;
8727 initial_length_size
= 4;
8730 compunit
.cu_version
= byte_get (hdrptr
, 2);
8733 cu_offset
= start
- section_begin
;
8734 start
+= compunit
.cu_length
+ initial_length_size
;
8736 if (elf_header
.e_type
== ET_REL
8737 && !debug_apply_rela_addends (file
, section
, offset_size
,
8738 section_begin
, hdrptr
, start
))
8741 cu_abbrev_offset_ptr
= hdrptr
;
8742 compunit
.cu_abbrev_offset
= byte_get (hdrptr
, offset_size
);
8743 hdrptr
+= offset_size
;
8745 compunit
.cu_pointer_size
= byte_get (hdrptr
, 1);
8750 printf (_(" Compilation Unit @ %lx:\n"), cu_offset
);
8751 printf (_(" Length: %ld\n"), compunit
.cu_length
);
8752 printf (_(" Version: %d\n"), compunit
.cu_version
);
8753 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
8754 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
8756 if (compunit
.cu_version
!= 2 && compunit
.cu_version
!= 3)
8758 warn (_("Only version 2 and 3 DWARF debug information is currently supported.\n"));
8764 /* Read in the abbrevs used by this compilation unit. */
8766 Elf_Internal_Shdr
*sec
;
8767 unsigned char *begin
;
8769 /* Locate the .debug_abbrev section and process it. */
8770 sec
= find_section (".debug_abbrev");
8773 warn (_("Unable to locate .debug_abbrev section!\n"));
8777 begin
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
8778 _("debug_abbrev section data"));
8782 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
8783 begin
+ sec
->sh_size
);
8789 while (tags
< start
)
8792 unsigned long abbrev_number
;
8793 abbrev_entry
*entry
;
8796 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
8799 /* A null DIE marks the end of a list of children. */
8800 if (abbrev_number
== 0)
8806 /* Scan through the abbreviation list until we reach the
8808 for (entry
= first_abbrev
;
8809 entry
&& entry
->entry
!= abbrev_number
;
8810 entry
= entry
->next
)
8815 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
8820 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
8822 (unsigned long) (tags
- section_begin
- bytes_read
),
8824 get_TAG_name (entry
->tag
));
8826 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
8827 tags
= read_and_display_attr (attr
->attribute
,
8830 compunit
.cu_pointer_size
,
8832 compunit
.cu_version
);
8834 if (entry
->children
)
8848 display_debug_aranges (Elf_Internal_Shdr
*section
,
8849 unsigned char *start
,
8850 FILE *file ATTRIBUTE_UNUSED
)
8852 unsigned char *end
= start
+ section
->sh_size
;
8854 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
8858 unsigned char *hdrptr
;
8859 DWARF2_Internal_ARange arange
;
8860 unsigned char *ranges
;
8861 unsigned long length
;
8862 unsigned long address
;
8865 int initial_length_size
;
8869 arange
.ar_length
= byte_get (hdrptr
, 4);
8872 if (arange
.ar_length
== 0xffffffff)
8874 arange
.ar_length
= byte_get (hdrptr
, 8);
8877 initial_length_size
= 12;
8882 initial_length_size
= 4;
8885 arange
.ar_version
= byte_get (hdrptr
, 2);
8888 arange
.ar_info_offset
= byte_get (hdrptr
, offset_size
);
8889 hdrptr
+= offset_size
;
8891 arange
.ar_pointer_size
= byte_get (hdrptr
, 1);
8894 arange
.ar_segment_size
= byte_get (hdrptr
, 1);
8897 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
8899 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
8903 printf (_(" Length: %ld\n"), arange
.ar_length
);
8904 printf (_(" Version: %d\n"), arange
.ar_version
);
8905 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
8906 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
8907 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
8909 printf (_("\n Address Length\n"));
8913 /* Must pad to an alignment boundary that is twice the pointer size. */
8914 excess
= (hdrptr
- start
) % (2 * arange
.ar_pointer_size
);
8916 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
8920 address
= byte_get (ranges
, arange
.ar_pointer_size
);
8922 ranges
+= arange
.ar_pointer_size
;
8924 length
= byte_get (ranges
, arange
.ar_pointer_size
);
8926 ranges
+= arange
.ar_pointer_size
;
8928 /* A pair of zeros marks the end of the list. */
8929 if (address
== 0 && length
== 0)
8932 printf (" %8.8lx %lu\n", address
, length
);
8935 start
+= arange
.ar_length
+ initial_length_size
;
8943 typedef struct Frame_Chunk
8945 struct Frame_Chunk
*next
;
8946 unsigned char *chunk_start
;
8948 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
8949 short int *col_type
;
8952 unsigned int code_factor
;
8954 unsigned long pc_begin
;
8955 unsigned long pc_range
;
8959 unsigned char fde_encoding
;
8960 unsigned char cfa_exp
;
8964 /* A marker for a col_type that means this column was never referenced
8965 in the frame info. */
8966 #define DW_CFA_unreferenced (-1)
8969 frame_need_space (Frame_Chunk
*fc
, int reg
)
8971 int prev
= fc
->ncols
;
8973 if (reg
< fc
->ncols
)
8976 fc
->ncols
= reg
+ 1;
8977 fc
->col_type
= xrealloc (fc
->col_type
, fc
->ncols
* sizeof (short int));
8978 fc
->col_offset
= xrealloc (fc
->col_offset
, fc
->ncols
* sizeof (int));
8980 while (prev
< fc
->ncols
)
8982 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
8983 fc
->col_offset
[prev
] = 0;
8989 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, int *max_regs
)
8994 if (*max_regs
< fc
->ncols
)
8995 *max_regs
= fc
->ncols
;
8997 if (*need_col_headers
)
8999 *need_col_headers
= 0;
9001 printf (" LOC CFA ");
9003 for (r
= 0; r
< *max_regs
; r
++)
9004 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
9009 printf ("r%-4d", r
);
9015 printf ("%08lx ", fc
->pc_begin
);
9017 strcpy (tmp
, "exp");
9019 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
9020 printf ("%-8s ", tmp
);
9022 for (r
= 0; r
< fc
->ncols
; r
++)
9024 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
9026 switch (fc
->col_type
[r
])
9028 case DW_CFA_undefined
:
9031 case DW_CFA_same_value
:
9035 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
9037 case DW_CFA_register
:
9038 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
9040 case DW_CFA_expression
:
9041 strcpy (tmp
, "exp");
9044 strcpy (tmp
, "n/a");
9047 printf ("%-5s", tmp
);
9054 size_of_encoded_value (int encoding
)
9056 switch (encoding
& 0x7)
9059 case 0: return is_32bit_elf
? 4 : 8;
9067 get_encoded_value (unsigned char *data
, int encoding
)
9069 int size
= size_of_encoded_value (encoding
);
9070 if (encoding
& DW_EH_PE_signed
)
9071 return byte_get_signed (data
, size
);
9073 return byte_get (data
, size
);
9076 #define GET(N) byte_get (start, N); start += N
9077 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
9078 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
9081 display_debug_frames (Elf_Internal_Shdr
*section
,
9082 unsigned char *start
,
9083 FILE *file ATTRIBUTE_UNUSED
)
9085 unsigned char *end
= start
+ section
->sh_size
;
9086 unsigned char *section_start
= start
;
9087 Frame_Chunk
*chunks
= 0;
9088 Frame_Chunk
*remembered_state
= 0;
9090 int is_eh
= (strcmp (SECTION_NAME (section
), ".eh_frame") == 0);
9093 int addr_size
= is_32bit_elf
? 4 : 8;
9095 printf (_("The section %s contains:\n"), SECTION_NAME (section
));
9099 unsigned char *saved_start
;
9100 unsigned char *block_end
;
9101 unsigned long length
;
9102 unsigned long cie_id
;
9105 int need_col_headers
= 1;
9106 unsigned char *augmentation_data
= NULL
;
9107 unsigned long augmentation_data_len
= 0;
9108 int encoded_ptr_size
= addr_size
;
9110 int initial_length_size
;
9112 saved_start
= start
;
9113 length
= byte_get (start
, 4); start
+= 4;
9117 printf ("\n%08lx ZERO terminator\n\n",
9118 (unsigned long)(saved_start
- section_start
));
9122 if (length
== 0xffffffff)
9124 length
= byte_get (start
, 8);
9127 initial_length_size
= 12;
9132 initial_length_size
= 4;
9135 block_end
= saved_start
+ length
+ initial_length_size
;
9136 cie_id
= byte_get (start
, offset_size
); start
+= offset_size
;
9138 if (elf_header
.e_type
== ET_REL
9139 && !debug_apply_rela_addends (file
, section
, offset_size
,
9140 section_start
, start
, block_end
))
9143 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
9147 fc
= xmalloc (sizeof (Frame_Chunk
));
9148 memset (fc
, 0, sizeof (Frame_Chunk
));
9152 fc
->chunk_start
= saved_start
;
9154 fc
->col_type
= xmalloc (sizeof (short int));
9155 fc
->col_offset
= xmalloc (sizeof (int));
9156 frame_need_space (fc
, max_regs
-1);
9160 fc
->augmentation
= start
;
9161 start
= strchr (start
, '\0') + 1;
9163 if (fc
->augmentation
[0] == 'z')
9165 fc
->code_factor
= LEB ();
9166 fc
->data_factor
= SLEB ();
9175 augmentation_data_len
= LEB ();
9176 augmentation_data
= start
;
9177 start
+= augmentation_data_len
;
9179 else if (strcmp (fc
->augmentation
, "eh") == 0)
9182 fc
->code_factor
= LEB ();
9183 fc
->data_factor
= SLEB ();
9195 fc
->code_factor
= LEB ();
9196 fc
->data_factor
= SLEB ();
9208 if (do_debug_frames_interp
)
9209 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
9210 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
9211 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
9215 printf ("\n%08lx %08lx %08lx CIE\n",
9216 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
9217 printf (" Version: %d\n", version
);
9218 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
9219 printf (" Code alignment factor: %u\n", fc
->code_factor
);
9220 printf (" Data alignment factor: %d\n", fc
->data_factor
);
9221 printf (" Return address column: %d\n", fc
->ra
);
9223 if (augmentation_data_len
)
9226 printf (" Augmentation data: ");
9227 for (i
= 0; i
< augmentation_data_len
; ++i
)
9228 printf (" %02x", augmentation_data
[i
]);
9234 if (augmentation_data_len
)
9236 unsigned char *p
, *q
;
9237 p
= fc
->augmentation
+ 1;
9238 q
= augmentation_data
;
9245 q
+= 1 + size_of_encoded_value (*q
);
9247 fc
->fde_encoding
= *q
++;
9253 if (fc
->fde_encoding
)
9254 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
9257 frame_need_space (fc
, fc
->ra
);
9261 unsigned char *look_for
;
9262 static Frame_Chunk fde_fc
;
9265 memset (fc
, 0, sizeof (Frame_Chunk
));
9267 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
9269 for (cie
= chunks
; cie
; cie
= cie
->next
)
9270 if (cie
->chunk_start
== look_for
)
9275 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
9276 cie_id
, saved_start
);
9279 fc
->col_type
= xmalloc (sizeof (short int));
9280 fc
->col_offset
= xmalloc (sizeof (int));
9281 frame_need_space (fc
, max_regs
- 1);
9283 fc
->augmentation
= "";
9284 fc
->fde_encoding
= 0;
9288 fc
->ncols
= cie
->ncols
;
9289 fc
->col_type
= xmalloc (fc
->ncols
* sizeof (short int));
9290 fc
->col_offset
= xmalloc (fc
->ncols
* sizeof (int));
9291 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
9292 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
9293 fc
->augmentation
= cie
->augmentation
;
9294 fc
->code_factor
= cie
->code_factor
;
9295 fc
->data_factor
= cie
->data_factor
;
9296 fc
->cfa_reg
= cie
->cfa_reg
;
9297 fc
->cfa_offset
= cie
->cfa_offset
;
9299 frame_need_space (fc
, max_regs
-1);
9300 fc
->fde_encoding
= cie
->fde_encoding
;
9303 if (fc
->fde_encoding
)
9304 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
9306 fc
->pc_begin
= get_encoded_value (start
, fc
->fde_encoding
);
9307 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
9308 /* Don't adjust for ET_REL since there's invariably a pcrel
9309 reloc here, which we haven't applied. */
9310 && elf_header
.e_type
!= ET_REL
)
9311 fc
->pc_begin
+= section
->sh_addr
+ (start
- section_start
);
9312 start
+= encoded_ptr_size
;
9313 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
9314 start
+= encoded_ptr_size
;
9316 if (cie
->augmentation
[0] == 'z')
9318 augmentation_data_len
= LEB ();
9319 augmentation_data
= start
;
9320 start
+= augmentation_data_len
;
9323 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
9324 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
9325 (unsigned long)(cie
->chunk_start
- section_start
),
9326 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
9327 if (! do_debug_frames_interp
&& augmentation_data_len
)
9330 printf (" Augmentation data: ");
9331 for (i
= 0; i
< augmentation_data_len
; ++i
)
9332 printf (" %02x", augmentation_data
[i
]);
9338 /* At this point, fc is the current chunk, cie (if any) is set, and we're
9339 about to interpret instructions for the chunk. */
9340 /* ??? At present we need to do this always, since this sizes the
9341 fc->col_type and fc->col_offset arrays, which we write into always.
9342 We should probably split the interpreted and non-interpreted bits
9343 into two different routines, since there's so much that doesn't
9344 really overlap between them. */
9345 if (1 || do_debug_frames_interp
)
9347 /* Start by making a pass over the chunk, allocating storage
9348 and taking note of what registers are used. */
9349 unsigned char *tmp
= start
;
9351 while (start
< block_end
)
9354 unsigned long reg
, tmp
;
9361 /* Warning: if you add any more cases to this switch, be
9362 sure to add them to the corresponding switch below. */
9365 case DW_CFA_advance_loc
:
9369 frame_need_space (fc
, opa
);
9370 fc
->col_type
[opa
] = DW_CFA_undefined
;
9372 case DW_CFA_restore
:
9373 frame_need_space (fc
, opa
);
9374 fc
->col_type
[opa
] = DW_CFA_undefined
;
9376 case DW_CFA_set_loc
:
9377 start
+= encoded_ptr_size
;
9379 case DW_CFA_advance_loc1
:
9382 case DW_CFA_advance_loc2
:
9385 case DW_CFA_advance_loc4
:
9388 case DW_CFA_offset_extended
:
9389 reg
= LEB (); LEB ();
9390 frame_need_space (fc
, reg
);
9391 fc
->col_type
[reg
] = DW_CFA_undefined
;
9393 case DW_CFA_restore_extended
:
9395 frame_need_space (fc
, reg
);
9396 fc
->col_type
[reg
] = DW_CFA_undefined
;
9398 case DW_CFA_undefined
:
9400 frame_need_space (fc
, reg
);
9401 fc
->col_type
[reg
] = DW_CFA_undefined
;
9403 case DW_CFA_same_value
:
9405 frame_need_space (fc
, reg
);
9406 fc
->col_type
[reg
] = DW_CFA_undefined
;
9408 case DW_CFA_register
:
9409 reg
= LEB (); LEB ();
9410 frame_need_space (fc
, reg
);
9411 fc
->col_type
[reg
] = DW_CFA_undefined
;
9413 case DW_CFA_def_cfa
:
9416 case DW_CFA_def_cfa_register
:
9419 case DW_CFA_def_cfa_offset
:
9422 case DW_CFA_def_cfa_expression
:
9426 case DW_CFA_expression
:
9430 frame_need_space (fc
, reg
);
9431 fc
->col_type
[reg
] = DW_CFA_undefined
;
9433 case DW_CFA_offset_extended_sf
:
9434 reg
= LEB (); SLEB ();
9435 frame_need_space (fc
, reg
);
9436 fc
->col_type
[reg
] = DW_CFA_undefined
;
9438 case DW_CFA_def_cfa_sf
:
9441 case DW_CFA_def_cfa_offset_sf
:
9444 case DW_CFA_MIPS_advance_loc8
:
9447 case DW_CFA_GNU_args_size
:
9450 case DW_CFA_GNU_negative_offset_extended
:
9451 reg
= LEB (); LEB ();
9452 frame_need_space (fc
, reg
);
9453 fc
->col_type
[reg
] = DW_CFA_undefined
;
9462 /* Now we know what registers are used, make a second pass over
9463 the chunk, this time actually printing out the info. */
9465 while (start
< block_end
)
9468 unsigned long ul
, reg
, roffs
;
9477 /* Warning: if you add any more cases to this switch, be
9478 sure to add them to the corresponding switch above. */
9481 case DW_CFA_advance_loc
:
9482 if (do_debug_frames_interp
)
9483 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9485 printf (" DW_CFA_advance_loc: %d to %08lx\n",
9486 opa
* fc
->code_factor
,
9487 fc
->pc_begin
+ opa
* fc
->code_factor
);
9488 fc
->pc_begin
+= opa
* fc
->code_factor
;
9493 if (! do_debug_frames_interp
)
9494 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
9495 opa
, roffs
* fc
->data_factor
);
9496 fc
->col_type
[opa
] = DW_CFA_offset
;
9497 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
9500 case DW_CFA_restore
:
9501 if (! do_debug_frames_interp
)
9502 printf (" DW_CFA_restore: r%d\n", opa
);
9503 fc
->col_type
[opa
] = cie
->col_type
[opa
];
9504 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
9507 case DW_CFA_set_loc
:
9508 vma
= get_encoded_value (start
, fc
->fde_encoding
);
9509 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
9510 && elf_header
.e_type
!= ET_REL
)
9511 vma
+= section
->sh_addr
+ (start
- section_start
);
9512 start
+= encoded_ptr_size
;
9513 if (do_debug_frames_interp
)
9514 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9516 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
9520 case DW_CFA_advance_loc1
:
9521 ofs
= byte_get (start
, 1); start
+= 1;
9522 if (do_debug_frames_interp
)
9523 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9525 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
9526 ofs
* fc
->code_factor
,
9527 fc
->pc_begin
+ ofs
* fc
->code_factor
);
9528 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9531 case DW_CFA_advance_loc2
:
9532 ofs
= byte_get (start
, 2); start
+= 2;
9533 if (do_debug_frames_interp
)
9534 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9536 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
9537 ofs
* fc
->code_factor
,
9538 fc
->pc_begin
+ ofs
* fc
->code_factor
);
9539 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9542 case DW_CFA_advance_loc4
:
9543 ofs
= byte_get (start
, 4); start
+= 4;
9544 if (do_debug_frames_interp
)
9545 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9547 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
9548 ofs
* fc
->code_factor
,
9549 fc
->pc_begin
+ ofs
* fc
->code_factor
);
9550 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9553 case DW_CFA_offset_extended
:
9556 if (! do_debug_frames_interp
)
9557 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
9558 reg
, roffs
* fc
->data_factor
);
9559 fc
->col_type
[reg
] = DW_CFA_offset
;
9560 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
9563 case DW_CFA_restore_extended
:
9565 if (! do_debug_frames_interp
)
9566 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
9567 fc
->col_type
[reg
] = cie
->col_type
[reg
];
9568 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
9571 case DW_CFA_undefined
:
9573 if (! do_debug_frames_interp
)
9574 printf (" DW_CFA_undefined: r%ld\n", reg
);
9575 fc
->col_type
[reg
] = DW_CFA_undefined
;
9576 fc
->col_offset
[reg
] = 0;
9579 case DW_CFA_same_value
:
9581 if (! do_debug_frames_interp
)
9582 printf (" DW_CFA_same_value: r%ld\n", reg
);
9583 fc
->col_type
[reg
] = DW_CFA_same_value
;
9584 fc
->col_offset
[reg
] = 0;
9587 case DW_CFA_register
:
9590 if (! do_debug_frames_interp
)
9591 printf (" DW_CFA_register: r%ld in r%ld\n", reg
, roffs
);
9592 fc
->col_type
[reg
] = DW_CFA_register
;
9593 fc
->col_offset
[reg
] = roffs
;
9596 case DW_CFA_remember_state
:
9597 if (! do_debug_frames_interp
)
9598 printf (" DW_CFA_remember_state\n");
9599 rs
= xmalloc (sizeof (Frame_Chunk
));
9600 rs
->ncols
= fc
->ncols
;
9601 rs
->col_type
= xmalloc (rs
->ncols
* sizeof (short int));
9602 rs
->col_offset
= xmalloc (rs
->ncols
* sizeof (int));
9603 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
9604 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
9605 rs
->next
= remembered_state
;
9606 remembered_state
= rs
;
9609 case DW_CFA_restore_state
:
9610 if (! do_debug_frames_interp
)
9611 printf (" DW_CFA_restore_state\n");
9612 rs
= remembered_state
;
9615 remembered_state
= rs
->next
;
9616 frame_need_space (fc
, rs
->ncols
-1);
9617 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
9618 memcpy (fc
->col_offset
, rs
->col_offset
,
9619 rs
->ncols
* sizeof (int));
9620 free (rs
->col_type
);
9621 free (rs
->col_offset
);
9624 else if (do_debug_frames_interp
)
9625 printf ("Mismatched DW_CFA_restore_state\n");
9628 case DW_CFA_def_cfa
:
9629 fc
->cfa_reg
= LEB ();
9630 fc
->cfa_offset
= LEB ();
9632 if (! do_debug_frames_interp
)
9633 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
9634 fc
->cfa_reg
, fc
->cfa_offset
);
9637 case DW_CFA_def_cfa_register
:
9638 fc
->cfa_reg
= LEB ();
9640 if (! do_debug_frames_interp
)
9641 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
9644 case DW_CFA_def_cfa_offset
:
9645 fc
->cfa_offset
= LEB ();
9646 if (! do_debug_frames_interp
)
9647 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
9651 if (! do_debug_frames_interp
)
9652 printf (" DW_CFA_nop\n");
9655 case DW_CFA_def_cfa_expression
:
9657 if (! do_debug_frames_interp
)
9659 printf (" DW_CFA_def_cfa_expression (");
9660 decode_location_expression (start
, addr_size
, ul
);
9667 case DW_CFA_expression
:
9670 if (! do_debug_frames_interp
)
9672 printf (" DW_CFA_expression: r%ld (", reg
);
9673 decode_location_expression (start
, addr_size
, ul
);
9676 fc
->col_type
[reg
] = DW_CFA_expression
;
9680 case DW_CFA_offset_extended_sf
:
9683 frame_need_space (fc
, reg
);
9684 if (! do_debug_frames_interp
)
9685 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
9686 reg
, l
* fc
->data_factor
);
9687 fc
->col_type
[reg
] = DW_CFA_offset
;
9688 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9691 case DW_CFA_def_cfa_sf
:
9692 fc
->cfa_reg
= LEB ();
9693 fc
->cfa_offset
= SLEB ();
9695 if (! do_debug_frames_interp
)
9696 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
9697 fc
->cfa_reg
, fc
->cfa_offset
);
9700 case DW_CFA_def_cfa_offset_sf
:
9701 fc
->cfa_offset
= SLEB ();
9702 if (! do_debug_frames_interp
)
9703 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
9706 case DW_CFA_MIPS_advance_loc8
:
9707 ofs
= byte_get (start
, 8); start
+= 8;
9708 if (do_debug_frames_interp
)
9709 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9711 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
9712 ofs
* fc
->code_factor
,
9713 fc
->pc_begin
+ ofs
* fc
->code_factor
);
9714 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9717 case DW_CFA_GNU_window_save
:
9718 if (! do_debug_frames_interp
)
9719 printf (" DW_CFA_GNU_window_save\n");
9722 case DW_CFA_GNU_args_size
:
9724 if (! do_debug_frames_interp
)
9725 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
9728 case DW_CFA_GNU_negative_offset_extended
:
9731 frame_need_space (fc
, reg
);
9732 if (! do_debug_frames_interp
)
9733 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
9734 reg
, l
* fc
->data_factor
);
9735 fc
->col_type
[reg
] = DW_CFA_offset
;
9736 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9740 fprintf (stderr
, "unsupported or unknown DW_CFA_%d\n", op
);
9745 if (do_debug_frames_interp
)
9746 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9761 display_debug_not_supported (Elf_Internal_Shdr
*section
,
9762 unsigned char *start ATTRIBUTE_UNUSED
,
9763 FILE *file ATTRIBUTE_UNUSED
)
9765 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
9766 SECTION_NAME (section
));
9771 /* A structure containing the name of a debug section
9772 and a pointer to a function that can decode it. */
9775 const char *const name
;
9776 int (*display
) (Elf_Internal_Shdr
*, unsigned char *, FILE *);
9780 { ".debug_abbrev", display_debug_abbrev
},
9781 { ".debug_aranges", display_debug_aranges
},
9782 { ".debug_frame", display_debug_frames
},
9783 { ".debug_info", display_debug_info
},
9784 { ".debug_line", display_debug_lines
},
9785 { ".debug_pubnames", display_debug_pubnames
},
9786 { ".eh_frame", display_debug_frames
},
9787 { ".debug_macinfo", display_debug_macinfo
},
9788 { ".debug_str", display_debug_str
},
9789 { ".debug_loc", display_debug_loc
},
9790 { ".debug_pubtypes", display_debug_pubnames
},
9791 { ".debug_ranges", display_debug_not_supported
},
9792 { ".debug_static_func", display_debug_not_supported
},
9793 { ".debug_static_vars", display_debug_not_supported
},
9794 { ".debug_types", display_debug_not_supported
},
9795 { ".debug_weaknames", display_debug_not_supported
}
9799 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
9801 char *name
= SECTION_NAME (section
);
9802 bfd_size_type length
;
9803 unsigned char *start
;
9806 length
= section
->sh_size
;
9809 printf (_("\nSection '%s' has no debugging data.\n"), name
);
9813 start
= get_data (NULL
, file
, section
->sh_offset
, length
,
9814 _("debug section data"));
9818 /* See if we know how to display the contents of this section. */
9819 if (strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
9820 name
= ".debug_info";
9822 for (i
= NUM_ELEM (debug_displays
); i
--;)
9823 if (strcmp (debug_displays
[i
].name
, name
) == 0)
9825 debug_displays
[i
].display (section
, start
, file
);
9830 printf (_("Unrecognized debug section: %s\n"), name
);
9834 /* If we loaded in the abbrev section at some point,
9835 we must release it here. */
9842 process_section_contents (FILE *file
)
9844 Elf_Internal_Shdr
*section
;
9850 for (i
= 0, section
= section_headers
;
9851 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
9854 #ifdef SUPPORT_DISASSEMBLY
9855 if (dump_sects
[i
] & DISASS_DUMP
)
9856 disassemble_section (section
, file
);
9858 if (dump_sects
[i
] & HEX_DUMP
)
9859 dump_section (section
, file
);
9861 if (dump_sects
[i
] & DEBUG_DUMP
)
9862 display_debug_section (section
, file
);
9865 if (i
< num_dump_sects
)
9866 warn (_("Some sections were not dumped because they do not exist!\n"));
9872 process_mips_fpe_exception (int mask
)
9877 if (mask
& OEX_FPU_INEX
)
9878 fputs ("INEX", stdout
), first
= 0;
9879 if (mask
& OEX_FPU_UFLO
)
9880 printf ("%sUFLO", first
? "" : "|"), first
= 0;
9881 if (mask
& OEX_FPU_OFLO
)
9882 printf ("%sOFLO", first
? "" : "|"), first
= 0;
9883 if (mask
& OEX_FPU_DIV0
)
9884 printf ("%sDIV0", first
? "" : "|"), first
= 0;
9885 if (mask
& OEX_FPU_INVAL
)
9886 printf ("%sINVAL", first
? "" : "|");
9889 fputs ("0", stdout
);
9893 process_mips_specific (FILE *file
)
9895 Elf_Internal_Dyn
*entry
;
9896 size_t liblist_offset
= 0;
9897 size_t liblistno
= 0;
9898 size_t conflictsno
= 0;
9899 size_t options_offset
= 0;
9900 size_t conflicts_offset
= 0;
9902 /* We have a lot of special sections. Thanks SGI! */
9903 if (dynamic_section
== NULL
)
9904 /* No information available. */
9907 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
9908 switch (entry
->d_tag
)
9910 case DT_MIPS_LIBLIST
:
9912 = offset_from_vma (file
, entry
->d_un
.d_val
,
9913 liblistno
* sizeof (Elf32_External_Lib
));
9915 case DT_MIPS_LIBLISTNO
:
9916 liblistno
= entry
->d_un
.d_val
;
9918 case DT_MIPS_OPTIONS
:
9919 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9921 case DT_MIPS_CONFLICT
:
9923 = offset_from_vma (file
, entry
->d_un
.d_val
,
9924 conflictsno
* sizeof (Elf32_External_Conflict
));
9926 case DT_MIPS_CONFLICTNO
:
9927 conflictsno
= entry
->d_un
.d_val
;
9933 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
9935 Elf32_External_Lib
*elib
;
9938 elib
= get_data (NULL
, file
, liblist_offset
,
9939 liblistno
* sizeof (Elf32_External_Lib
),
9943 printf ("\nSection '.liblist' contains %lu entries:\n",
9944 (unsigned long) liblistno
);
9945 fputs (" Library Time Stamp Checksum Version Flags\n",
9948 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
9955 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9956 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9957 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9958 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9959 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9961 tmp
= gmtime (&time
);
9962 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
9963 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9964 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9966 printf ("%3lu: ", (unsigned long) cnt
);
9967 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
9968 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
9970 printf ("<corrupt: %9ld>", liblist
.l_name
);
9971 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
9974 if (liblist
.l_flags
== 0)
9985 { " EXACT_MATCH", LL_EXACT_MATCH
},
9986 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
9987 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
9988 { " EXPORTS", LL_EXPORTS
},
9989 { " DELAY_LOAD", LL_DELAY_LOAD
},
9990 { " DELTA", LL_DELTA
}
9992 int flags
= liblist
.l_flags
;
9996 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
9998 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
10000 fputs (l_flags_vals
[fcnt
].name
, stdout
);
10001 flags
^= l_flags_vals
[fcnt
].bit
;
10004 printf (" %#x", (unsigned int) flags
);
10014 if (options_offset
!= 0)
10016 Elf_External_Options
*eopt
;
10017 Elf_Internal_Shdr
*sect
= section_headers
;
10018 Elf_Internal_Options
*iopt
;
10019 Elf_Internal_Options
*option
;
10023 /* Find the section header so that we get the size. */
10024 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
10027 eopt
= get_data (NULL
, file
, options_offset
, sect
->sh_size
,
10031 iopt
= malloc ((sect
->sh_size
/ sizeof (eopt
)) * sizeof (*iopt
));
10034 error (_("Out of memory"));
10041 while (offset
< sect
->sh_size
)
10043 Elf_External_Options
*eoption
;
10045 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
10047 option
->kind
= BYTE_GET (eoption
->kind
);
10048 option
->size
= BYTE_GET (eoption
->size
);
10049 option
->section
= BYTE_GET (eoption
->section
);
10050 option
->info
= BYTE_GET (eoption
->info
);
10052 offset
+= option
->size
;
10058 printf (_("\nSection '%s' contains %d entries:\n"),
10059 SECTION_NAME (sect
), cnt
);
10067 switch (option
->kind
)
10070 /* This shouldn't happen. */
10071 printf (" NULL %d %lx", option
->section
, option
->info
);
10074 printf (" REGINFO ");
10075 if (elf_header
.e_machine
== EM_MIPS
)
10078 Elf32_External_RegInfo
*ereg
;
10079 Elf32_RegInfo reginfo
;
10081 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
10082 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
10083 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
10084 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
10085 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
10086 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
10087 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
10089 printf ("GPR %08lx GP 0x%lx\n",
10090 reginfo
.ri_gprmask
,
10091 (unsigned long) reginfo
.ri_gp_value
);
10092 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
10093 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
10094 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
10099 Elf64_External_RegInfo
*ereg
;
10100 Elf64_Internal_RegInfo reginfo
;
10102 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
10103 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
10104 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
10105 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
10106 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
10107 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
10108 reginfo
.ri_gp_value
= BYTE_GET8 (ereg
->ri_gp_value
);
10110 printf ("GPR %08lx GP 0x",
10111 reginfo
.ri_gprmask
);
10112 printf_vma (reginfo
.ri_gp_value
);
10115 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
10116 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
10117 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
10121 case ODK_EXCEPTIONS
:
10122 fputs (" EXCEPTIONS fpe_min(", stdout
);
10123 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
10124 fputs (") fpe_max(", stdout
);
10125 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
10126 fputs (")", stdout
);
10128 if (option
->info
& OEX_PAGE0
)
10129 fputs (" PAGE0", stdout
);
10130 if (option
->info
& OEX_SMM
)
10131 fputs (" SMM", stdout
);
10132 if (option
->info
& OEX_FPDBUG
)
10133 fputs (" FPDBUG", stdout
);
10134 if (option
->info
& OEX_DISMISS
)
10135 fputs (" DISMISS", stdout
);
10138 fputs (" PAD ", stdout
);
10139 if (option
->info
& OPAD_PREFIX
)
10140 fputs (" PREFIX", stdout
);
10141 if (option
->info
& OPAD_POSTFIX
)
10142 fputs (" POSTFIX", stdout
);
10143 if (option
->info
& OPAD_SYMBOL
)
10144 fputs (" SYMBOL", stdout
);
10147 fputs (" HWPATCH ", stdout
);
10148 if (option
->info
& OHW_R4KEOP
)
10149 fputs (" R4KEOP", stdout
);
10150 if (option
->info
& OHW_R8KPFETCH
)
10151 fputs (" R8KPFETCH", stdout
);
10152 if (option
->info
& OHW_R5KEOP
)
10153 fputs (" R5KEOP", stdout
);
10154 if (option
->info
& OHW_R5KCVTL
)
10155 fputs (" R5KCVTL", stdout
);
10158 fputs (" FILL ", stdout
);
10159 /* XXX Print content of info word? */
10162 fputs (" TAGS ", stdout
);
10163 /* XXX Print content of info word? */
10166 fputs (" HWAND ", stdout
);
10167 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
10168 fputs (" R4KEOP_CHECKED", stdout
);
10169 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
10170 fputs (" R4KEOP_CLEAN", stdout
);
10173 fputs (" HWOR ", stdout
);
10174 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
10175 fputs (" R4KEOP_CHECKED", stdout
);
10176 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
10177 fputs (" R4KEOP_CLEAN", stdout
);
10180 printf (" GP_GROUP %#06lx self-contained %#06lx",
10181 option
->info
& OGP_GROUP
,
10182 (option
->info
& OGP_SELF
) >> 16);
10185 printf (" IDENT %#06lx self-contained %#06lx",
10186 option
->info
& OGP_GROUP
,
10187 (option
->info
& OGP_SELF
) >> 16);
10190 /* This shouldn't happen. */
10191 printf (" %3d ??? %d %lx",
10192 option
->kind
, option
->section
, option
->info
);
10196 len
= sizeof (*eopt
);
10197 while (len
< option
->size
)
10198 if (((char *) option
)[len
] >= ' '
10199 && ((char *) option
)[len
] < 0x7f)
10200 printf ("%c", ((char *) option
)[len
++]);
10202 printf ("\\%03o", ((char *) option
)[len
++]);
10204 fputs ("\n", stdout
);
10212 if (conflicts_offset
!= 0 && conflictsno
!= 0)
10214 Elf32_Conflict
*iconf
;
10217 if (dynamic_symbols
== NULL
)
10219 error (_("conflict list found without a dynamic symbol table"));
10223 iconf
= malloc (conflictsno
* sizeof (*iconf
));
10226 error (_("Out of memory"));
10232 Elf32_External_Conflict
*econf32
;
10234 econf32
= get_data (NULL
, file
, conflicts_offset
,
10235 conflictsno
* sizeof (*econf32
), _("conflict"));
10239 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10240 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
10246 Elf64_External_Conflict
*econf64
;
10248 econf64
= get_data (NULL
, file
, conflicts_offset
,
10249 conflictsno
* sizeof (*econf64
), _("conflict"));
10253 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10254 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
10259 printf (_("\nSection '.conflict' contains %lu entries:\n"),
10260 (unsigned long) conflictsno
);
10261 puts (_(" Num: Index Value Name"));
10263 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10265 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
10267 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
10268 print_vma (psym
->st_value
, FULL_HEX
);
10270 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10271 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10273 printf ("<corrupt: %14ld>", psym
->st_name
);
10284 process_gnu_liblist (FILE *file
)
10286 Elf_Internal_Shdr
*section
, *string_sec
;
10287 Elf32_External_Lib
*elib
;
10295 for (i
= 0, section
= section_headers
;
10296 i
< elf_header
.e_shnum
;
10299 switch (section
->sh_type
)
10301 case SHT_GNU_LIBLIST
:
10302 elib
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
10307 string_sec
= SECTION_HEADER (section
->sh_link
);
10309 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
10310 string_sec
->sh_size
, _("liblist string table"));
10313 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
10319 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
10320 SECTION_NAME (section
),
10321 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
10323 puts (" Library Time Stamp Checksum Version Flags");
10325 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
10333 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
10334 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
10335 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
10336 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
10337 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
10339 tmp
= gmtime (&time
);
10340 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
10341 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10342 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10344 printf ("%3lu: ", (unsigned long) cnt
);
10346 printf ("%-20s", strtab
+ liblist
.l_name
);
10348 printf ("%-20.20s", strtab
+ liblist
.l_name
);
10349 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
10350 liblist
.l_version
, liblist
.l_flags
);
10360 static const char *
10361 get_note_type (unsigned e_type
)
10363 static char buff
[64];
10367 case NT_AUXV
: return _("NT_AUXV (auxiliary vector)");
10368 case NT_PRSTATUS
: return _("NT_PRSTATUS (prstatus structure)");
10369 case NT_FPREGSET
: return _("NT_FPREGSET (floating point registers)");
10370 case NT_PRPSINFO
: return _("NT_PRPSINFO (prpsinfo structure)");
10371 case NT_TASKSTRUCT
: return _("NT_TASKSTRUCT (task structure)");
10372 case NT_PRXFPREG
: return _("NT_PRXFPREG (user_xfpregs structure)");
10373 case NT_PSTATUS
: return _("NT_PSTATUS (pstatus structure)");
10374 case NT_FPREGS
: return _("NT_FPREGS (floating point registers)");
10375 case NT_PSINFO
: return _("NT_PSINFO (psinfo structure)");
10376 case NT_LWPSTATUS
: return _("NT_LWPSTATUS (lwpstatus_t structure)");
10377 case NT_LWPSINFO
: return _("NT_LWPSINFO (lwpsinfo_t structure)");
10378 case NT_WIN32PSTATUS
: return _("NT_WIN32PSTATUS (win32_pstatus structure)");
10380 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
10385 static const char *
10386 get_netbsd_elfcore_note_type (unsigned e_type
)
10388 static char buff
[64];
10390 if (e_type
== NT_NETBSDCORE_PROCINFO
)
10392 /* NetBSD core "procinfo" structure. */
10393 return _("NetBSD procinfo structure");
10396 /* As of Jan 2002 there are no other machine-independent notes
10397 defined for NetBSD core files. If the note type is less
10398 than the start of the machine-dependent note types, we don't
10401 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
10403 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
10407 switch (elf_header
.e_machine
)
10409 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
10410 and PT_GETFPREGS == mach+2. */
10415 case EM_SPARC32PLUS
:
10419 case NT_NETBSDCORE_FIRSTMACH
+0:
10420 return _("PT_GETREGS (reg structure)");
10421 case NT_NETBSDCORE_FIRSTMACH
+2:
10422 return _("PT_GETFPREGS (fpreg structure)");
10428 /* On all other arch's, PT_GETREGS == mach+1 and
10429 PT_GETFPREGS == mach+3. */
10433 case NT_NETBSDCORE_FIRSTMACH
+1:
10434 return _("PT_GETREGS (reg structure)");
10435 case NT_NETBSDCORE_FIRSTMACH
+3:
10436 return _("PT_GETFPREGS (fpreg structure)");
10442 sprintf (buff
, _("PT_FIRSTMACH+%d"), e_type
- NT_NETBSDCORE_FIRSTMACH
);
10446 /* Note that by the ELF standard, the name field is already null byte
10447 terminated, and namesz includes the terminating null byte.
10448 I.E. the value of namesz for the name "FSF" is 4.
10450 If the value of namesz is zero, there is no name present. */
10452 process_note (Elf_Internal_Note
*pnote
)
10456 if (pnote
->namesz
== 0)
10458 /* If there is no note name, then use the default set of
10459 note type strings. */
10460 nt
= get_note_type (pnote
->type
);
10462 else if (strncmp (pnote
->namedata
, "NetBSD-CORE", 11) == 0)
10464 /* NetBSD-specific core file notes. */
10465 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
10469 /* Don't recognize this note name; just use the default set of
10470 note type strings. */
10471 nt
= get_note_type (pnote
->type
);
10474 printf (" %s\t\t0x%08lx\t%s\n",
10475 pnote
->namesz
? pnote
->namedata
: "(NONE)",
10476 pnote
->descsz
, nt
);
10482 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
10484 Elf_External_Note
*pnotes
;
10485 Elf_External_Note
*external
;
10491 pnotes
= get_data (NULL
, file
, offset
, length
, _("notes"));
10497 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
10498 (unsigned long) offset
, (unsigned long) length
);
10499 printf (_(" Owner\t\tData size\tDescription\n"));
10501 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
10503 Elf_External_Note
*next
;
10504 Elf_Internal_Note inote
;
10507 inote
.type
= BYTE_GET (external
->type
);
10508 inote
.namesz
= BYTE_GET (external
->namesz
);
10509 inote
.namedata
= external
->name
;
10510 inote
.descsz
= BYTE_GET (external
->descsz
);
10511 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
10512 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
10514 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
10516 if (((char *) next
) > (((char *) pnotes
) + length
))
10518 warn (_("corrupt note found at offset %x into core notes\n"),
10519 ((char *) external
) - ((char *) pnotes
));
10520 warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
10521 inote
.type
, inote
.namesz
, inote
.descsz
);
10527 /* Verify that name is null terminated. It appears that at least
10528 one version of Linux (RedHat 6.0) generates corefiles that don't
10529 comply with the ELF spec by failing to include the null byte in
10531 if (inote
.namedata
[inote
.namesz
] != '\0')
10533 temp
= malloc (inote
.namesz
+ 1);
10537 error (_("Out of memory\n"));
10542 strncpy (temp
, inote
.namedata
, inote
.namesz
);
10543 temp
[inote
.namesz
] = 0;
10545 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
10546 inote
.namedata
= temp
;
10549 res
&= process_note (& inote
);
10564 process_corefile_note_segments (FILE *file
)
10566 Elf_Internal_Phdr
*segment
;
10570 if (! get_program_headers (file
))
10573 for (i
= 0, segment
= program_headers
;
10574 i
< elf_header
.e_phnum
;
10577 if (segment
->p_type
== PT_NOTE
)
10578 res
&= process_corefile_note_segment (file
,
10579 (bfd_vma
) segment
->p_offset
,
10580 (bfd_vma
) segment
->p_filesz
);
10587 process_corefile_contents (FILE *file
)
10589 /* If we have not been asked to display the notes then do nothing. */
10593 /* If file is not a core file then exit. */
10594 if (elf_header
.e_type
!= ET_CORE
)
10597 /* No program headers means no NOTE segment. */
10598 if (elf_header
.e_phnum
== 0)
10600 printf (_("No note segments present in the core file.\n"));
10604 return process_corefile_note_segments (file
);
10608 process_arch_specific (FILE *file
)
10613 switch (elf_header
.e_machine
)
10616 case EM_MIPS_RS3_LE
:
10617 return process_mips_specific (file
);
10626 get_file_header (FILE *file
)
10628 /* Read in the identity array. */
10629 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
10632 /* Determine how to read the rest of the header. */
10633 switch (elf_header
.e_ident
[EI_DATA
])
10635 default: /* fall through */
10636 case ELFDATANONE
: /* fall through */
10638 byte_get
= byte_get_little_endian
;
10639 byte_put
= byte_put_little_endian
;
10642 byte_get
= byte_get_big_endian
;
10643 byte_put
= byte_put_big_endian
;
10647 /* For now we only support 32 bit and 64 bit ELF files. */
10648 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
10650 /* Read in the rest of the header. */
10653 Elf32_External_Ehdr ehdr32
;
10655 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
10658 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
10659 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
10660 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
10661 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
10662 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
10663 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
10664 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
10665 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
10666 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
10667 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
10668 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
10669 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
10670 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
10674 Elf64_External_Ehdr ehdr64
;
10676 /* If we have been compiled with sizeof (bfd_vma) == 4, then
10677 we will not be able to cope with the 64bit data found in
10678 64 ELF files. Detect this now and abort before we start
10679 overwriting things. */
10680 if (sizeof (bfd_vma
) < 8)
10682 error (_("This instance of readelf has been built without support for a\n\
10683 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10687 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
10690 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
10691 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
10692 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
10693 elf_header
.e_entry
= BYTE_GET8 (ehdr64
.e_entry
);
10694 elf_header
.e_phoff
= BYTE_GET8 (ehdr64
.e_phoff
);
10695 elf_header
.e_shoff
= BYTE_GET8 (ehdr64
.e_shoff
);
10696 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
10697 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
10698 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
10699 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
10700 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
10701 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
10702 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
10705 if (elf_header
.e_shoff
)
10707 /* There may be some extensions in the first section header. Don't
10708 bomb if we can't read it. */
10710 get_32bit_section_headers (file
, 1);
10712 get_64bit_section_headers (file
, 1);
10718 /* Process one ELF object file according to the command line options.
10719 This file may actually be stored in an archive. The file is
10720 positioned at the start of the ELF object. */
10723 process_object (char *file_name
, FILE *file
)
10727 if (! get_file_header (file
))
10729 error (_("%s: Failed to read file header\n"), file_name
);
10733 /* Initialise per file variables. */
10734 for (i
= NUM_ELEM (version_info
); i
--;)
10735 version_info
[i
] = 0;
10737 for (i
= NUM_ELEM (dynamic_info
); i
--;)
10738 dynamic_info
[i
] = 0;
10740 /* Process the file. */
10742 printf (_("\nFile: %s\n"), file_name
);
10744 if (! process_file_header ())
10747 if (! process_section_headers (file
)
10748 || ! process_section_groups (file
))
10750 /* Without loaded section headers and section groups we
10751 cannot process lots of things. */
10752 do_unwind
= do_version
= do_dump
= do_arch
= 0;
10754 if (! do_using_dynamic
)
10755 do_syms
= do_reloc
= 0;
10758 if (process_program_headers (file
))
10759 process_dynamic_section (file
);
10761 process_relocs (file
);
10763 process_unwind (file
);
10765 process_symbol_table (file
);
10767 process_syminfo (file
);
10769 process_version_sections (file
);
10771 process_section_contents (file
);
10773 process_corefile_contents (file
);
10775 process_gnu_liblist (file
);
10777 process_arch_specific (file
);
10779 if (program_headers
)
10781 free (program_headers
);
10782 program_headers
= NULL
;
10785 if (section_headers
)
10787 free (section_headers
);
10788 section_headers
= NULL
;
10793 free (string_table
);
10794 string_table
= NULL
;
10795 string_table_length
= 0;
10798 if (dynamic_strings
)
10800 free (dynamic_strings
);
10801 dynamic_strings
= NULL
;
10802 dynamic_strings_length
= 0;
10805 if (dynamic_symbols
)
10807 free (dynamic_symbols
);
10808 dynamic_symbols
= NULL
;
10809 num_dynamic_syms
= 0;
10812 if (dynamic_syminfo
)
10814 free (dynamic_syminfo
);
10815 dynamic_syminfo
= NULL
;
10818 if (section_headers_groups
)
10820 free (section_headers_groups
);
10821 section_headers_groups
= NULL
;
10824 if (section_groups
)
10826 struct group_list
*g
, *next
;
10828 for (i
= 0; i
< group_count
; i
++)
10830 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
10837 free (section_groups
);
10838 section_groups
= NULL
;
10844 /* Process an ELF archive. The file is positioned just after the
10848 process_archive (char *file_name
, FILE *file
)
10850 struct ar_hdr arhdr
;
10852 unsigned long size
;
10853 char *longnames
= NULL
;
10854 unsigned long longnames_size
= 0;
10855 size_t file_name_size
;
10860 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10861 if (got
!= sizeof arhdr
)
10866 error (_("%s: failed to read archive header\n"), file_name
);
10870 if (memcmp (arhdr
.ar_name
, "/ ", 16) == 0)
10872 /* This is the archive symbol table. Skip it.
10873 FIXME: We should have an option to dump it. */
10874 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10875 if (fseek (file
, size
+ (size
& 1), SEEK_CUR
) != 0)
10877 error (_("%s: failed to skip archive symbol table\n"), file_name
);
10881 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10882 if (got
!= sizeof arhdr
)
10887 error (_("%s: failed to read archive header\n"), file_name
);
10892 if (memcmp (arhdr
.ar_name
, "// ", 16) == 0)
10894 /* This is the archive string table holding long member
10897 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10899 longnames
= malloc (longnames_size
);
10900 if (longnames
== NULL
)
10902 error (_("Out of memory\n"));
10906 if (fread (longnames
, longnames_size
, 1, file
) != 1)
10909 error(_("%s: failed to read string table\n"), file_name
);
10913 if ((longnames_size
& 1) != 0)
10916 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10917 if (got
!= sizeof arhdr
)
10924 error (_("%s: failed to read archive header\n"), file_name
);
10929 file_name_size
= strlen (file_name
);
10938 if (arhdr
.ar_name
[0] == '/')
10942 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
10943 if (off
>= longnames_size
)
10945 error (_("%s: invalid archive string table offset %lu\n"), off
);
10950 name
= longnames
+ off
;
10951 nameend
= memchr (name
, '/', longnames_size
- off
);
10955 name
= arhdr
.ar_name
;
10956 nameend
= memchr (name
, '/', 16);
10959 if (nameend
== NULL
)
10961 error (_("%s: bad archive file name\n"));
10966 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
10967 if (namealc
== NULL
)
10969 error (_("Out of memory\n"));
10974 memcpy (namealc
, file_name
, file_name_size
);
10975 namealc
[file_name_size
] = '(';
10976 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
10977 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
10978 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
10980 archive_file_offset
= ftell (file
);
10981 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10983 ret
|= process_object (namealc
, file
);
10988 (archive_file_offset
10989 + archive_file_size
10990 + (archive_file_size
& 1)),
10993 error (_("%s: failed to seek to next archive header\n"), file_name
);
10998 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10999 if (got
!= sizeof arhdr
)
11004 error (_("%s: failed to read archive header\n"), file_name
);
11010 if (longnames
!= 0)
11017 process_file (char *file_name
)
11020 struct stat statbuf
;
11021 char armag
[SARMAG
];
11024 if (stat (file_name
, &statbuf
) < 0)
11026 if (errno
== ENOENT
)
11027 error (_("'%s': No such file\n"), file_name
);
11029 error (_("Could not locate '%s'. System error message: %s\n"),
11030 file_name
, strerror (errno
));
11034 if (! S_ISREG (statbuf
.st_mode
))
11036 error (_("'%s' is not an ordinary file\n"), file_name
);
11040 file
= fopen (file_name
, "rb");
11043 error (_("Input file '%s' is not readable.\n"), file_name
);
11047 if (fread (armag
, SARMAG
, 1, file
) != 1)
11049 error (_("%s: Failed to read file header\n"), file_name
);
11054 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
11055 ret
= process_archive (file_name
, file
);
11059 archive_file_size
= archive_file_offset
= 0;
11060 ret
= process_object (file_name
, file
);
11068 #ifdef SUPPORT_DISASSEMBLY
11069 /* Needed by the i386 disassembler. For extra credit, someone could
11070 fix this so that we insert symbolic addresses here, esp for GOT/PLT
11074 print_address (unsigned int addr
, FILE *outfile
)
11076 fprintf (outfile
,"0x%8.8x", addr
);
11079 /* Needed by the i386 disassembler. */
11081 db_task_printsym (unsigned int addr
)
11083 print_address (addr
, stderr
);
11088 main (int argc
, char **argv
)
11091 char *cmdline_dump_sects
= NULL
;
11092 unsigned num_cmdline_dump_sects
= 0;
11094 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
11095 setlocale (LC_MESSAGES
, "");
11097 #if defined (HAVE_SETLOCALE)
11098 setlocale (LC_CTYPE
, "");
11100 bindtextdomain (PACKAGE
, LOCALEDIR
);
11101 textdomain (PACKAGE
);
11103 parse_args (argc
, argv
);
11105 if (optind
< (argc
- 1))
11108 /* When processing more than one file remember the dump requests
11109 issued on command line to reset them after each file. */
11110 if (optind
+ 1 < argc
&& dump_sects
!= NULL
)
11112 cmdline_dump_sects
= malloc (num_dump_sects
);
11113 if (cmdline_dump_sects
== NULL
)
11114 error (_("Out of memory allocating dump request table."));
11117 memcpy (cmdline_dump_sects
, dump_sects
, num_dump_sects
);
11118 num_cmdline_dump_sects
= num_dump_sects
;
11123 while (optind
< argc
)
11125 err
|= process_file (argv
[optind
++]);
11127 /* Reset dump requests. */
11128 if (optind
< argc
&& dump_sects
!= NULL
)
11130 num_dump_sects
= num_cmdline_dump_sects
;
11131 if (num_cmdline_dump_sects
> 0)
11132 memcpy (dump_sects
, cmdline_dump_sects
, num_cmdline_dump_sects
);
11136 if (dump_sects
!= NULL
)
11138 if (cmdline_dump_sects
!= NULL
)
11139 free (cmdline_dump_sects
);