1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
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
;
164 int do_debug_frames_interp
;
165 int do_debug_macinfo
;
172 int need_base_address
;
173 bfd_vma eh_addr_size
;
177 struct group_list
*next
;
178 unsigned int section_index
;
183 struct group_list
*root
;
184 unsigned int group_index
;
187 struct group
*section_groups
;
190 struct group
**section_headers_groups
;
192 /* A dynamic array of flags indicating for which sections a hex dump
193 has been requested (via the -x switch) and/or a disassembly dump
194 (via the -i switch). */
195 char *cmdline_dump_sects
= NULL
;
196 unsigned num_cmdline_dump_sects
= 0;
198 /* A dynamic array of flags indicating for which sections a dump of
199 some kind has been requested. It is reset on a per-object file
200 basis and then initialised from the cmdline_dump_sects array and
201 the results of interpreting the -w switch. */
202 char *dump_sects
= NULL
;
203 unsigned int num_dump_sects
= 0;
205 #define HEX_DUMP (1 << 0)
206 #define DISASS_DUMP (1 << 1)
207 #define DEBUG_DUMP (1 << 2)
209 /* How to rpint a vma value. */
210 typedef enum print_mode
222 static bfd_vma (*byte_get
) (unsigned char *, int);
223 static void (*byte_put
) (unsigned char *, bfd_vma
, int);
227 #define SECTION_NAME(X) ((X) == NULL ? "<none>" : \
228 ((X)->sh_name >= string_table_length \
229 ? "<corrupt>" : string_table + (X)->sh_name))
231 /* Given st_shndx I, map to section_headers index. */
232 #define SECTION_HEADER_INDEX(I) \
233 ((I) < SHN_LORESERVE \
235 : ((I) <= SHN_HIRESERVE \
237 : (I) - (SHN_HIRESERVE + 1 - SHN_LORESERVE)))
239 /* Reverse of the above. */
240 #define SECTION_HEADER_NUM(N) \
241 ((N) < SHN_LORESERVE \
243 : (N) + (SHN_HIRESERVE + 1 - SHN_LORESERVE))
245 #define SECTION_HEADER(I) (section_headers + SECTION_HEADER_INDEX (I))
247 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
249 #define BYTE_GET(field) byte_get (field, sizeof (field))
251 /* If we can support a 64 bit data type then BFD64 should be defined
252 and sizeof (bfd_vma) == 8. In this case when translating from an
253 external 8 byte field to an internal field, we can assume that the
254 internal field is also 8 bytes wide and so we can extract all the data.
255 If, however, BFD64 is not defined, then we must assume that the
256 internal data structure only has 4 byte wide fields that are the
257 equivalent of the 8 byte wide external counterparts, and so we must
258 truncate the data. */
260 #define BYTE_GET8(field) byte_get (field, -8)
262 #define BYTE_GET8(field) byte_get (field, 8)
265 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
267 #define GET_ELF_SYMBOLS(file, section) \
268 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
269 : get_64bit_elf_symbols (file, section))
271 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
272 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
273 already been called and verified that the string exists. */
274 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
276 /* This is just a bit of syntatic sugar. */
277 #define streq(a,b) (strcmp ((a), (b)) == 0)
278 #define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
281 error (const char *message
, ...)
285 va_start (args
, message
);
286 fprintf (stderr
, _("%s: Error: "), program_name
);
287 vfprintf (stderr
, message
, args
);
292 warn (const char *message
, ...)
296 va_start (args
, message
);
297 fprintf (stderr
, _("%s: Warning: "), program_name
);
298 vfprintf (stderr
, message
, args
);
303 get_data (void *var
, FILE *file
, long offset
, size_t size
, const char *reason
)
310 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
312 error (_("Unable to seek to 0x%x for %s\n"),
313 archive_file_offset
+ offset
, reason
);
320 mvar
= malloc (size
);
324 error (_("Out of memory allocating 0x%x bytes for %s\n"),
330 if (fread (mvar
, size
, 1, file
) != 1)
332 error (_("Unable to read in 0x%x bytes of %s\n"), size
, reason
);
342 byte_get_little_endian (unsigned char *field
, int size
)
350 return ((unsigned int) (field
[0]))
351 | (((unsigned int) (field
[1])) << 8);
355 /* We want to extract data from an 8 byte wide field and
356 place it into a 4 byte wide field. Since this is a little
357 endian source we can just use the 4 byte extraction code. */
361 return ((unsigned long) (field
[0]))
362 | (((unsigned long) (field
[1])) << 8)
363 | (((unsigned long) (field
[2])) << 16)
364 | (((unsigned long) (field
[3])) << 24);
369 /* This is a special case, generated by the BYTE_GET8 macro.
370 It means that we are loading an 8 byte value from a field
371 in an external structure into an 8 byte value in a field
372 in an internal structure. */
373 return ((bfd_vma
) (field
[0]))
374 | (((bfd_vma
) (field
[1])) << 8)
375 | (((bfd_vma
) (field
[2])) << 16)
376 | (((bfd_vma
) (field
[3])) << 24)
377 | (((bfd_vma
) (field
[4])) << 32)
378 | (((bfd_vma
) (field
[5])) << 40)
379 | (((bfd_vma
) (field
[6])) << 48)
380 | (((bfd_vma
) (field
[7])) << 56);
383 error (_("Unhandled data length: %d\n"), size
);
389 byte_get_signed (unsigned char *field
, int size
)
391 bfd_vma x
= byte_get (field
, size
);
396 return (x
^ 0x80) - 0x80;
398 return (x
^ 0x8000) - 0x8000;
400 return (x
^ 0x80000000) - 0x80000000;
410 byte_put_little_endian (unsigned char *field
, bfd_vma value
, int size
)
415 field
[7] = (((value
>> 24) >> 24) >> 8) & 0xff;
416 field
[6] = ((value
>> 24) >> 24) & 0xff;
417 field
[5] = ((value
>> 24) >> 16) & 0xff;
418 field
[4] = ((value
>> 24) >> 8) & 0xff;
421 field
[3] = (value
>> 24) & 0xff;
422 field
[2] = (value
>> 16) & 0xff;
425 field
[1] = (value
>> 8) & 0xff;
428 field
[0] = value
& 0xff;
432 error (_("Unhandled data length: %d\n"), size
);
437 /* Print a VMA value. */
439 print_vma (bfd_vma vma
, print_mode mode
)
451 printf ("%8.8lx", (unsigned long) vma
);
457 printf ("%5ld", (long) vma
);
465 printf ("%lx", (unsigned long) vma
);
469 printf ("%ld", (unsigned long) vma
);
473 printf ("%lu", (unsigned long) vma
);
495 #if BFD_HOST_64BIT_LONG
498 if (_bfd_int64_high (vma
))
499 printf ("%lx%8.8lx", _bfd_int64_high (vma
), _bfd_int64_low (vma
));
501 printf ("%lx", _bfd_int64_low (vma
));
506 #if BFD_HOST_64BIT_LONG
509 if (_bfd_int64_high (vma
))
511 printf ("++%ld", _bfd_int64_low (vma
));
513 printf ("%ld", _bfd_int64_low (vma
));
518 #if BFD_HOST_64BIT_LONG
520 printf ("%5ld", vma
);
522 printf ("%#lx", vma
);
524 if (_bfd_int64_high (vma
))
526 printf ("++%ld", _bfd_int64_low (vma
));
527 else if (vma
<= 99999)
528 printf ("%5ld", _bfd_int64_low (vma
));
530 printf ("%#lx", _bfd_int64_low (vma
));
535 #if BFD_HOST_64BIT_LONG
538 if (_bfd_int64_high (vma
))
540 printf ("++%lu", _bfd_int64_low (vma
));
542 printf ("%lu", _bfd_int64_low (vma
));
550 /* Display a symbol on stdout. If do_wide is not true then
551 format the symbol to be at most WIDTH characters,
552 truncating as necessary. If WIDTH is negative then
553 format the string to be exactly - WIDTH characters,
554 truncating or padding as necessary. */
557 print_symbol (int width
, const char *symbol
)
560 printf ("%s", symbol
);
562 printf ("%-*.*s", width
, width
, symbol
);
564 printf ("%-.*s", width
, symbol
);
568 byte_get_big_endian (unsigned char *field
, int size
)
576 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
579 return ((unsigned long) (field
[3]))
580 | (((unsigned long) (field
[2])) << 8)
581 | (((unsigned long) (field
[1])) << 16)
582 | (((unsigned long) (field
[0])) << 24);
586 /* Although we are extracing data from an 8 byte wide field,
587 we are returning only 4 bytes of data. */
588 return ((unsigned long) (field
[7]))
589 | (((unsigned long) (field
[6])) << 8)
590 | (((unsigned long) (field
[5])) << 16)
591 | (((unsigned long) (field
[4])) << 24);
595 /* This is a special case, generated by the BYTE_GET8 macro.
596 It means that we are loading an 8 byte value from a field
597 in an external structure into an 8 byte value in a field
598 in an internal structure. */
599 return ((bfd_vma
) (field
[7]))
600 | (((bfd_vma
) (field
[6])) << 8)
601 | (((bfd_vma
) (field
[5])) << 16)
602 | (((bfd_vma
) (field
[4])) << 24)
603 | (((bfd_vma
) (field
[3])) << 32)
604 | (((bfd_vma
) (field
[2])) << 40)
605 | (((bfd_vma
) (field
[1])) << 48)
606 | (((bfd_vma
) (field
[0])) << 56);
610 error (_("Unhandled data length: %d\n"), size
);
616 byte_put_big_endian (unsigned char *field
, bfd_vma value
, int size
)
621 field
[7] = value
& 0xff;
622 field
[6] = (value
>> 8) & 0xff;
623 field
[5] = (value
>> 16) & 0xff;
624 field
[4] = (value
>> 24) & 0xff;
629 field
[3] = value
& 0xff;
630 field
[2] = (value
>> 8) & 0xff;
634 field
[1] = value
& 0xff;
638 field
[0] = value
& 0xff;
642 error (_("Unhandled data length: %d\n"), size
);
647 /* Return a pointer to section NAME, or NULL if no such section exists. */
649 static Elf_Internal_Shdr
*
650 find_section (const char *name
)
654 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
655 if (streq (SECTION_NAME (section_headers
+ i
), name
))
656 return section_headers
+ i
;
661 /* Guess the relocation size commonly used by the specific machines. */
664 guess_is_rela (unsigned long e_machine
)
668 /* Targets that use REL relocations. */
683 /* Targets that use RELA relocations. */
698 case EM_CYGNUS_MN10200
:
700 case EM_CYGNUS_MN10300
:
747 warn (_("Don't know about relocations on this machine architecture\n"));
753 slurp_rela_relocs (FILE *file
,
754 unsigned long rel_offset
,
755 unsigned long rel_size
,
756 Elf_Internal_Rela
**relasp
,
757 unsigned long *nrelasp
)
759 Elf_Internal_Rela
*relas
;
760 unsigned long nrelas
;
765 Elf32_External_Rela
*erelas
;
767 erelas
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
771 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
773 relas
= malloc (nrelas
* sizeof (Elf_Internal_Rela
));
777 error (_("out of memory parsing relocs"));
781 for (i
= 0; i
< nrelas
; i
++)
783 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
784 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
785 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
792 Elf64_External_Rela
*erelas
;
794 erelas
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
798 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
800 relas
= malloc (nrelas
* sizeof (Elf_Internal_Rela
));
804 error (_("out of memory parsing relocs"));
808 for (i
= 0; i
< nrelas
; i
++)
810 relas
[i
].r_offset
= BYTE_GET8 (erelas
[i
].r_offset
);
811 relas
[i
].r_info
= BYTE_GET8 (erelas
[i
].r_info
);
812 relas
[i
].r_addend
= BYTE_GET8 (erelas
[i
].r_addend
);
823 slurp_rel_relocs (FILE *file
,
824 unsigned long rel_offset
,
825 unsigned long rel_size
,
826 Elf_Internal_Rela
**relsp
,
827 unsigned long *nrelsp
)
829 Elf_Internal_Rela
*rels
;
835 Elf32_External_Rel
*erels
;
837 erels
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
841 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
843 rels
= malloc (nrels
* sizeof (Elf_Internal_Rela
));
847 error (_("out of memory parsing relocs"));
851 for (i
= 0; i
< nrels
; i
++)
853 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
854 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
855 rels
[i
].r_addend
= 0;
862 Elf64_External_Rel
*erels
;
864 erels
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
868 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
870 rels
= malloc (nrels
* sizeof (Elf_Internal_Rela
));
874 error (_("out of memory parsing relocs"));
878 for (i
= 0; i
< nrels
; i
++)
880 rels
[i
].r_offset
= BYTE_GET8 (erels
[i
].r_offset
);
881 rels
[i
].r_info
= BYTE_GET8 (erels
[i
].r_info
);
882 rels
[i
].r_addend
= 0;
892 /* Display the contents of the relocation data found at the specified
896 dump_relocations (FILE *file
,
897 unsigned long rel_offset
,
898 unsigned long rel_size
,
899 Elf_Internal_Sym
*symtab
,
902 unsigned long strtablen
,
906 Elf_Internal_Rela
*rels
;
909 if (is_rela
== UNKNOWN
)
910 is_rela
= guess_is_rela (elf_header
.e_machine
);
914 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
919 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
928 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
930 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
935 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
937 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
945 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
947 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
952 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
954 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
958 for (i
= 0; i
< rel_size
; i
++)
961 const char *rtype2
= NULL
;
962 const char *rtype3
= NULL
;
965 bfd_vma symtab_index
;
970 offset
= rels
[i
].r_offset
;
971 info
= rels
[i
].r_info
;
975 type
= ELF32_R_TYPE (info
);
976 symtab_index
= ELF32_R_SYM (info
);
980 /* The #ifdef BFD64 below is to prevent a compile time warning.
981 We know that if we do not have a 64 bit data type that we
982 will never execute this code anyway. */
984 if (elf_header
.e_machine
== EM_MIPS
)
986 /* In little-endian objects, r_info isn't really a 64-bit
987 little-endian value: it has a 32-bit little-endian
988 symbol index followed by four individual byte fields.
989 Reorder INFO accordingly. */
990 if (elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
991 info
= (((info
& 0xffffffff) << 32)
992 | ((info
>> 56) & 0xff)
993 | ((info
>> 40) & 0xff00)
994 | ((info
>> 24) & 0xff0000)
995 | ((info
>> 8) & 0xff000000));
996 type
= ELF64_MIPS_R_TYPE (info
);
997 type2
= ELF64_MIPS_R_TYPE2 (info
);
998 type3
= ELF64_MIPS_R_TYPE3 (info
);
1000 else if (elf_header
.e_machine
== EM_SPARCV9
)
1001 type
= ELF64_R_TYPE_ID (info
);
1003 type
= ELF64_R_TYPE (info
);
1005 symtab_index
= ELF64_R_SYM (info
);
1011 #ifdef _bfd_int64_low
1012 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset
), _bfd_int64_low (info
));
1014 printf ("%8.8lx %8.8lx ", offset
, info
);
1019 #ifdef _bfd_int64_low
1021 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1022 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1023 _bfd_int64_high (offset
),
1024 _bfd_int64_low (offset
),
1025 _bfd_int64_high (info
),
1026 _bfd_int64_low (info
));
1029 ? "%16.16lx %16.16lx "
1030 : "%12.12lx %12.12lx ",
1035 switch (elf_header
.e_machine
)
1042 case EM_CYGNUS_M32R
:
1043 rtype
= elf_m32r_reloc_type (type
);
1048 rtype
= elf_i386_reloc_type (type
);
1053 rtype
= elf_m68hc11_reloc_type (type
);
1057 rtype
= elf_m68k_reloc_type (type
);
1061 rtype
= elf_i960_reloc_type (type
);
1066 rtype
= elf_avr_reloc_type (type
);
1069 case EM_OLD_SPARCV9
:
1070 case EM_SPARC32PLUS
:
1073 rtype
= elf_sparc_reloc_type (type
);
1077 case EM_CYGNUS_V850
:
1078 rtype
= v850_reloc_type (type
);
1082 case EM_CYGNUS_D10V
:
1083 rtype
= elf_d10v_reloc_type (type
);
1087 case EM_CYGNUS_D30V
:
1088 rtype
= elf_d30v_reloc_type (type
);
1092 rtype
= elf_dlx_reloc_type (type
);
1096 rtype
= elf_sh_reloc_type (type
);
1100 case EM_CYGNUS_MN10300
:
1101 rtype
= elf_mn10300_reloc_type (type
);
1105 case EM_CYGNUS_MN10200
:
1106 rtype
= elf_mn10200_reloc_type (type
);
1110 case EM_CYGNUS_FR30
:
1111 rtype
= elf_fr30_reloc_type (type
);
1115 rtype
= elf_frv_reloc_type (type
);
1119 rtype
= elf_mcore_reloc_type (type
);
1123 rtype
= elf_mmix_reloc_type (type
);
1128 rtype
= elf_msp430_reloc_type (type
);
1132 rtype
= elf_ppc_reloc_type (type
);
1136 rtype
= elf_ppc64_reloc_type (type
);
1140 case EM_MIPS_RS3_LE
:
1141 rtype
= elf_mips_reloc_type (type
);
1144 rtype2
= elf_mips_reloc_type (type2
);
1145 rtype3
= elf_mips_reloc_type (type3
);
1150 rtype
= elf_alpha_reloc_type (type
);
1154 rtype
= elf_arm_reloc_type (type
);
1158 rtype
= elf_arc_reloc_type (type
);
1162 rtype
= elf_hppa_reloc_type (type
);
1168 rtype
= elf_h8_reloc_type (type
);
1173 rtype
= elf_or32_reloc_type (type
);
1178 rtype
= elf_pj_reloc_type (type
);
1181 rtype
= elf_ia64_reloc_type (type
);
1185 rtype
= elf_cris_reloc_type (type
);
1189 rtype
= elf_i860_reloc_type (type
);
1193 rtype
= elf_x86_64_reloc_type (type
);
1197 rtype
= i370_reloc_type (type
);
1202 rtype
= elf_s390_reloc_type (type
);
1206 rtype
= elf_xstormy16_reloc_type (type
);
1210 rtype
= elf_crx_reloc_type (type
);
1214 rtype
= elf_vax_reloc_type (type
);
1219 rtype
= elf_ip2k_reloc_type (type
);
1223 rtype
= elf_iq2000_reloc_type (type
);
1228 rtype
= elf_xtensa_reloc_type (type
);
1233 #ifdef _bfd_int64_low
1234 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type
));
1236 printf (_("unrecognized: %-7lx"), type
);
1239 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1243 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1244 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1247 Elf_Internal_Sym
*psym
;
1249 psym
= symtab
+ symtab_index
;
1252 print_vma (psym
->st_value
, LONG_HEX
);
1253 printf (is_32bit_elf
? " " : " ");
1255 if (psym
->st_name
== 0)
1257 const char *sec_name
= "<null>";
1260 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1262 bfd_vma sec_index
= (bfd_vma
) -1;
1264 if (psym
->st_shndx
< SHN_LORESERVE
)
1265 sec_index
= psym
->st_shndx
;
1266 else if (psym
->st_shndx
> SHN_HIRESERVE
)
1267 sec_index
= psym
->st_shndx
- (SHN_HIRESERVE
+ 1
1270 if (sec_index
!= (bfd_vma
) -1)
1271 sec_name
= SECTION_NAME (section_headers
+ sec_index
);
1272 else if (psym
->st_shndx
== SHN_ABS
)
1274 else if (psym
->st_shndx
== SHN_COMMON
)
1275 sec_name
= "COMMON";
1276 else if (elf_header
.e_machine
== EM_IA_64
1277 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1278 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1279 sec_name
= "ANSI_COM";
1282 sprintf (name_buf
, "<section 0x%x>",
1283 (unsigned int) psym
->st_shndx
);
1284 sec_name
= name_buf
;
1287 print_symbol (22, sec_name
);
1289 else if (strtab
== NULL
)
1290 printf (_("<string table index: %3ld>"), psym
->st_name
);
1291 else if (psym
->st_name
> strtablen
)
1292 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1294 print_symbol (22, strtab
+ psym
->st_name
);
1297 printf (" + %lx", (unsigned long) rels
[i
].r_addend
);
1302 printf ("%*c", is_32bit_elf
?
1303 (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1304 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1307 if (elf_header
.e_machine
== EM_SPARCV9
1308 && streq (rtype
, "R_SPARC_OLO10"))
1309 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1313 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1315 printf (" Type2: ");
1318 #ifdef _bfd_int64_low
1319 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2
));
1321 printf (_("unrecognized: %-7lx"), type2
);
1324 printf ("%-17.17s", rtype2
);
1326 printf ("\n Type3: ");
1329 #ifdef _bfd_int64_low
1330 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3
));
1332 printf (_("unrecognized: %-7lx"), type3
);
1335 printf ("%-17.17s", rtype3
);
1347 get_mips_dynamic_type (unsigned long type
)
1351 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1352 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1353 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1354 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1355 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1356 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1357 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1358 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1359 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1360 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1361 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1362 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1363 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1364 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1365 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1366 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1367 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1368 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1369 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1370 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1371 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1372 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1373 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1374 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1375 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1376 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1377 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1378 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1379 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1380 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1381 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1382 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1383 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1384 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1385 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1386 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1387 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1388 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1389 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1390 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1391 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1392 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1393 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1400 get_sparc64_dynamic_type (unsigned long type
)
1404 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1411 get_ppc64_dynamic_type (unsigned long type
)
1415 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1416 case DT_PPC64_OPD
: return "PPC64_OPD";
1417 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1424 get_parisc_dynamic_type (unsigned long type
)
1428 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1429 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1430 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1431 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1432 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1433 case DT_HP_PREINIT
: return "HP_PREINIT";
1434 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1435 case DT_HP_NEEDED
: return "HP_NEEDED";
1436 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1437 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1438 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1439 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1440 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1447 get_ia64_dynamic_type (unsigned long type
)
1451 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1458 get_dynamic_type (unsigned long type
)
1460 static char buff
[32];
1464 case DT_NULL
: return "NULL";
1465 case DT_NEEDED
: return "NEEDED";
1466 case DT_PLTRELSZ
: return "PLTRELSZ";
1467 case DT_PLTGOT
: return "PLTGOT";
1468 case DT_HASH
: return "HASH";
1469 case DT_STRTAB
: return "STRTAB";
1470 case DT_SYMTAB
: return "SYMTAB";
1471 case DT_RELA
: return "RELA";
1472 case DT_RELASZ
: return "RELASZ";
1473 case DT_RELAENT
: return "RELAENT";
1474 case DT_STRSZ
: return "STRSZ";
1475 case DT_SYMENT
: return "SYMENT";
1476 case DT_INIT
: return "INIT";
1477 case DT_FINI
: return "FINI";
1478 case DT_SONAME
: return "SONAME";
1479 case DT_RPATH
: return "RPATH";
1480 case DT_SYMBOLIC
: return "SYMBOLIC";
1481 case DT_REL
: return "REL";
1482 case DT_RELSZ
: return "RELSZ";
1483 case DT_RELENT
: return "RELENT";
1484 case DT_PLTREL
: return "PLTREL";
1485 case DT_DEBUG
: return "DEBUG";
1486 case DT_TEXTREL
: return "TEXTREL";
1487 case DT_JMPREL
: return "JMPREL";
1488 case DT_BIND_NOW
: return "BIND_NOW";
1489 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1490 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1491 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1492 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1493 case DT_RUNPATH
: return "RUNPATH";
1494 case DT_FLAGS
: return "FLAGS";
1496 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1497 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1499 case DT_CHECKSUM
: return "CHECKSUM";
1500 case DT_PLTPADSZ
: return "PLTPADSZ";
1501 case DT_MOVEENT
: return "MOVEENT";
1502 case DT_MOVESZ
: return "MOVESZ";
1503 case DT_FEATURE
: return "FEATURE";
1504 case DT_POSFLAG_1
: return "POSFLAG_1";
1505 case DT_SYMINSZ
: return "SYMINSZ";
1506 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1508 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1509 case DT_CONFIG
: return "CONFIG";
1510 case DT_DEPAUDIT
: return "DEPAUDIT";
1511 case DT_AUDIT
: return "AUDIT";
1512 case DT_PLTPAD
: return "PLTPAD";
1513 case DT_MOVETAB
: return "MOVETAB";
1514 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1516 case DT_VERSYM
: return "VERSYM";
1518 case DT_RELACOUNT
: return "RELACOUNT";
1519 case DT_RELCOUNT
: return "RELCOUNT";
1520 case DT_FLAGS_1
: return "FLAGS_1";
1521 case DT_VERDEF
: return "VERDEF";
1522 case DT_VERDEFNUM
: return "VERDEFNUM";
1523 case DT_VERNEED
: return "VERNEED";
1524 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1526 case DT_AUXILIARY
: return "AUXILIARY";
1527 case DT_USED
: return "USED";
1528 case DT_FILTER
: return "FILTER";
1530 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1531 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1532 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1533 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1534 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1537 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1541 switch (elf_header
.e_machine
)
1544 case EM_MIPS_RS3_LE
:
1545 result
= get_mips_dynamic_type (type
);
1548 result
= get_sparc64_dynamic_type (type
);
1551 result
= get_ppc64_dynamic_type (type
);
1554 result
= get_ia64_dynamic_type (type
);
1564 sprintf (buff
, _("Processor Specific: %lx"), type
);
1566 else if ((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1570 switch (elf_header
.e_machine
)
1573 result
= get_parisc_dynamic_type (type
);
1583 sprintf (buff
, _("Operating System specific: %lx"), type
);
1586 sprintf (buff
, _("<unknown>: %lx"), type
);
1593 get_file_type (unsigned e_type
)
1595 static char buff
[32];
1599 case ET_NONE
: return _("NONE (None)");
1600 case ET_REL
: return _("REL (Relocatable file)");
1601 case ET_EXEC
: return _("EXEC (Executable file)");
1602 case ET_DYN
: return _("DYN (Shared object file)");
1603 case ET_CORE
: return _("CORE (Core file)");
1606 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1607 sprintf (buff
, _("Processor Specific: (%x)"), e_type
);
1608 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1609 sprintf (buff
, _("OS Specific: (%x)"), e_type
);
1611 sprintf (buff
, _("<unknown>: %x"), e_type
);
1617 get_machine_name (unsigned e_machine
)
1619 static char buff
[64]; /* XXX */
1623 case EM_NONE
: return _("None");
1624 case EM_M32
: return "WE32100";
1625 case EM_SPARC
: return "Sparc";
1626 case EM_386
: return "Intel 80386";
1627 case EM_68K
: return "MC68000";
1628 case EM_88K
: return "MC88000";
1629 case EM_486
: return "Intel 80486";
1630 case EM_860
: return "Intel 80860";
1631 case EM_MIPS
: return "MIPS R3000";
1632 case EM_S370
: return "IBM System/370";
1633 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1634 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1635 case EM_PARISC
: return "HPPA";
1636 case EM_PPC_OLD
: return "Power PC (old)";
1637 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1638 case EM_960
: return "Intel 90860";
1639 case EM_PPC
: return "PowerPC";
1640 case EM_PPC64
: return "PowerPC64";
1641 case EM_V800
: return "NEC V800";
1642 case EM_FR20
: return "Fujitsu FR20";
1643 case EM_RH32
: return "TRW RH32";
1644 case EM_MCORE
: return "MCORE";
1645 case EM_ARM
: return "ARM";
1646 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1647 case EM_SH
: return "Renesas / SuperH SH";
1648 case EM_SPARCV9
: return "Sparc v9";
1649 case EM_TRICORE
: return "Siemens Tricore";
1650 case EM_ARC
: return "ARC";
1651 case EM_H8_300
: return "Renesas H8/300";
1652 case EM_H8_300H
: return "Renesas H8/300H";
1653 case EM_H8S
: return "Renesas H8S";
1654 case EM_H8_500
: return "Renesas H8/500";
1655 case EM_IA_64
: return "Intel IA-64";
1656 case EM_MIPS_X
: return "Stanford MIPS-X";
1657 case EM_COLDFIRE
: return "Motorola Coldfire";
1658 case EM_68HC12
: return "Motorola M68HC12";
1659 case EM_ALPHA
: return "Alpha";
1660 case EM_CYGNUS_D10V
:
1661 case EM_D10V
: return "d10v";
1662 case EM_CYGNUS_D30V
:
1663 case EM_D30V
: return "d30v";
1664 case EM_CYGNUS_M32R
:
1665 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1666 case EM_CYGNUS_V850
:
1667 case EM_V850
: return "NEC v850";
1668 case EM_CYGNUS_MN10300
:
1669 case EM_MN10300
: return "mn10300";
1670 case EM_CYGNUS_MN10200
:
1671 case EM_MN10200
: return "mn10200";
1672 case EM_CYGNUS_FR30
:
1673 case EM_FR30
: return "Fujitsu FR30";
1674 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1676 case EM_PJ
: return "picoJava";
1677 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1678 case EM_PCP
: return "Siemens PCP";
1679 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1680 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1681 case EM_STARCORE
: return "Motorola Star*Core processor";
1682 case EM_ME16
: return "Toyota ME16 processor";
1683 case EM_ST100
: return "STMicroelectronics ST100 processor";
1684 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1685 case EM_FX66
: return "Siemens FX66 microcontroller";
1686 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1687 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1688 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1689 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1690 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1691 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1692 case EM_SVX
: return "Silicon Graphics SVx";
1693 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1694 case EM_VAX
: return "Digital VAX";
1696 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1697 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1698 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1699 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1700 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1701 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1702 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1703 case EM_PRISM
: return "Vitesse Prism";
1704 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1706 case EM_S390
: return "IBM S/390";
1707 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1709 case EM_OR32
: return "OpenRISC";
1710 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1711 case EM_DLX
: return "OpenDLX";
1713 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1714 case EM_IQ2000
: return "Vitesse IQ2000";
1716 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1718 sprintf (buff
, _("<unknown>: %x"), e_machine
);
1724 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
1729 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1730 e_flags
&= ~ EF_ARM_EABIMASK
;
1732 /* Handle "generic" ARM flags. */
1733 if (e_flags
& EF_ARM_RELEXEC
)
1735 strcat (buf
, ", relocatable executable");
1736 e_flags
&= ~ EF_ARM_RELEXEC
;
1739 if (e_flags
& EF_ARM_HASENTRY
)
1741 strcat (buf
, ", has entry point");
1742 e_flags
&= ~ EF_ARM_HASENTRY
;
1745 /* Now handle EABI specific flags. */
1749 strcat (buf
, ", <unrecognized EABI>");
1754 case EF_ARM_EABI_VER1
:
1755 strcat (buf
, ", Version1 EABI");
1760 /* Process flags one bit at a time. */
1761 flag
= e_flags
& - e_flags
;
1766 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1767 strcat (buf
, ", sorted symbol tables");
1777 case EF_ARM_EABI_VER2
:
1778 strcat (buf
, ", Version2 EABI");
1783 /* Process flags one bit at a time. */
1784 flag
= e_flags
& - e_flags
;
1789 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1790 strcat (buf
, ", sorted symbol tables");
1793 case EF_ARM_DYNSYMSUSESEGIDX
:
1794 strcat (buf
, ", dynamic symbols use segment index");
1797 case EF_ARM_MAPSYMSFIRST
:
1798 strcat (buf
, ", mapping symbols precede others");
1808 case EF_ARM_EABI_VER3
:
1809 strcat (buf
, ", Version3 EABI");
1812 case EF_ARM_EABI_VER4
:
1813 strcat (buf
, ", Version4 EABI");
1818 /* Process flags one bit at a time. */
1819 flag
= e_flags
& - e_flags
;
1825 strcat (buf
, ", BE8");
1829 strcat (buf
, ", LE8");
1839 case EF_ARM_EABI_UNKNOWN
:
1840 strcat (buf
, ", GNU EABI");
1845 /* Process flags one bit at a time. */
1846 flag
= e_flags
& - e_flags
;
1851 case EF_ARM_INTERWORK
:
1852 strcat (buf
, ", interworking enabled");
1855 case EF_ARM_APCS_26
:
1856 strcat (buf
, ", uses APCS/26");
1859 case EF_ARM_APCS_FLOAT
:
1860 strcat (buf
, ", uses APCS/float");
1864 strcat (buf
, ", position independent");
1868 strcat (buf
, ", 8 bit structure alignment");
1871 case EF_ARM_NEW_ABI
:
1872 strcat (buf
, ", uses new ABI");
1875 case EF_ARM_OLD_ABI
:
1876 strcat (buf
, ", uses old ABI");
1879 case EF_ARM_SOFT_FLOAT
:
1880 strcat (buf
, ", software FP");
1883 case EF_ARM_VFP_FLOAT
:
1884 strcat (buf
, ", VFP");
1887 case EF_ARM_MAVERICK_FLOAT
:
1888 strcat (buf
, ", Maverick FP");
1899 strcat (buf
,", <unknown>");
1903 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
1905 static char buf
[1024];
1917 decode_ARM_machine_flags (e_flags
, buf
);
1921 switch (e_flags
& EF_FRV_CPU_MASK
)
1923 case EF_FRV_CPU_GENERIC
:
1927 strcat (buf
, ", fr???");
1930 case EF_FRV_CPU_FR300
:
1931 strcat (buf
, ", fr300");
1934 case EF_FRV_CPU_FR400
:
1935 strcat (buf
, ", fr400");
1937 case EF_FRV_CPU_FR405
:
1938 strcat (buf
, ", fr405");
1941 case EF_FRV_CPU_FR450
:
1942 strcat (buf
, ", fr450");
1945 case EF_FRV_CPU_FR500
:
1946 strcat (buf
, ", fr500");
1948 case EF_FRV_CPU_FR550
:
1949 strcat (buf
, ", fr550");
1952 case EF_FRV_CPU_SIMPLE
:
1953 strcat (buf
, ", simple");
1955 case EF_FRV_CPU_TOMCAT
:
1956 strcat (buf
, ", tomcat");
1962 if (e_flags
& EF_CPU32
)
1963 strcat (buf
, ", cpu32");
1964 if (e_flags
& EF_M68000
)
1965 strcat (buf
, ", m68000");
1969 if (e_flags
& EF_PPC_EMB
)
1970 strcat (buf
, ", emb");
1972 if (e_flags
& EF_PPC_RELOCATABLE
)
1973 strcat (buf
, ", relocatable");
1975 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
1976 strcat (buf
, ", relocatable-lib");
1980 case EM_CYGNUS_V850
:
1981 switch (e_flags
& EF_V850_ARCH
)
1984 strcat (buf
, ", v850e1");
1987 strcat (buf
, ", v850e");
1990 strcat (buf
, ", v850");
1993 strcat (buf
, ", unknown v850 architecture variant");
1999 case EM_CYGNUS_M32R
:
2000 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2001 strcat (buf
, ", m32r");
2006 case EM_MIPS_RS3_LE
:
2007 if (e_flags
& EF_MIPS_NOREORDER
)
2008 strcat (buf
, ", noreorder");
2010 if (e_flags
& EF_MIPS_PIC
)
2011 strcat (buf
, ", pic");
2013 if (e_flags
& EF_MIPS_CPIC
)
2014 strcat (buf
, ", cpic");
2016 if (e_flags
& EF_MIPS_UCODE
)
2017 strcat (buf
, ", ugen_reserved");
2019 if (e_flags
& EF_MIPS_ABI2
)
2020 strcat (buf
, ", abi2");
2022 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2023 strcat (buf
, ", odk first");
2025 if (e_flags
& EF_MIPS_32BITMODE
)
2026 strcat (buf
, ", 32bitmode");
2028 switch ((e_flags
& EF_MIPS_MACH
))
2030 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2031 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2032 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2033 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2034 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2035 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2036 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2037 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2038 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2039 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2041 /* We simply ignore the field in this case to avoid confusion:
2042 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2045 default: strcat (buf
, ", unknown CPU"); break;
2048 switch ((e_flags
& EF_MIPS_ABI
))
2050 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2051 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2052 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2053 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2055 /* We simply ignore the field in this case to avoid confusion:
2056 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2057 This means it is likely to be an o32 file, but not for
2060 default: strcat (buf
, ", unknown ABI"); break;
2063 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2064 strcat (buf
, ", mdmx");
2066 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2067 strcat (buf
, ", mips16");
2069 switch ((e_flags
& EF_MIPS_ARCH
))
2071 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2072 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2073 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2074 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2075 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2076 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2077 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2078 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2079 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2080 default: strcat (buf
, ", unknown ISA"); break;
2086 switch ((e_flags
& EF_SH_MACH_MASK
))
2088 case EF_SH1
: strcat (buf
, ", sh1"); break;
2089 case EF_SH2
: strcat (buf
, ", sh2"); break;
2090 case EF_SH3
: strcat (buf
, ", sh3"); break;
2091 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2092 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2093 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2094 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2095 case EF_SH4
: strcat (buf
, ", sh4"); break;
2096 case EF_SH5
: strcat (buf
, ", sh5"); break;
2097 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2098 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2099 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2100 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2101 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2102 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2103 default: strcat (buf
, ", unknown ISA"); break;
2109 if (e_flags
& EF_SPARC_32PLUS
)
2110 strcat (buf
, ", v8+");
2112 if (e_flags
& EF_SPARC_SUN_US1
)
2113 strcat (buf
, ", ultrasparcI");
2115 if (e_flags
& EF_SPARC_SUN_US3
)
2116 strcat (buf
, ", ultrasparcIII");
2118 if (e_flags
& EF_SPARC_HAL_R1
)
2119 strcat (buf
, ", halr1");
2121 if (e_flags
& EF_SPARC_LEDATA
)
2122 strcat (buf
, ", ledata");
2124 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2125 strcat (buf
, ", tso");
2127 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2128 strcat (buf
, ", pso");
2130 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2131 strcat (buf
, ", rmo");
2135 switch (e_flags
& EF_PARISC_ARCH
)
2137 case EFA_PARISC_1_0
:
2138 strcpy (buf
, ", PA-RISC 1.0");
2140 case EFA_PARISC_1_1
:
2141 strcpy (buf
, ", PA-RISC 1.1");
2143 case EFA_PARISC_2_0
:
2144 strcpy (buf
, ", PA-RISC 2.0");
2149 if (e_flags
& EF_PARISC_TRAPNIL
)
2150 strcat (buf
, ", trapnil");
2151 if (e_flags
& EF_PARISC_EXT
)
2152 strcat (buf
, ", ext");
2153 if (e_flags
& EF_PARISC_LSB
)
2154 strcat (buf
, ", lsb");
2155 if (e_flags
& EF_PARISC_WIDE
)
2156 strcat (buf
, ", wide");
2157 if (e_flags
& EF_PARISC_NO_KABP
)
2158 strcat (buf
, ", no kabp");
2159 if (e_flags
& EF_PARISC_LAZYSWAP
)
2160 strcat (buf
, ", lazyswap");
2165 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2166 strcat (buf
, ", new calling convention");
2168 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2169 strcat (buf
, ", gnu calling convention");
2173 if ((e_flags
& EF_IA_64_ABI64
))
2174 strcat (buf
, ", 64-bit");
2176 strcat (buf
, ", 32-bit");
2177 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2178 strcat (buf
, ", reduced fp model");
2179 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2180 strcat (buf
, ", no function descriptors, constant gp");
2181 else if ((e_flags
& EF_IA_64_CONS_GP
))
2182 strcat (buf
, ", constant gp");
2183 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2184 strcat (buf
, ", absolute");
2188 if ((e_flags
& EF_VAX_NONPIC
))
2189 strcat (buf
, ", non-PIC");
2190 if ((e_flags
& EF_VAX_DFLOAT
))
2191 strcat (buf
, ", D-Float");
2192 if ((e_flags
& EF_VAX_GFLOAT
))
2193 strcat (buf
, ", G-Float");
2202 get_osabi_name (unsigned int osabi
)
2204 static char buff
[32];
2208 case ELFOSABI_NONE
: return "UNIX - System V";
2209 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2210 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2211 case ELFOSABI_LINUX
: return "UNIX - Linux";
2212 case ELFOSABI_HURD
: return "GNU/Hurd";
2213 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2214 case ELFOSABI_AIX
: return "UNIX - AIX";
2215 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2216 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2217 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2218 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2219 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2220 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2221 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2222 case ELFOSABI_AROS
: return "Amiga Research OS";
2223 case ELFOSABI_STANDALONE
: return _("Standalone App");
2224 case ELFOSABI_ARM
: return "ARM";
2226 sprintf (buff
, _("<unknown: %x>"), osabi
);
2232 get_mips_segment_type (unsigned long type
)
2236 case PT_MIPS_REGINFO
:
2238 case PT_MIPS_RTPROC
:
2240 case PT_MIPS_OPTIONS
:
2250 get_parisc_segment_type (unsigned long type
)
2254 case PT_HP_TLS
: return "HP_TLS";
2255 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2256 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2257 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2258 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2259 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2260 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2261 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2262 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2263 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2264 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2265 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2266 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2267 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2276 get_ia64_segment_type (unsigned long type
)
2280 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2281 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2282 case PT_HP_TLS
: return "HP_TLS";
2283 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2284 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2285 case PT_IA_64_HP_STACK
: return "HP_STACK";
2294 get_segment_type (unsigned long p_type
)
2296 static char buff
[32];
2300 case PT_NULL
: return "NULL";
2301 case PT_LOAD
: return "LOAD";
2302 case PT_DYNAMIC
: return "DYNAMIC";
2303 case PT_INTERP
: return "INTERP";
2304 case PT_NOTE
: return "NOTE";
2305 case PT_SHLIB
: return "SHLIB";
2306 case PT_PHDR
: return "PHDR";
2307 case PT_TLS
: return "TLS";
2309 case PT_GNU_EH_FRAME
:
2310 return "GNU_EH_FRAME";
2311 case PT_GNU_STACK
: return "GNU_STACK";
2312 case PT_GNU_RELRO
: return "GNU_RELRO";
2315 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2319 switch (elf_header
.e_machine
)
2322 case EM_MIPS_RS3_LE
:
2323 result
= get_mips_segment_type (p_type
);
2326 result
= get_parisc_segment_type (p_type
);
2329 result
= get_ia64_segment_type (p_type
);
2339 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2341 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2345 switch (elf_header
.e_machine
)
2348 result
= get_parisc_segment_type (p_type
);
2351 result
= get_ia64_segment_type (p_type
);
2361 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2364 sprintf (buff
, _("<unknown>: %lx"), p_type
);
2371 get_mips_section_type_name (unsigned int sh_type
)
2375 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2376 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2377 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2378 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2379 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2380 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2381 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2382 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2383 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2384 case SHT_MIPS_RELD
: return "MIPS_RELD";
2385 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2386 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2387 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2388 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2389 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2390 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2391 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2392 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2393 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2394 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2395 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2396 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2397 case SHT_MIPS_LINE
: return "MIPS_LINE";
2398 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2399 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2400 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2401 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2402 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2403 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2404 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2405 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2406 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2407 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2408 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2409 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2410 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2411 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2412 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2413 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2421 get_parisc_section_type_name (unsigned int sh_type
)
2425 case SHT_PARISC_EXT
: return "PARISC_EXT";
2426 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2427 case SHT_PARISC_DOC
: return "PARISC_DOC";
2435 get_ia64_section_type_name (unsigned int sh_type
)
2437 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2438 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2439 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2443 case SHT_IA_64_EXT
: return "IA_64_EXT";
2444 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2445 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2453 get_x86_64_section_type_name (unsigned int sh_type
)
2457 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2465 get_arm_section_type_name (unsigned int sh_type
)
2478 get_section_type_name (unsigned int sh_type
)
2480 static char buff
[32];
2484 case SHT_NULL
: return "NULL";
2485 case SHT_PROGBITS
: return "PROGBITS";
2486 case SHT_SYMTAB
: return "SYMTAB";
2487 case SHT_STRTAB
: return "STRTAB";
2488 case SHT_RELA
: return "RELA";
2489 case SHT_HASH
: return "HASH";
2490 case SHT_DYNAMIC
: return "DYNAMIC";
2491 case SHT_NOTE
: return "NOTE";
2492 case SHT_NOBITS
: return "NOBITS";
2493 case SHT_REL
: return "REL";
2494 case SHT_SHLIB
: return "SHLIB";
2495 case SHT_DYNSYM
: return "DYNSYM";
2496 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2497 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2498 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2499 case SHT_GROUP
: return "GROUP";
2500 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2501 case SHT_GNU_verdef
: return "VERDEF";
2502 case SHT_GNU_verneed
: return "VERNEED";
2503 case SHT_GNU_versym
: return "VERSYM";
2504 case 0x6ffffff0: return "VERSYM";
2505 case 0x6ffffffc: return "VERDEF";
2506 case 0x7ffffffd: return "AUXILIARY";
2507 case 0x7fffffff: return "FILTER";
2508 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2511 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2515 switch (elf_header
.e_machine
)
2518 case EM_MIPS_RS3_LE
:
2519 result
= get_mips_section_type_name (sh_type
);
2522 result
= get_parisc_section_type_name (sh_type
);
2525 result
= get_ia64_section_type_name (sh_type
);
2528 result
= get_x86_64_section_type_name (sh_type
);
2531 result
= get_arm_section_type_name (sh_type
);
2541 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2543 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2544 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2545 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2546 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2548 sprintf (buff
, _("<unknown>: %x"), sh_type
);
2554 #define OPTION_DEBUG_DUMP 512
2556 struct option options
[] =
2558 {"all", no_argument
, 0, 'a'},
2559 {"file-header", no_argument
, 0, 'h'},
2560 {"program-headers", no_argument
, 0, 'l'},
2561 {"headers", no_argument
, 0, 'e'},
2562 {"histogram", no_argument
, 0, 'I'},
2563 {"segments", no_argument
, 0, 'l'},
2564 {"sections", no_argument
, 0, 'S'},
2565 {"section-headers", no_argument
, 0, 'S'},
2566 {"section-groups", no_argument
, 0, 'g'},
2567 {"symbols", no_argument
, 0, 's'},
2568 {"syms", no_argument
, 0, 's'},
2569 {"relocs", no_argument
, 0, 'r'},
2570 {"notes", no_argument
, 0, 'n'},
2571 {"dynamic", no_argument
, 0, 'd'},
2572 {"arch-specific", no_argument
, 0, 'A'},
2573 {"version-info", no_argument
, 0, 'V'},
2574 {"use-dynamic", no_argument
, 0, 'D'},
2575 {"hex-dump", required_argument
, 0, 'x'},
2576 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2577 {"unwind", no_argument
, 0, 'u'},
2578 #ifdef SUPPORT_DISASSEMBLY
2579 {"instruction-dump", required_argument
, 0, 'i'},
2582 {"version", no_argument
, 0, 'v'},
2583 {"wide", no_argument
, 0, 'W'},
2584 {"help", no_argument
, 0, 'H'},
2585 {0, no_argument
, 0, 0}
2591 fprintf (stdout
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2592 fprintf (stdout
, _(" Display information about the contents of ELF format files\n"));
2593 fprintf (stdout
, _(" Options are:\n\
2594 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2595 -h --file-header Display the ELF file header\n\
2596 -l --program-headers Display the program headers\n\
2597 --segments An alias for --program-headers\n\
2598 -S --section-headers Display the sections' header\n\
2599 --sections An alias for --section-headers\n\
2600 -g --section-groups Display the section groups\n\
2601 -e --headers Equivalent to: -h -l -S\n\
2602 -s --syms Display the symbol table\n\
2603 --symbols An alias for --syms\n\
2604 -n --notes Display the core notes (if present)\n\
2605 -r --relocs Display the relocations (if present)\n\
2606 -u --unwind Display the unwind info (if present)\n\
2607 -d --dynamic Display the dynamic section (if present)\n\
2608 -V --version-info Display the version sections (if present)\n\
2609 -A --arch-specific Display architecture specific information (if any).\n\
2610 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2611 -x --hex-dump=<number> Dump the contents of section <number>\n\
2612 -w[liaprmfFsoR] or\n\
2613 --debug-dump[=line,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
2614 Display the contents of DWARF2 debug sections\n"));
2615 #ifdef SUPPORT_DISASSEMBLY
2616 fprintf (stdout
, _("\
2617 -i --instruction-dump=<number>\n\
2618 Disassemble the contents of section <number>\n"));
2620 fprintf (stdout
, _("\
2621 -I --histogram Display histogram of bucket list lengths\n\
2622 -W --wide Allow output width to exceed 80 characters\n\
2623 -H --help Display this information\n\
2624 -v --version Display the version number of readelf\n"));
2625 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2630 /* Record the fact that the user wants the contents of section number
2631 SECTION to be displayed using the method(s) encoded as flags bits
2632 in TYPE. Note, TYPE can be zero if we are creating the array for
2636 request_dump (unsigned int section
, int type
)
2638 if (section
>= num_dump_sects
)
2640 char *new_dump_sects
;
2642 new_dump_sects
= calloc (section
+ 1, 1);
2644 if (new_dump_sects
== NULL
)
2645 error (_("Out of memory allocating dump request table."));
2648 /* Copy current flag settings. */
2649 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2653 dump_sects
= new_dump_sects
;
2654 num_dump_sects
= section
+ 1;
2659 dump_sects
[section
] |= type
;
2665 parse_args (int argc
, char **argv
)
2672 while ((c
= getopt_long
2673 (argc
, argv
, "ersuahnldSDAIgw::x:i:vVWH", options
, NULL
)) != EOF
)
2694 do_section_groups
++;
2702 do_section_groups
++;
2744 section
= strtoul (optarg
, & cp
, 0);
2745 if (! *cp
&& section
>= 0)
2747 request_dump (section
, HEX_DUMP
);
2757 unsigned int index
= 0;
2761 while (optarg
[index
])
2762 switch (optarg
[index
++])
2771 do_debug_abbrevs
= 1;
2781 do_debug_pubnames
= 1;
2785 do_debug_aranges
= 1;
2789 do_debug_ranges
= 1;
2793 do_debug_frames_interp
= 1;
2795 do_debug_frames
= 1;
2800 do_debug_macinfo
= 1;
2814 warn (_("Unrecognized debug option '%s'\n"), optarg
);
2819 case OPTION_DEBUG_DUMP
:
2827 const char * option
;
2830 debug_dump_long_opts
;
2832 debug_dump_long_opts opts_table
[] =
2834 /* Please keep this table alpha- sorted. */
2835 { "Ranges", & do_debug_ranges
},
2836 { "abbrev", & do_debug_abbrevs
},
2837 { "aranges", & do_debug_aranges
},
2838 { "frames", & do_debug_frames
},
2839 { "frames-interp", & do_debug_frames_interp
},
2840 { "info", & do_debug_info
},
2841 { "line", & do_debug_lines
},
2842 { "loc", & do_debug_loc
},
2843 { "macro", & do_debug_macinfo
},
2844 { "pubnames", & do_debug_pubnames
},
2845 /* This entry is for compatability
2846 with earlier versions of readelf. */
2847 { "ranges", & do_debug_aranges
},
2848 { "str", & do_debug_str
},
2859 debug_dump_long_opts
* entry
;
2861 for (entry
= opts_table
; entry
->option
; entry
++)
2863 size_t len
= strlen (entry
->option
);
2865 if (strneq (p
, entry
->option
, len
)
2866 && (p
[len
] == ',' || p
[len
] == '\0'))
2868 * entry
->variable
= 1;
2870 /* The --debug-dump=frames-interp option also
2871 enables the --debug-dump=frames option. */
2872 if (do_debug_frames_interp
)
2873 do_debug_frames
= 1;
2880 if (entry
->option
== NULL
)
2882 warn (_("Unrecognized debug option '%s'\n"), p
);
2883 p
= strchr (p
, ',');
2893 #ifdef SUPPORT_DISASSEMBLY
2896 section
= strtoul (optarg
, & cp
, 0);
2897 if (! *cp
&& section
>= 0)
2899 request_dump (section
, DISASS_DUMP
);
2905 print_version (program_name
);
2915 /* xgettext:c-format */
2916 error (_("Invalid option '-%c'\n"), c
);
2923 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
2924 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
2925 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
2926 && !do_section_groups
)
2930 warn (_("Nothing to do.\n"));
2936 get_elf_class (unsigned int elf_class
)
2938 static char buff
[32];
2942 case ELFCLASSNONE
: return _("none");
2943 case ELFCLASS32
: return "ELF32";
2944 case ELFCLASS64
: return "ELF64";
2946 sprintf (buff
, _("<unknown: %x>"), elf_class
);
2952 get_data_encoding (unsigned int encoding
)
2954 static char buff
[32];
2958 case ELFDATANONE
: return _("none");
2959 case ELFDATA2LSB
: return _("2's complement, little endian");
2960 case ELFDATA2MSB
: return _("2's complement, big endian");
2962 sprintf (buff
, _("<unknown: %x>"), encoding
);
2967 /* Decode the data held in 'elf_header'. */
2970 process_file_header (void)
2972 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
2973 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
2974 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
2975 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
2978 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2986 printf (_("ELF Header:\n"));
2987 printf (_(" Magic: "));
2988 for (i
= 0; i
< EI_NIDENT
; i
++)
2989 printf ("%2.2x ", elf_header
.e_ident
[i
]);
2991 printf (_(" Class: %s\n"),
2992 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
2993 printf (_(" Data: %s\n"),
2994 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
2995 printf (_(" Version: %d %s\n"),
2996 elf_header
.e_ident
[EI_VERSION
],
2997 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
2999 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3002 printf (_(" OS/ABI: %s\n"),
3003 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3004 printf (_(" ABI Version: %d\n"),
3005 elf_header
.e_ident
[EI_ABIVERSION
]);
3006 printf (_(" Type: %s\n"),
3007 get_file_type (elf_header
.e_type
));
3008 printf (_(" Machine: %s\n"),
3009 get_machine_name (elf_header
.e_machine
));
3010 printf (_(" Version: 0x%lx\n"),
3011 (unsigned long) elf_header
.e_version
);
3013 printf (_(" Entry point address: "));
3014 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3015 printf (_("\n Start of program headers: "));
3016 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3017 printf (_(" (bytes into file)\n Start of section headers: "));
3018 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3019 printf (_(" (bytes into file)\n"));
3021 printf (_(" Flags: 0x%lx%s\n"),
3022 (unsigned long) elf_header
.e_flags
,
3023 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3024 printf (_(" Size of this header: %ld (bytes)\n"),
3025 (long) elf_header
.e_ehsize
);
3026 printf (_(" Size of program headers: %ld (bytes)\n"),
3027 (long) elf_header
.e_phentsize
);
3028 printf (_(" Number of program headers: %ld\n"),
3029 (long) elf_header
.e_phnum
);
3030 printf (_(" Size of section headers: %ld (bytes)\n"),
3031 (long) elf_header
.e_shentsize
);
3032 printf (_(" Number of section headers: %ld"),
3033 (long) elf_header
.e_shnum
);
3034 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
3035 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3036 putc ('\n', stdout
);
3037 printf (_(" Section header string table index: %ld"),
3038 (long) elf_header
.e_shstrndx
);
3039 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
3040 printf (" (%ld)", (long) section_headers
[0].sh_link
);
3041 putc ('\n', stdout
);
3044 if (section_headers
!= NULL
)
3046 if (elf_header
.e_shnum
== 0)
3047 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3048 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
3049 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3050 free (section_headers
);
3051 section_headers
= NULL
;
3059 get_32bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3061 Elf32_External_Phdr
*phdrs
;
3062 Elf32_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_offset
= BYTE_GET (external
->p_offset
);
3078 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3079 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3080 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3081 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3082 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3083 internal
->p_align
= BYTE_GET (external
->p_align
);
3092 get_64bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3094 Elf64_External_Phdr
*phdrs
;
3095 Elf64_External_Phdr
*external
;
3096 Elf_Internal_Phdr
*internal
;
3099 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3100 elf_header
.e_phentsize
* elf_header
.e_phnum
,
3101 _("program headers"));
3105 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3106 i
< elf_header
.e_phnum
;
3107 i
++, internal
++, external
++)
3109 internal
->p_type
= BYTE_GET (external
->p_type
);
3110 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3111 internal
->p_offset
= BYTE_GET8 (external
->p_offset
);
3112 internal
->p_vaddr
= BYTE_GET8 (external
->p_vaddr
);
3113 internal
->p_paddr
= BYTE_GET8 (external
->p_paddr
);
3114 internal
->p_filesz
= BYTE_GET8 (external
->p_filesz
);
3115 internal
->p_memsz
= BYTE_GET8 (external
->p_memsz
);
3116 internal
->p_align
= BYTE_GET8 (external
->p_align
);
3124 /* Returns 1 if the program headers were read into `program_headers'. */
3127 get_program_headers (FILE *file
)
3129 Elf_Internal_Phdr
*phdrs
;
3131 /* Check cache of prior read. */
3132 if (program_headers
!= NULL
)
3135 phdrs
= malloc (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
3139 error (_("Out of memory\n"));
3144 ? get_32bit_program_headers (file
, phdrs
)
3145 : get_64bit_program_headers (file
, phdrs
))
3147 program_headers
= phdrs
;
3155 /* Returns 1 if the program headers were loaded. */
3158 process_program_headers (FILE *file
)
3160 Elf_Internal_Phdr
*segment
;
3163 if (elf_header
.e_phnum
== 0)
3166 printf (_("\nThere are no program headers in this file.\n"));
3170 if (do_segments
&& !do_header
)
3172 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3173 printf (_("Entry point "));
3174 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3175 printf (_("\nThere are %d program headers, starting at offset "),
3176 elf_header
.e_phnum
);
3177 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3181 if (! get_program_headers (file
))
3186 if (elf_header
.e_phnum
> 1)
3187 printf (_("\nProgram Headers:\n"));
3189 printf (_("\nProgram Headers:\n"));
3193 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3196 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3200 (_(" Type Offset VirtAddr PhysAddr\n"));
3202 (_(" FileSiz MemSiz Flags Align\n"));
3209 for (i
= 0, segment
= program_headers
;
3210 i
< elf_header
.e_phnum
;
3215 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3219 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3220 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3221 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3222 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3223 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3225 (segment
->p_flags
& PF_R
? 'R' : ' '),
3226 (segment
->p_flags
& PF_W
? 'W' : ' '),
3227 (segment
->p_flags
& PF_X
? 'E' : ' '));
3228 printf ("%#lx", (unsigned long) segment
->p_align
);
3232 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3233 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3236 print_vma (segment
->p_offset
, FULL_HEX
);
3240 print_vma (segment
->p_vaddr
, FULL_HEX
);
3242 print_vma (segment
->p_paddr
, FULL_HEX
);
3245 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3246 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3249 print_vma (segment
->p_filesz
, FULL_HEX
);
3253 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3254 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3257 print_vma (segment
->p_offset
, FULL_HEX
);
3261 (segment
->p_flags
& PF_R
? 'R' : ' '),
3262 (segment
->p_flags
& PF_W
? 'W' : ' '),
3263 (segment
->p_flags
& PF_X
? 'E' : ' '));
3265 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3266 printf ("%#lx", (unsigned long) segment
->p_align
);
3269 print_vma (segment
->p_align
, PREFIX_HEX
);
3274 print_vma (segment
->p_offset
, FULL_HEX
);
3276 print_vma (segment
->p_vaddr
, FULL_HEX
);
3278 print_vma (segment
->p_paddr
, FULL_HEX
);
3280 print_vma (segment
->p_filesz
, FULL_HEX
);
3282 print_vma (segment
->p_memsz
, FULL_HEX
);
3284 (segment
->p_flags
& PF_R
? 'R' : ' '),
3285 (segment
->p_flags
& PF_W
? 'W' : ' '),
3286 (segment
->p_flags
& PF_X
? 'E' : ' '));
3287 print_vma (segment
->p_align
, HEX
);
3291 switch (segment
->p_type
)
3295 error (_("more than one dynamic segment\n"));
3297 /* Try to locate the .dynamic section. If there is
3298 a section header table, we can easily locate it. */
3299 if (section_headers
!= NULL
)
3301 Elf_Internal_Shdr
*sec
;
3303 sec
= find_section (".dynamic");
3304 if (sec
== NULL
|| sec
->sh_size
== 0)
3306 error (_("no .dynamic section in the dynamic segment"));
3310 dynamic_addr
= sec
->sh_offset
;
3311 dynamic_size
= sec
->sh_size
;
3313 if (dynamic_addr
< segment
->p_offset
3314 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3315 warn (_("the .dynamic section is not contained within the dynamic segment"));
3316 else if (dynamic_addr
> segment
->p_offset
)
3317 warn (_("the .dynamic section is not the first section in the dynamic segment."));
3321 /* Otherwise, we can only assume that the .dynamic
3322 section is the first section in the DYNAMIC segment. */
3323 dynamic_addr
= segment
->p_offset
;
3324 dynamic_size
= segment
->p_filesz
;
3329 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3331 error (_("Unable to find program interpreter name\n"));
3334 program_interpreter
[0] = 0;
3335 fscanf (file
, "%63s", program_interpreter
);
3338 printf (_("\n [Requesting program interpreter: %s]"),
3339 program_interpreter
);
3345 putc ('\n', stdout
);
3348 if (do_segments
&& section_headers
!= NULL
)
3350 printf (_("\n Section to Segment mapping:\n"));
3351 printf (_(" Segment Sections...\n"));
3353 assert (string_table
!= NULL
);
3355 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3358 Elf_Internal_Shdr
*section
;
3360 segment
= program_headers
+ i
;
3361 section
= section_headers
;
3363 printf (" %2.2d ", i
);
3365 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3367 if (section
->sh_size
> 0
3368 /* Compare allocated sections by VMA, unallocated
3369 sections by file offset. */
3370 && (section
->sh_flags
& SHF_ALLOC
3371 ? (section
->sh_addr
>= segment
->p_vaddr
3372 && section
->sh_addr
+ section
->sh_size
3373 <= segment
->p_vaddr
+ segment
->p_memsz
)
3374 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
3375 && (section
->sh_offset
+ section
->sh_size
3376 <= segment
->p_offset
+ segment
->p_filesz
)))
3377 /* .tbss is special. It doesn't contribute memory space
3378 to normal segments. */
3379 && (!((section
->sh_flags
& SHF_TLS
) != 0
3380 && section
->sh_type
== SHT_NOBITS
)
3381 || segment
->p_type
== PT_TLS
))
3382 printf ("%s ", SECTION_NAME (section
));
3393 /* Find the file offset corresponding to VMA by using the program headers. */
3396 offset_from_vma (FILE *file
, bfd_vma vma
, bfd_size_type size
)
3398 Elf_Internal_Phdr
*seg
;
3400 if (! get_program_headers (file
))
3402 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3406 for (seg
= program_headers
;
3407 seg
< program_headers
+ elf_header
.e_phnum
;
3410 if (seg
->p_type
!= PT_LOAD
)
3413 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3414 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3415 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3418 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3425 get_32bit_section_headers (FILE *file
, unsigned int num
)
3427 Elf32_External_Shdr
*shdrs
;
3428 Elf_Internal_Shdr
*internal
;
3431 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3432 elf_header
.e_shentsize
* num
, _("section headers"));
3436 section_headers
= malloc (num
* sizeof (Elf_Internal_Shdr
));
3438 if (section_headers
== NULL
)
3440 error (_("Out of memory\n"));
3444 for (i
= 0, internal
= section_headers
;
3448 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3449 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3450 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3451 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3452 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3453 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3454 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3455 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3456 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3457 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3466 get_64bit_section_headers (FILE *file
, unsigned int num
)
3468 Elf64_External_Shdr
*shdrs
;
3469 Elf_Internal_Shdr
*internal
;
3472 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3473 elf_header
.e_shentsize
* num
, _("section headers"));
3477 section_headers
= malloc (num
* sizeof (Elf_Internal_Shdr
));
3479 if (section_headers
== NULL
)
3481 error (_("Out of memory\n"));
3485 for (i
= 0, internal
= section_headers
;
3489 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3490 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3491 internal
->sh_flags
= BYTE_GET8 (shdrs
[i
].sh_flags
);
3492 internal
->sh_addr
= BYTE_GET8 (shdrs
[i
].sh_addr
);
3493 internal
->sh_size
= BYTE_GET8 (shdrs
[i
].sh_size
);
3494 internal
->sh_entsize
= BYTE_GET8 (shdrs
[i
].sh_entsize
);
3495 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3496 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3497 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3498 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3506 static Elf_Internal_Sym
*
3507 get_32bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3509 unsigned long number
;
3510 Elf32_External_Sym
*esyms
;
3511 Elf_External_Sym_Shndx
*shndx
;
3512 Elf_Internal_Sym
*isyms
;
3513 Elf_Internal_Sym
*psym
;
3516 esyms
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
3522 if (symtab_shndx_hdr
!= NULL
3523 && (symtab_shndx_hdr
->sh_link
3524 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3526 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3527 symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3535 number
= section
->sh_size
/ section
->sh_entsize
;
3536 isyms
= malloc (number
* sizeof (Elf_Internal_Sym
));
3540 error (_("Out of memory\n"));
3547 for (j
= 0, psym
= isyms
;
3551 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3552 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3553 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3554 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3555 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3557 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3558 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3559 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3569 static Elf_Internal_Sym
*
3570 get_64bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3572 unsigned long number
;
3573 Elf64_External_Sym
*esyms
;
3574 Elf_External_Sym_Shndx
*shndx
;
3575 Elf_Internal_Sym
*isyms
;
3576 Elf_Internal_Sym
*psym
;
3579 esyms
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
3585 if (symtab_shndx_hdr
!= NULL
3586 && (symtab_shndx_hdr
->sh_link
3587 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3589 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3590 symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3598 number
= section
->sh_size
/ section
->sh_entsize
;
3599 isyms
= malloc (number
* sizeof (Elf_Internal_Sym
));
3603 error (_("Out of memory\n"));
3610 for (j
= 0, psym
= isyms
;
3614 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3615 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3616 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3617 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3618 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3620 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3621 psym
->st_value
= BYTE_GET8 (esyms
[j
].st_value
);
3622 psym
->st_size
= BYTE_GET8 (esyms
[j
].st_size
);
3633 get_elf_section_flags (bfd_vma sh_flags
)
3635 static char buff
[32];
3643 flag
= sh_flags
& - sh_flags
;
3648 case SHF_WRITE
: strcat (buff
, "W"); break;
3649 case SHF_ALLOC
: strcat (buff
, "A"); break;
3650 case SHF_EXECINSTR
: strcat (buff
, "X"); break;
3651 case SHF_MERGE
: strcat (buff
, "M"); break;
3652 case SHF_STRINGS
: strcat (buff
, "S"); break;
3653 case SHF_INFO_LINK
: strcat (buff
, "I"); break;
3654 case SHF_LINK_ORDER
: strcat (buff
, "L"); break;
3655 case SHF_OS_NONCONFORMING
: strcat (buff
, "O"); break;
3656 case SHF_GROUP
: strcat (buff
, "G"); break;
3657 case SHF_TLS
: strcat (buff
, "T"); break;
3660 if (flag
& SHF_MASKOS
)
3663 sh_flags
&= ~ SHF_MASKOS
;
3665 else if (flag
& SHF_MASKPROC
)
3668 sh_flags
&= ~ SHF_MASKPROC
;
3680 process_section_headers (FILE *file
)
3682 Elf_Internal_Shdr
*section
;
3685 section_headers
= NULL
;
3687 if (elf_header
.e_shnum
== 0)
3690 printf (_("\nThere are no sections in this file.\n"));
3695 if (do_sections
&& !do_header
)
3696 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3697 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
3701 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
3704 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
3707 /* Read in the string table, so that we have names to display. */
3708 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
3710 if (section
->sh_size
!= 0)
3712 string_table
= get_data (NULL
, file
, section
->sh_offset
,
3713 section
->sh_size
, _("string table"));
3715 if (string_table
== NULL
)
3718 string_table_length
= section
->sh_size
;
3721 /* Scan the sections for the dynamic symbol table
3722 and dynamic string table and debug sections. */
3723 dynamic_symbols
= NULL
;
3724 dynamic_strings
= NULL
;
3725 dynamic_syminfo
= NULL
;
3726 symtab_shndx_hdr
= NULL
;
3728 eh_addr_size
= is_32bit_elf
? 4 : 8;
3729 switch (elf_header
.e_machine
)
3732 case EM_MIPS_RS3_LE
:
3733 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
3734 FDE addresses. However, the ABI also has a semi-official ILP32
3735 variant for which the normal FDE address size rules apply.
3737 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
3738 section, where XX is the size of longs in bits. Unfortunately,
3739 earlier compilers provided no way of distinguishing ILP32 objects
3740 from LP64 objects, so if there's any doubt, we should assume that
3741 the official LP64 form is being used. */
3742 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
3743 && find_section (".gcc_compiled_long32") == NULL
)
3748 for (i
= 0, section
= section_headers
;
3749 i
< elf_header
.e_shnum
;
3752 char *name
= SECTION_NAME (section
);
3754 if (section
->sh_type
== SHT_DYNSYM
)
3756 if (dynamic_symbols
!= NULL
)
3758 error (_("File contains multiple dynamic symbol tables\n"));
3762 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
3763 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
3765 else if (section
->sh_type
== SHT_STRTAB
3766 && streq (name
, ".dynstr"))
3768 if (dynamic_strings
!= NULL
)
3770 error (_("File contains multiple dynamic string tables\n"));
3774 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
3775 section
->sh_size
, _("dynamic strings"));
3776 dynamic_strings_length
= section
->sh_size
;
3778 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
3780 if (symtab_shndx_hdr
!= NULL
)
3782 error (_("File contains multiple symtab shndx tables\n"));
3785 symtab_shndx_hdr
= section
;
3787 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
3788 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
3789 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
3790 || do_debug_loc
|| do_debug_ranges
)
3791 && strneq (name
, ".debug_", 7))
3796 || (do_debug_info
&& streq (name
, "info"))
3797 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
3798 || (do_debug_lines
&& streq (name
, "line"))
3799 || (do_debug_pubnames
&& streq (name
, "pubnames"))
3800 || (do_debug_aranges
&& streq (name
, "aranges"))
3801 || (do_debug_ranges
&& streq (name
, "ranges"))
3802 || (do_debug_frames
&& streq (name
, "frame"))
3803 || (do_debug_macinfo
&& streq (name
, "macinfo"))
3804 || (do_debug_str
&& streq (name
, "str"))
3805 || (do_debug_loc
&& streq (name
, "loc"))
3807 request_dump (i
, DEBUG_DUMP
);
3809 /* linkonce section to be combined with .debug_info at link time. */
3810 else if ((do_debugging
|| do_debug_info
)
3811 && strneq (name
, ".gnu.linkonce.wi.", 17))
3812 request_dump (i
, DEBUG_DUMP
);
3813 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
3814 request_dump (i
, DEBUG_DUMP
);
3820 if (elf_header
.e_shnum
> 1)
3821 printf (_("\nSection Headers:\n"));
3823 printf (_("\nSection Header:\n"));
3827 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
3830 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
3833 printf (_(" [Nr] Name Type Address Offset\n"));
3834 printf (_(" Size EntSize Flags Link Info Align\n"));
3837 for (i
= 0, section
= section_headers
;
3838 i
< elf_header
.e_shnum
;
3841 printf (" [%2u] %-17.17s %-15.15s ",
3842 SECTION_HEADER_NUM (i
),
3843 SECTION_NAME (section
),
3844 get_section_type_name (section
->sh_type
));
3848 print_vma (section
->sh_addr
, LONG_HEX
);
3850 printf ( " %6.6lx %6.6lx %2.2lx",
3851 (unsigned long) section
->sh_offset
,
3852 (unsigned long) section
->sh_size
,
3853 (unsigned long) section
->sh_entsize
);
3855 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3857 printf ("%2ld %3lu %2ld\n",
3858 (unsigned long) section
->sh_link
,
3859 (unsigned long) section
->sh_info
,
3860 (unsigned long) section
->sh_addralign
);
3864 print_vma (section
->sh_addr
, LONG_HEX
);
3866 if ((long) section
->sh_offset
== section
->sh_offset
)
3867 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
3871 print_vma (section
->sh_offset
, LONG_HEX
);
3874 if ((unsigned long) section
->sh_size
== section
->sh_size
)
3875 printf (" %6.6lx", (unsigned long) section
->sh_size
);
3879 print_vma (section
->sh_size
, LONG_HEX
);
3882 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
3883 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
3887 print_vma (section
->sh_entsize
, LONG_HEX
);
3890 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3892 printf ("%2ld %3lu ",
3893 (unsigned long) section
->sh_link
,
3894 (unsigned long) section
->sh_info
);
3896 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
3897 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
3900 print_vma (section
->sh_addralign
, DEC
);
3907 print_vma (section
->sh_addr
, LONG_HEX
);
3908 if ((long) section
->sh_offset
== section
->sh_offset
)
3909 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
3913 print_vma (section
->sh_offset
, LONG_HEX
);
3916 print_vma (section
->sh_size
, LONG_HEX
);
3918 print_vma (section
->sh_entsize
, LONG_HEX
);
3920 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3922 printf (" %2ld %3lu %ld\n",
3923 (unsigned long) section
->sh_link
,
3924 (unsigned long) section
->sh_info
,
3925 (unsigned long) section
->sh_addralign
);
3929 printf (_("Key to Flags:\n\
3930 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
3931 I (info), L (link order), G (group), x (unknown)\n\
3932 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3938 get_group_flags (unsigned int flags
)
3940 static char buff
[32];
3947 sprintf (buff
, _("[<unknown>: 0x%x]"), flags
);
3954 process_section_groups (FILE *file
)
3956 Elf_Internal_Shdr
*section
;
3958 struct group
*group
;
3959 Elf_Internal_Shdr
*symtab_sec
, *strtab_sec
;
3960 Elf_Internal_Sym
*symtab
;
3963 /* Don't process section groups unless needed. */
3964 if (!do_unwind
&& !do_section_groups
)
3967 if (elf_header
.e_shnum
== 0)
3969 if (do_section_groups
)
3970 printf (_("\nThere are no sections in this file.\n"));
3975 if (section_headers
== NULL
)
3977 error (_("Section headers are not available!\n"));
3981 section_headers_groups
= calloc (elf_header
.e_shnum
,
3982 sizeof (struct group
*));
3984 if (section_headers_groups
== NULL
)
3986 error (_("Out of memory\n"));
3990 /* Scan the sections for the group section. */
3992 for (i
= 0, section
= section_headers
;
3993 i
< elf_header
.e_shnum
;
3995 if (section
->sh_type
== SHT_GROUP
)
3998 if (group_count
== 0)
4000 if (do_section_groups
)
4001 printf (_("\nThere are no section groups in this file.\n"));
4006 section_groups
= calloc (group_count
, sizeof (struct group
));
4008 if (section_groups
== NULL
)
4010 error (_("Out of memory\n"));
4018 for (i
= 0, section
= section_headers
, group
= section_groups
;
4019 i
< elf_header
.e_shnum
;
4022 if (section
->sh_type
== SHT_GROUP
)
4024 char *name
= SECTION_NAME (section
);
4025 char *group_name
, *start
, *indices
;
4026 unsigned int entry
, j
, size
;
4027 Elf_Internal_Shdr
*sec
;
4028 Elf_Internal_Sym
*sym
;
4030 /* Get the symbol table. */
4031 sec
= SECTION_HEADER (section
->sh_link
);
4032 if (sec
->sh_type
!= SHT_SYMTAB
)
4034 error (_("Bad sh_link in group section `%s'\n"), name
);
4038 if (symtab_sec
!= sec
)
4043 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4046 sym
= symtab
+ section
->sh_info
;
4048 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4050 bfd_vma sec_index
= SECTION_HEADER_INDEX (sym
->st_shndx
);
4053 error (_("Bad sh_info in group section `%s'\n"), name
);
4057 group_name
= SECTION_NAME (section_headers
+ sec_index
);
4062 /* Get the string table. */
4063 sec
= SECTION_HEADER (symtab_sec
->sh_link
);
4064 if (strtab_sec
!= sec
)
4069 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
4070 strtab_sec
->sh_size
,
4073 group_name
= strtab
+ sym
->st_name
;
4076 start
= get_data (NULL
, file
, section
->sh_offset
,
4077 section
->sh_size
, _("section data"));
4080 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4081 entry
= byte_get (indices
, 4);
4084 if (do_section_groups
)
4086 printf ("\n%s group section `%s' [%s] contains %u sections:\n",
4087 get_group_flags (entry
), name
, group_name
, size
);
4089 printf (_(" [Index] Name\n"));
4092 group
->group_index
= i
;
4094 for (j
= 0; j
< size
; j
++)
4096 struct group_list
*g
;
4098 entry
= byte_get (indices
, 4);
4101 if (section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4106 error (_("section [%5u] already in group section [%5u]\n"),
4108 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4113 /* Intel C/C++ compiler may put section 0 in a
4114 section group. We just warn it the first time
4115 and ignore it afterwards. */
4116 static int warned
= 0;
4119 error (_("section 0 in group section [%5u]\n"),
4120 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4126 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4129 if (do_section_groups
)
4131 sec
= SECTION_HEADER (entry
);
4132 printf (" [%5u] %s\n",
4133 entry
, SECTION_NAME (sec
));
4136 g
= xmalloc (sizeof (struct group_list
));
4137 g
->section_index
= entry
;
4138 g
->next
= group
->root
;
4162 } dynamic_relocations
[] =
4164 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4165 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4166 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4169 /* Process the reloc section. */
4172 process_relocs (FILE *file
)
4174 unsigned long rel_size
;
4175 unsigned long rel_offset
;
4181 if (do_using_dynamic
)
4185 int has_dynamic_reloc
;
4188 has_dynamic_reloc
= 0;
4190 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4192 is_rela
= dynamic_relocations
[i
].rela
;
4193 name
= dynamic_relocations
[i
].name
;
4194 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4195 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4197 has_dynamic_reloc
|= rel_size
;
4199 if (is_rela
== UNKNOWN
)
4201 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4202 switch (dynamic_info
[DT_PLTREL
])
4216 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4217 name
, rel_offset
, rel_size
);
4219 dump_relocations (file
,
4220 offset_from_vma (file
, rel_offset
, rel_size
),
4222 dynamic_symbols
, num_dynamic_syms
,
4223 dynamic_strings
, dynamic_strings_length
, is_rela
);
4227 if (! has_dynamic_reloc
)
4228 printf (_("\nThere are no dynamic relocations in this file.\n"));
4232 Elf_Internal_Shdr
*section
;
4236 for (i
= 0, section
= section_headers
;
4237 i
< elf_header
.e_shnum
;
4240 if ( section
->sh_type
!= SHT_RELA
4241 && section
->sh_type
!= SHT_REL
)
4244 rel_offset
= section
->sh_offset
;
4245 rel_size
= section
->sh_size
;
4249 Elf_Internal_Shdr
*strsec
;
4252 printf (_("\nRelocation section "));
4254 if (string_table
== NULL
)
4255 printf ("%d", section
->sh_name
);
4257 printf (_("'%s'"), SECTION_NAME (section
));
4259 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4260 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4262 is_rela
= section
->sh_type
== SHT_RELA
;
4264 if (section
->sh_link
)
4266 Elf_Internal_Shdr
*symsec
;
4267 Elf_Internal_Sym
*symtab
;
4268 unsigned long nsyms
;
4269 unsigned long strtablen
;
4270 char *strtab
= NULL
;
4272 symsec
= SECTION_HEADER (section
->sh_link
);
4273 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4274 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4279 strsec
= SECTION_HEADER (symsec
->sh_link
);
4281 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4282 strsec
->sh_size
, _("string table"));
4283 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4285 dump_relocations (file
, rel_offset
, rel_size
,
4286 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4292 dump_relocations (file
, rel_offset
, rel_size
,
4293 NULL
, 0, NULL
, 0, is_rela
);
4300 printf (_("\nThere are no relocations in this file.\n"));
4306 /* Process the unwind section. */
4308 #include "unwind-ia64.h"
4310 /* An absolute address consists of a section and an offset. If the
4311 section is NULL, the offset itself is the address, otherwise, the
4312 address equals to LOAD_ADDRESS(section) + offset. */
4316 unsigned short section
;
4320 struct ia64_unw_aux_info
4322 struct ia64_unw_table_entry
4324 struct absaddr start
;
4326 struct absaddr info
;
4328 *table
; /* Unwind table. */
4329 unsigned long table_len
; /* Length of unwind table. */
4330 unsigned char *info
; /* Unwind info. */
4331 unsigned long info_size
; /* Size of unwind info. */
4332 bfd_vma info_addr
; /* starting address of unwind info. */
4333 bfd_vma seg_base
; /* Starting address of segment. */
4334 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4335 unsigned long nsyms
; /* Number of symbols. */
4336 char *strtab
; /* The string table. */
4337 unsigned long strtab_size
; /* Size of string table. */
4341 find_symbol_for_address (Elf_Internal_Sym
*symtab
,
4342 unsigned long nsyms
,
4344 unsigned long strtab_size
,
4345 struct absaddr addr
,
4346 const char **symname
,
4349 bfd_vma dist
= 0x100000;
4350 Elf_Internal_Sym
*sym
, *best
= NULL
;
4353 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
4355 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4356 && sym
->st_name
!= 0
4357 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4358 && addr
.offset
>= sym
->st_value
4359 && addr
.offset
- sym
->st_value
< dist
)
4362 dist
= addr
.offset
- sym
->st_value
;
4369 *symname
= (best
->st_name
>= strtab_size
4370 ? "<corrupt>" : strtab
+ best
->st_name
);
4375 *offset
= addr
.offset
;
4379 dump_ia64_unwind (struct ia64_unw_aux_info
*aux
)
4381 struct ia64_unw_table_entry
*tp
;
4384 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4388 const unsigned char *dp
;
4389 const unsigned char *head
;
4390 const char *procname
;
4392 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4393 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
4395 fputs ("\n<", stdout
);
4399 fputs (procname
, stdout
);
4402 printf ("+%lx", (unsigned long) offset
);
4405 fputs (">: [", stdout
);
4406 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4407 fputc ('-', stdout
);
4408 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4409 printf ("], info at +0x%lx\n",
4410 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4412 head
= aux
->info
+ (tp
->info
.offset
- aux
->info_addr
);
4413 stamp
= BYTE_GET8 ((unsigned char *) head
);
4415 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4416 (unsigned) UNW_VER (stamp
),
4417 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4418 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4419 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4420 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
4422 if (UNW_VER (stamp
) != 1)
4424 printf ("\tUnknown version.\n");
4429 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
4430 dp
= unw_decode (dp
, in_body
, & in_body
);
4435 slurp_ia64_unwind_table (FILE *file
,
4436 struct ia64_unw_aux_info
*aux
,
4437 Elf_Internal_Shdr
*sec
)
4439 unsigned long size
, nrelas
, i
;
4440 Elf_Internal_Phdr
*seg
;
4441 struct ia64_unw_table_entry
*tep
;
4442 Elf_Internal_Shdr
*relsec
;
4443 Elf_Internal_Rela
*rela
, *rp
;
4444 unsigned char *table
, *tp
;
4445 Elf_Internal_Sym
*sym
;
4446 const char *relname
;
4448 /* First, find the starting address of the segment that includes
4451 if (elf_header
.e_phnum
)
4453 if (! get_program_headers (file
))
4456 for (seg
= program_headers
;
4457 seg
< program_headers
+ elf_header
.e_phnum
;
4460 if (seg
->p_type
!= PT_LOAD
)
4463 if (sec
->sh_addr
>= seg
->p_vaddr
4464 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4466 aux
->seg_base
= seg
->p_vaddr
;
4472 /* Second, build the unwind table from the contents of the unwind section: */
4473 size
= sec
->sh_size
;
4474 table
= get_data (NULL
, file
, sec
->sh_offset
, size
, _("unwind table"));
4478 aux
->table
= xmalloc (size
/ (3 * eh_addr_size
) * sizeof (aux
->table
[0]));
4480 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * eh_addr_size
, ++tep
)
4482 tep
->start
.section
= SHN_UNDEF
;
4483 tep
->end
.section
= SHN_UNDEF
;
4484 tep
->info
.section
= SHN_UNDEF
;
4487 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4488 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4489 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
4493 tep
->start
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 0);
4494 tep
->end
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 8);
4495 tep
->info
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 16);
4497 tep
->start
.offset
+= aux
->seg_base
;
4498 tep
->end
.offset
+= aux
->seg_base
;
4499 tep
->info
.offset
+= aux
->seg_base
;
4503 /* Third, apply any relocations to the unwind table: */
4505 for (relsec
= section_headers
;
4506 relsec
< section_headers
+ elf_header
.e_shnum
;
4509 if (relsec
->sh_type
!= SHT_RELA
4510 || SECTION_HEADER (relsec
->sh_info
) != sec
)
4513 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
4517 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4521 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4522 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4526 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4527 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4530 if (! strneq (relname
, "R_IA64_SEGREL", 13))
4532 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4536 i
= rp
->r_offset
/ (3 * eh_addr_size
);
4538 switch (rp
->r_offset
/eh_addr_size
% 3)
4541 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4542 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
4545 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4546 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
4549 aux
->table
[i
].info
.section
= sym
->st_shndx
;
4550 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
4560 aux
->table_len
= size
/ (3 * eh_addr_size
);
4565 ia64_process_unwind (FILE *file
)
4567 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
4568 unsigned long i
, unwcount
= 0, unwstart
= 0;
4569 struct ia64_unw_aux_info aux
;
4571 memset (& aux
, 0, sizeof (aux
));
4573 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4575 if (sec
->sh_type
== SHT_SYMTAB
)
4577 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
4578 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
4580 strsec
= SECTION_HEADER (sec
->sh_link
);
4581 aux
.strtab_size
= strsec
->sh_size
;
4582 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4583 aux
.strtab_size
, _("string table"));
4585 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4590 printf (_("\nThere are no unwind sections in this file.\n"));
4592 while (unwcount
-- > 0)
4597 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
4598 i
< elf_header
.e_shnum
; ++i
, ++sec
)
4599 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4606 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
4608 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
4610 /* We need to find which section group it is in. */
4611 struct group_list
*g
= section_headers_groups
[i
]->root
;
4613 for (; g
!= NULL
; g
= g
->next
)
4615 sec
= SECTION_HEADER (g
->section_index
);
4617 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
4622 i
= elf_header
.e_shnum
;
4624 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
4626 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
4627 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
4628 suffix
= SECTION_NAME (unwsec
) + len
;
4629 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4631 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
4632 && streq (SECTION_NAME (sec
) + len2
, suffix
))
4637 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
4638 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
4639 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
4640 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
4642 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
4643 suffix
= SECTION_NAME (unwsec
) + len
;
4644 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4646 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
4647 && streq (SECTION_NAME (sec
) + len2
, suffix
))
4651 if (i
== elf_header
.e_shnum
)
4653 printf (_("\nCould not find unwind info section for "));
4655 if (string_table
== NULL
)
4656 printf ("%d", unwsec
->sh_name
);
4658 printf (_("'%s'"), SECTION_NAME (unwsec
));
4662 aux
.info_size
= sec
->sh_size
;
4663 aux
.info_addr
= sec
->sh_addr
;
4664 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, aux
.info_size
,
4667 printf (_("\nUnwind section "));
4669 if (string_table
== NULL
)
4670 printf ("%d", unwsec
->sh_name
);
4672 printf (_("'%s'"), SECTION_NAME (unwsec
));
4674 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4675 (unsigned long) unwsec
->sh_offset
,
4676 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
4678 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
4680 if (aux
.table_len
> 0)
4681 dump_ia64_unwind (& aux
);
4684 free ((char *) aux
.table
);
4686 free ((char *) aux
.info
);
4695 free ((char *) aux
.strtab
);
4700 struct hppa_unw_aux_info
4702 struct hppa_unw_table_entry
4704 struct absaddr start
;
4706 unsigned int Cannot_unwind
:1; /* 0 */
4707 unsigned int Millicode
:1; /* 1 */
4708 unsigned int Millicode_save_sr0
:1; /* 2 */
4709 unsigned int Region_description
:2; /* 3..4 */
4710 unsigned int reserved1
:1; /* 5 */
4711 unsigned int Entry_SR
:1; /* 6 */
4712 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
4713 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
4714 unsigned int Args_stored
:1; /* 16 */
4715 unsigned int Variable_Frame
:1; /* 17 */
4716 unsigned int Separate_Package_Body
:1; /* 18 */
4717 unsigned int Frame_Extension_Millicode
:1; /* 19 */
4718 unsigned int Stack_Overflow_Check
:1; /* 20 */
4719 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
4720 unsigned int Ada_Region
:1; /* 22 */
4721 unsigned int cxx_info
:1; /* 23 */
4722 unsigned int cxx_try_catch
:1; /* 24 */
4723 unsigned int sched_entry_seq
:1; /* 25 */
4724 unsigned int reserved2
:1; /* 26 */
4725 unsigned int Save_SP
:1; /* 27 */
4726 unsigned int Save_RP
:1; /* 28 */
4727 unsigned int Save_MRP_in_frame
:1; /* 29 */
4728 unsigned int extn_ptr_defined
:1; /* 30 */
4729 unsigned int Cleanup_defined
:1; /* 31 */
4731 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
4732 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
4733 unsigned int Large_frame
:1; /* 2 */
4734 unsigned int Pseudo_SP_Set
:1; /* 3 */
4735 unsigned int reserved4
:1; /* 4 */
4736 unsigned int Total_frame_size
:27; /* 5..31 */
4738 *table
; /* Unwind table. */
4739 unsigned long table_len
; /* Length of unwind table. */
4740 bfd_vma seg_base
; /* Starting address of segment. */
4741 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4742 unsigned long nsyms
; /* Number of symbols. */
4743 char *strtab
; /* The string table. */
4744 unsigned long strtab_size
; /* Size of string table. */
4748 dump_hppa_unwind (struct hppa_unw_aux_info
*aux
)
4750 struct hppa_unw_table_entry
*tp
;
4752 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4755 const char *procname
;
4757 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4758 aux
->strtab_size
, tp
->start
, &procname
,
4761 fputs ("\n<", stdout
);
4765 fputs (procname
, stdout
);
4768 printf ("+%lx", (unsigned long) offset
);
4771 fputs (">: [", stdout
);
4772 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4773 fputc ('-', stdout
);
4774 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4777 #define PF(_m) if (tp->_m) printf (#_m " ");
4778 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
4781 PF(Millicode_save_sr0
);
4782 /* PV(Region_description); */
4788 PF(Separate_Package_Body
);
4789 PF(Frame_Extension_Millicode
);
4790 PF(Stack_Overflow_Check
);
4791 PF(Two_Instruction_SP_Increment
);
4795 PF(sched_entry_seq
);
4798 PF(Save_MRP_in_frame
);
4799 PF(extn_ptr_defined
);
4800 PF(Cleanup_defined
);
4801 PF(MPE_XL_interrupt_marker
);
4802 PF(HP_UX_interrupt_marker
);
4805 PV(Total_frame_size
);
4814 slurp_hppa_unwind_table (FILE *file
,
4815 struct hppa_unw_aux_info
*aux
,
4816 Elf_Internal_Shdr
*sec
)
4818 unsigned long size
, unw_ent_size
, nrelas
, i
;
4819 Elf_Internal_Phdr
*seg
;
4820 struct hppa_unw_table_entry
*tep
;
4821 Elf_Internal_Shdr
*relsec
;
4822 Elf_Internal_Rela
*rela
, *rp
;
4823 unsigned char *table
, *tp
;
4824 Elf_Internal_Sym
*sym
;
4825 const char *relname
;
4827 /* First, find the starting address of the segment that includes
4830 if (elf_header
.e_phnum
)
4832 if (! get_program_headers (file
))
4835 for (seg
= program_headers
;
4836 seg
< program_headers
+ elf_header
.e_phnum
;
4839 if (seg
->p_type
!= PT_LOAD
)
4842 if (sec
->sh_addr
>= seg
->p_vaddr
4843 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4845 aux
->seg_base
= seg
->p_vaddr
;
4851 /* Second, build the unwind table from the contents of the unwind
4853 size
= sec
->sh_size
;
4854 table
= get_data (NULL
, file
, sec
->sh_offset
, size
, _("unwind table"));
4858 unw_ent_size
= 2 * eh_addr_size
+ 8;
4860 tep
= aux
->table
= xmalloc (size
/ unw_ent_size
* sizeof (aux
->table
[0]));
4862 for (tp
= table
; tp
< table
+ size
; tp
+= (2 * eh_addr_size
+ 8), ++tep
)
4864 unsigned int tmp1
, tmp2
;
4866 tep
->start
.section
= SHN_UNDEF
;
4867 tep
->end
.section
= SHN_UNDEF
;
4871 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4872 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4873 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
4874 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
4878 tep
->start
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 0);
4879 tep
->end
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 8);
4880 tmp1
= byte_get ((unsigned char *) tp
+ 16, 4);
4881 tmp2
= byte_get ((unsigned char *) tp
+ 20, 4);
4884 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
4885 tep
->Millicode
= (tmp1
>> 30) & 0x1;
4886 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
4887 tep
->Region_description
= (tmp1
>> 27) & 0x3;
4888 tep
->reserved1
= (tmp1
>> 26) & 0x1;
4889 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
4890 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
4891 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
4892 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
4893 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
4894 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
4895 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
4896 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
4897 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
4898 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
4899 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
4900 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
4901 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
4902 tep
->reserved2
= (tmp1
>> 5) & 0x1;
4903 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
4904 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
4905 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
4906 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
4907 tep
->Cleanup_defined
= tmp1
& 0x1;
4909 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
4910 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
4911 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
4912 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
4913 tep
->reserved4
= (tmp2
>> 27) & 0x1;
4914 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
4916 tep
->start
.offset
+= aux
->seg_base
;
4917 tep
->end
.offset
+= aux
->seg_base
;
4921 /* Third, apply any relocations to the unwind table. */
4923 for (relsec
= section_headers
;
4924 relsec
< section_headers
+ elf_header
.e_shnum
;
4927 if (relsec
->sh_type
!= SHT_RELA
4928 || SECTION_HEADER (relsec
->sh_info
) != sec
)
4931 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
4935 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4939 relname
= elf_hppa_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4940 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4944 relname
= elf_hppa_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4945 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4948 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
4949 if (strncmp (relname
, "R_PARISC_SEGREL", 15) != 0)
4951 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4955 i
= rp
->r_offset
/ unw_ent_size
;
4957 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
4960 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4961 aux
->table
[i
].start
.offset
+= sym
->st_value
+ rp
->r_addend
;
4964 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4965 aux
->table
[i
].end
.offset
+= sym
->st_value
+ rp
->r_addend
;
4975 aux
->table_len
= size
/ unw_ent_size
;
4981 hppa_process_unwind (FILE *file
)
4983 struct hppa_unw_aux_info aux
;
4984 Elf_Internal_Shdr
*unwsec
= NULL
;
4985 Elf_Internal_Shdr
*strsec
;
4986 Elf_Internal_Shdr
*sec
;
4989 memset (& aux
, 0, sizeof (aux
));
4991 assert (string_table
!= NULL
);
4993 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4995 if (sec
->sh_type
== SHT_SYMTAB
)
4997 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
4998 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5000 strsec
= SECTION_HEADER (sec
->sh_link
);
5001 aux
.strtab_size
= strsec
->sh_size
;
5002 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5003 aux
.strtab_size
, _("string table"));
5005 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5010 printf (_("\nThere are no unwind sections in this file.\n"));
5012 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5014 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5016 printf (_("\nUnwind section "));
5017 printf (_("'%s'"), SECTION_NAME (sec
));
5019 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5020 (unsigned long) sec
->sh_offset
,
5021 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5023 slurp_hppa_unwind_table (file
, &aux
, sec
);
5024 if (aux
.table_len
> 0)
5025 dump_hppa_unwind (&aux
);
5028 free ((char *) aux
.table
);
5036 free ((char *) aux
.strtab
);
5042 process_unwind (FILE *file
)
5044 struct unwind_handler
{
5046 int (*handler
)(FILE *file
);
5048 { EM_IA_64
, ia64_process_unwind
},
5049 { EM_PARISC
, hppa_process_unwind
},
5057 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5058 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5059 return handlers
[i
].handler (file
);
5061 printf (_("\nThere are no unwind sections in this file.\n"));
5066 dynamic_section_mips_val (Elf_Internal_Dyn
*entry
)
5068 switch (entry
->d_tag
)
5071 if (entry
->d_un
.d_val
== 0)
5075 static const char * opts
[] =
5077 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5078 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5079 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5080 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5085 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++cnt
)
5086 if (entry
->d_un
.d_val
& (1 << cnt
))
5088 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5095 case DT_MIPS_IVERSION
:
5096 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5097 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5099 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5102 case DT_MIPS_TIME_STAMP
:
5107 time_t time
= entry
->d_un
.d_val
;
5108 tmp
= gmtime (&time
);
5109 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
5110 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5111 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5112 printf ("Time Stamp: %s\n", timebuf
);
5116 case DT_MIPS_RLD_VERSION
:
5117 case DT_MIPS_LOCAL_GOTNO
:
5118 case DT_MIPS_CONFLICTNO
:
5119 case DT_MIPS_LIBLISTNO
:
5120 case DT_MIPS_SYMTABNO
:
5121 case DT_MIPS_UNREFEXTNO
:
5122 case DT_MIPS_HIPAGENO
:
5123 case DT_MIPS_DELTA_CLASS_NO
:
5124 case DT_MIPS_DELTA_INSTANCE_NO
:
5125 case DT_MIPS_DELTA_RELOC_NO
:
5126 case DT_MIPS_DELTA_SYM_NO
:
5127 case DT_MIPS_DELTA_CLASSSYM_NO
:
5128 case DT_MIPS_COMPACT_SIZE
:
5129 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5133 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
5139 dynamic_section_parisc_val (Elf_Internal_Dyn
*entry
)
5141 switch (entry
->d_tag
)
5143 case DT_HP_DLD_FLAGS
:
5152 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5153 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5154 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5155 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5156 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5157 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5158 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5159 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5160 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5161 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5162 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
5166 bfd_vma val
= entry
->d_un
.d_val
;
5168 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
5169 if (val
& flags
[cnt
].bit
)
5173 fputs (flags
[cnt
].str
, stdout
);
5175 val
^= flags
[cnt
].bit
;
5178 if (val
!= 0 || first
)
5182 print_vma (val
, HEX
);
5188 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5195 dynamic_section_ia64_val (Elf_Internal_Dyn
*entry
)
5197 switch (entry
->d_tag
)
5199 case DT_IA_64_PLT_RESERVE
:
5200 /* First 3 slots reserved. */
5201 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5203 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5207 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5214 get_32bit_dynamic_section (FILE *file
)
5216 Elf32_External_Dyn
*edyn
, *ext
;
5217 Elf_Internal_Dyn
*entry
;
5219 edyn
= get_data (NULL
, file
, dynamic_addr
, dynamic_size
,
5220 _("dynamic section"));
5224 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5225 might not have the luxury of section headers. Look for the DT_NULL
5226 terminator to determine the number of entries. */
5227 for (ext
= edyn
, dynamic_nent
= 0;
5228 (char *) ext
< (char *) edyn
+ dynamic_size
;
5232 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5236 dynamic_section
= malloc (dynamic_nent
* sizeof (*entry
));
5237 if (dynamic_section
== NULL
)
5239 error (_("Out of memory\n"));
5244 for (ext
= edyn
, entry
= dynamic_section
;
5245 entry
< dynamic_section
+ dynamic_nent
;
5248 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5249 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5258 get_64bit_dynamic_section (FILE *file
)
5260 Elf64_External_Dyn
*edyn
, *ext
;
5261 Elf_Internal_Dyn
*entry
;
5263 edyn
= get_data (NULL
, file
, dynamic_addr
, dynamic_size
,
5264 _("dynamic section"));
5268 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5269 might not have the luxury of section headers. Look for the DT_NULL
5270 terminator to determine the number of entries. */
5271 for (ext
= edyn
, dynamic_nent
= 0;
5272 (char *) ext
< (char *) edyn
+ dynamic_size
;
5276 if (BYTE_GET8 (ext
->d_tag
) == DT_NULL
)
5280 dynamic_section
= malloc (dynamic_nent
* sizeof (*entry
));
5281 if (dynamic_section
== NULL
)
5283 error (_("Out of memory\n"));
5288 for (ext
= edyn
, entry
= dynamic_section
;
5289 entry
< dynamic_section
+ dynamic_nent
;
5292 entry
->d_tag
= BYTE_GET8 (ext
->d_tag
);
5293 entry
->d_un
.d_val
= BYTE_GET8 (ext
->d_un
.d_val
);
5302 get_dynamic_flags (bfd_vma flags
)
5304 static char buff
[128];
5312 flag
= flags
& - flags
;
5320 case DF_ORIGIN
: strcpy (p
, "ORIGIN"); break;
5321 case DF_SYMBOLIC
: strcpy (p
, "SYMBOLIC"); break;
5322 case DF_TEXTREL
: strcpy (p
, "TEXTREL"); break;
5323 case DF_BIND_NOW
: strcpy (p
, "BIND_NOW"); break;
5324 case DF_STATIC_TLS
: strcpy (p
, "STATIC_TLS"); break;
5325 default: strcpy (p
, "unknown"); break;
5328 p
= strchr (p
, '\0');
5333 /* Parse and display the contents of the dynamic section. */
5336 process_dynamic_section (FILE *file
)
5338 Elf_Internal_Dyn
*entry
;
5340 if (dynamic_size
== 0)
5343 printf (_("\nThere is no dynamic section in this file.\n"));
5350 if (! get_32bit_dynamic_section (file
))
5353 else if (! get_64bit_dynamic_section (file
))
5356 /* Find the appropriate symbol table. */
5357 if (dynamic_symbols
== NULL
)
5359 for (entry
= dynamic_section
;
5360 entry
< dynamic_section
+ dynamic_nent
;
5363 Elf_Internal_Shdr section
;
5365 if (entry
->d_tag
!= DT_SYMTAB
)
5368 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
5370 /* Since we do not know how big the symbol table is,
5371 we default to reading in the entire file (!) and
5372 processing that. This is overkill, I know, but it
5374 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5376 if (archive_file_offset
!= 0)
5377 section
.sh_size
= archive_file_size
- section
.sh_offset
;
5380 if (fseek (file
, 0, SEEK_END
))
5381 error (_("Unable to seek to end of file!"));
5383 section
.sh_size
= ftell (file
) - section
.sh_offset
;
5387 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
5389 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
5391 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
5392 if (num_dynamic_syms
< 1)
5394 error (_("Unable to determine the number of symbols to load\n"));
5398 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
5402 /* Similarly find a string table. */
5403 if (dynamic_strings
== NULL
)
5405 for (entry
= dynamic_section
;
5406 entry
< dynamic_section
+ dynamic_nent
;
5409 unsigned long offset
;
5412 if (entry
->d_tag
!= DT_STRTAB
)
5415 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
5417 /* Since we do not know how big the string table is,
5418 we default to reading in the entire file (!) and
5419 processing that. This is overkill, I know, but it
5422 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5424 if (archive_file_offset
!= 0)
5425 str_tab_len
= archive_file_size
- offset
;
5428 if (fseek (file
, 0, SEEK_END
))
5429 error (_("Unable to seek to end of file\n"));
5430 str_tab_len
= ftell (file
) - offset
;
5433 if (str_tab_len
< 1)
5436 (_("Unable to determine the length of the dynamic string table\n"));
5440 dynamic_strings
= get_data (NULL
, file
, offset
, str_tab_len
,
5441 _("dynamic string table"));
5442 dynamic_strings_length
= str_tab_len
;
5447 /* And find the syminfo section if available. */
5448 if (dynamic_syminfo
== NULL
)
5450 unsigned long syminsz
= 0;
5452 for (entry
= dynamic_section
;
5453 entry
< dynamic_section
+ dynamic_nent
;
5456 if (entry
->d_tag
== DT_SYMINENT
)
5458 /* Note: these braces are necessary to avoid a syntax
5459 error from the SunOS4 C compiler. */
5460 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
5462 else if (entry
->d_tag
== DT_SYMINSZ
)
5463 syminsz
= entry
->d_un
.d_val
;
5464 else if (entry
->d_tag
== DT_SYMINFO
)
5465 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
5469 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
5471 Elf_External_Syminfo
*extsyminfo
, *extsym
;
5472 Elf_Internal_Syminfo
*syminfo
;
5474 /* There is a syminfo section. Read the data. */
5475 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, syminsz
,
5476 _("symbol information"));
5480 dynamic_syminfo
= malloc (syminsz
);
5481 if (dynamic_syminfo
== NULL
)
5483 error (_("Out of memory\n"));
5487 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
5488 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
5489 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
5490 ++syminfo
, ++extsym
)
5492 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
5493 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
5500 if (do_dynamic
&& dynamic_addr
)
5501 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
5502 dynamic_addr
, dynamic_nent
);
5504 printf (_(" Tag Type Name/Value\n"));
5506 for (entry
= dynamic_section
;
5507 entry
< dynamic_section
+ dynamic_nent
;
5515 print_vma (entry
->d_tag
, FULL_HEX
);
5516 dtype
= get_dynamic_type (entry
->d_tag
);
5517 printf (" (%s)%*s", dtype
,
5518 ((is_32bit_elf
? 27 : 19)
5519 - (int) strlen (dtype
)),
5523 switch (entry
->d_tag
)
5527 puts (get_dynamic_flags (entry
->d_un
.d_val
));
5537 switch (entry
->d_tag
)
5540 printf (_("Auxiliary library"));
5544 printf (_("Filter library"));
5548 printf (_("Configuration file"));
5552 printf (_("Dependency audit library"));
5556 printf (_("Audit library"));
5560 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5561 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5565 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5574 printf (_("Flags:"));
5576 if (entry
->d_un
.d_val
== 0)
5577 printf (_(" None\n"));
5580 unsigned long int val
= entry
->d_un
.d_val
;
5582 if (val
& DTF_1_PARINIT
)
5584 printf (" PARINIT");
5585 val
^= DTF_1_PARINIT
;
5587 if (val
& DTF_1_CONFEXP
)
5589 printf (" CONFEXP");
5590 val
^= DTF_1_CONFEXP
;
5593 printf (" %lx", val
);
5602 printf (_("Flags:"));
5604 if (entry
->d_un
.d_val
== 0)
5605 printf (_(" None\n"));
5608 unsigned long int val
= entry
->d_un
.d_val
;
5610 if (val
& DF_P1_LAZYLOAD
)
5612 printf (" LAZYLOAD");
5613 val
^= DF_P1_LAZYLOAD
;
5615 if (val
& DF_P1_GROUPPERM
)
5617 printf (" GROUPPERM");
5618 val
^= DF_P1_GROUPPERM
;
5621 printf (" %lx", val
);
5630 printf (_("Flags:"));
5631 if (entry
->d_un
.d_val
== 0)
5632 printf (_(" None\n"));
5635 unsigned long int val
= entry
->d_un
.d_val
;
5642 if (val
& DF_1_GLOBAL
)
5647 if (val
& DF_1_GROUP
)
5652 if (val
& DF_1_NODELETE
)
5654 printf (" NODELETE");
5655 val
^= DF_1_NODELETE
;
5657 if (val
& DF_1_LOADFLTR
)
5659 printf (" LOADFLTR");
5660 val
^= DF_1_LOADFLTR
;
5662 if (val
& DF_1_INITFIRST
)
5664 printf (" INITFIRST");
5665 val
^= DF_1_INITFIRST
;
5667 if (val
& DF_1_NOOPEN
)
5672 if (val
& DF_1_ORIGIN
)
5677 if (val
& DF_1_DIRECT
)
5682 if (val
& DF_1_TRANS
)
5687 if (val
& DF_1_INTERPOSE
)
5689 printf (" INTERPOSE");
5690 val
^= DF_1_INTERPOSE
;
5692 if (val
& DF_1_NODEFLIB
)
5694 printf (" NODEFLIB");
5695 val
^= DF_1_NODEFLIB
;
5697 if (val
& DF_1_NODUMP
)
5702 if (val
& DF_1_CONLFAT
)
5704 printf (" CONLFAT");
5705 val
^= DF_1_CONLFAT
;
5708 printf (" %lx", val
);
5715 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5717 puts (get_dynamic_type (entry
->d_un
.d_val
));
5737 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5743 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5744 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
5750 switch (entry
->d_tag
)
5753 printf (_("Shared library: [%s]"), name
);
5755 if (streq (name
, program_interpreter
))
5756 printf (_(" program interpreter"));
5760 printf (_("Library soname: [%s]"), name
);
5764 printf (_("Library rpath: [%s]"), name
);
5768 printf (_("Library runpath: [%s]"), name
);
5772 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5777 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5790 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5794 case DT_INIT_ARRAYSZ
:
5795 case DT_FINI_ARRAYSZ
:
5796 case DT_GNU_CONFLICTSZ
:
5797 case DT_GNU_LIBLISTSZ
:
5800 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5801 printf (" (bytes)\n");
5811 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5824 if (entry
->d_tag
== DT_USED
5825 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5827 char *name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
5831 printf (_("Not needed object: [%s]\n"), name
);
5836 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5842 /* The value of this entry is ignored. */
5847 case DT_GNU_PRELINKED
:
5851 time_t time
= entry
->d_un
.d_val
;
5853 tmp
= gmtime (&time
);
5854 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
5855 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5856 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5862 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
5863 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
5868 switch (elf_header
.e_machine
)
5871 case EM_MIPS_RS3_LE
:
5872 dynamic_section_mips_val (entry
);
5875 dynamic_section_parisc_val (entry
);
5878 dynamic_section_ia64_val (entry
);
5881 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5893 get_ver_flags (unsigned int flags
)
5895 static char buff
[32];
5902 if (flags
& VER_FLG_BASE
)
5903 strcat (buff
, "BASE ");
5905 if (flags
& VER_FLG_WEAK
)
5907 if (flags
& VER_FLG_BASE
)
5908 strcat (buff
, "| ");
5910 strcat (buff
, "WEAK ");
5913 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
5914 strcat (buff
, "| <unknown>");
5919 /* Display the contents of the version sections. */
5921 process_version_sections (FILE *file
)
5923 Elf_Internal_Shdr
*section
;
5930 for (i
= 0, section
= section_headers
;
5931 i
< elf_header
.e_shnum
;
5934 switch (section
->sh_type
)
5936 case SHT_GNU_verdef
:
5938 Elf_External_Verdef
*edefs
;
5945 (_("\nVersion definition section '%s' contains %ld entries:\n"),
5946 SECTION_NAME (section
), section
->sh_info
);
5948 printf (_(" Addr: 0x"));
5949 printf_vma (section
->sh_addr
);
5950 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5951 (unsigned long) section
->sh_offset
, section
->sh_link
,
5952 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
5954 edefs
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
5955 _("version definition section"));
5959 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
5962 Elf_External_Verdef
*edef
;
5963 Elf_Internal_Verdef ent
;
5964 Elf_External_Verdaux
*eaux
;
5965 Elf_Internal_Verdaux aux
;
5969 vstart
= ((char *) edefs
) + idx
;
5971 edef
= (Elf_External_Verdef
*) vstart
;
5973 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
5974 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
5975 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
5976 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
5977 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
5978 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
5979 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
5981 printf (_(" %#06x: Rev: %d Flags: %s"),
5982 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
5984 printf (_(" Index: %d Cnt: %d "),
5985 ent
.vd_ndx
, ent
.vd_cnt
);
5987 vstart
+= ent
.vd_aux
;
5989 eaux
= (Elf_External_Verdaux
*) vstart
;
5991 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
5992 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
5994 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
5995 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
5997 printf (_("Name index: %ld\n"), aux
.vda_name
);
5999 isum
= idx
+ ent
.vd_aux
;
6001 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6003 isum
+= aux
.vda_next
;
6004 vstart
+= aux
.vda_next
;
6006 eaux
= (Elf_External_Verdaux
*) vstart
;
6008 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6009 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6011 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6012 printf (_(" %#06x: Parent %d: %s\n"),
6013 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6015 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6016 isum
, j
, aux
.vda_name
);
6026 case SHT_GNU_verneed
:
6028 Elf_External_Verneed
*eneed
;
6034 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
6035 SECTION_NAME (section
), section
->sh_info
);
6037 printf (_(" Addr: 0x"));
6038 printf_vma (section
->sh_addr
);
6039 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
6040 (unsigned long) section
->sh_offset
, section
->sh_link
,
6041 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
6043 eneed
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
6044 _("version need section"));
6048 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6050 Elf_External_Verneed
*entry
;
6051 Elf_Internal_Verneed ent
;
6056 vstart
= ((char *) eneed
) + idx
;
6058 entry
= (Elf_External_Verneed
*) vstart
;
6060 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6061 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6062 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6063 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6064 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6066 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6068 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6069 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6071 printf (_(" File: %lx"), ent
.vn_file
);
6073 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6075 vstart
+= ent
.vn_aux
;
6077 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6079 Elf_External_Vernaux
*eaux
;
6080 Elf_Internal_Vernaux aux
;
6082 eaux
= (Elf_External_Vernaux
*) vstart
;
6084 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6085 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6086 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6087 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6088 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6090 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6091 printf (_(" %#06x: Name: %s"),
6092 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6094 printf (_(" %#06x: Name index: %lx"),
6095 isum
, aux
.vna_name
);
6097 printf (_(" Flags: %s Version: %d\n"),
6098 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6100 isum
+= aux
.vna_next
;
6101 vstart
+= aux
.vna_next
;
6111 case SHT_GNU_versym
:
6113 Elf_Internal_Shdr
*link_section
;
6116 unsigned char *edata
;
6117 unsigned short *data
;
6119 Elf_Internal_Sym
*symbols
;
6120 Elf_Internal_Shdr
*string_sec
;
6123 link_section
= SECTION_HEADER (section
->sh_link
);
6124 total
= section
->sh_size
/ section
->sh_entsize
;
6128 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6130 string_sec
= SECTION_HEADER (link_section
->sh_link
);
6132 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
6133 string_sec
->sh_size
, _("version string table"));
6137 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6138 SECTION_NAME (section
), total
);
6140 printf (_(" Addr: "));
6141 printf_vma (section
->sh_addr
);
6142 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6143 (unsigned long) section
->sh_offset
, section
->sh_link
,
6144 SECTION_NAME (link_section
));
6146 off
= offset_from_vma (file
,
6147 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6148 total
* sizeof (short));
6149 edata
= get_data (NULL
, file
, off
, total
* sizeof (short),
6150 _("version symbol data"));
6157 data
= malloc (total
* sizeof (short));
6159 for (cnt
= total
; cnt
--;)
6160 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6165 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6168 int check_def
, check_need
;
6171 printf (" %03x:", cnt
);
6173 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6174 switch (data
[cnt
+ j
])
6177 fputs (_(" 0 (*local*) "), stdout
);
6181 fputs (_(" 1 (*global*) "), stdout
);
6185 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
6186 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
6190 if (SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
6193 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6200 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6202 Elf_Internal_Verneed ivn
;
6203 unsigned long offset
;
6205 offset
= offset_from_vma
6206 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6207 sizeof (Elf_External_Verneed
));
6211 Elf_Internal_Vernaux ivna
;
6212 Elf_External_Verneed evn
;
6213 Elf_External_Vernaux evna
;
6214 unsigned long a_off
;
6216 get_data (&evn
, file
, offset
, sizeof (evn
),
6219 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6220 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6222 a_off
= offset
+ ivn
.vn_aux
;
6226 get_data (&evna
, file
, a_off
, sizeof (evna
),
6227 _("version need aux (2)"));
6229 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6230 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6232 a_off
+= ivna
.vna_next
;
6234 while (ivna
.vna_other
!= data
[cnt
+ j
]
6235 && ivna
.vna_next
!= 0);
6237 if (ivna
.vna_other
== data
[cnt
+ j
])
6239 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6241 name
= strtab
+ ivna
.vna_name
;
6242 nn
+= printf ("(%s%-*s",
6244 12 - (int) strlen (name
),
6250 offset
+= ivn
.vn_next
;
6252 while (ivn
.vn_next
);
6255 if (check_def
&& data
[cnt
+ j
] != 0x8001
6256 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6258 Elf_Internal_Verdef ivd
;
6259 Elf_External_Verdef evd
;
6260 unsigned long offset
;
6262 offset
= offset_from_vma
6263 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6268 get_data (&evd
, file
, offset
, sizeof (evd
),
6271 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6272 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6274 offset
+= ivd
.vd_next
;
6276 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
6277 && ivd
.vd_next
!= 0);
6279 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
6281 Elf_External_Verdaux evda
;
6282 Elf_Internal_Verdaux ivda
;
6284 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6286 get_data (&evda
, file
,
6287 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
6288 sizeof (evda
), _("version def aux"));
6290 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6292 name
= strtab
+ ivda
.vda_name
;
6293 nn
+= printf ("(%s%-*s",
6295 12 - (int) strlen (name
),
6301 printf ("%*c", 18 - nn
, ' ');
6319 printf (_("\nNo version information found in this file.\n"));
6325 get_symbol_binding (unsigned int binding
)
6327 static char buff
[32];
6331 case STB_LOCAL
: return "LOCAL";
6332 case STB_GLOBAL
: return "GLOBAL";
6333 case STB_WEAK
: return "WEAK";
6335 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
6336 sprintf (buff
, _("<processor specific>: %d"), binding
);
6337 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
6338 sprintf (buff
, _("<OS specific>: %d"), binding
);
6340 sprintf (buff
, _("<unknown>: %d"), binding
);
6346 get_symbol_type (unsigned int type
)
6348 static char buff
[32];
6352 case STT_NOTYPE
: return "NOTYPE";
6353 case STT_OBJECT
: return "OBJECT";
6354 case STT_FUNC
: return "FUNC";
6355 case STT_SECTION
: return "SECTION";
6356 case STT_FILE
: return "FILE";
6357 case STT_COMMON
: return "COMMON";
6358 case STT_TLS
: return "TLS";
6360 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
6362 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
6363 return "THUMB_FUNC";
6365 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
6368 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
6369 return "PARISC_MILLI";
6371 sprintf (buff
, _("<processor specific>: %d"), type
);
6373 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
6375 if (elf_header
.e_machine
== EM_PARISC
)
6377 if (type
== STT_HP_OPAQUE
)
6379 if (type
== STT_HP_STUB
)
6383 sprintf (buff
, _("<OS specific>: %d"), type
);
6386 sprintf (buff
, _("<unknown>: %d"), type
);
6392 get_symbol_visibility (unsigned int visibility
)
6396 case STV_DEFAULT
: return "DEFAULT";
6397 case STV_INTERNAL
: return "INTERNAL";
6398 case STV_HIDDEN
: return "HIDDEN";
6399 case STV_PROTECTED
: return "PROTECTED";
6405 get_symbol_index_type (unsigned int type
)
6407 static char buff
[32];
6411 case SHN_UNDEF
: return "UND";
6412 case SHN_ABS
: return "ABS";
6413 case SHN_COMMON
: return "COM";
6415 if (type
== SHN_IA_64_ANSI_COMMON
6416 && elf_header
.e_machine
== EM_IA_64
6417 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
6419 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
6420 sprintf (buff
, "PRC[0x%04x]", type
);
6421 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
6422 sprintf (buff
, "OS [0x%04x]", type
);
6423 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
6424 sprintf (buff
, "RSV[0x%04x]", type
);
6426 sprintf (buff
, "%3d", type
);
6434 get_dynamic_data (FILE *file
, unsigned int number
)
6436 unsigned char *e_data
;
6439 e_data
= malloc (number
* 4);
6443 error (_("Out of memory\n"));
6447 if (fread (e_data
, 4, number
, file
) != number
)
6449 error (_("Unable to read in dynamic data\n"));
6453 i_data
= malloc (number
* sizeof (*i_data
));
6457 error (_("Out of memory\n"));
6463 i_data
[number
] = byte_get (e_data
+ number
* 4, 4);
6470 /* Dump the symbol table. */
6472 process_symbol_table (FILE *file
)
6474 Elf_Internal_Shdr
*section
;
6475 unsigned char nb
[4];
6476 unsigned char nc
[4];
6479 int *buckets
= NULL
;
6482 if (! do_syms
&& !do_histogram
)
6485 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
6489 (archive_file_offset
6490 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
6491 sizeof nb
+ sizeof nc
)),
6494 error (_("Unable to seek to start of dynamic information"));
6498 if (fread (nb
, sizeof (nb
), 1, file
) != 1)
6500 error (_("Failed to read in number of buckets\n"));
6504 if (fread (nc
, sizeof (nc
), 1, file
) != 1)
6506 error (_("Failed to read in number of chains\n"));
6510 nbuckets
= byte_get (nb
, 4);
6511 nchains
= byte_get (nc
, 4);
6513 buckets
= get_dynamic_data (file
, nbuckets
);
6514 chains
= get_dynamic_data (file
, nchains
);
6516 if (buckets
== NULL
|| chains
== NULL
)
6521 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
6526 printf (_("\nSymbol table for image:\n"));
6528 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6530 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6532 for (hn
= 0; hn
< nbuckets
; hn
++)
6537 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
6539 Elf_Internal_Sym
*psym
;
6541 psym
= dynamic_symbols
+ si
;
6543 printf (" %3d %3d: ", si
, hn
);
6544 print_vma (psym
->st_value
, LONG_HEX
);
6546 print_vma (psym
->st_size
, DEC_5
);
6548 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6549 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6550 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6551 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
6552 if (VALID_DYNAMIC_NAME (psym
->st_name
))
6553 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
6555 printf (" <corrupt: %14ld>", psym
->st_name
);
6560 else if (do_syms
&& !do_using_dynamic
)
6564 for (i
= 0, section
= section_headers
;
6565 i
< elf_header
.e_shnum
;
6570 Elf_Internal_Sym
*symtab
;
6571 Elf_Internal_Sym
*psym
;
6574 if ( section
->sh_type
!= SHT_SYMTAB
6575 && section
->sh_type
!= SHT_DYNSYM
)
6578 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
6579 SECTION_NAME (section
),
6580 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
6582 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6584 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6586 symtab
= GET_ELF_SYMBOLS (file
, section
);
6590 if (section
->sh_link
== elf_header
.e_shstrndx
)
6591 strtab
= string_table
;
6594 Elf_Internal_Shdr
*string_sec
;
6596 string_sec
= SECTION_HEADER (section
->sh_link
);
6598 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
6599 string_sec
->sh_size
, _("string table"));
6602 for (si
= 0, psym
= symtab
;
6603 si
< section
->sh_size
/ section
->sh_entsize
;
6606 printf ("%6d: ", si
);
6607 print_vma (psym
->st_value
, LONG_HEX
);
6609 print_vma (psym
->st_size
, DEC_5
);
6610 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6611 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6612 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6613 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
6614 print_symbol (25, strtab
+ psym
->st_name
);
6616 if (section
->sh_type
== SHT_DYNSYM
&&
6617 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
6619 unsigned char data
[2];
6620 unsigned short vers_data
;
6621 unsigned long offset
;
6625 offset
= offset_from_vma
6626 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6627 sizeof data
+ si
* sizeof (vers_data
));
6629 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
6630 sizeof (data
), _("version data"));
6632 vers_data
= byte_get (data
, 2);
6634 is_nobits
= (SECTION_HEADER (psym
->st_shndx
)->sh_type
6637 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
6639 if ((vers_data
& 0x8000) || vers_data
> 1)
6641 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
6642 && (is_nobits
|| ! check_def
))
6644 Elf_External_Verneed evn
;
6645 Elf_Internal_Verneed ivn
;
6646 Elf_Internal_Vernaux ivna
;
6648 /* We must test both. */
6649 offset
= offset_from_vma
6650 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6655 unsigned long vna_off
;
6657 get_data (&evn
, file
, offset
, sizeof (evn
),
6660 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6661 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6663 vna_off
= offset
+ ivn
.vn_aux
;
6667 Elf_External_Vernaux evna
;
6669 get_data (&evna
, file
, vna_off
,
6671 _("version need aux (3)"));
6673 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6674 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6675 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6677 vna_off
+= ivna
.vna_next
;
6679 while (ivna
.vna_other
!= vers_data
6680 && ivna
.vna_next
!= 0);
6682 if (ivna
.vna_other
== vers_data
)
6685 offset
+= ivn
.vn_next
;
6687 while (ivn
.vn_next
!= 0);
6689 if (ivna
.vna_other
== vers_data
)
6692 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
6695 else if (! is_nobits
)
6696 error (_("bad dynamic symbol"));
6703 if (vers_data
!= 0x8001
6704 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6706 Elf_Internal_Verdef ivd
;
6707 Elf_Internal_Verdaux ivda
;
6708 Elf_External_Verdaux evda
;
6709 unsigned long offset
;
6711 offset
= offset_from_vma
6713 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6714 sizeof (Elf_External_Verdef
));
6718 Elf_External_Verdef evd
;
6720 get_data (&evd
, file
, offset
, sizeof (evd
),
6723 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6724 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6725 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6727 offset
+= ivd
.vd_next
;
6729 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
6730 && ivd
.vd_next
!= 0);
6732 offset
-= ivd
.vd_next
;
6733 offset
+= ivd
.vd_aux
;
6735 get_data (&evda
, file
, offset
, sizeof (evda
),
6736 _("version def aux"));
6738 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6740 if (psym
->st_name
!= ivda
.vda_name
)
6741 printf ((vers_data
& 0x8000)
6743 strtab
+ ivda
.vda_name
);
6753 if (strtab
!= string_table
)
6759 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
6761 if (do_histogram
&& buckets
!= NULL
)
6768 int nzero_counts
= 0;
6771 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
6773 printf (_(" Length Number %% of total Coverage\n"));
6775 lengths
= calloc (nbuckets
, sizeof (int));
6776 if (lengths
== NULL
)
6778 error (_("Out of memory"));
6781 for (hn
= 0; hn
< nbuckets
; ++hn
)
6786 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
6789 if (maxlength
< ++lengths
[hn
])
6794 counts
= calloc (maxlength
+ 1, sizeof (int));
6797 error (_("Out of memory"));
6801 for (hn
= 0; hn
< nbuckets
; ++hn
)
6802 ++counts
[lengths
[hn
]];
6806 printf (" 0 %-10d (%5.1f%%)\n",
6807 counts
[0], (counts
[0] * 100.0) / nbuckets
);
6808 for (si
= 1; si
<= maxlength
; ++si
)
6810 nzero_counts
+= counts
[si
] * si
;
6811 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
6812 si
, counts
[si
], (counts
[si
] * 100.0) / nbuckets
,
6813 (nzero_counts
* 100.0) / nsyms
);
6821 if (buckets
!= NULL
)
6831 process_syminfo (FILE *file ATTRIBUTE_UNUSED
)
6835 if (dynamic_syminfo
== NULL
6837 /* No syminfo, this is ok. */
6840 /* There better should be a dynamic symbol section. */
6841 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
6845 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
6846 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
6848 printf (_(" Num: Name BoundTo Flags\n"));
6849 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
6851 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
6853 printf ("%4d: ", i
);
6854 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
6855 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
6857 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
6860 switch (dynamic_syminfo
[i
].si_boundto
)
6862 case SYMINFO_BT_SELF
:
6863 fputs ("SELF ", stdout
);
6865 case SYMINFO_BT_PARENT
:
6866 fputs ("PARENT ", stdout
);
6869 if (dynamic_syminfo
[i
].si_boundto
> 0
6870 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
6871 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
6873 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
6877 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
6881 if (flags
& SYMINFO_FLG_DIRECT
)
6883 if (flags
& SYMINFO_FLG_PASSTHRU
)
6884 printf (" PASSTHRU");
6885 if (flags
& SYMINFO_FLG_COPY
)
6887 if (flags
& SYMINFO_FLG_LAZYLOAD
)
6888 printf (" LAZYLOAD");
6896 #ifdef SUPPORT_DISASSEMBLY
6898 disassemble_section (Elf_Internal_Shdr
*section
, FILE *file
)
6900 printf (_("\nAssembly dump of section %s\n"),
6901 SECTION_NAME (section
));
6903 /* XXX -- to be done --- XXX */
6910 dump_section (Elf_Internal_Shdr
*section
, FILE *file
)
6912 bfd_size_type bytes
;
6914 unsigned char *data
;
6915 unsigned char *start
;
6917 bytes
= section
->sh_size
;
6919 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
6921 printf (_("\nSection '%s' has no data to dump.\n"),
6922 SECTION_NAME (section
));
6926 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
6928 addr
= section
->sh_addr
;
6930 start
= get_data (NULL
, file
, section
->sh_offset
, bytes
, _("section data"));
6942 lbytes
= (bytes
> 16 ? 16 : bytes
);
6944 printf (" 0x%8.8lx ", (unsigned long) addr
);
6946 switch (elf_header
.e_ident
[EI_DATA
])
6950 for (j
= 15; j
>= 0; j
--)
6953 printf ("%2.2x", data
[j
]);
6963 for (j
= 0; j
< 16; j
++)
6966 printf ("%2.2x", data
[j
]);
6976 for (j
= 0; j
< lbytes
; j
++)
6979 if (k
>= ' ' && k
< 0x7f)
6998 static unsigned long int
6999 read_leb128 (unsigned char *data
, int *length_return
, int sign
)
7001 unsigned long int result
= 0;
7002 unsigned int num_read
= 0;
7003 unsigned int shift
= 0;
7011 result
|= ((unsigned long int) (byte
& 0x7f)) << shift
;
7016 while (byte
& 0x80);
7018 if (length_return
!= NULL
)
7019 *length_return
= num_read
;
7021 if (sign
&& (shift
< 8 * sizeof (result
)) && (byte
& 0x40))
7022 result
|= -1L << shift
;
7027 typedef struct State_Machine_Registers
7029 unsigned long address
;
7032 unsigned int column
;
7036 /* This variable hold the number of the last entry seen
7037 in the File Table. */
7038 unsigned int last_file_entry
;
7041 static SMR state_machine_regs
;
7044 reset_state_machine (int is_stmt
)
7046 state_machine_regs
.address
= 0;
7047 state_machine_regs
.file
= 1;
7048 state_machine_regs
.line
= 1;
7049 state_machine_regs
.column
= 0;
7050 state_machine_regs
.is_stmt
= is_stmt
;
7051 state_machine_regs
.basic_block
= 0;
7052 state_machine_regs
.end_sequence
= 0;
7053 state_machine_regs
.last_file_entry
= 0;
7056 /* Handled an extend line op. Returns true if this is the end
7060 process_extended_line_op (unsigned char *data
, int is_stmt
, int pointer_size
)
7062 unsigned char op_code
;
7065 unsigned char *name
;
7068 len
= read_leb128 (data
, & bytes_read
, 0);
7073 warn (_("badly formed extended line op encountered!\n"));
7080 printf (_(" Extended opcode %d: "), op_code
);
7084 case DW_LNE_end_sequence
:
7085 printf (_("End of Sequence\n\n"));
7086 reset_state_machine (is_stmt
);
7089 case DW_LNE_set_address
:
7090 adr
= byte_get (data
, pointer_size
);
7091 printf (_("set Address to 0x%lx\n"), adr
);
7092 state_machine_regs
.address
= adr
;
7095 case DW_LNE_define_file
:
7096 printf (_(" define new File Table entry\n"));
7097 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
7099 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
7101 data
+= strlen ((char *) data
) + 1;
7102 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7104 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7106 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7107 printf (_("%s\n\n"), name
);
7111 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
7118 static const char *debug_str_contents
;
7119 static bfd_vma debug_str_size
;
7122 load_debug_str (FILE *file
)
7124 Elf_Internal_Shdr
*sec
;
7126 /* If it is already loaded, do nothing. */
7127 if (debug_str_contents
!= NULL
)
7130 /* Locate the .debug_str section. */
7131 sec
= find_section (".debug_str");
7135 debug_str_size
= sec
->sh_size
;
7137 debug_str_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7138 _("debug_str section data"));
7142 free_debug_str (void)
7144 if (debug_str_contents
== NULL
)
7147 free ((char *) debug_str_contents
);
7148 debug_str_contents
= NULL
;
7153 fetch_indirect_string (unsigned long offset
)
7155 if (debug_str_contents
== NULL
)
7156 return _("<no .debug_str section>");
7158 if (offset
> debug_str_size
)
7159 return _("<offset is too big>");
7161 return debug_str_contents
+ offset
;
7164 static const char *debug_loc_contents
;
7165 static bfd_vma debug_loc_size
;
7168 load_debug_loc (FILE *file
)
7170 Elf_Internal_Shdr
*sec
;
7172 /* If it is already loaded, do nothing. */
7173 if (debug_loc_contents
!= NULL
)
7176 /* Locate the .debug_loc section. */
7177 sec
= find_section (".debug_loc");
7181 debug_loc_size
= sec
->sh_size
;
7183 debug_loc_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7184 _("debug_loc section data"));
7188 free_debug_loc (void)
7190 if (debug_loc_contents
== NULL
)
7193 free ((char *) debug_loc_contents
);
7194 debug_loc_contents
= NULL
;
7198 static const char * debug_range_contents
;
7199 static unsigned long debug_range_size
;
7202 load_debug_range (FILE *file
)
7204 Elf_Internal_Shdr
*sec
;
7206 /* If it is already loaded, do nothing. */
7207 if (debug_range_contents
!= NULL
)
7210 /* Locate the .debug_str section. */
7211 sec
= find_section (".debug_ranges");
7215 debug_range_size
= sec
->sh_size
;
7217 debug_range_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7218 _("debug_range section data"));
7222 free_debug_range (void)
7224 if (debug_range_contents
== NULL
)
7227 free ((char *) debug_range_contents
);
7228 debug_range_contents
= NULL
;
7229 debug_range_size
= 0;
7232 /* Apply addends of RELA relocations. */
7235 debug_apply_rela_addends (FILE *file
,
7236 Elf_Internal_Shdr
*section
,
7238 unsigned char *sec_data
,
7239 unsigned char *start
,
7242 Elf_Internal_Shdr
*relsec
;
7244 if (end
- start
< reloc_size
)
7247 for (relsec
= section_headers
;
7248 relsec
< section_headers
+ elf_header
.e_shnum
;
7251 unsigned long nrelas
;
7252 Elf_Internal_Rela
*rela
, *rp
;
7253 Elf_Internal_Shdr
*symsec
;
7254 Elf_Internal_Sym
*symtab
;
7255 Elf_Internal_Sym
*sym
;
7257 if (relsec
->sh_type
!= SHT_RELA
7258 || SECTION_HEADER (relsec
->sh_info
) != section
7259 || relsec
->sh_size
== 0)
7262 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7266 symsec
= SECTION_HEADER (relsec
->sh_link
);
7267 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
7269 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7273 if (rp
->r_offset
>= (bfd_vma
) (start
- sec_data
)
7274 && rp
->r_offset
< (bfd_vma
) (end
- sec_data
) - reloc_size
)
7275 loc
= sec_data
+ rp
->r_offset
;
7281 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
7283 if (ELF32_R_SYM (rp
->r_info
) != 0
7284 && ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
7285 /* Relocations against object symbols can happen,
7286 eg when referencing a global array. For an
7287 example of this see the _clz.o binary in libgcc.a. */
7288 && ELF32_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7290 warn (_("%s: skipping unexpected symbol type %s in relocation in section .rela%s\n"),
7291 get_symbol_type (ELF32_ST_TYPE (sym
->st_info
)),
7292 SECTION_NAME (section
));
7298 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
7300 if (ELF64_R_SYM (rp
->r_info
) != 0
7301 && ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
7302 && ELF64_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7304 warn (_("skipping unexpected symbol type %s in relocation in section .rela.%s\n"),
7305 get_symbol_type (ELF64_ST_TYPE (sym
->st_info
)),
7306 SECTION_NAME (section
));
7311 byte_put (loc
, rp
->r_addend
, reloc_size
);
7321 /* FIXME: There are better and more efficient ways to handle
7322 these structures. For now though, I just want something that
7323 is simple to implement. */
7324 typedef struct abbrev_attr
7326 unsigned long attribute
;
7328 struct abbrev_attr
*next
;
7332 typedef struct abbrev_entry
7334 unsigned long entry
;
7337 struct abbrev_attr
*first_attr
;
7338 struct abbrev_attr
*last_attr
;
7339 struct abbrev_entry
*next
;
7343 static abbrev_entry
*first_abbrev
= NULL
;
7344 static abbrev_entry
*last_abbrev
= NULL
;
7349 abbrev_entry
*abbrev
;
7351 for (abbrev
= first_abbrev
; abbrev
;)
7353 abbrev_entry
*next
= abbrev
->next
;
7356 for (attr
= abbrev
->first_attr
; attr
;)
7358 abbrev_attr
*next
= attr
->next
;
7368 last_abbrev
= first_abbrev
= NULL
;
7372 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
7374 abbrev_entry
*entry
;
7376 entry
= malloc (sizeof (*entry
));
7382 entry
->entry
= number
;
7384 entry
->children
= children
;
7385 entry
->first_attr
= NULL
;
7386 entry
->last_attr
= NULL
;
7389 if (first_abbrev
== NULL
)
7390 first_abbrev
= entry
;
7392 last_abbrev
->next
= entry
;
7394 last_abbrev
= entry
;
7398 add_abbrev_attr (unsigned long attribute
, unsigned long form
)
7402 attr
= malloc (sizeof (*attr
));
7408 attr
->attribute
= attribute
;
7412 if (last_abbrev
->first_attr
== NULL
)
7413 last_abbrev
->first_attr
= attr
;
7415 last_abbrev
->last_attr
->next
= attr
;
7417 last_abbrev
->last_attr
= attr
;
7420 /* Processes the (partial) contents of a .debug_abbrev section.
7421 Returns NULL if the end of the section was encountered.
7422 Returns the address after the last byte read if the end of
7423 an abbreviation set was found. */
7425 static unsigned char *
7426 process_abbrev_section (unsigned char *start
, unsigned char *end
)
7428 if (first_abbrev
!= NULL
)
7434 unsigned long entry
;
7436 unsigned long attribute
;
7439 entry
= read_leb128 (start
, & bytes_read
, 0);
7440 start
+= bytes_read
;
7442 /* A single zero is supposed to end the section according
7443 to the standard. If there's more, then signal that to
7446 return start
== end
? NULL
: start
;
7448 tag
= read_leb128 (start
, & bytes_read
, 0);
7449 start
+= bytes_read
;
7451 children
= *start
++;
7453 add_abbrev (entry
, tag
, children
);
7459 attribute
= read_leb128 (start
, & bytes_read
, 0);
7460 start
+= bytes_read
;
7462 form
= read_leb128 (start
, & bytes_read
, 0);
7463 start
+= bytes_read
;
7466 add_abbrev_attr (attribute
, form
);
7468 while (attribute
!= 0);
7475 get_TAG_name (unsigned long tag
)
7479 case DW_TAG_padding
: return "DW_TAG_padding";
7480 case DW_TAG_array_type
: return "DW_TAG_array_type";
7481 case DW_TAG_class_type
: return "DW_TAG_class_type";
7482 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
7483 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
7484 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
7485 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
7486 case DW_TAG_label
: return "DW_TAG_label";
7487 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
7488 case DW_TAG_member
: return "DW_TAG_member";
7489 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
7490 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
7491 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
7492 case DW_TAG_string_type
: return "DW_TAG_string_type";
7493 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
7494 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
7495 case DW_TAG_typedef
: return "DW_TAG_typedef";
7496 case DW_TAG_union_type
: return "DW_TAG_union_type";
7497 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
7498 case DW_TAG_variant
: return "DW_TAG_variant";
7499 case DW_TAG_common_block
: return "DW_TAG_common_block";
7500 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
7501 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
7502 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
7503 case DW_TAG_module
: return "DW_TAG_module";
7504 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
7505 case DW_TAG_set_type
: return "DW_TAG_set_type";
7506 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
7507 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
7508 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
7509 case DW_TAG_base_type
: return "DW_TAG_base_type";
7510 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
7511 case DW_TAG_const_type
: return "DW_TAG_const_type";
7512 case DW_TAG_constant
: return "DW_TAG_constant";
7513 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
7514 case DW_TAG_file_type
: return "DW_TAG_file_type";
7515 case DW_TAG_friend
: return "DW_TAG_friend";
7516 case DW_TAG_namelist
: return "DW_TAG_namelist";
7517 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
7518 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
7519 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
7520 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
7521 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
7522 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
7523 case DW_TAG_try_block
: return "DW_TAG_try_block";
7524 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
7525 case DW_TAG_variable
: return "DW_TAG_variable";
7526 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
7527 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
7528 case DW_TAG_format_label
: return "DW_TAG_format_label";
7529 case DW_TAG_function_template
: return "DW_TAG_function_template";
7530 case DW_TAG_class_template
: return "DW_TAG_class_template";
7531 /* DWARF 2.1 values. */
7532 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
7533 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
7534 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
7535 case DW_TAG_namespace
: return "DW_TAG_namespace";
7536 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
7537 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
7538 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
7539 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
7541 case DW_TAG_upc_shared_type
: return "DW_TAG_upc_shared_type";
7542 case DW_TAG_upc_strict_type
: return "DW_TAG_upc_strict_type";
7543 case DW_TAG_upc_relaxed_type
: return "DW_TAG_upc_relaxed_type";
7546 static char buffer
[100];
7548 sprintf (buffer
, _("Unknown TAG value: %lx"), tag
);
7555 get_FORM_name (unsigned long form
)
7559 case DW_FORM_addr
: return "DW_FORM_addr";
7560 case DW_FORM_block2
: return "DW_FORM_block2";
7561 case DW_FORM_block4
: return "DW_FORM_block4";
7562 case DW_FORM_data2
: return "DW_FORM_data2";
7563 case DW_FORM_data4
: return "DW_FORM_data4";
7564 case DW_FORM_data8
: return "DW_FORM_data8";
7565 case DW_FORM_string
: return "DW_FORM_string";
7566 case DW_FORM_block
: return "DW_FORM_block";
7567 case DW_FORM_block1
: return "DW_FORM_block1";
7568 case DW_FORM_data1
: return "DW_FORM_data1";
7569 case DW_FORM_flag
: return "DW_FORM_flag";
7570 case DW_FORM_sdata
: return "DW_FORM_sdata";
7571 case DW_FORM_strp
: return "DW_FORM_strp";
7572 case DW_FORM_udata
: return "DW_FORM_udata";
7573 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
7574 case DW_FORM_ref1
: return "DW_FORM_ref1";
7575 case DW_FORM_ref2
: return "DW_FORM_ref2";
7576 case DW_FORM_ref4
: return "DW_FORM_ref4";
7577 case DW_FORM_ref8
: return "DW_FORM_ref8";
7578 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
7579 case DW_FORM_indirect
: return "DW_FORM_indirect";
7582 static char buffer
[100];
7584 sprintf (buffer
, _("Unknown FORM value: %lx"), form
);
7590 static unsigned char *
7591 display_block (unsigned char *data
, unsigned long length
)
7593 printf (_(" %lu byte block: "), length
);
7596 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
7602 decode_location_expression (unsigned char * data
,
7603 unsigned int pointer_size
,
7604 unsigned long length
,
7605 unsigned long cu_offset
)
7609 unsigned long uvalue
;
7610 unsigned char *end
= data
+ length
;
7611 int need_frame_base
= 0;
7620 printf ("DW_OP_addr: %lx",
7621 (unsigned long) byte_get (data
, pointer_size
));
7622 data
+= pointer_size
;
7625 printf ("DW_OP_deref");
7628 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
7631 printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data
++, 1));
7634 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
7638 printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data
, 2));
7642 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
7646 printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data
, 4));
7650 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
7651 (unsigned long) byte_get (data
+ 4, 4));
7655 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
7656 (long) byte_get (data
+ 4, 4));
7660 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
7664 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
7668 printf ("DW_OP_dup");
7671 printf ("DW_OP_drop");
7674 printf ("DW_OP_over");
7677 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
7680 printf ("DW_OP_swap");
7683 printf ("DW_OP_rot");
7686 printf ("DW_OP_xderef");
7689 printf ("DW_OP_abs");
7692 printf ("DW_OP_and");
7695 printf ("DW_OP_div");
7698 printf ("DW_OP_minus");
7701 printf ("DW_OP_mod");
7704 printf ("DW_OP_mul");
7707 printf ("DW_OP_neg");
7710 printf ("DW_OP_not");
7713 printf ("DW_OP_or");
7716 printf ("DW_OP_plus");
7718 case DW_OP_plus_uconst
:
7719 printf ("DW_OP_plus_uconst: %lu",
7720 read_leb128 (data
, &bytes_read
, 0));
7724 printf ("DW_OP_shl");
7727 printf ("DW_OP_shr");
7730 printf ("DW_OP_shra");
7733 printf ("DW_OP_xor");
7736 printf ("DW_OP_bra: %ld", (long) byte_get_signed (data
, 2));
7740 printf ("DW_OP_eq");
7743 printf ("DW_OP_ge");
7746 printf ("DW_OP_gt");
7749 printf ("DW_OP_le");
7752 printf ("DW_OP_lt");
7755 printf ("DW_OP_ne");
7758 printf ("DW_OP_skip: %ld", (long) byte_get_signed (data
, 2));
7794 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
7829 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
7864 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
7865 read_leb128 (data
, &bytes_read
, 1));
7870 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
7874 need_frame_base
= 1;
7875 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
7879 uvalue
= read_leb128 (data
, &bytes_read
, 0);
7881 printf ("DW_OP_bregx: %lu %ld", uvalue
,
7882 read_leb128 (data
, &bytes_read
, 1));
7886 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
7889 case DW_OP_deref_size
:
7890 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
7892 case DW_OP_xderef_size
:
7893 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
7896 printf ("DW_OP_nop");
7899 /* DWARF 3 extensions. */
7900 case DW_OP_push_object_address
:
7901 printf ("DW_OP_push_object_address");
7904 /* XXX: Strictly speaking for 64-bit DWARF3 files
7905 this ought to be an 8-byte wide computation. */
7906 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2) + cu_offset
);
7910 /* XXX: Strictly speaking for 64-bit DWARF3 files
7911 this ought to be an 8-byte wide computation. */
7912 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4) + cu_offset
);
7915 case DW_OP_call_ref
:
7916 printf ("DW_OP_call_ref");
7919 /* GNU extensions. */
7920 case DW_OP_GNU_push_tls_address
:
7921 printf ("DW_OP_GNU_push_tls_address");
7925 if (op
>= DW_OP_lo_user
7926 && op
<= DW_OP_hi_user
)
7927 printf (_("(User defined location op)"));
7929 printf (_("(Unknown location op)"));
7930 /* No way to tell where the next op is, so just bail. */
7931 return need_frame_base
;
7934 /* Separate the ops. */
7939 return need_frame_base
;
7942 /* This structure records the information that
7943 we extract from the.debug_info section. */
7946 unsigned int pointer_size
;
7947 unsigned long cu_offset
;
7948 unsigned long base_address
;
7949 /* This is an array of offsets to the location list table. */
7950 unsigned long *loc_offsets
;
7951 int *have_frame_base
;
7952 unsigned int num_loc_offsets
;
7953 unsigned int max_loc_offsets
;
7954 unsigned long *range_lists
;
7955 unsigned int num_range_lists
;
7956 unsigned int max_range_lists
;
7960 static debug_info
* debug_information
= NULL
;
7961 static unsigned int num_debug_info_entries
= 0;
7962 static unsigned int last_pointer_size
= 0;
7963 static int warned_about_missing_comp_units
= FALSE
;
7965 static unsigned char *
7966 read_and_display_attr_value (unsigned long attribute
,
7968 unsigned char *data
,
7969 unsigned long cu_offset
,
7970 unsigned long pointer_size
,
7971 unsigned long offset_size
,
7973 debug_info
*debug_info_p
,
7976 unsigned long uvalue
= 0;
7977 unsigned char *block_start
= NULL
;
7985 case DW_FORM_ref_addr
:
7986 if (dwarf_version
== 2)
7988 uvalue
= byte_get (data
, pointer_size
);
7989 data
+= pointer_size
;
7991 else if (dwarf_version
== 3)
7993 uvalue
= byte_get (data
, offset_size
);
7994 data
+= offset_size
;
7998 error (_("Internal error: DWARF version is not 2 or 3.\n"));
8003 uvalue
= byte_get (data
, pointer_size
);
8004 data
+= pointer_size
;
8008 uvalue
= byte_get (data
, offset_size
);
8009 data
+= offset_size
;
8015 uvalue
= byte_get (data
++, 1);
8020 uvalue
= byte_get (data
, 2);
8026 uvalue
= byte_get (data
, 4);
8031 uvalue
= read_leb128 (data
, & bytes_read
, 1);
8035 case DW_FORM_ref_udata
:
8037 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8041 case DW_FORM_indirect
:
8042 form
= read_leb128 (data
, & bytes_read
, 0);
8045 printf (" %s", get_FORM_name (form
));
8046 return read_and_display_attr_value (attribute
, form
, data
,
8047 cu_offset
, pointer_size
,
8048 offset_size
, dwarf_version
,
8049 debug_info_p
, do_loc
);
8054 case DW_FORM_ref_addr
:
8056 printf (" <#%lx>", uvalue
);
8062 case DW_FORM_ref_udata
:
8064 printf (" <%lx>", uvalue
+ cu_offset
);
8070 printf (" %#lx", uvalue
);
8079 printf (" %ld", uvalue
);
8086 uvalue
= byte_get (data
, 4);
8087 printf (" %lx", uvalue
);
8088 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
8090 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8091 && num_debug_info_entries
== 0)
8093 if (sizeof (uvalue
) == 8)
8094 uvalue
= byte_get (data
, 8);
8096 error (_("DW_FORM_data8 is unsupported when sizeof (unsigned long) != 8\n"));
8101 case DW_FORM_string
:
8103 printf (" %s", data
);
8104 data
+= strlen ((char *) data
) + 1;
8108 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8109 block_start
= data
+ bytes_read
;
8111 data
= block_start
+ uvalue
;
8113 data
= display_block (block_start
, uvalue
);
8116 case DW_FORM_block1
:
8117 uvalue
= byte_get (data
, 1);
8118 block_start
= data
+ 1;
8120 data
= block_start
+ uvalue
;
8122 data
= display_block (block_start
, uvalue
);
8125 case DW_FORM_block2
:
8126 uvalue
= byte_get (data
, 2);
8127 block_start
= data
+ 2;
8129 data
= block_start
+ uvalue
;
8131 data
= display_block (block_start
, uvalue
);
8134 case DW_FORM_block4
:
8135 uvalue
= byte_get (data
, 4);
8136 block_start
= data
+ 4;
8138 data
= block_start
+ uvalue
;
8140 data
= display_block (block_start
, uvalue
);
8145 printf (_(" (indirect string, offset: 0x%lx): %s"),
8146 uvalue
, fetch_indirect_string (uvalue
));
8149 case DW_FORM_indirect
:
8150 /* Handled above. */
8154 warn (_("Unrecognized form: %d\n"), form
);
8158 /* For some attributes we can display further information. */
8159 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8160 && num_debug_info_entries
== 0)
8164 case DW_AT_frame_base
:
8165 have_frame_base
= 1;
8166 case DW_AT_location
:
8167 case DW_AT_data_member_location
:
8168 case DW_AT_vtable_elem_location
:
8169 case DW_AT_allocated
:
8170 case DW_AT_associated
:
8171 case DW_AT_data_location
:
8173 case DW_AT_upper_bound
:
8174 case DW_AT_lower_bound
:
8175 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8177 /* Process location list. */
8178 unsigned int max
= debug_info_p
->max_loc_offsets
;
8179 unsigned int num
= debug_info_p
->num_loc_offsets
;
8181 if (max
== 0 || num
>= max
)
8184 debug_info_p
->loc_offsets
8185 = xrealloc (debug_info_p
->loc_offsets
,
8186 max
* sizeof (*debug_info_p
->loc_offsets
));
8187 debug_info_p
->have_frame_base
8188 = xrealloc (debug_info_p
->have_frame_base
,
8189 max
* sizeof (*debug_info_p
->have_frame_base
));
8190 debug_info_p
->max_loc_offsets
= max
;
8192 debug_info_p
->loc_offsets
[num
] = uvalue
;
8193 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
8194 debug_info_p
->num_loc_offsets
++;
8199 if (need_base_address
)
8200 debug_info_p
->base_address
= uvalue
;
8204 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8206 /* Process range list. */
8207 unsigned int max
= debug_info_p
->max_range_lists
;
8208 unsigned int num
= debug_info_p
->num_range_lists
;
8210 if (max
== 0 || num
>= max
)
8213 debug_info_p
->range_lists
8214 = xrealloc (debug_info_p
->range_lists
,
8215 max
* sizeof (*debug_info_p
->range_lists
));
8216 debug_info_p
->max_range_lists
= max
;
8218 debug_info_p
->range_lists
[num
] = uvalue
;
8219 debug_info_p
->num_range_lists
++;
8238 case DW_INL_not_inlined
:
8239 printf (_("(not inlined)"));
8241 case DW_INL_inlined
:
8242 printf (_("(inlined)"));
8244 case DW_INL_declared_not_inlined
:
8245 printf (_("(declared as inline but ignored)"));
8247 case DW_INL_declared_inlined
:
8248 printf (_("(declared as inline and inlined)"));
8251 printf (_(" (Unknown inline attribute value: %lx)"), uvalue
);
8256 case DW_AT_language
:
8259 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
8260 case DW_LANG_C89
: printf ("(ANSI C)"); break;
8261 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
8262 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
8263 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
8264 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
8265 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
8266 case DW_LANG_Ada83
: printf ("(Ada)"); break;
8267 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
8268 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
8269 /* DWARF 2.1 values. */
8270 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
8271 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
8272 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
8273 /* MIPS extension. */
8274 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
8275 /* UPC extension. */
8276 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
8278 printf ("(Unknown: %lx)", uvalue
);
8283 case DW_AT_encoding
:
8286 case DW_ATE_void
: printf ("(void)"); break;
8287 case DW_ATE_address
: printf ("(machine address)"); break;
8288 case DW_ATE_boolean
: printf ("(boolean)"); break;
8289 case DW_ATE_complex_float
: printf ("(complex float)"); break;
8290 case DW_ATE_float
: printf ("(float)"); break;
8291 case DW_ATE_signed
: printf ("(signed)"); break;
8292 case DW_ATE_signed_char
: printf ("(signed char)"); break;
8293 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
8294 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
8295 /* DWARF 2.1 value. */
8296 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
8298 if (uvalue
>= DW_ATE_lo_user
8299 && uvalue
<= DW_ATE_hi_user
)
8300 printf ("(user defined type)");
8302 printf ("(unknown type)");
8307 case DW_AT_accessibility
:
8310 case DW_ACCESS_public
: printf ("(public)"); break;
8311 case DW_ACCESS_protected
: printf ("(protected)"); break;
8312 case DW_ACCESS_private
: printf ("(private)"); break;
8314 printf ("(unknown accessibility)");
8319 case DW_AT_visibility
:
8322 case DW_VIS_local
: printf ("(local)"); break;
8323 case DW_VIS_exported
: printf ("(exported)"); break;
8324 case DW_VIS_qualified
: printf ("(qualified)"); break;
8325 default: printf ("(unknown visibility)"); break;
8329 case DW_AT_virtuality
:
8332 case DW_VIRTUALITY_none
: printf ("(none)"); break;
8333 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
8334 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
8335 default: printf ("(unknown virtuality)"); break;
8339 case DW_AT_identifier_case
:
8342 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
8343 case DW_ID_up_case
: printf ("(up_case)"); break;
8344 case DW_ID_down_case
: printf ("(down_case)"); break;
8345 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
8346 default: printf ("(unknown case)"); break;
8350 case DW_AT_calling_convention
:
8353 case DW_CC_normal
: printf ("(normal)"); break;
8354 case DW_CC_program
: printf ("(program)"); break;
8355 case DW_CC_nocall
: printf ("(nocall)"); break;
8357 if (uvalue
>= DW_CC_lo_user
8358 && uvalue
<= DW_CC_hi_user
)
8359 printf ("(user defined)");
8361 printf ("(unknown convention)");
8365 case DW_AT_ordering
:
8368 case -1: printf ("(undefined)"); break;
8369 case 0: printf ("(row major)"); break;
8370 case 1: printf ("(column major)"); break;
8374 case DW_AT_frame_base
:
8375 have_frame_base
= 1;
8376 case DW_AT_location
:
8377 case DW_AT_data_member_location
:
8378 case DW_AT_vtable_elem_location
:
8379 case DW_AT_allocated
:
8380 case DW_AT_associated
:
8381 case DW_AT_data_location
:
8383 case DW_AT_upper_bound
:
8384 case DW_AT_lower_bound
:
8387 int need_frame_base
;
8390 need_frame_base
= decode_location_expression (block_start
,
8395 if (need_frame_base
&& !have_frame_base
)
8396 printf (_(" [without DW_AT_frame_base]"));
8398 else if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8399 printf (_("(location list)"));
8411 get_AT_name (unsigned long attribute
)
8415 case DW_AT_sibling
: return "DW_AT_sibling";
8416 case DW_AT_location
: return "DW_AT_location";
8417 case DW_AT_name
: return "DW_AT_name";
8418 case DW_AT_ordering
: return "DW_AT_ordering";
8419 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
8420 case DW_AT_byte_size
: return "DW_AT_byte_size";
8421 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
8422 case DW_AT_bit_size
: return "DW_AT_bit_size";
8423 case DW_AT_element_list
: return "DW_AT_element_list";
8424 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
8425 case DW_AT_low_pc
: return "DW_AT_low_pc";
8426 case DW_AT_high_pc
: return "DW_AT_high_pc";
8427 case DW_AT_language
: return "DW_AT_language";
8428 case DW_AT_member
: return "DW_AT_member";
8429 case DW_AT_discr
: return "DW_AT_discr";
8430 case DW_AT_discr_value
: return "DW_AT_discr_value";
8431 case DW_AT_visibility
: return "DW_AT_visibility";
8432 case DW_AT_import
: return "DW_AT_import";
8433 case DW_AT_string_length
: return "DW_AT_string_length";
8434 case DW_AT_common_reference
: return "DW_AT_common_reference";
8435 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
8436 case DW_AT_const_value
: return "DW_AT_const_value";
8437 case DW_AT_containing_type
: return "DW_AT_containing_type";
8438 case DW_AT_default_value
: return "DW_AT_default_value";
8439 case DW_AT_inline
: return "DW_AT_inline";
8440 case DW_AT_is_optional
: return "DW_AT_is_optional";
8441 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
8442 case DW_AT_producer
: return "DW_AT_producer";
8443 case DW_AT_prototyped
: return "DW_AT_prototyped";
8444 case DW_AT_return_addr
: return "DW_AT_return_addr";
8445 case DW_AT_start_scope
: return "DW_AT_start_scope";
8446 case DW_AT_stride_size
: return "DW_AT_stride_size";
8447 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
8448 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
8449 case DW_AT_accessibility
: return "DW_AT_accessibility";
8450 case DW_AT_address_class
: return "DW_AT_address_class";
8451 case DW_AT_artificial
: return "DW_AT_artificial";
8452 case DW_AT_base_types
: return "DW_AT_base_types";
8453 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
8454 case DW_AT_count
: return "DW_AT_count";
8455 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
8456 case DW_AT_decl_column
: return "DW_AT_decl_column";
8457 case DW_AT_decl_file
: return "DW_AT_decl_file";
8458 case DW_AT_decl_line
: return "DW_AT_decl_line";
8459 case DW_AT_declaration
: return "DW_AT_declaration";
8460 case DW_AT_discr_list
: return "DW_AT_discr_list";
8461 case DW_AT_encoding
: return "DW_AT_encoding";
8462 case DW_AT_external
: return "DW_AT_external";
8463 case DW_AT_frame_base
: return "DW_AT_frame_base";
8464 case DW_AT_friend
: return "DW_AT_friend";
8465 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
8466 case DW_AT_macro_info
: return "DW_AT_macro_info";
8467 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
8468 case DW_AT_priority
: return "DW_AT_priority";
8469 case DW_AT_segment
: return "DW_AT_segment";
8470 case DW_AT_specification
: return "DW_AT_specification";
8471 case DW_AT_static_link
: return "DW_AT_static_link";
8472 case DW_AT_type
: return "DW_AT_type";
8473 case DW_AT_use_location
: return "DW_AT_use_location";
8474 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
8475 case DW_AT_virtuality
: return "DW_AT_virtuality";
8476 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
8477 /* DWARF 2.1 values. */
8478 case DW_AT_allocated
: return "DW_AT_allocated";
8479 case DW_AT_associated
: return "DW_AT_associated";
8480 case DW_AT_data_location
: return "DW_AT_data_location";
8481 case DW_AT_stride
: return "DW_AT_stride";
8482 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
8483 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
8484 case DW_AT_extension
: return "DW_AT_extension";
8485 case DW_AT_ranges
: return "DW_AT_ranges";
8486 case DW_AT_trampoline
: return "DW_AT_trampoline";
8487 case DW_AT_call_column
: return "DW_AT_call_column";
8488 case DW_AT_call_file
: return "DW_AT_call_file";
8489 case DW_AT_call_line
: return "DW_AT_call_line";
8490 /* SGI/MIPS extensions. */
8491 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
8492 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
8493 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
8494 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
8495 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
8496 case DW_AT_MIPS_software_pipeline_depth
:
8497 return "DW_AT_MIPS_software_pipeline_depth";
8498 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
8499 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
8500 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
8501 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
8502 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
8503 /* GNU extensions. */
8504 case DW_AT_sf_names
: return "DW_AT_sf_names";
8505 case DW_AT_src_info
: return "DW_AT_src_info";
8506 case DW_AT_mac_info
: return "DW_AT_mac_info";
8507 case DW_AT_src_coords
: return "DW_AT_src_coords";
8508 case DW_AT_body_begin
: return "DW_AT_body_begin";
8509 case DW_AT_body_end
: return "DW_AT_body_end";
8510 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
8511 /* UPC extension. */
8512 case DW_AT_upc_threads_scaled
: return "DW_AT_upc_threads_scaled";
8515 static char buffer
[100];
8517 sprintf (buffer
, _("Unknown AT value: %lx"), attribute
);
8523 static unsigned char *
8524 read_and_display_attr (unsigned long attribute
,
8526 unsigned char *data
,
8527 unsigned long cu_offset
,
8528 unsigned long pointer_size
,
8529 unsigned long offset_size
,
8531 debug_info
*debug_info_p
,
8535 printf (" %-18s:", get_AT_name (attribute
));
8536 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
8537 pointer_size
, offset_size
,
8538 dwarf_version
, debug_info_p
,
8546 /* Process the contents of a .debug_info section. If do_loc is non-zero
8547 then we are scanning for location lists and we do not want to display
8548 anything to the user. */
8551 process_debug_info (Elf_Internal_Shdr
*section
, unsigned char *start
,
8552 FILE *file
, int do_loc
)
8554 unsigned char *end
= start
+ section
->sh_size
;
8555 unsigned char *section_begin
;
8557 unsigned int num_units
= 0;
8559 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8560 && num_debug_info_entries
== 0)
8562 unsigned long length
;
8564 /* First scan the section to get the number of comp units. */
8565 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
8568 /* Read the first 4 bytes. For a 32-bit DWARF section, this
8569 will be the length. For a 64-bit DWARF section, it'll be
8570 the escape code 0xffffffff followed by an 8 byte length. */
8571 length
= byte_get (section_begin
, 4);
8573 if (length
== 0xffffffff)
8575 length
= byte_get (section_begin
+ 4, 8);
8576 section_begin
+= length
+ 12;
8579 section_begin
+= length
+ 4;
8584 error (_("No comp units in .debug_info section ?"));
8588 /* Then allocate an array to hold the information. */
8589 debug_information
= malloc (num_units
*
8590 sizeof (* debug_information
));
8591 if (debug_information
== NULL
)
8593 error (_("Not enough memory for a debug info array of %u entries"),
8601 printf (_("The section %s contains:\n\n"),
8602 SECTION_NAME (section
));
8604 load_debug_str (file
);
8605 load_debug_loc (file
);
8606 load_debug_range (file
);
8609 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
8611 DWARF2_Internal_CompUnit compunit
;
8612 unsigned char *hdrptr
;
8613 unsigned char *cu_abbrev_offset_ptr
;
8614 unsigned char *tags
;
8616 unsigned long cu_offset
;
8618 int initial_length_size
;
8622 compunit
.cu_length
= byte_get (hdrptr
, 4);
8625 if (compunit
.cu_length
== 0xffffffff)
8627 compunit
.cu_length
= byte_get (hdrptr
, 8);
8630 initial_length_size
= 12;
8635 initial_length_size
= 4;
8638 compunit
.cu_version
= byte_get (hdrptr
, 2);
8641 cu_offset
= start
- section_begin
;
8642 start
+= compunit
.cu_length
+ initial_length_size
;
8644 if (elf_header
.e_type
== ET_REL
8645 && !debug_apply_rela_addends (file
, section
, offset_size
,
8646 section_begin
, hdrptr
, start
))
8649 cu_abbrev_offset_ptr
= hdrptr
;
8650 compunit
.cu_abbrev_offset
= byte_get (hdrptr
, offset_size
);
8651 hdrptr
+= offset_size
;
8653 compunit
.cu_pointer_size
= byte_get (hdrptr
, 1);
8655 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8656 && num_debug_info_entries
== 0)
8658 debug_information
[unit
].cu_offset
= cu_offset
;
8659 debug_information
[unit
].pointer_size
8660 = compunit
.cu_pointer_size
;
8661 debug_information
[unit
].base_address
= 0;
8662 debug_information
[unit
].loc_offsets
= NULL
;
8663 debug_information
[unit
].have_frame_base
= NULL
;
8664 debug_information
[unit
].max_loc_offsets
= 0;
8665 debug_information
[unit
].num_loc_offsets
= 0;
8666 debug_information
[unit
].range_lists
= NULL
;
8667 debug_information
[unit
].max_range_lists
= 0;
8668 debug_information
[unit
].num_range_lists
= 0;
8675 printf (_(" Compilation Unit @ %lx:\n"), cu_offset
);
8676 printf (_(" Length: %ld\n"), compunit
.cu_length
);
8677 printf (_(" Version: %d\n"), compunit
.cu_version
);
8678 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
8679 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
8682 if (compunit
.cu_version
!= 2 && compunit
.cu_version
!= 3)
8684 warn (_("Only version 2 and 3 DWARF debug information is currently supported.\n"));
8690 /* Read in the abbrevs used by this compilation unit. */
8692 Elf_Internal_Shdr
*sec
;
8693 unsigned char *begin
;
8695 /* Locate the .debug_abbrev section and process it. */
8696 sec
= find_section (".debug_abbrev");
8699 warn (_("Unable to locate .debug_abbrev section!\n"));
8703 begin
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
8704 _("debug_abbrev section data"));
8708 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
8709 begin
+ sec
->sh_size
);
8715 while (tags
< start
)
8718 unsigned long abbrev_number
;
8719 abbrev_entry
*entry
;
8722 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
8725 /* A null DIE marks the end of a list of children. */
8726 if (abbrev_number
== 0)
8732 /* Scan through the abbreviation list until we reach the
8734 for (entry
= first_abbrev
;
8735 entry
&& entry
->entry
!= abbrev_number
;
8736 entry
= entry
->next
)
8741 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
8747 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
8749 (unsigned long) (tags
- section_begin
8752 get_TAG_name (entry
->tag
));
8757 need_base_address
= 0;
8759 case DW_TAG_compile_unit
:
8760 need_base_address
= 1;
8762 case DW_TAG_entry_point
:
8763 case DW_TAG_inlined_subroutine
:
8764 case DW_TAG_subprogram
:
8765 need_base_address
= 0;
8766 /* Assuming that there is no DW_AT_frame_base. */
8767 have_frame_base
= 0;
8771 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
8772 tags
= read_and_display_attr (attr
->attribute
,
8775 compunit
.cu_pointer_size
,
8777 compunit
.cu_version
,
8778 &debug_information
[unit
],
8781 if (entry
->children
)
8786 /* Set num_debug_info_entries here so that it can be used to check if
8787 we need to proecess .debug_loc and .debug_ranges sections. */
8788 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8789 && num_debug_info_entries
== 0)
8790 num_debug_info_entries
= num_units
;
8794 free_debug_range ();
8804 /* Retrieve the pointer size associated with the given compilation unit.
8805 Optionally the offset of this unit into the .debug_info section is
8806 also retutned. If there is no .debug_info section then an error
8807 message is issued and 0 is returned. If the requested comp unit has
8808 not been defined in the .debug_info section then a warning message
8809 is issued and the last know pointer size is returned. This message
8810 is only issued once per section dumped per file dumped. */
8813 get_pointer_size_and_offset_of_comp_unit (unsigned int comp_unit
,
8814 const char * section_name
,
8815 unsigned long * offset_return
)
8817 unsigned long offset
= 0;
8819 if (num_debug_info_entries
== 0)
8820 error (_("%s section needs a populated .debug_info section\n"),
8823 else if (comp_unit
>= num_debug_info_entries
)
8825 if (!warned_about_missing_comp_units
)
8827 warn (_("%s section has more comp units than .debug_info section\n"),
8829 warn (_("assuming that the pointer size is %d, from the last comp unit in .debug_info\n\n"),
8831 warned_about_missing_comp_units
= TRUE
;
8836 last_pointer_size
= debug_information
[comp_unit
].pointer_size
;
8837 offset
= debug_information
[comp_unit
].cu_offset
;
8840 if (offset_return
!= NULL
)
8841 * offset_return
= offset
;
8843 return last_pointer_size
;
8846 /* Locate and scan the .debug_info section in the file and record the pointer
8847 sizes and offsets for the compilation units in it. Usually an executable
8848 will have just one pointer size, but this is not guaranteed, and so we try
8849 not to make any assumptions. Returns zero upon failure, or the number of
8850 compilation units upon success. */
8853 get_debug_info (FILE * file
)
8855 Elf_Internal_Shdr
* section
;
8856 unsigned char * start
;
8859 /* Reset the last pointer size so that we can issue correct error
8860 messages if we are displaying the contents of more than one section. */
8861 last_pointer_size
= 0;
8862 warned_about_missing_comp_units
= FALSE
;
8864 /* If we already have the information there is nothing else to do. */
8865 if (num_debug_info_entries
> 0)
8866 return num_debug_info_entries
;
8868 section
= find_section (".debug_info");
8869 if (section
== NULL
)
8872 start
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
8873 _("extracting information from .debug_info section"));
8877 ret
= process_debug_info (section
, start
, file
, 1);
8880 return ret
? num_debug_info_entries
: 0;
8884 display_debug_lines (Elf_Internal_Shdr
*section
,
8885 unsigned char *start
, FILE *file
)
8887 unsigned char *data
= start
;
8888 unsigned char *end
= start
+ section
->sh_size
;
8889 unsigned int comp_unit
= 0;
8891 printf (_("\nDump of debug contents of section %s:\n\n"),
8892 SECTION_NAME (section
));
8894 get_debug_info (file
);
8898 DWARF2_Internal_LineInfo info
;
8899 unsigned char *standard_opcodes
;
8900 unsigned char *end_of_sequence
;
8901 unsigned char *hdrptr
;
8902 unsigned int pointer_size
;
8903 int initial_length_size
;
8909 /* Check the length of the block. */
8910 info
.li_length
= byte_get (hdrptr
, 4);
8913 if (info
.li_length
== 0xffffffff)
8915 /* This section is 64-bit DWARF 3. */
8916 info
.li_length
= byte_get (hdrptr
, 8);
8919 initial_length_size
= 12;
8924 initial_length_size
= 4;
8927 if (info
.li_length
+ initial_length_size
> section
->sh_size
)
8930 (_("The line info appears to be corrupt - the section is too small\n"));
8934 /* Check its version number. */
8935 info
.li_version
= byte_get (hdrptr
, 2);
8937 if (info
.li_version
!= 2 && info
.li_version
!= 3)
8939 warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
8943 info
.li_prologue_length
= byte_get (hdrptr
, offset_size
);
8944 hdrptr
+= offset_size
;
8945 info
.li_min_insn_length
= byte_get (hdrptr
, 1);
8947 info
.li_default_is_stmt
= byte_get (hdrptr
, 1);
8949 info
.li_line_base
= byte_get (hdrptr
, 1);
8951 info
.li_line_range
= byte_get (hdrptr
, 1);
8953 info
.li_opcode_base
= byte_get (hdrptr
, 1);
8956 /* Sign extend the line base field. */
8957 info
.li_line_base
<<= 24;
8958 info
.li_line_base
>>= 24;
8960 /* Get the pointer size from the comp unit associated
8961 with this block of line number information. */
8962 pointer_size
= get_pointer_size_and_offset_of_comp_unit
8963 (comp_unit
, ".debug_lines", NULL
);
8966 printf (_(" Length: %ld\n"), info
.li_length
);
8967 printf (_(" DWARF Version: %d\n"), info
.li_version
);
8968 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
8969 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
8970 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
8971 printf (_(" Line Base: %d\n"), info
.li_line_base
);
8972 printf (_(" Line Range: %d\n"), info
.li_line_range
);
8973 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
8974 printf (_(" (Pointer size: %u)\n"), pointer_size
);
8976 end_of_sequence
= data
+ info
.li_length
+ initial_length_size
;
8978 reset_state_machine (info
.li_default_is_stmt
);
8980 /* Display the contents of the Opcodes table. */
8981 standard_opcodes
= hdrptr
;
8983 printf (_("\n Opcodes:\n"));
8985 for (i
= 1; i
< info
.li_opcode_base
; i
++)
8986 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
8988 /* Display the contents of the Directory table. */
8989 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
8992 printf (_("\n The Directory Table is empty.\n"));
8995 printf (_("\n The Directory Table:\n"));
8999 printf (_(" %s\n"), data
);
9001 data
+= strlen ((char *) data
) + 1;
9005 /* Skip the NUL at the end of the table. */
9008 /* Display the contents of the File Name table. */
9010 printf (_("\n The File Name Table is empty.\n"));
9013 printf (_("\n The File Name Table:\n"));
9014 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
9018 unsigned char *name
;
9021 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
9024 data
+= strlen ((char *) data
) + 1;
9026 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9028 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9030 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9032 printf (_("%s\n"), name
);
9036 /* Skip the NUL at the end of the table. */
9039 /* Now display the statements. */
9040 printf (_("\n Line Number Statements:\n"));
9042 while (data
< end_of_sequence
)
9044 unsigned char op_code
;
9050 if (op_code
>= info
.li_opcode_base
)
9052 op_code
-= info
.li_opcode_base
;
9053 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
9054 state_machine_regs
.address
+= adv
;
9055 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
9056 op_code
, adv
, state_machine_regs
.address
);
9057 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
9058 state_machine_regs
.line
+= adv
;
9059 printf (_(" and Line by %d to %d\n"),
9060 adv
, state_machine_regs
.line
);
9062 else switch (op_code
)
9064 case DW_LNS_extended_op
:
9065 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
9070 printf (_(" Copy\n"));
9073 case DW_LNS_advance_pc
:
9074 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
9076 state_machine_regs
.address
+= adv
;
9077 printf (_(" Advance PC by %d to %lx\n"), adv
,
9078 state_machine_regs
.address
);
9081 case DW_LNS_advance_line
:
9082 adv
= read_leb128 (data
, & bytes_read
, 1);
9084 state_machine_regs
.line
+= adv
;
9085 printf (_(" Advance Line by %d to %d\n"), adv
,
9086 state_machine_regs
.line
);
9089 case DW_LNS_set_file
:
9090 adv
= read_leb128 (data
, & bytes_read
, 0);
9092 printf (_(" Set File Name to entry %d in the File Name Table\n"),
9094 state_machine_regs
.file
= adv
;
9097 case DW_LNS_set_column
:
9098 adv
= read_leb128 (data
, & bytes_read
, 0);
9100 printf (_(" Set column to %d\n"), adv
);
9101 state_machine_regs
.column
= adv
;
9104 case DW_LNS_negate_stmt
:
9105 adv
= state_machine_regs
.is_stmt
;
9107 printf (_(" Set is_stmt to %d\n"), adv
);
9108 state_machine_regs
.is_stmt
= adv
;
9111 case DW_LNS_set_basic_block
:
9112 printf (_(" Set basic block\n"));
9113 state_machine_regs
.basic_block
= 1;
9116 case DW_LNS_const_add_pc
:
9117 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
9118 * info
.li_min_insn_length
);
9119 state_machine_regs
.address
+= adv
;
9120 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
9121 state_machine_regs
.address
);
9124 case DW_LNS_fixed_advance_pc
:
9125 adv
= byte_get (data
, 2);
9127 state_machine_regs
.address
+= adv
;
9128 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
9129 adv
, state_machine_regs
.address
);
9132 case DW_LNS_set_prologue_end
:
9133 printf (_(" Set prologue_end to true\n"));
9136 case DW_LNS_set_epilogue_begin
:
9137 printf (_(" Set epilogue_begin to true\n"));
9140 case DW_LNS_set_isa
:
9141 adv
= read_leb128 (data
, & bytes_read
, 0);
9143 printf (_(" Set ISA to %d\n"), adv
);
9147 printf (_(" Unknown opcode %d with operands: "), op_code
);
9149 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
9151 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
9152 i
== 1 ? "" : ", ");
9166 display_debug_pubnames (Elf_Internal_Shdr
*section
,
9167 unsigned char *start
,
9168 FILE *file ATTRIBUTE_UNUSED
)
9170 DWARF2_Internal_PubNames pubnames
;
9173 end
= start
+ section
->sh_size
;
9175 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9179 unsigned char *data
;
9180 unsigned long offset
;
9181 int offset_size
, initial_length_size
;
9185 pubnames
.pn_length
= byte_get (data
, 4);
9187 if (pubnames
.pn_length
== 0xffffffff)
9189 pubnames
.pn_length
= byte_get (data
, 8);
9192 initial_length_size
= 12;
9197 initial_length_size
= 4;
9200 pubnames
.pn_version
= byte_get (data
, 2);
9202 pubnames
.pn_offset
= byte_get (data
, offset_size
);
9203 data
+= offset_size
;
9204 pubnames
.pn_size
= byte_get (data
, offset_size
);
9205 data
+= offset_size
;
9207 start
+= pubnames
.pn_length
+ initial_length_size
;
9209 if (pubnames
.pn_version
!= 2 && pubnames
.pn_version
!= 3)
9211 static int warned
= 0;
9215 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
9222 printf (_(" Length: %ld\n"),
9223 pubnames
.pn_length
);
9224 printf (_(" Version: %d\n"),
9225 pubnames
.pn_version
);
9226 printf (_(" Offset into .debug_info section: %ld\n"),
9227 pubnames
.pn_offset
);
9228 printf (_(" Size of area in .debug_info section: %ld\n"),
9231 printf (_("\n Offset\tName\n"));
9235 offset
= byte_get (data
, offset_size
);
9239 data
+= offset_size
;
9240 printf (" %-6ld\t\t%s\n", offset
, data
);
9241 data
+= strlen ((char *) data
) + 1;
9244 while (offset
!= 0);
9252 display_debug_macinfo (Elf_Internal_Shdr
*section
,
9253 unsigned char *start
,
9254 FILE *file ATTRIBUTE_UNUSED
)
9256 unsigned char *end
= start
+ section
->sh_size
;
9257 unsigned char *curr
= start
;
9258 unsigned int bytes_read
;
9259 enum dwarf_macinfo_record_type op
;
9261 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9265 unsigned int lineno
;
9273 case DW_MACINFO_start_file
:
9275 unsigned int filenum
;
9277 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9279 filenum
= read_leb128 (curr
, & bytes_read
, 0);
9282 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
9287 case DW_MACINFO_end_file
:
9288 printf (_(" DW_MACINFO_end_file\n"));
9291 case DW_MACINFO_define
:
9292 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9295 curr
+= strlen (string
) + 1;
9296 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
9300 case DW_MACINFO_undef
:
9301 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9304 curr
+= strlen (string
) + 1;
9305 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
9309 case DW_MACINFO_vendor_ext
:
9311 unsigned int constant
;
9313 constant
= read_leb128 (curr
, & bytes_read
, 0);
9316 curr
+= strlen (string
) + 1;
9317 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
9329 display_debug_abbrev (Elf_Internal_Shdr
*section
,
9330 unsigned char *start
,
9331 FILE *file ATTRIBUTE_UNUSED
)
9333 abbrev_entry
*entry
;
9334 unsigned char *end
= start
+ section
->sh_size
;
9336 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9340 start
= process_abbrev_section (start
, end
);
9342 if (first_abbrev
== NULL
)
9345 printf (_(" Number TAG\n"));
9347 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
9351 printf (_(" %ld %s [%s]\n"),
9353 get_TAG_name (entry
->tag
),
9354 entry
->children
? _("has children") : _("no children"));
9356 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
9357 printf (_(" %-18s %s\n"),
9358 get_AT_name (attr
->attribute
),
9359 get_FORM_name (attr
->form
));
9372 display_debug_loc (Elf_Internal_Shdr
*section
,
9373 unsigned char *start
, FILE *file
)
9375 unsigned char *section_end
;
9376 unsigned long bytes
;
9377 unsigned char *section_begin
= start
;
9378 unsigned int num_loc_list
= 0;
9379 unsigned long last_offset
= 0;
9380 unsigned int first
= 0;
9383 int seen_first_offset
= 0;
9384 int use_debug_info
= 1;
9385 unsigned char *next
;
9387 bytes
= section
->sh_size
;
9388 section_end
= start
+ bytes
;
9392 printf (_("\nThe .debug_loc section is empty.\n"));
9396 get_debug_info (file
);
9398 /* Check the order of location list in .debug_info section. If
9399 offsets of location lists are in the ascending order, we can
9400 use `debug_information' directly. */
9401 for (i
= 0; i
< num_debug_info_entries
; i
++)
9405 num
= debug_information
[i
].num_loc_offsets
;
9406 num_loc_list
+= num
;
9408 /* Check if we can use `debug_information' directly. */
9409 if (use_debug_info
&& num
!= 0)
9411 if (!seen_first_offset
)
9413 /* This is the first location list. */
9414 last_offset
= debug_information
[i
].loc_offsets
[0];
9416 seen_first_offset
= 1;
9422 for (; j
< num
; j
++)
9425 debug_information
[i
].loc_offsets
[j
])
9430 last_offset
= debug_information
[i
].loc_offsets
[j
];
9435 if (!use_debug_info
)
9436 /* FIXME: Should we handle this case? */
9437 error (_("Location lists in .debug_info section aren't in ascending order!\n"));
9439 if (!seen_first_offset
)
9440 error (_("No location lists in .debug_info section!\n"));
9442 if (debug_information
[first
].loc_offsets
[0] != 0)
9443 warn (_("Location lists in .debug_loc section start at 0x%lx\n"),
9444 debug_information
[first
].loc_offsets
[0]);
9446 printf (_("Contents of the .debug_loc section:\n\n"));
9447 printf (_(" Offset Begin End Expression\n"));
9449 seen_first_offset
= 0;
9450 for (i
= first
; i
< num_debug_info_entries
; i
++)
9452 unsigned long begin
;
9454 unsigned short length
;
9455 unsigned long offset
;
9456 unsigned int pointer_size
;
9457 unsigned long cu_offset
;
9458 unsigned long base_address
;
9459 int need_frame_base
;
9462 pointer_size
= debug_information
[i
].pointer_size
;
9463 cu_offset
= debug_information
[i
].cu_offset
;
9465 for (j
= 0; j
< debug_information
[i
].num_loc_offsets
; j
++)
9467 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
9468 offset
= debug_information
[i
].loc_offsets
[j
];
9469 next
= section_begin
+ offset
;
9470 base_address
= debug_information
[i
].base_address
;
9472 if (!seen_first_offset
)
9473 seen_first_offset
= 1;
9477 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
9478 start
- section_begin
, next
- section_begin
);
9479 else if (start
> next
)
9480 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
9481 start
- section_begin
, next
- section_begin
);
9487 begin
= byte_get (start
, pointer_size
);
9488 start
+= pointer_size
;
9489 end
= byte_get (start
, pointer_size
);
9490 start
+= pointer_size
;
9492 if (begin
== 0 && end
== 0)
9494 printf (_(" %8.8lx <End of list>\n"), offset
);
9498 /* Check base address specifiers. */
9499 if (begin
== -1UL && end
!= -1UL)
9502 printf (" %8.8lx %8.8lx %8.8lx (base address)\n",
9503 offset
, begin
, end
);
9507 length
= byte_get (start
, 2);
9510 printf (" %8.8lx %8.8lx %8.8lx (",
9511 offset
, begin
+ base_address
, end
+ base_address
);
9512 need_frame_base
= decode_location_expression (start
,
9518 if (need_frame_base
&& !has_frame_base
)
9519 printf (_(" [without DW_AT_frame_base]"));
9522 fputs (_(" (start == end)"), stdout
);
9523 else if (begin
> end
)
9524 fputs (_(" (start > end)"), stdout
);
9536 display_debug_str (Elf_Internal_Shdr
*section
,
9537 unsigned char *start
,
9538 FILE *file ATTRIBUTE_UNUSED
)
9540 unsigned long bytes
;
9543 addr
= section
->sh_addr
;
9544 bytes
= section
->sh_size
;
9548 printf (_("\nThe .debug_str section is empty.\n"));
9552 printf (_("Contents of the .debug_str section:\n\n"));
9560 lbytes
= (bytes
> 16 ? 16 : bytes
);
9562 printf (" 0x%8.8lx ", (unsigned long) addr
);
9564 for (j
= 0; j
< 16; j
++)
9567 printf ("%2.2x", start
[j
]);
9575 for (j
= 0; j
< lbytes
; j
++)
9578 if (k
>= ' ' && k
< 0x80)
9598 display_debug_info (Elf_Internal_Shdr
* section
,
9599 unsigned char * start
, FILE * file
)
9601 return process_debug_info (section
, start
, file
, 0);
9606 display_debug_aranges (Elf_Internal_Shdr
*section
,
9607 unsigned char *start
,
9608 FILE *file ATTRIBUTE_UNUSED
)
9610 unsigned char *end
= start
+ section
->sh_size
;
9612 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
9616 unsigned char *hdrptr
;
9617 DWARF2_Internal_ARange arange
;
9618 unsigned char *ranges
;
9619 unsigned long length
;
9620 unsigned long address
;
9623 int initial_length_size
;
9627 arange
.ar_length
= byte_get (hdrptr
, 4);
9630 if (arange
.ar_length
== 0xffffffff)
9632 arange
.ar_length
= byte_get (hdrptr
, 8);
9635 initial_length_size
= 12;
9640 initial_length_size
= 4;
9643 arange
.ar_version
= byte_get (hdrptr
, 2);
9646 arange
.ar_info_offset
= byte_get (hdrptr
, offset_size
);
9647 hdrptr
+= offset_size
;
9649 arange
.ar_pointer_size
= byte_get (hdrptr
, 1);
9652 arange
.ar_segment_size
= byte_get (hdrptr
, 1);
9655 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
9657 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
9661 printf (_(" Length: %ld\n"), arange
.ar_length
);
9662 printf (_(" Version: %d\n"), arange
.ar_version
);
9663 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
9664 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
9665 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
9667 printf (_("\n Address Length\n"));
9671 /* Must pad to an alignment boundary that is twice the pointer size. */
9672 excess
= (hdrptr
- start
) % (2 * arange
.ar_pointer_size
);
9674 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
9678 address
= byte_get (ranges
, arange
.ar_pointer_size
);
9680 ranges
+= arange
.ar_pointer_size
;
9682 length
= byte_get (ranges
, arange
.ar_pointer_size
);
9684 ranges
+= arange
.ar_pointer_size
;
9686 /* A pair of zeros marks the end of the list. */
9687 if (address
== 0 && length
== 0)
9690 printf (" %8.8lx %lu\n", address
, length
);
9693 start
+= arange
.ar_length
+ initial_length_size
;
9702 display_debug_ranges (Elf_Internal_Shdr
*section
,
9703 unsigned char *start
,
9704 FILE *file ATTRIBUTE_UNUSED
)
9706 unsigned char *section_end
;
9707 unsigned long bytes
;
9708 unsigned char *section_begin
= start
;
9709 unsigned int num_range_list
= 0;
9710 unsigned long last_offset
= 0;
9711 unsigned int first
= 0;
9714 int seen_first_offset
= 0;
9715 int use_debug_info
= 1;
9716 unsigned char *next
;
9718 bytes
= section
->sh_size
;
9719 section_end
= start
+ bytes
;
9723 printf (_("\nThe .debug_ranges section is empty.\n"));
9727 get_debug_info (file
);
9729 /* Check the order of range list in .debug_info section. If
9730 offsets of range lists are in the ascending order, we can
9731 use `debug_information' directly. */
9732 for (i
= 0; i
< num_debug_info_entries
; i
++)
9736 num
= debug_information
[i
].num_range_lists
;
9737 num_range_list
+= num
;
9739 /* Check if we can use `debug_information' directly. */
9740 if (use_debug_info
&& num
!= 0)
9742 if (!seen_first_offset
)
9744 /* This is the first range list. */
9745 last_offset
= debug_information
[i
].range_lists
[0];
9747 seen_first_offset
= 1;
9753 for (; j
< num
; j
++)
9756 debug_information
[i
].range_lists
[j
])
9761 last_offset
= debug_information
[i
].range_lists
[j
];
9766 if (!use_debug_info
)
9767 /* FIXME: Should we handle this case? */
9768 error (_("Range lists in .debug_info section aren't in ascending order!\n"));
9770 if (!seen_first_offset
)
9771 error (_("No range lists in .debug_info section!\n"));
9773 if (debug_information
[first
].range_lists
[0] != 0)
9774 warn (_("Range lists in .debug_ranges section start at 0x%lx\n"),
9775 debug_information
[first
].range_lists
[0]);
9777 printf (_("Contents of the .debug_ranges section:\n\n"));
9778 printf (_(" Offset Begin End\n"));
9780 seen_first_offset
= 0;
9781 for (i
= first
; i
< num_debug_info_entries
; i
++)
9783 unsigned long begin
;
9785 unsigned long offset
;
9786 unsigned int pointer_size
;
9787 unsigned long base_address
;
9789 pointer_size
= debug_information
[i
].pointer_size
;
9791 for (j
= 0; j
< debug_information
[i
].num_range_lists
; j
++)
9793 offset
= debug_information
[i
].range_lists
[j
];
9794 next
= section_begin
+ offset
;
9795 base_address
= debug_information
[i
].base_address
;
9797 if (!seen_first_offset
)
9798 seen_first_offset
= 1;
9802 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_ranges section.\n"),
9803 start
- section_begin
, next
- section_begin
);
9804 else if (start
> next
)
9805 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_ranges section.\n"),
9806 start
- section_begin
, next
- section_begin
);
9812 begin
= byte_get (start
, pointer_size
);
9813 start
+= pointer_size
;
9814 end
= byte_get (start
, pointer_size
);
9815 start
+= pointer_size
;
9817 if (begin
== 0 && end
== 0)
9820 /* Check base address specifiers. */
9821 if (begin
== -1UL && end
!= -1UL)
9824 printf (" %8.8lx %8.8lx %8.8lx (base address)\n",
9825 offset
, begin
, end
);
9829 printf (" %8.8lx %8.8lx %8.8lx",
9830 offset
, begin
+ base_address
, end
+ base_address
);
9833 fputs (_(" (start == end)"), stdout
);
9834 else if (begin
> end
)
9835 fputs (_(" (start > end)"), stdout
);
9839 fputs (_(" <End of list>\n"), stdout
);
9846 typedef struct Frame_Chunk
9848 struct Frame_Chunk
*next
;
9849 unsigned char *chunk_start
;
9851 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
9852 short int *col_type
;
9855 unsigned int code_factor
;
9857 unsigned long pc_begin
;
9858 unsigned long pc_range
;
9862 unsigned char fde_encoding
;
9863 unsigned char cfa_exp
;
9867 /* A marker for a col_type that means this column was never referenced
9868 in the frame info. */
9869 #define DW_CFA_unreferenced (-1)
9872 frame_need_space (Frame_Chunk
*fc
, int reg
)
9874 int prev
= fc
->ncols
;
9876 if (reg
< fc
->ncols
)
9879 fc
->ncols
= reg
+ 1;
9880 fc
->col_type
= xrealloc (fc
->col_type
, fc
->ncols
* sizeof (short int));
9881 fc
->col_offset
= xrealloc (fc
->col_offset
, fc
->ncols
* sizeof (int));
9883 while (prev
< fc
->ncols
)
9885 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
9886 fc
->col_offset
[prev
] = 0;
9892 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, int *max_regs
)
9897 if (*max_regs
< fc
->ncols
)
9898 *max_regs
= fc
->ncols
;
9900 if (*need_col_headers
)
9902 *need_col_headers
= 0;
9904 printf (" LOC CFA ");
9906 for (r
= 0; r
< *max_regs
; r
++)
9907 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
9912 printf ("r%-4d", r
);
9918 printf ("%08lx ", fc
->pc_begin
);
9920 strcpy (tmp
, "exp");
9922 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
9923 printf ("%-8s ", tmp
);
9925 for (r
= 0; r
< fc
->ncols
; r
++)
9927 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
9929 switch (fc
->col_type
[r
])
9931 case DW_CFA_undefined
:
9934 case DW_CFA_same_value
:
9938 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
9940 case DW_CFA_register
:
9941 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
9943 case DW_CFA_expression
:
9944 strcpy (tmp
, "exp");
9947 strcpy (tmp
, "n/a");
9950 printf ("%-5s", tmp
);
9957 size_of_encoded_value (int encoding
)
9959 switch (encoding
& 0x7)
9962 case 0: return eh_addr_size
;
9970 get_encoded_value (unsigned char *data
, int encoding
)
9972 int size
= size_of_encoded_value (encoding
);
9973 if (encoding
& DW_EH_PE_signed
)
9974 return byte_get_signed (data
, size
);
9976 return byte_get (data
, size
);
9979 #define GET(N) byte_get (start, N); start += N
9980 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
9981 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
9984 display_debug_frames (Elf_Internal_Shdr
*section
,
9985 unsigned char *start
,
9986 FILE *file ATTRIBUTE_UNUSED
)
9988 unsigned char *end
= start
+ section
->sh_size
;
9989 unsigned char *section_start
= start
;
9990 Frame_Chunk
*chunks
= 0;
9991 Frame_Chunk
*remembered_state
= 0;
9993 int is_eh
= streq (SECTION_NAME (section
), ".eh_frame");
9997 printf (_("The section %s contains:\n"), SECTION_NAME (section
));
10001 unsigned char *saved_start
;
10002 unsigned char *block_end
;
10003 unsigned long length
;
10004 unsigned long cie_id
;
10007 int need_col_headers
= 1;
10008 unsigned char *augmentation_data
= NULL
;
10009 unsigned long augmentation_data_len
= 0;
10010 int encoded_ptr_size
= eh_addr_size
;
10012 int initial_length_size
;
10014 saved_start
= start
;
10015 length
= byte_get (start
, 4); start
+= 4;
10019 printf ("\n%08lx ZERO terminator\n\n",
10020 (unsigned long)(saved_start
- section_start
));
10024 if (length
== 0xffffffff)
10026 length
= byte_get (start
, 8);
10029 initial_length_size
= 12;
10034 initial_length_size
= 4;
10037 block_end
= saved_start
+ length
+ initial_length_size
;
10038 cie_id
= byte_get (start
, offset_size
); start
+= offset_size
;
10040 if (elf_header
.e_type
== ET_REL
10041 && !debug_apply_rela_addends (file
, section
, offset_size
,
10042 section_start
, start
, block_end
))
10045 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
10049 fc
= xmalloc (sizeof (Frame_Chunk
));
10050 memset (fc
, 0, sizeof (Frame_Chunk
));
10054 fc
->chunk_start
= saved_start
;
10056 fc
->col_type
= xmalloc (sizeof (short int));
10057 fc
->col_offset
= xmalloc (sizeof (int));
10058 frame_need_space (fc
, max_regs
-1);
10060 version
= *start
++;
10062 fc
->augmentation
= start
;
10063 start
= strchr (start
, '\0') + 1;
10065 if (fc
->augmentation
[0] == 'z')
10067 fc
->code_factor
= LEB ();
10068 fc
->data_factor
= SLEB ();
10077 augmentation_data_len
= LEB ();
10078 augmentation_data
= start
;
10079 start
+= augmentation_data_len
;
10081 else if (streq (fc
->augmentation
, "eh"))
10083 start
+= eh_addr_size
;
10084 fc
->code_factor
= LEB ();
10085 fc
->data_factor
= SLEB ();
10097 fc
->code_factor
= LEB ();
10098 fc
->data_factor
= SLEB ();
10110 if (do_debug_frames_interp
)
10111 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
10112 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
10113 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
10117 printf ("\n%08lx %08lx %08lx CIE\n",
10118 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
10119 printf (" Version: %d\n", version
);
10120 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
10121 printf (" Code alignment factor: %u\n", fc
->code_factor
);
10122 printf (" Data alignment factor: %d\n", fc
->data_factor
);
10123 printf (" Return address column: %d\n", fc
->ra
);
10125 if (augmentation_data_len
)
10128 printf (" Augmentation data: ");
10129 for (i
= 0; i
< augmentation_data_len
; ++i
)
10130 printf (" %02x", augmentation_data
[i
]);
10136 if (augmentation_data_len
)
10138 unsigned char *p
, *q
;
10139 p
= fc
->augmentation
+ 1;
10140 q
= augmentation_data
;
10146 else if (*p
== 'P')
10147 q
+= 1 + size_of_encoded_value (*q
);
10148 else if (*p
== 'R')
10149 fc
->fde_encoding
= *q
++;
10155 if (fc
->fde_encoding
)
10156 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
10159 frame_need_space (fc
, fc
->ra
);
10163 unsigned char *look_for
;
10164 static Frame_Chunk fde_fc
;
10167 memset (fc
, 0, sizeof (Frame_Chunk
));
10169 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
10171 for (cie
= chunks
; cie
; cie
= cie
->next
)
10172 if (cie
->chunk_start
== look_for
)
10177 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
10178 cie_id
, saved_start
);
10181 fc
->col_type
= xmalloc (sizeof (short int));
10182 fc
->col_offset
= xmalloc (sizeof (int));
10183 frame_need_space (fc
, max_regs
- 1);
10185 fc
->augmentation
= "";
10186 fc
->fde_encoding
= 0;
10190 fc
->ncols
= cie
->ncols
;
10191 fc
->col_type
= xmalloc (fc
->ncols
* sizeof (short int));
10192 fc
->col_offset
= xmalloc (fc
->ncols
* sizeof (int));
10193 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
10194 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
10195 fc
->augmentation
= cie
->augmentation
;
10196 fc
->code_factor
= cie
->code_factor
;
10197 fc
->data_factor
= cie
->data_factor
;
10198 fc
->cfa_reg
= cie
->cfa_reg
;
10199 fc
->cfa_offset
= cie
->cfa_offset
;
10201 frame_need_space (fc
, max_regs
-1);
10202 fc
->fde_encoding
= cie
->fde_encoding
;
10205 if (fc
->fde_encoding
)
10206 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
10208 fc
->pc_begin
= get_encoded_value (start
, fc
->fde_encoding
);
10209 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
10210 /* Don't adjust for ET_REL since there's invariably a pcrel
10211 reloc here, which we haven't applied. */
10212 && elf_header
.e_type
!= ET_REL
)
10213 fc
->pc_begin
+= section
->sh_addr
+ (start
- section_start
);
10214 start
+= encoded_ptr_size
;
10215 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
10216 start
+= encoded_ptr_size
;
10218 if (cie
->augmentation
[0] == 'z')
10220 augmentation_data_len
= LEB ();
10221 augmentation_data
= start
;
10222 start
+= augmentation_data_len
;
10225 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
10226 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
10227 (unsigned long)(cie
->chunk_start
- section_start
),
10228 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
10229 if (! do_debug_frames_interp
&& augmentation_data_len
)
10233 printf (" Augmentation data: ");
10234 for (i
= 0; i
< augmentation_data_len
; ++i
)
10235 printf (" %02x", augmentation_data
[i
]);
10241 /* At this point, fc is the current chunk, cie (if any) is set, and
10242 we're about to interpret instructions for the chunk. */
10243 /* ??? At present we need to do this always, since this sizes the
10244 fc->col_type and fc->col_offset arrays, which we write into always.
10245 We should probably split the interpreted and non-interpreted bits
10246 into two different routines, since there's so much that doesn't
10247 really overlap between them. */
10248 if (1 || do_debug_frames_interp
)
10250 /* Start by making a pass over the chunk, allocating storage
10251 and taking note of what registers are used. */
10252 unsigned char *tmp
= start
;
10254 while (start
< block_end
)
10257 unsigned long reg
, tmp
;
10264 /* Warning: if you add any more cases to this switch, be
10265 sure to add them to the corresponding switch below. */
10268 case DW_CFA_advance_loc
:
10270 case DW_CFA_offset
:
10272 frame_need_space (fc
, opa
);
10273 fc
->col_type
[opa
] = DW_CFA_undefined
;
10275 case DW_CFA_restore
:
10276 frame_need_space (fc
, opa
);
10277 fc
->col_type
[opa
] = DW_CFA_undefined
;
10279 case DW_CFA_set_loc
:
10280 start
+= encoded_ptr_size
;
10282 case DW_CFA_advance_loc1
:
10285 case DW_CFA_advance_loc2
:
10288 case DW_CFA_advance_loc4
:
10291 case DW_CFA_offset_extended
:
10292 reg
= LEB (); LEB ();
10293 frame_need_space (fc
, reg
);
10294 fc
->col_type
[reg
] = DW_CFA_undefined
;
10296 case DW_CFA_restore_extended
:
10298 frame_need_space (fc
, reg
);
10299 fc
->col_type
[reg
] = DW_CFA_undefined
;
10301 case DW_CFA_undefined
:
10303 frame_need_space (fc
, reg
);
10304 fc
->col_type
[reg
] = DW_CFA_undefined
;
10306 case DW_CFA_same_value
:
10308 frame_need_space (fc
, reg
);
10309 fc
->col_type
[reg
] = DW_CFA_undefined
;
10311 case DW_CFA_register
:
10312 reg
= LEB (); LEB ();
10313 frame_need_space (fc
, reg
);
10314 fc
->col_type
[reg
] = DW_CFA_undefined
;
10316 case DW_CFA_def_cfa
:
10319 case DW_CFA_def_cfa_register
:
10322 case DW_CFA_def_cfa_offset
:
10325 case DW_CFA_def_cfa_expression
:
10329 case DW_CFA_expression
:
10333 frame_need_space (fc
, reg
);
10334 fc
->col_type
[reg
] = DW_CFA_undefined
;
10336 case DW_CFA_offset_extended_sf
:
10337 reg
= LEB (); SLEB ();
10338 frame_need_space (fc
, reg
);
10339 fc
->col_type
[reg
] = DW_CFA_undefined
;
10341 case DW_CFA_def_cfa_sf
:
10344 case DW_CFA_def_cfa_offset_sf
:
10347 case DW_CFA_MIPS_advance_loc8
:
10350 case DW_CFA_GNU_args_size
:
10353 case DW_CFA_GNU_negative_offset_extended
:
10354 reg
= LEB (); LEB ();
10355 frame_need_space (fc
, reg
);
10356 fc
->col_type
[reg
] = DW_CFA_undefined
;
10365 /* Now we know what registers are used, make a second pass over
10366 the chunk, this time actually printing out the info. */
10368 while (start
< block_end
)
10371 unsigned long ul
, reg
, roffs
;
10380 /* Warning: if you add any more cases to this switch, be
10381 sure to add them to the corresponding switch above. */
10384 case DW_CFA_advance_loc
:
10385 if (do_debug_frames_interp
)
10386 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10388 printf (" DW_CFA_advance_loc: %d to %08lx\n",
10389 opa
* fc
->code_factor
,
10390 fc
->pc_begin
+ opa
* fc
->code_factor
);
10391 fc
->pc_begin
+= opa
* fc
->code_factor
;
10394 case DW_CFA_offset
:
10396 if (! do_debug_frames_interp
)
10397 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
10398 opa
, roffs
* fc
->data_factor
);
10399 fc
->col_type
[opa
] = DW_CFA_offset
;
10400 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
10403 case DW_CFA_restore
:
10404 if (! do_debug_frames_interp
)
10405 printf (" DW_CFA_restore: r%d\n", opa
);
10406 fc
->col_type
[opa
] = cie
->col_type
[opa
];
10407 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
10410 case DW_CFA_set_loc
:
10411 vma
= get_encoded_value (start
, fc
->fde_encoding
);
10412 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
10413 && elf_header
.e_type
!= ET_REL
)
10414 vma
+= section
->sh_addr
+ (start
- section_start
);
10415 start
+= encoded_ptr_size
;
10416 if (do_debug_frames_interp
)
10417 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10419 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
10420 fc
->pc_begin
= vma
;
10423 case DW_CFA_advance_loc1
:
10424 ofs
= byte_get (start
, 1); start
+= 1;
10425 if (do_debug_frames_interp
)
10426 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10428 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
10429 ofs
* fc
->code_factor
,
10430 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10431 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10434 case DW_CFA_advance_loc2
:
10435 ofs
= byte_get (start
, 2); start
+= 2;
10436 if (do_debug_frames_interp
)
10437 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10439 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
10440 ofs
* fc
->code_factor
,
10441 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10442 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10445 case DW_CFA_advance_loc4
:
10446 ofs
= byte_get (start
, 4); start
+= 4;
10447 if (do_debug_frames_interp
)
10448 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10450 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
10451 ofs
* fc
->code_factor
,
10452 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10453 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10456 case DW_CFA_offset_extended
:
10459 if (! do_debug_frames_interp
)
10460 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
10461 reg
, roffs
* fc
->data_factor
);
10462 fc
->col_type
[reg
] = DW_CFA_offset
;
10463 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
10466 case DW_CFA_restore_extended
:
10468 if (! do_debug_frames_interp
)
10469 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
10470 fc
->col_type
[reg
] = cie
->col_type
[reg
];
10471 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
10474 case DW_CFA_undefined
:
10476 if (! do_debug_frames_interp
)
10477 printf (" DW_CFA_undefined: r%ld\n", reg
);
10478 fc
->col_type
[reg
] = DW_CFA_undefined
;
10479 fc
->col_offset
[reg
] = 0;
10482 case DW_CFA_same_value
:
10484 if (! do_debug_frames_interp
)
10485 printf (" DW_CFA_same_value: r%ld\n", reg
);
10486 fc
->col_type
[reg
] = DW_CFA_same_value
;
10487 fc
->col_offset
[reg
] = 0;
10490 case DW_CFA_register
:
10493 if (! do_debug_frames_interp
)
10494 printf (" DW_CFA_register: r%ld in r%ld\n", reg
, roffs
);
10495 fc
->col_type
[reg
] = DW_CFA_register
;
10496 fc
->col_offset
[reg
] = roffs
;
10499 case DW_CFA_remember_state
:
10500 if (! do_debug_frames_interp
)
10501 printf (" DW_CFA_remember_state\n");
10502 rs
= xmalloc (sizeof (Frame_Chunk
));
10503 rs
->ncols
= fc
->ncols
;
10504 rs
->col_type
= xmalloc (rs
->ncols
* sizeof (short int));
10505 rs
->col_offset
= xmalloc (rs
->ncols
* sizeof (int));
10506 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
10507 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
10508 rs
->next
= remembered_state
;
10509 remembered_state
= rs
;
10512 case DW_CFA_restore_state
:
10513 if (! do_debug_frames_interp
)
10514 printf (" DW_CFA_restore_state\n");
10515 rs
= remembered_state
;
10518 remembered_state
= rs
->next
;
10519 frame_need_space (fc
, rs
->ncols
-1);
10520 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
10521 memcpy (fc
->col_offset
, rs
->col_offset
,
10522 rs
->ncols
* sizeof (int));
10523 free (rs
->col_type
);
10524 free (rs
->col_offset
);
10527 else if (do_debug_frames_interp
)
10528 printf ("Mismatched DW_CFA_restore_state\n");
10531 case DW_CFA_def_cfa
:
10532 fc
->cfa_reg
= LEB ();
10533 fc
->cfa_offset
= LEB ();
10535 if (! do_debug_frames_interp
)
10536 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
10537 fc
->cfa_reg
, fc
->cfa_offset
);
10540 case DW_CFA_def_cfa_register
:
10541 fc
->cfa_reg
= LEB ();
10543 if (! do_debug_frames_interp
)
10544 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
10547 case DW_CFA_def_cfa_offset
:
10548 fc
->cfa_offset
= LEB ();
10549 if (! do_debug_frames_interp
)
10550 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
10554 if (! do_debug_frames_interp
)
10555 printf (" DW_CFA_nop\n");
10558 case DW_CFA_def_cfa_expression
:
10560 if (! do_debug_frames_interp
)
10562 printf (" DW_CFA_def_cfa_expression (");
10563 decode_location_expression (start
, eh_addr_size
, ul
, 0);
10570 case DW_CFA_expression
:
10573 if (! do_debug_frames_interp
)
10575 printf (" DW_CFA_expression: r%ld (", reg
);
10576 decode_location_expression (start
, eh_addr_size
, ul
, 0);
10579 fc
->col_type
[reg
] = DW_CFA_expression
;
10583 case DW_CFA_offset_extended_sf
:
10586 frame_need_space (fc
, reg
);
10587 if (! do_debug_frames_interp
)
10588 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
10589 reg
, l
* fc
->data_factor
);
10590 fc
->col_type
[reg
] = DW_CFA_offset
;
10591 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
10594 case DW_CFA_def_cfa_sf
:
10595 fc
->cfa_reg
= LEB ();
10596 fc
->cfa_offset
= SLEB ();
10598 if (! do_debug_frames_interp
)
10599 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
10600 fc
->cfa_reg
, fc
->cfa_offset
);
10603 case DW_CFA_def_cfa_offset_sf
:
10604 fc
->cfa_offset
= SLEB ();
10605 if (! do_debug_frames_interp
)
10606 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
10609 case DW_CFA_MIPS_advance_loc8
:
10610 ofs
= byte_get (start
, 8); start
+= 8;
10611 if (do_debug_frames_interp
)
10612 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10614 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
10615 ofs
* fc
->code_factor
,
10616 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10617 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10620 case DW_CFA_GNU_window_save
:
10621 if (! do_debug_frames_interp
)
10622 printf (" DW_CFA_GNU_window_save\n");
10625 case DW_CFA_GNU_args_size
:
10627 if (! do_debug_frames_interp
)
10628 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
10631 case DW_CFA_GNU_negative_offset_extended
:
10634 frame_need_space (fc
, reg
);
10635 if (! do_debug_frames_interp
)
10636 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
10637 reg
, l
* fc
->data_factor
);
10638 fc
->col_type
[reg
] = DW_CFA_offset
;
10639 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
10643 warn (_("unsupported or unknown DW_CFA_%d\n"), op
);
10648 if (do_debug_frames_interp
)
10649 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10664 display_debug_not_supported (Elf_Internal_Shdr
*section
,
10665 unsigned char *start ATTRIBUTE_UNUSED
,
10666 FILE *file ATTRIBUTE_UNUSED
)
10668 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
10669 SECTION_NAME (section
));
10674 /* A structure containing the name of a debug section
10675 and a pointer to a function that can decode it. */
10678 const char *const name
;
10679 int (*display
) (Elf_Internal_Shdr
*, unsigned char *, FILE *);
10683 { ".debug_abbrev", display_debug_abbrev
},
10684 { ".debug_aranges", display_debug_aranges
},
10685 { ".debug_frame", display_debug_frames
},
10686 { ".debug_info", display_debug_info
},
10687 { ".debug_line", display_debug_lines
},
10688 { ".debug_pubnames", display_debug_pubnames
},
10689 { ".eh_frame", display_debug_frames
},
10690 { ".debug_macinfo", display_debug_macinfo
},
10691 { ".debug_str", display_debug_str
},
10692 { ".debug_loc", display_debug_loc
},
10693 { ".debug_pubtypes", display_debug_pubnames
},
10694 { ".debug_ranges", display_debug_ranges
},
10695 { ".debug_static_func", display_debug_not_supported
},
10696 { ".debug_static_vars", display_debug_not_supported
},
10697 { ".debug_types", display_debug_not_supported
},
10698 { ".debug_weaknames", display_debug_not_supported
}
10702 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
10704 char *name
= SECTION_NAME (section
);
10705 bfd_size_type length
;
10709 length
= section
->sh_size
;
10712 printf (_("\nSection '%s' has no debugging data.\n"), name
);
10716 if (strneq (name
, ".gnu.linkonce.wi.", 17))
10717 name
= ".debug_info";
10719 /* See if we know how to display the contents of this section. */
10720 for (i
= NUM_ELEM (debug_displays
); i
--;)
10721 if (streq (debug_displays
[i
].name
, name
))
10723 unsigned char *start
;
10725 start
= get_data (NULL
, file
, section
->sh_offset
, length
,
10726 _("debug section data"));
10733 result
&= debug_displays
[i
].display (section
, start
, file
);
10736 /* If we loaded in the abbrev section
10737 at some point, we must release it here. */
10745 printf (_("Unrecognized debug section: %s\n"), name
);
10753 process_section_contents (FILE *file
)
10755 Elf_Internal_Shdr
*section
;
10761 for (i
= 0, section
= section_headers
;
10762 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
10765 #ifdef SUPPORT_DISASSEMBLY
10766 if (dump_sects
[i
] & DISASS_DUMP
)
10767 disassemble_section (section
, file
);
10769 if (dump_sects
[i
] & HEX_DUMP
)
10770 dump_section (section
, file
);
10772 if (dump_sects
[i
] & DEBUG_DUMP
)
10773 display_debug_section (section
, file
);
10776 /* Check to see if the user requested a
10777 dump of a section that does not exist. */
10778 while (i
++ < num_dump_sects
)
10780 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
10784 process_mips_fpe_exception (int mask
)
10789 if (mask
& OEX_FPU_INEX
)
10790 fputs ("INEX", stdout
), first
= 0;
10791 if (mask
& OEX_FPU_UFLO
)
10792 printf ("%sUFLO", first
? "" : "|"), first
= 0;
10793 if (mask
& OEX_FPU_OFLO
)
10794 printf ("%sOFLO", first
? "" : "|"), first
= 0;
10795 if (mask
& OEX_FPU_DIV0
)
10796 printf ("%sDIV0", first
? "" : "|"), first
= 0;
10797 if (mask
& OEX_FPU_INVAL
)
10798 printf ("%sINVAL", first
? "" : "|");
10801 fputs ("0", stdout
);
10805 process_mips_specific (FILE *file
)
10807 Elf_Internal_Dyn
*entry
;
10808 size_t liblist_offset
= 0;
10809 size_t liblistno
= 0;
10810 size_t conflictsno
= 0;
10811 size_t options_offset
= 0;
10812 size_t conflicts_offset
= 0;
10814 /* We have a lot of special sections. Thanks SGI! */
10815 if (dynamic_section
== NULL
)
10816 /* No information available. */
10819 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
10820 switch (entry
->d_tag
)
10822 case DT_MIPS_LIBLIST
:
10824 = offset_from_vma (file
, entry
->d_un
.d_val
,
10825 liblistno
* sizeof (Elf32_External_Lib
));
10827 case DT_MIPS_LIBLISTNO
:
10828 liblistno
= entry
->d_un
.d_val
;
10830 case DT_MIPS_OPTIONS
:
10831 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
10833 case DT_MIPS_CONFLICT
:
10835 = offset_from_vma (file
, entry
->d_un
.d_val
,
10836 conflictsno
* sizeof (Elf32_External_Conflict
));
10838 case DT_MIPS_CONFLICTNO
:
10839 conflictsno
= entry
->d_un
.d_val
;
10845 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
10847 Elf32_External_Lib
*elib
;
10850 elib
= get_data (NULL
, file
, liblist_offset
,
10851 liblistno
* sizeof (Elf32_External_Lib
),
10855 printf ("\nSection '.liblist' contains %lu entries:\n",
10856 (unsigned long) liblistno
);
10857 fputs (" Library Time Stamp Checksum Version Flags\n",
10860 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
10867 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
10868 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
10869 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
10870 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
10871 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
10873 tmp
= gmtime (&time
);
10874 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
10875 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10876 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10878 printf ("%3lu: ", (unsigned long) cnt
);
10879 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
10880 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
10882 printf ("<corrupt: %9ld>", liblist
.l_name
);
10883 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
10884 liblist
.l_version
);
10886 if (liblist
.l_flags
== 0)
10890 static const struct
10897 { " EXACT_MATCH", LL_EXACT_MATCH
},
10898 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
10899 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
10900 { " EXPORTS", LL_EXPORTS
},
10901 { " DELAY_LOAD", LL_DELAY_LOAD
},
10902 { " DELTA", LL_DELTA
}
10904 int flags
= liblist
.l_flags
;
10908 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
10910 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
10912 fputs (l_flags_vals
[fcnt
].name
, stdout
);
10913 flags
^= l_flags_vals
[fcnt
].bit
;
10916 printf (" %#x", (unsigned int) flags
);
10926 if (options_offset
!= 0)
10928 Elf_External_Options
*eopt
;
10929 Elf_Internal_Shdr
*sect
= section_headers
;
10930 Elf_Internal_Options
*iopt
;
10931 Elf_Internal_Options
*option
;
10935 /* Find the section header so that we get the size. */
10936 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
10939 eopt
= get_data (NULL
, file
, options_offset
, sect
->sh_size
,
10943 iopt
= malloc ((sect
->sh_size
/ sizeof (eopt
)) * sizeof (*iopt
));
10946 error (_("Out of memory"));
10953 while (offset
< sect
->sh_size
)
10955 Elf_External_Options
*eoption
;
10957 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
10959 option
->kind
= BYTE_GET (eoption
->kind
);
10960 option
->size
= BYTE_GET (eoption
->size
);
10961 option
->section
= BYTE_GET (eoption
->section
);
10962 option
->info
= BYTE_GET (eoption
->info
);
10964 offset
+= option
->size
;
10970 printf (_("\nSection '%s' contains %d entries:\n"),
10971 SECTION_NAME (sect
), cnt
);
10979 switch (option
->kind
)
10982 /* This shouldn't happen. */
10983 printf (" NULL %d %lx", option
->section
, option
->info
);
10986 printf (" REGINFO ");
10987 if (elf_header
.e_machine
== EM_MIPS
)
10990 Elf32_External_RegInfo
*ereg
;
10991 Elf32_RegInfo reginfo
;
10993 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
10994 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
10995 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
10996 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
10997 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
10998 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
10999 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
11001 printf ("GPR %08lx GP 0x%lx\n",
11002 reginfo
.ri_gprmask
,
11003 (unsigned long) reginfo
.ri_gp_value
);
11004 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11005 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11006 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11011 Elf64_External_RegInfo
*ereg
;
11012 Elf64_Internal_RegInfo reginfo
;
11014 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
11015 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
11016 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
11017 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
11018 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
11019 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
11020 reginfo
.ri_gp_value
= BYTE_GET8 (ereg
->ri_gp_value
);
11022 printf ("GPR %08lx GP 0x",
11023 reginfo
.ri_gprmask
);
11024 printf_vma (reginfo
.ri_gp_value
);
11027 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11028 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11029 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11033 case ODK_EXCEPTIONS
:
11034 fputs (" EXCEPTIONS fpe_min(", stdout
);
11035 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
11036 fputs (") fpe_max(", stdout
);
11037 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
11038 fputs (")", stdout
);
11040 if (option
->info
& OEX_PAGE0
)
11041 fputs (" PAGE0", stdout
);
11042 if (option
->info
& OEX_SMM
)
11043 fputs (" SMM", stdout
);
11044 if (option
->info
& OEX_FPDBUG
)
11045 fputs (" FPDBUG", stdout
);
11046 if (option
->info
& OEX_DISMISS
)
11047 fputs (" DISMISS", stdout
);
11050 fputs (" PAD ", stdout
);
11051 if (option
->info
& OPAD_PREFIX
)
11052 fputs (" PREFIX", stdout
);
11053 if (option
->info
& OPAD_POSTFIX
)
11054 fputs (" POSTFIX", stdout
);
11055 if (option
->info
& OPAD_SYMBOL
)
11056 fputs (" SYMBOL", stdout
);
11059 fputs (" HWPATCH ", stdout
);
11060 if (option
->info
& OHW_R4KEOP
)
11061 fputs (" R4KEOP", stdout
);
11062 if (option
->info
& OHW_R8KPFETCH
)
11063 fputs (" R8KPFETCH", stdout
);
11064 if (option
->info
& OHW_R5KEOP
)
11065 fputs (" R5KEOP", stdout
);
11066 if (option
->info
& OHW_R5KCVTL
)
11067 fputs (" R5KCVTL", stdout
);
11070 fputs (" FILL ", stdout
);
11071 /* XXX Print content of info word? */
11074 fputs (" TAGS ", stdout
);
11075 /* XXX Print content of info word? */
11078 fputs (" HWAND ", stdout
);
11079 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11080 fputs (" R4KEOP_CHECKED", stdout
);
11081 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11082 fputs (" R4KEOP_CLEAN", stdout
);
11085 fputs (" HWOR ", stdout
);
11086 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11087 fputs (" R4KEOP_CHECKED", stdout
);
11088 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11089 fputs (" R4KEOP_CLEAN", stdout
);
11092 printf (" GP_GROUP %#06lx self-contained %#06lx",
11093 option
->info
& OGP_GROUP
,
11094 (option
->info
& OGP_SELF
) >> 16);
11097 printf (" IDENT %#06lx self-contained %#06lx",
11098 option
->info
& OGP_GROUP
,
11099 (option
->info
& OGP_SELF
) >> 16);
11102 /* This shouldn't happen. */
11103 printf (" %3d ??? %d %lx",
11104 option
->kind
, option
->section
, option
->info
);
11108 len
= sizeof (*eopt
);
11109 while (len
< option
->size
)
11110 if (((char *) option
)[len
] >= ' '
11111 && ((char *) option
)[len
] < 0x7f)
11112 printf ("%c", ((char *) option
)[len
++]);
11114 printf ("\\%03o", ((char *) option
)[len
++]);
11116 fputs ("\n", stdout
);
11124 if (conflicts_offset
!= 0 && conflictsno
!= 0)
11126 Elf32_Conflict
*iconf
;
11129 if (dynamic_symbols
== NULL
)
11131 error (_("conflict list found without a dynamic symbol table"));
11135 iconf
= malloc (conflictsno
* sizeof (*iconf
));
11138 error (_("Out of memory"));
11144 Elf32_External_Conflict
*econf32
;
11146 econf32
= get_data (NULL
, file
, conflicts_offset
,
11147 conflictsno
* sizeof (*econf32
), _("conflict"));
11151 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11152 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
11158 Elf64_External_Conflict
*econf64
;
11160 econf64
= get_data (NULL
, file
, conflicts_offset
,
11161 conflictsno
* sizeof (*econf64
), _("conflict"));
11165 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11166 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
11171 printf (_("\nSection '.conflict' contains %lu entries:\n"),
11172 (unsigned long) conflictsno
);
11173 puts (_(" Num: Index Value Name"));
11175 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11177 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
11179 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
11180 print_vma (psym
->st_value
, FULL_HEX
);
11182 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11183 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11185 printf ("<corrupt: %14ld>", psym
->st_name
);
11196 process_gnu_liblist (FILE *file
)
11198 Elf_Internal_Shdr
*section
, *string_sec
;
11199 Elf32_External_Lib
*elib
;
11207 for (i
= 0, section
= section_headers
;
11208 i
< elf_header
.e_shnum
;
11211 switch (section
->sh_type
)
11213 case SHT_GNU_LIBLIST
:
11214 elib
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
11219 string_sec
= SECTION_HEADER (section
->sh_link
);
11221 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
11222 string_sec
->sh_size
, _("liblist string table"));
11225 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
11231 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
11232 SECTION_NAME (section
),
11233 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
11235 puts (" Library Time Stamp Checksum Version Flags");
11237 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
11245 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
11246 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
11247 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
11248 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
11249 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
11251 tmp
= gmtime (&time
);
11252 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
11253 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11254 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11256 printf ("%3lu: ", (unsigned long) cnt
);
11258 printf ("%-20s", strtab
+ liblist
.l_name
);
11260 printf ("%-20.20s", strtab
+ liblist
.l_name
);
11261 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
11262 liblist
.l_version
, liblist
.l_flags
);
11272 static const char *
11273 get_note_type (unsigned e_type
)
11275 static char buff
[64];
11277 if (elf_header
.e_type
== ET_CORE
)
11281 return _("NT_AUXV (auxiliary vector)");
11283 return _("NT_PRSTATUS (prstatus structure)");
11285 return _("NT_FPREGSET (floating point registers)");
11287 return _("NT_PRPSINFO (prpsinfo structure)");
11288 case NT_TASKSTRUCT
:
11289 return _("NT_TASKSTRUCT (task structure)");
11291 return _("NT_PRXFPREG (user_xfpregs structure)");
11293 return _("NT_PSTATUS (pstatus structure)");
11295 return _("NT_FPREGS (floating point registers)");
11297 return _("NT_PSINFO (psinfo structure)");
11299 return _("NT_LWPSTATUS (lwpstatus_t structure)");
11301 return _("NT_LWPSINFO (lwpsinfo_t structure)");
11302 case NT_WIN32PSTATUS
:
11303 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
11311 return _("NT_VERSION (version)");
11313 return _("NT_ARCH (architecture)");
11318 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
11322 static const char *
11323 get_netbsd_elfcore_note_type (unsigned e_type
)
11325 static char buff
[64];
11327 if (e_type
== NT_NETBSDCORE_PROCINFO
)
11329 /* NetBSD core "procinfo" structure. */
11330 return _("NetBSD procinfo structure");
11333 /* As of Jan 2002 there are no other machine-independent notes
11334 defined for NetBSD core files. If the note type is less
11335 than the start of the machine-dependent note types, we don't
11338 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
11340 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
11344 switch (elf_header
.e_machine
)
11346 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
11347 and PT_GETFPREGS == mach+2. */
11352 case EM_SPARC32PLUS
:
11356 case NT_NETBSDCORE_FIRSTMACH
+0:
11357 return _("PT_GETREGS (reg structure)");
11358 case NT_NETBSDCORE_FIRSTMACH
+2:
11359 return _("PT_GETFPREGS (fpreg structure)");
11365 /* On all other arch's, PT_GETREGS == mach+1 and
11366 PT_GETFPREGS == mach+3. */
11370 case NT_NETBSDCORE_FIRSTMACH
+1:
11371 return _("PT_GETREGS (reg structure)");
11372 case NT_NETBSDCORE_FIRSTMACH
+3:
11373 return _("PT_GETFPREGS (fpreg structure)");
11379 sprintf (buff
, _("PT_FIRSTMACH+%d"), e_type
- NT_NETBSDCORE_FIRSTMACH
);
11383 /* Note that by the ELF standard, the name field is already null byte
11384 terminated, and namesz includes the terminating null byte.
11385 I.E. the value of namesz for the name "FSF" is 4.
11387 If the value of namesz is zero, there is no name present. */
11389 process_note (Elf_Internal_Note
*pnote
)
11393 if (pnote
->namesz
== 0)
11394 /* If there is no note name, then use the default set of
11395 note type strings. */
11396 nt
= get_note_type (pnote
->type
);
11398 else if (strneq (pnote
->namedata
, "NetBSD-CORE", 11))
11399 /* NetBSD-specific core file notes. */
11400 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
11403 /* Don't recognize this note name; just use the default set of
11404 note type strings. */
11405 nt
= get_note_type (pnote
->type
);
11407 printf (" %s\t\t0x%08lx\t%s\n",
11408 pnote
->namesz
? pnote
->namedata
: "(NONE)",
11409 pnote
->descsz
, nt
);
11415 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
11417 Elf_External_Note
*pnotes
;
11418 Elf_External_Note
*external
;
11424 pnotes
= get_data (NULL
, file
, offset
, length
, _("notes"));
11430 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
11431 (unsigned long) offset
, (unsigned long) length
);
11432 printf (_(" Owner\t\tData size\tDescription\n"));
11434 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
11436 Elf_External_Note
*next
;
11437 Elf_Internal_Note inote
;
11440 inote
.type
= BYTE_GET (external
->type
);
11441 inote
.namesz
= BYTE_GET (external
->namesz
);
11442 inote
.namedata
= external
->name
;
11443 inote
.descsz
= BYTE_GET (external
->descsz
);
11444 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
11445 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
11447 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
11449 if (((char *) next
) > (((char *) pnotes
) + length
))
11451 warn (_("corrupt note found at offset %x into core notes\n"),
11452 ((char *) external
) - ((char *) pnotes
));
11453 warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
11454 inote
.type
, inote
.namesz
, inote
.descsz
);
11460 /* Verify that name is null terminated. It appears that at least
11461 one version of Linux (RedHat 6.0) generates corefiles that don't
11462 comply with the ELF spec by failing to include the null byte in
11464 if (inote
.namedata
[inote
.namesz
] != '\0')
11466 temp
= malloc (inote
.namesz
+ 1);
11470 error (_("Out of memory\n"));
11475 strncpy (temp
, inote
.namedata
, inote
.namesz
);
11476 temp
[inote
.namesz
] = 0;
11478 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
11479 inote
.namedata
= temp
;
11482 res
&= process_note (& inote
);
11497 process_corefile_note_segments (FILE *file
)
11499 Elf_Internal_Phdr
*segment
;
11503 if (! get_program_headers (file
))
11506 for (i
= 0, segment
= program_headers
;
11507 i
< elf_header
.e_phnum
;
11510 if (segment
->p_type
== PT_NOTE
)
11511 res
&= process_corefile_note_segment (file
,
11512 (bfd_vma
) segment
->p_offset
,
11513 (bfd_vma
) segment
->p_filesz
);
11520 process_note_sections (FILE *file
)
11522 Elf_Internal_Shdr
*section
;
11526 for (i
= 0, section
= section_headers
;
11527 i
< elf_header
.e_shnum
;
11529 if (section
->sh_type
== SHT_NOTE
)
11530 res
&= process_corefile_note_segment (file
,
11531 (bfd_vma
) section
->sh_offset
,
11532 (bfd_vma
) section
->sh_size
);
11538 process_notes (FILE *file
)
11540 /* If we have not been asked to display the notes then do nothing. */
11544 if (elf_header
.e_type
!= ET_CORE
)
11545 return process_note_sections (file
);
11547 /* No program headers means no NOTE segment. */
11548 if (elf_header
.e_phnum
> 0)
11549 return process_corefile_note_segments (file
);
11551 printf (_("No note segments present in the core file.\n"));
11556 process_arch_specific (FILE *file
)
11561 switch (elf_header
.e_machine
)
11564 case EM_MIPS_RS3_LE
:
11565 return process_mips_specific (file
);
11574 get_file_header (FILE *file
)
11576 /* Read in the identity array. */
11577 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
11580 /* Determine how to read the rest of the header. */
11581 switch (elf_header
.e_ident
[EI_DATA
])
11583 default: /* fall through */
11584 case ELFDATANONE
: /* fall through */
11586 byte_get
= byte_get_little_endian
;
11587 byte_put
= byte_put_little_endian
;
11590 byte_get
= byte_get_big_endian
;
11591 byte_put
= byte_put_big_endian
;
11595 /* For now we only support 32 bit and 64 bit ELF files. */
11596 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
11598 /* Read in the rest of the header. */
11601 Elf32_External_Ehdr ehdr32
;
11603 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
11606 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
11607 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
11608 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
11609 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
11610 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
11611 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
11612 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
11613 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
11614 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
11615 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
11616 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
11617 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
11618 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
11622 Elf64_External_Ehdr ehdr64
;
11624 /* If we have been compiled with sizeof (bfd_vma) == 4, then
11625 we will not be able to cope with the 64bit data found in
11626 64 ELF files. Detect this now and abort before we start
11627 overwriting things. */
11628 if (sizeof (bfd_vma
) < 8)
11630 error (_("This instance of readelf has been built without support for a\n\
11631 64 bit data type and so it cannot read 64 bit ELF files.\n"));
11635 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
11638 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
11639 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
11640 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
11641 elf_header
.e_entry
= BYTE_GET8 (ehdr64
.e_entry
);
11642 elf_header
.e_phoff
= BYTE_GET8 (ehdr64
.e_phoff
);
11643 elf_header
.e_shoff
= BYTE_GET8 (ehdr64
.e_shoff
);
11644 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
11645 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
11646 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
11647 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
11648 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
11649 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
11650 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
11653 if (elf_header
.e_shoff
)
11655 /* There may be some extensions in the first section header. Don't
11656 bomb if we can't read it. */
11658 get_32bit_section_headers (file
, 1);
11660 get_64bit_section_headers (file
, 1);
11666 /* Process one ELF object file according to the command line options.
11667 This file may actually be stored in an archive. The file is
11668 positioned at the start of the ELF object. */
11671 process_object (char *file_name
, FILE *file
)
11675 if (! get_file_header (file
))
11677 error (_("%s: Failed to read file header\n"), file_name
);
11681 /* Initialise per file variables. */
11682 for (i
= NUM_ELEM (version_info
); i
--;)
11683 version_info
[i
] = 0;
11685 for (i
= NUM_ELEM (dynamic_info
); i
--;)
11686 dynamic_info
[i
] = 0;
11688 /* Process the file. */
11690 printf (_("\nFile: %s\n"), file_name
);
11692 /* Initialise the dump_sects array from the cmdline_dump_sects array.
11693 Note we do this even if cmdline_dump_sects is empty because we
11694 must make sure that the dump_sets array is zeroed out before each
11695 object file is processed. */
11696 if (num_dump_sects
> num_cmdline_dump_sects
)
11697 memset (dump_sects
, 0, num_dump_sects
);
11699 if (num_cmdline_dump_sects
> 0)
11701 if (num_dump_sects
== 0)
11702 /* A sneaky way of allocating the dump_sects array. */
11703 request_dump (num_cmdline_dump_sects
, 0);
11705 assert (num_dump_sects
>= num_cmdline_dump_sects
);
11706 memcpy (dump_sects
, cmdline_dump_sects
, num_cmdline_dump_sects
);
11709 if (! process_file_header ())
11712 if (! process_section_headers (file
))
11714 /* Without loaded section headers we cannot process lots of
11716 do_unwind
= do_version
= do_dump
= do_arch
= 0;
11718 if (! do_using_dynamic
)
11719 do_syms
= do_reloc
= 0;
11722 if (! process_section_groups (file
))
11724 /* Without loaded section groups we cannot process unwind. */
11728 if (process_program_headers (file
))
11729 process_dynamic_section (file
);
11731 process_relocs (file
);
11733 process_unwind (file
);
11735 process_symbol_table (file
);
11737 process_syminfo (file
);
11739 process_version_sections (file
);
11741 process_section_contents (file
);
11743 process_notes (file
);
11745 process_gnu_liblist (file
);
11747 process_arch_specific (file
);
11749 if (program_headers
)
11751 free (program_headers
);
11752 program_headers
= NULL
;
11755 if (section_headers
)
11757 free (section_headers
);
11758 section_headers
= NULL
;
11763 free (string_table
);
11764 string_table
= NULL
;
11765 string_table_length
= 0;
11768 if (dynamic_strings
)
11770 free (dynamic_strings
);
11771 dynamic_strings
= NULL
;
11772 dynamic_strings_length
= 0;
11775 if (dynamic_symbols
)
11777 free (dynamic_symbols
);
11778 dynamic_symbols
= NULL
;
11779 num_dynamic_syms
= 0;
11782 if (dynamic_syminfo
)
11784 free (dynamic_syminfo
);
11785 dynamic_syminfo
= NULL
;
11788 if (section_headers_groups
)
11790 free (section_headers_groups
);
11791 section_headers_groups
= NULL
;
11794 if (section_groups
)
11796 struct group_list
*g
, *next
;
11798 for (i
= 0; i
< group_count
; i
++)
11800 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
11807 free (section_groups
);
11808 section_groups
= NULL
;
11811 if (debug_information
)
11813 for (i
= 0; i
< num_debug_info_entries
; i
++)
11815 if (!debug_information
[i
].max_loc_offsets
)
11817 free (debug_information
[i
].loc_offsets
);
11818 free (debug_information
[i
].have_frame_base
);
11820 if (!debug_information
[i
].max_range_lists
)
11821 free (debug_information
[i
].range_lists
);
11823 free (debug_information
);
11824 debug_information
= NULL
;
11825 num_debug_info_entries
= 0;
11831 /* Process an ELF archive. The file is positioned just after the
11835 process_archive (char *file_name
, FILE *file
)
11837 struct ar_hdr arhdr
;
11839 unsigned long size
;
11840 char *longnames
= NULL
;
11841 unsigned long longnames_size
= 0;
11842 size_t file_name_size
;
11847 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
11848 if (got
!= sizeof arhdr
)
11853 error (_("%s: failed to read archive header\n"), file_name
);
11857 if (memcmp (arhdr
.ar_name
, "/ ", 16) == 0)
11859 /* This is the archive symbol table. Skip it.
11860 FIXME: We should have an option to dump it. */
11861 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
11862 if (fseek (file
, size
+ (size
& 1), SEEK_CUR
) != 0)
11864 error (_("%s: failed to skip archive symbol table\n"), file_name
);
11868 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
11869 if (got
!= sizeof arhdr
)
11874 error (_("%s: failed to read archive header\n"), file_name
);
11879 if (memcmp (arhdr
.ar_name
, "// ", 16) == 0)
11881 /* This is the archive string table holding long member
11884 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
11886 longnames
= malloc (longnames_size
);
11887 if (longnames
== NULL
)
11889 error (_("Out of memory\n"));
11893 if (fread (longnames
, longnames_size
, 1, file
) != 1)
11896 error (_("%s: failed to read string table\n"), file_name
);
11900 if ((longnames_size
& 1) != 0)
11903 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
11904 if (got
!= sizeof arhdr
)
11911 error (_("%s: failed to read archive header\n"), file_name
);
11916 file_name_size
= strlen (file_name
);
11925 if (arhdr
.ar_name
[0] == '/')
11929 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
11930 if (off
>= longnames_size
)
11932 error (_("%s: invalid archive string table offset %lu\n"), off
);
11937 name
= longnames
+ off
;
11938 nameend
= memchr (name
, '/', longnames_size
- off
);
11942 name
= arhdr
.ar_name
;
11943 nameend
= memchr (name
, '/', 16);
11946 if (nameend
== NULL
)
11948 error (_("%s: bad archive file name\n"));
11953 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
11954 if (namealc
== NULL
)
11956 error (_("Out of memory\n"));
11961 memcpy (namealc
, file_name
, file_name_size
);
11962 namealc
[file_name_size
] = '(';
11963 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
11964 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
11965 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
11967 archive_file_offset
= ftell (file
);
11968 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
11970 ret
|= process_object (namealc
, file
);
11975 (archive_file_offset
11976 + archive_file_size
11977 + (archive_file_size
& 1)),
11980 error (_("%s: failed to seek to next archive header\n"), file_name
);
11985 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
11986 if (got
!= sizeof arhdr
)
11991 error (_("%s: failed to read archive header\n"), file_name
);
11997 if (longnames
!= 0)
12004 process_file (char *file_name
)
12007 struct stat statbuf
;
12008 char armag
[SARMAG
];
12011 if (stat (file_name
, &statbuf
) < 0)
12013 if (errno
== ENOENT
)
12014 error (_("'%s': No such file\n"), file_name
);
12016 error (_("Could not locate '%s'. System error message: %s\n"),
12017 file_name
, strerror (errno
));
12021 if (! S_ISREG (statbuf
.st_mode
))
12023 error (_("'%s' is not an ordinary file\n"), file_name
);
12027 file
= fopen (file_name
, "rb");
12030 error (_("Input file '%s' is not readable.\n"), file_name
);
12034 if (fread (armag
, SARMAG
, 1, file
) != 1)
12036 error (_("%s: Failed to read file header\n"), file_name
);
12041 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
12042 ret
= process_archive (file_name
, file
);
12046 archive_file_size
= archive_file_offset
= 0;
12047 ret
= process_object (file_name
, file
);
12055 #ifdef SUPPORT_DISASSEMBLY
12056 /* Needed by the i386 disassembler. For extra credit, someone could
12057 fix this so that we insert symbolic addresses here, esp for GOT/PLT
12061 print_address (unsigned int addr
, FILE *outfile
)
12063 fprintf (outfile
,"0x%8.8x", addr
);
12066 /* Needed by the i386 disassembler. */
12068 db_task_printsym (unsigned int addr
)
12070 print_address (addr
, stderr
);
12075 main (int argc
, char **argv
)
12079 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
12080 setlocale (LC_MESSAGES
, "");
12082 #if defined (HAVE_SETLOCALE)
12083 setlocale (LC_CTYPE
, "");
12085 bindtextdomain (PACKAGE
, LOCALEDIR
);
12086 textdomain (PACKAGE
);
12088 parse_args (argc
, argv
);
12090 if (num_dump_sects
> 0)
12092 /* Make a copy of the dump_sects array. */
12093 cmdline_dump_sects
= malloc (num_dump_sects
);
12094 if (cmdline_dump_sects
== NULL
)
12095 error (_("Out of memory allocating dump request table."));
12098 memcpy (cmdline_dump_sects
, dump_sects
, num_dump_sects
);
12099 num_cmdline_dump_sects
= num_dump_sects
;
12103 if (optind
< (argc
- 1))
12107 while (optind
< argc
)
12108 err
|= process_file (argv
[optind
++]);
12110 if (dump_sects
!= NULL
)
12112 if (cmdline_dump_sects
!= NULL
)
12113 free (cmdline_dump_sects
);