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)
9495 /* Check base address specifiers. */
9496 if (begin
== -1UL && end
!= -1UL)
9499 printf (" %8.8lx %8.8lx %8.8lx (base address)\n",
9500 offset
, begin
, end
);
9504 length
= byte_get (start
, 2);
9507 printf (" %8.8lx %8.8lx %8.8lx (",
9508 offset
, begin
+ base_address
, end
+ base_address
);
9509 need_frame_base
= decode_location_expression (start
,
9515 if (need_frame_base
&& !has_frame_base
)
9516 printf (_(" [without DW_AT_frame_base]"));
9519 fputs (_(" (start == end)"), stdout
);
9520 else if (begin
> end
)
9521 fputs (_(" (start > end)"), stdout
);
9528 fputs (_(" <End of list>\n"), stdout
);
9535 display_debug_str (Elf_Internal_Shdr
*section
,
9536 unsigned char *start
,
9537 FILE *file ATTRIBUTE_UNUSED
)
9539 unsigned long bytes
;
9542 addr
= section
->sh_addr
;
9543 bytes
= section
->sh_size
;
9547 printf (_("\nThe .debug_str section is empty.\n"));
9551 printf (_("Contents of the .debug_str section:\n\n"));
9559 lbytes
= (bytes
> 16 ? 16 : bytes
);
9561 printf (" 0x%8.8lx ", (unsigned long) addr
);
9563 for (j
= 0; j
< 16; j
++)
9566 printf ("%2.2x", start
[j
]);
9574 for (j
= 0; j
< lbytes
; j
++)
9577 if (k
>= ' ' && k
< 0x80)
9597 display_debug_info (Elf_Internal_Shdr
* section
,
9598 unsigned char * start
, FILE * file
)
9600 return process_debug_info (section
, start
, file
, 0);
9605 display_debug_aranges (Elf_Internal_Shdr
*section
,
9606 unsigned char *start
,
9607 FILE *file ATTRIBUTE_UNUSED
)
9609 unsigned char *end
= start
+ section
->sh_size
;
9611 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
9615 unsigned char *hdrptr
;
9616 DWARF2_Internal_ARange arange
;
9617 unsigned char *ranges
;
9618 unsigned long length
;
9619 unsigned long address
;
9622 int initial_length_size
;
9626 arange
.ar_length
= byte_get (hdrptr
, 4);
9629 if (arange
.ar_length
== 0xffffffff)
9631 arange
.ar_length
= byte_get (hdrptr
, 8);
9634 initial_length_size
= 12;
9639 initial_length_size
= 4;
9642 arange
.ar_version
= byte_get (hdrptr
, 2);
9645 arange
.ar_info_offset
= byte_get (hdrptr
, offset_size
);
9646 hdrptr
+= offset_size
;
9648 arange
.ar_pointer_size
= byte_get (hdrptr
, 1);
9651 arange
.ar_segment_size
= byte_get (hdrptr
, 1);
9654 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
9656 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
9660 printf (_(" Length: %ld\n"), arange
.ar_length
);
9661 printf (_(" Version: %d\n"), arange
.ar_version
);
9662 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
9663 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
9664 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
9666 printf (_("\n Address Length\n"));
9670 /* Must pad to an alignment boundary that is twice the pointer size. */
9671 excess
= (hdrptr
- start
) % (2 * arange
.ar_pointer_size
);
9673 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
9677 address
= byte_get (ranges
, arange
.ar_pointer_size
);
9679 ranges
+= arange
.ar_pointer_size
;
9681 length
= byte_get (ranges
, arange
.ar_pointer_size
);
9683 ranges
+= arange
.ar_pointer_size
;
9685 /* A pair of zeros marks the end of the list. */
9686 if (address
== 0 && length
== 0)
9689 printf (" %8.8lx %lu\n", address
, length
);
9692 start
+= arange
.ar_length
+ initial_length_size
;
9701 display_debug_ranges (Elf_Internal_Shdr
*section
,
9702 unsigned char *start
,
9703 FILE *file ATTRIBUTE_UNUSED
)
9705 unsigned char *section_end
;
9706 unsigned long bytes
;
9707 unsigned char *section_begin
= start
;
9708 unsigned int num_range_list
= 0;
9709 unsigned long last_offset
= 0;
9710 unsigned int first
= 0;
9713 int seen_first_offset
= 0;
9714 int use_debug_info
= 1;
9715 unsigned char *next
;
9717 bytes
= section
->sh_size
;
9718 section_end
= start
+ bytes
;
9722 printf (_("\nThe .debug_ranges section is empty.\n"));
9726 get_debug_info (file
);
9728 /* Check the order of range list in .debug_info section. If
9729 offsets of range lists are in the ascending order, we can
9730 use `debug_information' directly. */
9731 for (i
= 0; i
< num_debug_info_entries
; i
++)
9735 num
= debug_information
[i
].num_range_lists
;
9736 num_range_list
+= num
;
9738 /* Check if we can use `debug_information' directly. */
9739 if (use_debug_info
&& num
!= 0)
9741 if (!seen_first_offset
)
9743 /* This is the first range list. */
9744 last_offset
= debug_information
[i
].range_lists
[0];
9746 seen_first_offset
= 1;
9752 for (; j
< num
; j
++)
9755 debug_information
[i
].range_lists
[j
])
9760 last_offset
= debug_information
[i
].range_lists
[j
];
9765 if (!use_debug_info
)
9766 /* FIXME: Should we handle this case? */
9767 error (_("Range lists in .debug_info section aren't in ascending order!\n"));
9769 if (!seen_first_offset
)
9770 error (_("No range lists in .debug_info section!\n"));
9772 if (debug_information
[first
].range_lists
[0] != 0)
9773 warn (_("Range lists in .debug_ranges section start at 0x%lx\n"),
9774 debug_information
[first
].range_lists
[0]);
9776 printf (_("Contents of the .debug_ranges section:\n\n"));
9777 printf (_(" Offset Begin End\n"));
9779 seen_first_offset
= 0;
9780 for (i
= first
; i
< num_debug_info_entries
; i
++)
9782 unsigned long begin
;
9784 unsigned long offset
;
9785 unsigned int pointer_size
;
9786 unsigned long base_address
;
9788 pointer_size
= debug_information
[i
].pointer_size
;
9790 for (j
= 0; j
< debug_information
[i
].num_range_lists
; j
++)
9792 offset
= debug_information
[i
].range_lists
[j
];
9793 next
= section_begin
+ offset
;
9794 base_address
= debug_information
[i
].base_address
;
9796 if (!seen_first_offset
)
9797 seen_first_offset
= 1;
9801 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_ranges section.\n"),
9802 start
- section_begin
, next
- section_begin
);
9803 else if (start
> next
)
9804 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_ranges section.\n"),
9805 start
- section_begin
, next
- section_begin
);
9811 begin
= byte_get (start
, pointer_size
);
9812 start
+= pointer_size
;
9813 end
= byte_get (start
, pointer_size
);
9814 start
+= pointer_size
;
9816 if (begin
== 0 && end
== 0)
9819 /* Check base address specifiers. */
9820 if (begin
== -1UL && end
!= -1UL)
9823 printf (" %8.8lx %8.8lx %8.8lx (base address)\n",
9824 offset
, begin
, end
);
9828 printf (" %8.8lx %8.8lx %8.8lx",
9829 offset
, begin
+ base_address
, end
+ base_address
);
9832 fputs (_(" (start == end)"), stdout
);
9833 else if (begin
> end
)
9834 fputs (_(" (start > end)"), stdout
);
9838 fputs (_(" <End of list>\n"), stdout
);
9845 typedef struct Frame_Chunk
9847 struct Frame_Chunk
*next
;
9848 unsigned char *chunk_start
;
9850 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
9851 short int *col_type
;
9854 unsigned int code_factor
;
9856 unsigned long pc_begin
;
9857 unsigned long pc_range
;
9861 unsigned char fde_encoding
;
9862 unsigned char cfa_exp
;
9866 /* A marker for a col_type that means this column was never referenced
9867 in the frame info. */
9868 #define DW_CFA_unreferenced (-1)
9871 frame_need_space (Frame_Chunk
*fc
, int reg
)
9873 int prev
= fc
->ncols
;
9875 if (reg
< fc
->ncols
)
9878 fc
->ncols
= reg
+ 1;
9879 fc
->col_type
= xrealloc (fc
->col_type
, fc
->ncols
* sizeof (short int));
9880 fc
->col_offset
= xrealloc (fc
->col_offset
, fc
->ncols
* sizeof (int));
9882 while (prev
< fc
->ncols
)
9884 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
9885 fc
->col_offset
[prev
] = 0;
9891 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, int *max_regs
)
9896 if (*max_regs
< fc
->ncols
)
9897 *max_regs
= fc
->ncols
;
9899 if (*need_col_headers
)
9901 *need_col_headers
= 0;
9903 printf (" LOC CFA ");
9905 for (r
= 0; r
< *max_regs
; r
++)
9906 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
9911 printf ("r%-4d", r
);
9917 printf ("%08lx ", fc
->pc_begin
);
9919 strcpy (tmp
, "exp");
9921 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
9922 printf ("%-8s ", tmp
);
9924 for (r
= 0; r
< fc
->ncols
; r
++)
9926 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
9928 switch (fc
->col_type
[r
])
9930 case DW_CFA_undefined
:
9933 case DW_CFA_same_value
:
9937 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
9939 case DW_CFA_register
:
9940 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
9942 case DW_CFA_expression
:
9943 strcpy (tmp
, "exp");
9946 strcpy (tmp
, "n/a");
9949 printf ("%-5s", tmp
);
9956 size_of_encoded_value (int encoding
)
9958 switch (encoding
& 0x7)
9961 case 0: return eh_addr_size
;
9969 get_encoded_value (unsigned char *data
, int encoding
)
9971 int size
= size_of_encoded_value (encoding
);
9972 if (encoding
& DW_EH_PE_signed
)
9973 return byte_get_signed (data
, size
);
9975 return byte_get (data
, size
);
9978 #define GET(N) byte_get (start, N); start += N
9979 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
9980 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
9983 display_debug_frames (Elf_Internal_Shdr
*section
,
9984 unsigned char *start
,
9985 FILE *file ATTRIBUTE_UNUSED
)
9987 unsigned char *end
= start
+ section
->sh_size
;
9988 unsigned char *section_start
= start
;
9989 Frame_Chunk
*chunks
= 0;
9990 Frame_Chunk
*remembered_state
= 0;
9992 int is_eh
= streq (SECTION_NAME (section
), ".eh_frame");
9996 printf (_("The section %s contains:\n"), SECTION_NAME (section
));
10000 unsigned char *saved_start
;
10001 unsigned char *block_end
;
10002 unsigned long length
;
10003 unsigned long cie_id
;
10006 int need_col_headers
= 1;
10007 unsigned char *augmentation_data
= NULL
;
10008 unsigned long augmentation_data_len
= 0;
10009 int encoded_ptr_size
= eh_addr_size
;
10011 int initial_length_size
;
10013 saved_start
= start
;
10014 length
= byte_get (start
, 4); start
+= 4;
10018 printf ("\n%08lx ZERO terminator\n\n",
10019 (unsigned long)(saved_start
- section_start
));
10023 if (length
== 0xffffffff)
10025 length
= byte_get (start
, 8);
10028 initial_length_size
= 12;
10033 initial_length_size
= 4;
10036 block_end
= saved_start
+ length
+ initial_length_size
;
10037 cie_id
= byte_get (start
, offset_size
); start
+= offset_size
;
10039 if (elf_header
.e_type
== ET_REL
10040 && !debug_apply_rela_addends (file
, section
, offset_size
,
10041 section_start
, start
, block_end
))
10044 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
10048 fc
= xmalloc (sizeof (Frame_Chunk
));
10049 memset (fc
, 0, sizeof (Frame_Chunk
));
10053 fc
->chunk_start
= saved_start
;
10055 fc
->col_type
= xmalloc (sizeof (short int));
10056 fc
->col_offset
= xmalloc (sizeof (int));
10057 frame_need_space (fc
, max_regs
-1);
10059 version
= *start
++;
10061 fc
->augmentation
= start
;
10062 start
= strchr (start
, '\0') + 1;
10064 if (fc
->augmentation
[0] == 'z')
10066 fc
->code_factor
= LEB ();
10067 fc
->data_factor
= SLEB ();
10076 augmentation_data_len
= LEB ();
10077 augmentation_data
= start
;
10078 start
+= augmentation_data_len
;
10080 else if (streq (fc
->augmentation
, "eh"))
10082 start
+= eh_addr_size
;
10083 fc
->code_factor
= LEB ();
10084 fc
->data_factor
= SLEB ();
10096 fc
->code_factor
= LEB ();
10097 fc
->data_factor
= SLEB ();
10109 if (do_debug_frames_interp
)
10110 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
10111 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
10112 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
10116 printf ("\n%08lx %08lx %08lx CIE\n",
10117 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
10118 printf (" Version: %d\n", version
);
10119 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
10120 printf (" Code alignment factor: %u\n", fc
->code_factor
);
10121 printf (" Data alignment factor: %d\n", fc
->data_factor
);
10122 printf (" Return address column: %d\n", fc
->ra
);
10124 if (augmentation_data_len
)
10127 printf (" Augmentation data: ");
10128 for (i
= 0; i
< augmentation_data_len
; ++i
)
10129 printf (" %02x", augmentation_data
[i
]);
10135 if (augmentation_data_len
)
10137 unsigned char *p
, *q
;
10138 p
= fc
->augmentation
+ 1;
10139 q
= augmentation_data
;
10145 else if (*p
== 'P')
10146 q
+= 1 + size_of_encoded_value (*q
);
10147 else if (*p
== 'R')
10148 fc
->fde_encoding
= *q
++;
10154 if (fc
->fde_encoding
)
10155 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
10158 frame_need_space (fc
, fc
->ra
);
10162 unsigned char *look_for
;
10163 static Frame_Chunk fde_fc
;
10166 memset (fc
, 0, sizeof (Frame_Chunk
));
10168 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
10170 for (cie
= chunks
; cie
; cie
= cie
->next
)
10171 if (cie
->chunk_start
== look_for
)
10176 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
10177 cie_id
, saved_start
);
10180 fc
->col_type
= xmalloc (sizeof (short int));
10181 fc
->col_offset
= xmalloc (sizeof (int));
10182 frame_need_space (fc
, max_regs
- 1);
10184 fc
->augmentation
= "";
10185 fc
->fde_encoding
= 0;
10189 fc
->ncols
= cie
->ncols
;
10190 fc
->col_type
= xmalloc (fc
->ncols
* sizeof (short int));
10191 fc
->col_offset
= xmalloc (fc
->ncols
* sizeof (int));
10192 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
10193 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
10194 fc
->augmentation
= cie
->augmentation
;
10195 fc
->code_factor
= cie
->code_factor
;
10196 fc
->data_factor
= cie
->data_factor
;
10197 fc
->cfa_reg
= cie
->cfa_reg
;
10198 fc
->cfa_offset
= cie
->cfa_offset
;
10200 frame_need_space (fc
, max_regs
-1);
10201 fc
->fde_encoding
= cie
->fde_encoding
;
10204 if (fc
->fde_encoding
)
10205 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
10207 fc
->pc_begin
= get_encoded_value (start
, fc
->fde_encoding
);
10208 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
10209 /* Don't adjust for ET_REL since there's invariably a pcrel
10210 reloc here, which we haven't applied. */
10211 && elf_header
.e_type
!= ET_REL
)
10212 fc
->pc_begin
+= section
->sh_addr
+ (start
- section_start
);
10213 start
+= encoded_ptr_size
;
10214 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
10215 start
+= encoded_ptr_size
;
10217 if (cie
->augmentation
[0] == 'z')
10219 augmentation_data_len
= LEB ();
10220 augmentation_data
= start
;
10221 start
+= augmentation_data_len
;
10224 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
10225 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
10226 (unsigned long)(cie
->chunk_start
- section_start
),
10227 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
10228 if (! do_debug_frames_interp
&& augmentation_data_len
)
10232 printf (" Augmentation data: ");
10233 for (i
= 0; i
< augmentation_data_len
; ++i
)
10234 printf (" %02x", augmentation_data
[i
]);
10240 /* At this point, fc is the current chunk, cie (if any) is set, and
10241 we're about to interpret instructions for the chunk. */
10242 /* ??? At present we need to do this always, since this sizes the
10243 fc->col_type and fc->col_offset arrays, which we write into always.
10244 We should probably split the interpreted and non-interpreted bits
10245 into two different routines, since there's so much that doesn't
10246 really overlap between them. */
10247 if (1 || do_debug_frames_interp
)
10249 /* Start by making a pass over the chunk, allocating storage
10250 and taking note of what registers are used. */
10251 unsigned char *tmp
= start
;
10253 while (start
< block_end
)
10256 unsigned long reg
, tmp
;
10263 /* Warning: if you add any more cases to this switch, be
10264 sure to add them to the corresponding switch below. */
10267 case DW_CFA_advance_loc
:
10269 case DW_CFA_offset
:
10271 frame_need_space (fc
, opa
);
10272 fc
->col_type
[opa
] = DW_CFA_undefined
;
10274 case DW_CFA_restore
:
10275 frame_need_space (fc
, opa
);
10276 fc
->col_type
[opa
] = DW_CFA_undefined
;
10278 case DW_CFA_set_loc
:
10279 start
+= encoded_ptr_size
;
10281 case DW_CFA_advance_loc1
:
10284 case DW_CFA_advance_loc2
:
10287 case DW_CFA_advance_loc4
:
10290 case DW_CFA_offset_extended
:
10291 reg
= LEB (); LEB ();
10292 frame_need_space (fc
, reg
);
10293 fc
->col_type
[reg
] = DW_CFA_undefined
;
10295 case DW_CFA_restore_extended
:
10297 frame_need_space (fc
, reg
);
10298 fc
->col_type
[reg
] = DW_CFA_undefined
;
10300 case DW_CFA_undefined
:
10302 frame_need_space (fc
, reg
);
10303 fc
->col_type
[reg
] = DW_CFA_undefined
;
10305 case DW_CFA_same_value
:
10307 frame_need_space (fc
, reg
);
10308 fc
->col_type
[reg
] = DW_CFA_undefined
;
10310 case DW_CFA_register
:
10311 reg
= LEB (); LEB ();
10312 frame_need_space (fc
, reg
);
10313 fc
->col_type
[reg
] = DW_CFA_undefined
;
10315 case DW_CFA_def_cfa
:
10318 case DW_CFA_def_cfa_register
:
10321 case DW_CFA_def_cfa_offset
:
10324 case DW_CFA_def_cfa_expression
:
10328 case DW_CFA_expression
:
10332 frame_need_space (fc
, reg
);
10333 fc
->col_type
[reg
] = DW_CFA_undefined
;
10335 case DW_CFA_offset_extended_sf
:
10336 reg
= LEB (); SLEB ();
10337 frame_need_space (fc
, reg
);
10338 fc
->col_type
[reg
] = DW_CFA_undefined
;
10340 case DW_CFA_def_cfa_sf
:
10343 case DW_CFA_def_cfa_offset_sf
:
10346 case DW_CFA_MIPS_advance_loc8
:
10349 case DW_CFA_GNU_args_size
:
10352 case DW_CFA_GNU_negative_offset_extended
:
10353 reg
= LEB (); LEB ();
10354 frame_need_space (fc
, reg
);
10355 fc
->col_type
[reg
] = DW_CFA_undefined
;
10364 /* Now we know what registers are used, make a second pass over
10365 the chunk, this time actually printing out the info. */
10367 while (start
< block_end
)
10370 unsigned long ul
, reg
, roffs
;
10379 /* Warning: if you add any more cases to this switch, be
10380 sure to add them to the corresponding switch above. */
10383 case DW_CFA_advance_loc
:
10384 if (do_debug_frames_interp
)
10385 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10387 printf (" DW_CFA_advance_loc: %d to %08lx\n",
10388 opa
* fc
->code_factor
,
10389 fc
->pc_begin
+ opa
* fc
->code_factor
);
10390 fc
->pc_begin
+= opa
* fc
->code_factor
;
10393 case DW_CFA_offset
:
10395 if (! do_debug_frames_interp
)
10396 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
10397 opa
, roffs
* fc
->data_factor
);
10398 fc
->col_type
[opa
] = DW_CFA_offset
;
10399 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
10402 case DW_CFA_restore
:
10403 if (! do_debug_frames_interp
)
10404 printf (" DW_CFA_restore: r%d\n", opa
);
10405 fc
->col_type
[opa
] = cie
->col_type
[opa
];
10406 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
10409 case DW_CFA_set_loc
:
10410 vma
= get_encoded_value (start
, fc
->fde_encoding
);
10411 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
10412 && elf_header
.e_type
!= ET_REL
)
10413 vma
+= section
->sh_addr
+ (start
- section_start
);
10414 start
+= encoded_ptr_size
;
10415 if (do_debug_frames_interp
)
10416 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10418 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
10419 fc
->pc_begin
= vma
;
10422 case DW_CFA_advance_loc1
:
10423 ofs
= byte_get (start
, 1); start
+= 1;
10424 if (do_debug_frames_interp
)
10425 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10427 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
10428 ofs
* fc
->code_factor
,
10429 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10430 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10433 case DW_CFA_advance_loc2
:
10434 ofs
= byte_get (start
, 2); start
+= 2;
10435 if (do_debug_frames_interp
)
10436 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10438 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
10439 ofs
* fc
->code_factor
,
10440 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10441 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10444 case DW_CFA_advance_loc4
:
10445 ofs
= byte_get (start
, 4); start
+= 4;
10446 if (do_debug_frames_interp
)
10447 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10449 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
10450 ofs
* fc
->code_factor
,
10451 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10452 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10455 case DW_CFA_offset_extended
:
10458 if (! do_debug_frames_interp
)
10459 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
10460 reg
, roffs
* fc
->data_factor
);
10461 fc
->col_type
[reg
] = DW_CFA_offset
;
10462 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
10465 case DW_CFA_restore_extended
:
10467 if (! do_debug_frames_interp
)
10468 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
10469 fc
->col_type
[reg
] = cie
->col_type
[reg
];
10470 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
10473 case DW_CFA_undefined
:
10475 if (! do_debug_frames_interp
)
10476 printf (" DW_CFA_undefined: r%ld\n", reg
);
10477 fc
->col_type
[reg
] = DW_CFA_undefined
;
10478 fc
->col_offset
[reg
] = 0;
10481 case DW_CFA_same_value
:
10483 if (! do_debug_frames_interp
)
10484 printf (" DW_CFA_same_value: r%ld\n", reg
);
10485 fc
->col_type
[reg
] = DW_CFA_same_value
;
10486 fc
->col_offset
[reg
] = 0;
10489 case DW_CFA_register
:
10492 if (! do_debug_frames_interp
)
10493 printf (" DW_CFA_register: r%ld in r%ld\n", reg
, roffs
);
10494 fc
->col_type
[reg
] = DW_CFA_register
;
10495 fc
->col_offset
[reg
] = roffs
;
10498 case DW_CFA_remember_state
:
10499 if (! do_debug_frames_interp
)
10500 printf (" DW_CFA_remember_state\n");
10501 rs
= xmalloc (sizeof (Frame_Chunk
));
10502 rs
->ncols
= fc
->ncols
;
10503 rs
->col_type
= xmalloc (rs
->ncols
* sizeof (short int));
10504 rs
->col_offset
= xmalloc (rs
->ncols
* sizeof (int));
10505 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
10506 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
10507 rs
->next
= remembered_state
;
10508 remembered_state
= rs
;
10511 case DW_CFA_restore_state
:
10512 if (! do_debug_frames_interp
)
10513 printf (" DW_CFA_restore_state\n");
10514 rs
= remembered_state
;
10517 remembered_state
= rs
->next
;
10518 frame_need_space (fc
, rs
->ncols
-1);
10519 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
10520 memcpy (fc
->col_offset
, rs
->col_offset
,
10521 rs
->ncols
* sizeof (int));
10522 free (rs
->col_type
);
10523 free (rs
->col_offset
);
10526 else if (do_debug_frames_interp
)
10527 printf ("Mismatched DW_CFA_restore_state\n");
10530 case DW_CFA_def_cfa
:
10531 fc
->cfa_reg
= LEB ();
10532 fc
->cfa_offset
= LEB ();
10534 if (! do_debug_frames_interp
)
10535 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
10536 fc
->cfa_reg
, fc
->cfa_offset
);
10539 case DW_CFA_def_cfa_register
:
10540 fc
->cfa_reg
= LEB ();
10542 if (! do_debug_frames_interp
)
10543 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
10546 case DW_CFA_def_cfa_offset
:
10547 fc
->cfa_offset
= LEB ();
10548 if (! do_debug_frames_interp
)
10549 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
10553 if (! do_debug_frames_interp
)
10554 printf (" DW_CFA_nop\n");
10557 case DW_CFA_def_cfa_expression
:
10559 if (! do_debug_frames_interp
)
10561 printf (" DW_CFA_def_cfa_expression (");
10562 decode_location_expression (start
, eh_addr_size
, ul
, 0);
10569 case DW_CFA_expression
:
10572 if (! do_debug_frames_interp
)
10574 printf (" DW_CFA_expression: r%ld (", reg
);
10575 decode_location_expression (start
, eh_addr_size
, ul
, 0);
10578 fc
->col_type
[reg
] = DW_CFA_expression
;
10582 case DW_CFA_offset_extended_sf
:
10585 frame_need_space (fc
, reg
);
10586 if (! do_debug_frames_interp
)
10587 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
10588 reg
, l
* fc
->data_factor
);
10589 fc
->col_type
[reg
] = DW_CFA_offset
;
10590 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
10593 case DW_CFA_def_cfa_sf
:
10594 fc
->cfa_reg
= LEB ();
10595 fc
->cfa_offset
= SLEB ();
10597 if (! do_debug_frames_interp
)
10598 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
10599 fc
->cfa_reg
, fc
->cfa_offset
);
10602 case DW_CFA_def_cfa_offset_sf
:
10603 fc
->cfa_offset
= SLEB ();
10604 if (! do_debug_frames_interp
)
10605 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
10608 case DW_CFA_MIPS_advance_loc8
:
10609 ofs
= byte_get (start
, 8); start
+= 8;
10610 if (do_debug_frames_interp
)
10611 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10613 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
10614 ofs
* fc
->code_factor
,
10615 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10616 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10619 case DW_CFA_GNU_window_save
:
10620 if (! do_debug_frames_interp
)
10621 printf (" DW_CFA_GNU_window_save\n");
10624 case DW_CFA_GNU_args_size
:
10626 if (! do_debug_frames_interp
)
10627 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
10630 case DW_CFA_GNU_negative_offset_extended
:
10633 frame_need_space (fc
, reg
);
10634 if (! do_debug_frames_interp
)
10635 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
10636 reg
, l
* fc
->data_factor
);
10637 fc
->col_type
[reg
] = DW_CFA_offset
;
10638 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
10642 warn (_("unsupported or unknown DW_CFA_%d\n"), op
);
10647 if (do_debug_frames_interp
)
10648 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10663 display_debug_not_supported (Elf_Internal_Shdr
*section
,
10664 unsigned char *start ATTRIBUTE_UNUSED
,
10665 FILE *file ATTRIBUTE_UNUSED
)
10667 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
10668 SECTION_NAME (section
));
10673 /* A structure containing the name of a debug section
10674 and a pointer to a function that can decode it. */
10677 const char *const name
;
10678 int (*display
) (Elf_Internal_Shdr
*, unsigned char *, FILE *);
10682 { ".debug_abbrev", display_debug_abbrev
},
10683 { ".debug_aranges", display_debug_aranges
},
10684 { ".debug_frame", display_debug_frames
},
10685 { ".debug_info", display_debug_info
},
10686 { ".debug_line", display_debug_lines
},
10687 { ".debug_pubnames", display_debug_pubnames
},
10688 { ".eh_frame", display_debug_frames
},
10689 { ".debug_macinfo", display_debug_macinfo
},
10690 { ".debug_str", display_debug_str
},
10691 { ".debug_loc", display_debug_loc
},
10692 { ".debug_pubtypes", display_debug_pubnames
},
10693 { ".debug_ranges", display_debug_ranges
},
10694 { ".debug_static_func", display_debug_not_supported
},
10695 { ".debug_static_vars", display_debug_not_supported
},
10696 { ".debug_types", display_debug_not_supported
},
10697 { ".debug_weaknames", display_debug_not_supported
}
10701 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
10703 char *name
= SECTION_NAME (section
);
10704 bfd_size_type length
;
10708 length
= section
->sh_size
;
10711 printf (_("\nSection '%s' has no debugging data.\n"), name
);
10715 if (strneq (name
, ".gnu.linkonce.wi.", 17))
10716 name
= ".debug_info";
10718 /* See if we know how to display the contents of this section. */
10719 for (i
= NUM_ELEM (debug_displays
); i
--;)
10720 if (streq (debug_displays
[i
].name
, name
))
10722 unsigned char *start
;
10724 start
= get_data (NULL
, file
, section
->sh_offset
, length
,
10725 _("debug section data"));
10732 result
&= debug_displays
[i
].display (section
, start
, file
);
10735 /* If we loaded in the abbrev section
10736 at some point, we must release it here. */
10744 printf (_("Unrecognized debug section: %s\n"), name
);
10752 process_section_contents (FILE *file
)
10754 Elf_Internal_Shdr
*section
;
10760 for (i
= 0, section
= section_headers
;
10761 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
10764 #ifdef SUPPORT_DISASSEMBLY
10765 if (dump_sects
[i
] & DISASS_DUMP
)
10766 disassemble_section (section
, file
);
10768 if (dump_sects
[i
] & HEX_DUMP
)
10769 dump_section (section
, file
);
10771 if (dump_sects
[i
] & DEBUG_DUMP
)
10772 display_debug_section (section
, file
);
10775 /* Check to see if the user requested a
10776 dump of a section that does not exist. */
10777 while (i
++ < num_dump_sects
)
10779 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
10783 process_mips_fpe_exception (int mask
)
10788 if (mask
& OEX_FPU_INEX
)
10789 fputs ("INEX", stdout
), first
= 0;
10790 if (mask
& OEX_FPU_UFLO
)
10791 printf ("%sUFLO", first
? "" : "|"), first
= 0;
10792 if (mask
& OEX_FPU_OFLO
)
10793 printf ("%sOFLO", first
? "" : "|"), first
= 0;
10794 if (mask
& OEX_FPU_DIV0
)
10795 printf ("%sDIV0", first
? "" : "|"), first
= 0;
10796 if (mask
& OEX_FPU_INVAL
)
10797 printf ("%sINVAL", first
? "" : "|");
10800 fputs ("0", stdout
);
10804 process_mips_specific (FILE *file
)
10806 Elf_Internal_Dyn
*entry
;
10807 size_t liblist_offset
= 0;
10808 size_t liblistno
= 0;
10809 size_t conflictsno
= 0;
10810 size_t options_offset
= 0;
10811 size_t conflicts_offset
= 0;
10813 /* We have a lot of special sections. Thanks SGI! */
10814 if (dynamic_section
== NULL
)
10815 /* No information available. */
10818 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
10819 switch (entry
->d_tag
)
10821 case DT_MIPS_LIBLIST
:
10823 = offset_from_vma (file
, entry
->d_un
.d_val
,
10824 liblistno
* sizeof (Elf32_External_Lib
));
10826 case DT_MIPS_LIBLISTNO
:
10827 liblistno
= entry
->d_un
.d_val
;
10829 case DT_MIPS_OPTIONS
:
10830 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
10832 case DT_MIPS_CONFLICT
:
10834 = offset_from_vma (file
, entry
->d_un
.d_val
,
10835 conflictsno
* sizeof (Elf32_External_Conflict
));
10837 case DT_MIPS_CONFLICTNO
:
10838 conflictsno
= entry
->d_un
.d_val
;
10844 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
10846 Elf32_External_Lib
*elib
;
10849 elib
= get_data (NULL
, file
, liblist_offset
,
10850 liblistno
* sizeof (Elf32_External_Lib
),
10854 printf ("\nSection '.liblist' contains %lu entries:\n",
10855 (unsigned long) liblistno
);
10856 fputs (" Library Time Stamp Checksum Version Flags\n",
10859 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
10866 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
10867 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
10868 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
10869 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
10870 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
10872 tmp
= gmtime (&time
);
10873 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
10874 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10875 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10877 printf ("%3lu: ", (unsigned long) cnt
);
10878 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
10879 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
10881 printf ("<corrupt: %9ld>", liblist
.l_name
);
10882 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
10883 liblist
.l_version
);
10885 if (liblist
.l_flags
== 0)
10889 static const struct
10896 { " EXACT_MATCH", LL_EXACT_MATCH
},
10897 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
10898 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
10899 { " EXPORTS", LL_EXPORTS
},
10900 { " DELAY_LOAD", LL_DELAY_LOAD
},
10901 { " DELTA", LL_DELTA
}
10903 int flags
= liblist
.l_flags
;
10907 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
10909 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
10911 fputs (l_flags_vals
[fcnt
].name
, stdout
);
10912 flags
^= l_flags_vals
[fcnt
].bit
;
10915 printf (" %#x", (unsigned int) flags
);
10925 if (options_offset
!= 0)
10927 Elf_External_Options
*eopt
;
10928 Elf_Internal_Shdr
*sect
= section_headers
;
10929 Elf_Internal_Options
*iopt
;
10930 Elf_Internal_Options
*option
;
10934 /* Find the section header so that we get the size. */
10935 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
10938 eopt
= get_data (NULL
, file
, options_offset
, sect
->sh_size
,
10942 iopt
= malloc ((sect
->sh_size
/ sizeof (eopt
)) * sizeof (*iopt
));
10945 error (_("Out of memory"));
10952 while (offset
< sect
->sh_size
)
10954 Elf_External_Options
*eoption
;
10956 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
10958 option
->kind
= BYTE_GET (eoption
->kind
);
10959 option
->size
= BYTE_GET (eoption
->size
);
10960 option
->section
= BYTE_GET (eoption
->section
);
10961 option
->info
= BYTE_GET (eoption
->info
);
10963 offset
+= option
->size
;
10969 printf (_("\nSection '%s' contains %d entries:\n"),
10970 SECTION_NAME (sect
), cnt
);
10978 switch (option
->kind
)
10981 /* This shouldn't happen. */
10982 printf (" NULL %d %lx", option
->section
, option
->info
);
10985 printf (" REGINFO ");
10986 if (elf_header
.e_machine
== EM_MIPS
)
10989 Elf32_External_RegInfo
*ereg
;
10990 Elf32_RegInfo reginfo
;
10992 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
10993 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
10994 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
10995 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
10996 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
10997 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
10998 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
11000 printf ("GPR %08lx GP 0x%lx\n",
11001 reginfo
.ri_gprmask
,
11002 (unsigned long) reginfo
.ri_gp_value
);
11003 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11004 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11005 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11010 Elf64_External_RegInfo
*ereg
;
11011 Elf64_Internal_RegInfo reginfo
;
11013 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
11014 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
11015 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
11016 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
11017 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
11018 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
11019 reginfo
.ri_gp_value
= BYTE_GET8 (ereg
->ri_gp_value
);
11021 printf ("GPR %08lx GP 0x",
11022 reginfo
.ri_gprmask
);
11023 printf_vma (reginfo
.ri_gp_value
);
11026 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11027 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11028 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11032 case ODK_EXCEPTIONS
:
11033 fputs (" EXCEPTIONS fpe_min(", stdout
);
11034 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
11035 fputs (") fpe_max(", stdout
);
11036 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
11037 fputs (")", stdout
);
11039 if (option
->info
& OEX_PAGE0
)
11040 fputs (" PAGE0", stdout
);
11041 if (option
->info
& OEX_SMM
)
11042 fputs (" SMM", stdout
);
11043 if (option
->info
& OEX_FPDBUG
)
11044 fputs (" FPDBUG", stdout
);
11045 if (option
->info
& OEX_DISMISS
)
11046 fputs (" DISMISS", stdout
);
11049 fputs (" PAD ", stdout
);
11050 if (option
->info
& OPAD_PREFIX
)
11051 fputs (" PREFIX", stdout
);
11052 if (option
->info
& OPAD_POSTFIX
)
11053 fputs (" POSTFIX", stdout
);
11054 if (option
->info
& OPAD_SYMBOL
)
11055 fputs (" SYMBOL", stdout
);
11058 fputs (" HWPATCH ", stdout
);
11059 if (option
->info
& OHW_R4KEOP
)
11060 fputs (" R4KEOP", stdout
);
11061 if (option
->info
& OHW_R8KPFETCH
)
11062 fputs (" R8KPFETCH", stdout
);
11063 if (option
->info
& OHW_R5KEOP
)
11064 fputs (" R5KEOP", stdout
);
11065 if (option
->info
& OHW_R5KCVTL
)
11066 fputs (" R5KCVTL", stdout
);
11069 fputs (" FILL ", stdout
);
11070 /* XXX Print content of info word? */
11073 fputs (" TAGS ", stdout
);
11074 /* XXX Print content of info word? */
11077 fputs (" HWAND ", stdout
);
11078 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11079 fputs (" R4KEOP_CHECKED", stdout
);
11080 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11081 fputs (" R4KEOP_CLEAN", stdout
);
11084 fputs (" HWOR ", stdout
);
11085 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11086 fputs (" R4KEOP_CHECKED", stdout
);
11087 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11088 fputs (" R4KEOP_CLEAN", stdout
);
11091 printf (" GP_GROUP %#06lx self-contained %#06lx",
11092 option
->info
& OGP_GROUP
,
11093 (option
->info
& OGP_SELF
) >> 16);
11096 printf (" IDENT %#06lx self-contained %#06lx",
11097 option
->info
& OGP_GROUP
,
11098 (option
->info
& OGP_SELF
) >> 16);
11101 /* This shouldn't happen. */
11102 printf (" %3d ??? %d %lx",
11103 option
->kind
, option
->section
, option
->info
);
11107 len
= sizeof (*eopt
);
11108 while (len
< option
->size
)
11109 if (((char *) option
)[len
] >= ' '
11110 && ((char *) option
)[len
] < 0x7f)
11111 printf ("%c", ((char *) option
)[len
++]);
11113 printf ("\\%03o", ((char *) option
)[len
++]);
11115 fputs ("\n", stdout
);
11123 if (conflicts_offset
!= 0 && conflictsno
!= 0)
11125 Elf32_Conflict
*iconf
;
11128 if (dynamic_symbols
== NULL
)
11130 error (_("conflict list found without a dynamic symbol table"));
11134 iconf
= malloc (conflictsno
* sizeof (*iconf
));
11137 error (_("Out of memory"));
11143 Elf32_External_Conflict
*econf32
;
11145 econf32
= get_data (NULL
, file
, conflicts_offset
,
11146 conflictsno
* sizeof (*econf32
), _("conflict"));
11150 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11151 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
11157 Elf64_External_Conflict
*econf64
;
11159 econf64
= get_data (NULL
, file
, conflicts_offset
,
11160 conflictsno
* sizeof (*econf64
), _("conflict"));
11164 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11165 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
11170 printf (_("\nSection '.conflict' contains %lu entries:\n"),
11171 (unsigned long) conflictsno
);
11172 puts (_(" Num: Index Value Name"));
11174 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11176 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
11178 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
11179 print_vma (psym
->st_value
, FULL_HEX
);
11181 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11182 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11184 printf ("<corrupt: %14ld>", psym
->st_name
);
11195 process_gnu_liblist (FILE *file
)
11197 Elf_Internal_Shdr
*section
, *string_sec
;
11198 Elf32_External_Lib
*elib
;
11206 for (i
= 0, section
= section_headers
;
11207 i
< elf_header
.e_shnum
;
11210 switch (section
->sh_type
)
11212 case SHT_GNU_LIBLIST
:
11213 elib
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
11218 string_sec
= SECTION_HEADER (section
->sh_link
);
11220 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
11221 string_sec
->sh_size
, _("liblist string table"));
11224 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
11230 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
11231 SECTION_NAME (section
),
11232 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
11234 puts (" Library Time Stamp Checksum Version Flags");
11236 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
11244 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
11245 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
11246 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
11247 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
11248 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
11250 tmp
= gmtime (&time
);
11251 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
11252 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11253 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11255 printf ("%3lu: ", (unsigned long) cnt
);
11257 printf ("%-20s", strtab
+ liblist
.l_name
);
11259 printf ("%-20.20s", strtab
+ liblist
.l_name
);
11260 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
11261 liblist
.l_version
, liblist
.l_flags
);
11271 static const char *
11272 get_note_type (unsigned e_type
)
11274 static char buff
[64];
11276 if (elf_header
.e_type
== ET_CORE
)
11280 return _("NT_AUXV (auxiliary vector)");
11282 return _("NT_PRSTATUS (prstatus structure)");
11284 return _("NT_FPREGSET (floating point registers)");
11286 return _("NT_PRPSINFO (prpsinfo structure)");
11287 case NT_TASKSTRUCT
:
11288 return _("NT_TASKSTRUCT (task structure)");
11290 return _("NT_PRXFPREG (user_xfpregs structure)");
11292 return _("NT_PSTATUS (pstatus structure)");
11294 return _("NT_FPREGS (floating point registers)");
11296 return _("NT_PSINFO (psinfo structure)");
11298 return _("NT_LWPSTATUS (lwpstatus_t structure)");
11300 return _("NT_LWPSINFO (lwpsinfo_t structure)");
11301 case NT_WIN32PSTATUS
:
11302 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
11310 return _("NT_VERSION (version)");
11312 return _("NT_ARCH (architecture)");
11317 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
11321 static const char *
11322 get_netbsd_elfcore_note_type (unsigned e_type
)
11324 static char buff
[64];
11326 if (e_type
== NT_NETBSDCORE_PROCINFO
)
11328 /* NetBSD core "procinfo" structure. */
11329 return _("NetBSD procinfo structure");
11332 /* As of Jan 2002 there are no other machine-independent notes
11333 defined for NetBSD core files. If the note type is less
11334 than the start of the machine-dependent note types, we don't
11337 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
11339 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
11343 switch (elf_header
.e_machine
)
11345 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
11346 and PT_GETFPREGS == mach+2. */
11351 case EM_SPARC32PLUS
:
11355 case NT_NETBSDCORE_FIRSTMACH
+0:
11356 return _("PT_GETREGS (reg structure)");
11357 case NT_NETBSDCORE_FIRSTMACH
+2:
11358 return _("PT_GETFPREGS (fpreg structure)");
11364 /* On all other arch's, PT_GETREGS == mach+1 and
11365 PT_GETFPREGS == mach+3. */
11369 case NT_NETBSDCORE_FIRSTMACH
+1:
11370 return _("PT_GETREGS (reg structure)");
11371 case NT_NETBSDCORE_FIRSTMACH
+3:
11372 return _("PT_GETFPREGS (fpreg structure)");
11378 sprintf (buff
, _("PT_FIRSTMACH+%d"), e_type
- NT_NETBSDCORE_FIRSTMACH
);
11382 /* Note that by the ELF standard, the name field is already null byte
11383 terminated, and namesz includes the terminating null byte.
11384 I.E. the value of namesz for the name "FSF" is 4.
11386 If the value of namesz is zero, there is no name present. */
11388 process_note (Elf_Internal_Note
*pnote
)
11392 if (pnote
->namesz
== 0)
11393 /* If there is no note name, then use the default set of
11394 note type strings. */
11395 nt
= get_note_type (pnote
->type
);
11397 else if (strneq (pnote
->namedata
, "NetBSD-CORE", 11))
11398 /* NetBSD-specific core file notes. */
11399 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
11402 /* Don't recognize this note name; just use the default set of
11403 note type strings. */
11404 nt
= get_note_type (pnote
->type
);
11406 printf (" %s\t\t0x%08lx\t%s\n",
11407 pnote
->namesz
? pnote
->namedata
: "(NONE)",
11408 pnote
->descsz
, nt
);
11414 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
11416 Elf_External_Note
*pnotes
;
11417 Elf_External_Note
*external
;
11423 pnotes
= get_data (NULL
, file
, offset
, length
, _("notes"));
11429 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
11430 (unsigned long) offset
, (unsigned long) length
);
11431 printf (_(" Owner\t\tData size\tDescription\n"));
11433 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
11435 Elf_External_Note
*next
;
11436 Elf_Internal_Note inote
;
11439 inote
.type
= BYTE_GET (external
->type
);
11440 inote
.namesz
= BYTE_GET (external
->namesz
);
11441 inote
.namedata
= external
->name
;
11442 inote
.descsz
= BYTE_GET (external
->descsz
);
11443 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
11444 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
11446 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
11448 if (((char *) next
) > (((char *) pnotes
) + length
))
11450 warn (_("corrupt note found at offset %x into core notes\n"),
11451 ((char *) external
) - ((char *) pnotes
));
11452 warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
11453 inote
.type
, inote
.namesz
, inote
.descsz
);
11459 /* Verify that name is null terminated. It appears that at least
11460 one version of Linux (RedHat 6.0) generates corefiles that don't
11461 comply with the ELF spec by failing to include the null byte in
11463 if (inote
.namedata
[inote
.namesz
] != '\0')
11465 temp
= malloc (inote
.namesz
+ 1);
11469 error (_("Out of memory\n"));
11474 strncpy (temp
, inote
.namedata
, inote
.namesz
);
11475 temp
[inote
.namesz
] = 0;
11477 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
11478 inote
.namedata
= temp
;
11481 res
&= process_note (& inote
);
11496 process_corefile_note_segments (FILE *file
)
11498 Elf_Internal_Phdr
*segment
;
11502 if (! get_program_headers (file
))
11505 for (i
= 0, segment
= program_headers
;
11506 i
< elf_header
.e_phnum
;
11509 if (segment
->p_type
== PT_NOTE
)
11510 res
&= process_corefile_note_segment (file
,
11511 (bfd_vma
) segment
->p_offset
,
11512 (bfd_vma
) segment
->p_filesz
);
11519 process_note_sections (FILE *file
)
11521 Elf_Internal_Shdr
*section
;
11525 for (i
= 0, section
= section_headers
;
11526 i
< elf_header
.e_shnum
;
11528 if (section
->sh_type
== SHT_NOTE
)
11529 res
&= process_corefile_note_segment (file
,
11530 (bfd_vma
) section
->sh_offset
,
11531 (bfd_vma
) section
->sh_size
);
11537 process_notes (FILE *file
)
11539 /* If we have not been asked to display the notes then do nothing. */
11543 if (elf_header
.e_type
!= ET_CORE
)
11544 return process_note_sections (file
);
11546 /* No program headers means no NOTE segment. */
11547 if (elf_header
.e_phnum
> 0)
11548 return process_corefile_note_segments (file
);
11550 printf (_("No note segments present in the core file.\n"));
11555 process_arch_specific (FILE *file
)
11560 switch (elf_header
.e_machine
)
11563 case EM_MIPS_RS3_LE
:
11564 return process_mips_specific (file
);
11573 get_file_header (FILE *file
)
11575 /* Read in the identity array. */
11576 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
11579 /* Determine how to read the rest of the header. */
11580 switch (elf_header
.e_ident
[EI_DATA
])
11582 default: /* fall through */
11583 case ELFDATANONE
: /* fall through */
11585 byte_get
= byte_get_little_endian
;
11586 byte_put
= byte_put_little_endian
;
11589 byte_get
= byte_get_big_endian
;
11590 byte_put
= byte_put_big_endian
;
11594 /* For now we only support 32 bit and 64 bit ELF files. */
11595 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
11597 /* Read in the rest of the header. */
11600 Elf32_External_Ehdr ehdr32
;
11602 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
11605 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
11606 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
11607 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
11608 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
11609 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
11610 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
11611 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
11612 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
11613 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
11614 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
11615 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
11616 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
11617 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
11621 Elf64_External_Ehdr ehdr64
;
11623 /* If we have been compiled with sizeof (bfd_vma) == 4, then
11624 we will not be able to cope with the 64bit data found in
11625 64 ELF files. Detect this now and abort before we start
11626 overwriting things. */
11627 if (sizeof (bfd_vma
) < 8)
11629 error (_("This instance of readelf has been built without support for a\n\
11630 64 bit data type and so it cannot read 64 bit ELF files.\n"));
11634 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
11637 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
11638 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
11639 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
11640 elf_header
.e_entry
= BYTE_GET8 (ehdr64
.e_entry
);
11641 elf_header
.e_phoff
= BYTE_GET8 (ehdr64
.e_phoff
);
11642 elf_header
.e_shoff
= BYTE_GET8 (ehdr64
.e_shoff
);
11643 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
11644 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
11645 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
11646 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
11647 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
11648 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
11649 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
11652 if (elf_header
.e_shoff
)
11654 /* There may be some extensions in the first section header. Don't
11655 bomb if we can't read it. */
11657 get_32bit_section_headers (file
, 1);
11659 get_64bit_section_headers (file
, 1);
11665 /* Process one ELF object file according to the command line options.
11666 This file may actually be stored in an archive. The file is
11667 positioned at the start of the ELF object. */
11670 process_object (char *file_name
, FILE *file
)
11674 if (! get_file_header (file
))
11676 error (_("%s: Failed to read file header\n"), file_name
);
11680 /* Initialise per file variables. */
11681 for (i
= NUM_ELEM (version_info
); i
--;)
11682 version_info
[i
] = 0;
11684 for (i
= NUM_ELEM (dynamic_info
); i
--;)
11685 dynamic_info
[i
] = 0;
11687 /* Process the file. */
11689 printf (_("\nFile: %s\n"), file_name
);
11691 /* Initialise the dump_sects array from the cmdline_dump_sects array.
11692 Note we do this even if cmdline_dump_sects is empty because we
11693 must make sure that the dump_sets array is zeroed out before each
11694 object file is processed. */
11695 if (num_dump_sects
> num_cmdline_dump_sects
)
11696 memset (dump_sects
, 0, num_dump_sects
);
11698 if (num_cmdline_dump_sects
> 0)
11700 if (num_dump_sects
== 0)
11701 /* A sneaky way of allocating the dump_sects array. */
11702 request_dump (num_cmdline_dump_sects
, 0);
11704 assert (num_dump_sects
>= num_cmdline_dump_sects
);
11705 memcpy (dump_sects
, cmdline_dump_sects
, num_cmdline_dump_sects
);
11708 if (! process_file_header ())
11711 if (! process_section_headers (file
))
11713 /* Without loaded section headers we cannot process lots of
11715 do_unwind
= do_version
= do_dump
= do_arch
= 0;
11717 if (! do_using_dynamic
)
11718 do_syms
= do_reloc
= 0;
11721 if (! process_section_groups (file
))
11723 /* Without loaded section groups we cannot process unwind. */
11727 if (process_program_headers (file
))
11728 process_dynamic_section (file
);
11730 process_relocs (file
);
11732 process_unwind (file
);
11734 process_symbol_table (file
);
11736 process_syminfo (file
);
11738 process_version_sections (file
);
11740 process_section_contents (file
);
11742 process_notes (file
);
11744 process_gnu_liblist (file
);
11746 process_arch_specific (file
);
11748 if (program_headers
)
11750 free (program_headers
);
11751 program_headers
= NULL
;
11754 if (section_headers
)
11756 free (section_headers
);
11757 section_headers
= NULL
;
11762 free (string_table
);
11763 string_table
= NULL
;
11764 string_table_length
= 0;
11767 if (dynamic_strings
)
11769 free (dynamic_strings
);
11770 dynamic_strings
= NULL
;
11771 dynamic_strings_length
= 0;
11774 if (dynamic_symbols
)
11776 free (dynamic_symbols
);
11777 dynamic_symbols
= NULL
;
11778 num_dynamic_syms
= 0;
11781 if (dynamic_syminfo
)
11783 free (dynamic_syminfo
);
11784 dynamic_syminfo
= NULL
;
11787 if (section_headers_groups
)
11789 free (section_headers_groups
);
11790 section_headers_groups
= NULL
;
11793 if (section_groups
)
11795 struct group_list
*g
, *next
;
11797 for (i
= 0; i
< group_count
; i
++)
11799 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
11806 free (section_groups
);
11807 section_groups
= NULL
;
11810 if (debug_information
)
11812 for (i
= 0; i
< num_debug_info_entries
; i
++)
11814 if (!debug_information
[i
].max_loc_offsets
)
11816 free (debug_information
[i
].loc_offsets
);
11817 free (debug_information
[i
].have_frame_base
);
11819 if (!debug_information
[i
].max_range_lists
)
11820 free (debug_information
[i
].range_lists
);
11822 free (debug_information
);
11823 debug_information
= NULL
;
11824 num_debug_info_entries
= 0;
11830 /* Process an ELF archive. The file is positioned just after the
11834 process_archive (char *file_name
, FILE *file
)
11836 struct ar_hdr arhdr
;
11838 unsigned long size
;
11839 char *longnames
= NULL
;
11840 unsigned long longnames_size
= 0;
11841 size_t file_name_size
;
11846 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
11847 if (got
!= sizeof arhdr
)
11852 error (_("%s: failed to read archive header\n"), file_name
);
11856 if (memcmp (arhdr
.ar_name
, "/ ", 16) == 0)
11858 /* This is the archive symbol table. Skip it.
11859 FIXME: We should have an option to dump it. */
11860 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
11861 if (fseek (file
, size
+ (size
& 1), SEEK_CUR
) != 0)
11863 error (_("%s: failed to skip archive symbol table\n"), file_name
);
11867 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
11868 if (got
!= sizeof arhdr
)
11873 error (_("%s: failed to read archive header\n"), file_name
);
11878 if (memcmp (arhdr
.ar_name
, "// ", 16) == 0)
11880 /* This is the archive string table holding long member
11883 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
11885 longnames
= malloc (longnames_size
);
11886 if (longnames
== NULL
)
11888 error (_("Out of memory\n"));
11892 if (fread (longnames
, longnames_size
, 1, file
) != 1)
11895 error (_("%s: failed to read string table\n"), file_name
);
11899 if ((longnames_size
& 1) != 0)
11902 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
11903 if (got
!= sizeof arhdr
)
11910 error (_("%s: failed to read archive header\n"), file_name
);
11915 file_name_size
= strlen (file_name
);
11924 if (arhdr
.ar_name
[0] == '/')
11928 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
11929 if (off
>= longnames_size
)
11931 error (_("%s: invalid archive string table offset %lu\n"), off
);
11936 name
= longnames
+ off
;
11937 nameend
= memchr (name
, '/', longnames_size
- off
);
11941 name
= arhdr
.ar_name
;
11942 nameend
= memchr (name
, '/', 16);
11945 if (nameend
== NULL
)
11947 error (_("%s: bad archive file name\n"));
11952 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
11953 if (namealc
== NULL
)
11955 error (_("Out of memory\n"));
11960 memcpy (namealc
, file_name
, file_name_size
);
11961 namealc
[file_name_size
] = '(';
11962 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
11963 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
11964 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
11966 archive_file_offset
= ftell (file
);
11967 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
11969 ret
|= process_object (namealc
, file
);
11974 (archive_file_offset
11975 + archive_file_size
11976 + (archive_file_size
& 1)),
11979 error (_("%s: failed to seek to next archive header\n"), file_name
);
11984 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
11985 if (got
!= sizeof arhdr
)
11990 error (_("%s: failed to read archive header\n"), file_name
);
11996 if (longnames
!= 0)
12003 process_file (char *file_name
)
12006 struct stat statbuf
;
12007 char armag
[SARMAG
];
12010 if (stat (file_name
, &statbuf
) < 0)
12012 if (errno
== ENOENT
)
12013 error (_("'%s': No such file\n"), file_name
);
12015 error (_("Could not locate '%s'. System error message: %s\n"),
12016 file_name
, strerror (errno
));
12020 if (! S_ISREG (statbuf
.st_mode
))
12022 error (_("'%s' is not an ordinary file\n"), file_name
);
12026 file
= fopen (file_name
, "rb");
12029 error (_("Input file '%s' is not readable.\n"), file_name
);
12033 if (fread (armag
, SARMAG
, 1, file
) != 1)
12035 error (_("%s: Failed to read file header\n"), file_name
);
12040 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
12041 ret
= process_archive (file_name
, file
);
12045 archive_file_size
= archive_file_offset
= 0;
12046 ret
= process_object (file_name
, file
);
12054 #ifdef SUPPORT_DISASSEMBLY
12055 /* Needed by the i386 disassembler. For extra credit, someone could
12056 fix this so that we insert symbolic addresses here, esp for GOT/PLT
12060 print_address (unsigned int addr
, FILE *outfile
)
12062 fprintf (outfile
,"0x%8.8x", addr
);
12065 /* Needed by the i386 disassembler. */
12067 db_task_printsym (unsigned int addr
)
12069 print_address (addr
, stderr
);
12074 main (int argc
, char **argv
)
12078 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
12079 setlocale (LC_MESSAGES
, "");
12081 #if defined (HAVE_SETLOCALE)
12082 setlocale (LC_CTYPE
, "");
12084 bindtextdomain (PACKAGE
, LOCALEDIR
);
12085 textdomain (PACKAGE
);
12087 parse_args (argc
, argv
);
12089 if (num_dump_sects
> 0)
12091 /* Make a copy of the dump_sects array. */
12092 cmdline_dump_sects
= malloc (num_dump_sects
);
12093 if (cmdline_dump_sects
== NULL
)
12094 error (_("Out of memory allocating dump request table."));
12097 memcpy (cmdline_dump_sects
, dump_sects
, num_dump_sects
);
12098 num_cmdline_dump_sects
= num_dump_sects
;
12102 if (optind
< (argc
- 1))
12106 while (optind
< argc
)
12107 err
|= process_file (argv
[optind
++]);
12109 if (dump_sects
!= NULL
)
12111 if (cmdline_dump_sects
!= NULL
)
12112 free (cmdline_dump_sects
);