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
;
188 size_t group_count
= 0;
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
;
3960 if (elf_header
.e_shnum
== 0)
3962 if (do_section_groups
)
3963 printf (_("\nThere are no section groups in this file.\n"));
3968 if (section_headers
== NULL
)
3970 error (_("Section headers are not available!\n"));
3974 section_headers_groups
= calloc (elf_header
.e_shnum
,
3975 sizeof (struct group
*));
3977 if (section_headers_groups
== NULL
)
3979 error (_("Out of memory\n"));
3983 /* Scan the sections for the group section. */
3984 for (i
= 0, section
= section_headers
;
3985 i
< elf_header
.e_shnum
;
3987 if (section
->sh_type
== SHT_GROUP
)
3990 section_groups
= calloc (group_count
, sizeof (struct group
));
3992 if (section_groups
== NULL
)
3994 error (_("Out of memory\n"));
3998 for (i
= 0, section
= section_headers
, group
= section_groups
;
3999 i
< elf_header
.e_shnum
;
4002 if (section
->sh_type
== SHT_GROUP
)
4004 char *name
= SECTION_NAME (section
);
4005 char *group_name
, *strtab
, *start
, *indices
;
4006 unsigned int entry
, j
, size
;
4007 Elf_Internal_Sym
*sym
;
4008 Elf_Internal_Shdr
*symtab_sec
, *strtab_sec
, *sec
;
4009 Elf_Internal_Sym
*symtab
;
4011 /* Get the symbol table. */
4012 symtab_sec
= SECTION_HEADER (section
->sh_link
);
4013 if (symtab_sec
->sh_type
!= SHT_SYMTAB
)
4015 error (_("Bad sh_link in group section `%s'\n"), name
);
4018 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4020 sym
= symtab
+ section
->sh_info
;
4022 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4024 bfd_vma sec_index
= SECTION_HEADER_INDEX (sym
->st_shndx
);
4027 error (_("Bad sh_info in group section `%s'\n"), name
);
4031 group_name
= SECTION_NAME (section_headers
+ sec_index
);
4036 /* Get the string table. */
4037 strtab_sec
= SECTION_HEADER (symtab_sec
->sh_link
);
4038 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
4039 strtab_sec
->sh_size
,
4042 group_name
= strtab
+ sym
->st_name
;
4045 start
= get_data (NULL
, file
, section
->sh_offset
,
4046 section
->sh_size
, _("section data"));
4049 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4050 entry
= byte_get (indices
, 4);
4053 if (do_section_groups
)
4055 printf ("\n%s group section `%s' [%s] contains %u sections:\n",
4056 get_group_flags (entry
), name
, group_name
, size
);
4058 printf (_(" [Index] Name\n"));
4061 group
->group_index
= i
;
4063 for (j
= 0; j
< size
; j
++)
4065 struct group_list
*g
;
4067 entry
= byte_get (indices
, 4);
4070 if (section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4073 error (_("section [%5u] already in group section [%5u]\n"),
4074 entry
, section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4078 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4081 if (do_section_groups
)
4083 sec
= SECTION_HEADER (entry
);
4084 printf (" [%5u] %s\n",
4085 entry
, SECTION_NAME (sec
));
4088 g
= xmalloc (sizeof (struct group_list
));
4089 g
->section_index
= entry
;
4090 g
->next
= group
->root
;
4114 } dynamic_relocations
[] =
4116 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4117 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4118 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4121 /* Process the reloc section. */
4124 process_relocs (FILE *file
)
4126 unsigned long rel_size
;
4127 unsigned long rel_offset
;
4133 if (do_using_dynamic
)
4137 int has_dynamic_reloc
;
4140 has_dynamic_reloc
= 0;
4142 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4144 is_rela
= dynamic_relocations
[i
].rela
;
4145 name
= dynamic_relocations
[i
].name
;
4146 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4147 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4149 has_dynamic_reloc
|= rel_size
;
4151 if (is_rela
== UNKNOWN
)
4153 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4154 switch (dynamic_info
[DT_PLTREL
])
4168 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4169 name
, rel_offset
, rel_size
);
4171 dump_relocations (file
,
4172 offset_from_vma (file
, rel_offset
, rel_size
),
4174 dynamic_symbols
, num_dynamic_syms
,
4175 dynamic_strings
, dynamic_strings_length
, is_rela
);
4179 if (! has_dynamic_reloc
)
4180 printf (_("\nThere are no dynamic relocations in this file.\n"));
4184 Elf_Internal_Shdr
*section
;
4188 for (i
= 0, section
= section_headers
;
4189 i
< elf_header
.e_shnum
;
4192 if ( section
->sh_type
!= SHT_RELA
4193 && section
->sh_type
!= SHT_REL
)
4196 rel_offset
= section
->sh_offset
;
4197 rel_size
= section
->sh_size
;
4201 Elf_Internal_Shdr
*strsec
;
4204 printf (_("\nRelocation section "));
4206 if (string_table
== NULL
)
4207 printf ("%d", section
->sh_name
);
4209 printf (_("'%s'"), SECTION_NAME (section
));
4211 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4212 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4214 is_rela
= section
->sh_type
== SHT_RELA
;
4216 if (section
->sh_link
)
4218 Elf_Internal_Shdr
*symsec
;
4219 Elf_Internal_Sym
*symtab
;
4220 unsigned long nsyms
;
4221 unsigned long strtablen
;
4222 char *strtab
= NULL
;
4224 symsec
= SECTION_HEADER (section
->sh_link
);
4225 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4226 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4231 strsec
= SECTION_HEADER (symsec
->sh_link
);
4233 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4234 strsec
->sh_size
, _("string table"));
4235 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4237 dump_relocations (file
, rel_offset
, rel_size
,
4238 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4244 dump_relocations (file
, rel_offset
, rel_size
,
4245 NULL
, 0, NULL
, 0, is_rela
);
4252 printf (_("\nThere are no relocations in this file.\n"));
4258 /* Process the unwind section. */
4260 #include "unwind-ia64.h"
4262 /* An absolute address consists of a section and an offset. If the
4263 section is NULL, the offset itself is the address, otherwise, the
4264 address equals to LOAD_ADDRESS(section) + offset. */
4268 unsigned short section
;
4272 struct ia64_unw_aux_info
4274 struct ia64_unw_table_entry
4276 struct absaddr start
;
4278 struct absaddr info
;
4280 *table
; /* Unwind table. */
4281 unsigned long table_len
; /* Length of unwind table. */
4282 unsigned char *info
; /* Unwind info. */
4283 unsigned long info_size
; /* Size of unwind info. */
4284 bfd_vma info_addr
; /* starting address of unwind info. */
4285 bfd_vma seg_base
; /* Starting address of segment. */
4286 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4287 unsigned long nsyms
; /* Number of symbols. */
4288 char *strtab
; /* The string table. */
4289 unsigned long strtab_size
; /* Size of string table. */
4293 find_symbol_for_address (Elf_Internal_Sym
*symtab
,
4294 unsigned long nsyms
,
4296 unsigned long strtab_size
,
4297 struct absaddr addr
,
4298 const char **symname
,
4301 bfd_vma dist
= 0x100000;
4302 Elf_Internal_Sym
*sym
, *best
= NULL
;
4305 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
4307 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4308 && sym
->st_name
!= 0
4309 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4310 && addr
.offset
>= sym
->st_value
4311 && addr
.offset
- sym
->st_value
< dist
)
4314 dist
= addr
.offset
- sym
->st_value
;
4321 *symname
= (best
->st_name
>= strtab_size
4322 ? "<corrupt>" : strtab
+ best
->st_name
);
4327 *offset
= addr
.offset
;
4331 dump_ia64_unwind (struct ia64_unw_aux_info
*aux
)
4333 struct ia64_unw_table_entry
*tp
;
4336 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4340 const unsigned char *dp
;
4341 const unsigned char *head
;
4342 const char *procname
;
4344 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4345 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
4347 fputs ("\n<", stdout
);
4351 fputs (procname
, stdout
);
4354 printf ("+%lx", (unsigned long) offset
);
4357 fputs (">: [", stdout
);
4358 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4359 fputc ('-', stdout
);
4360 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4361 printf ("], info at +0x%lx\n",
4362 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4364 head
= aux
->info
+ (tp
->info
.offset
- aux
->info_addr
);
4365 stamp
= BYTE_GET8 ((unsigned char *) head
);
4367 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4368 (unsigned) UNW_VER (stamp
),
4369 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4370 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4371 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4372 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
4374 if (UNW_VER (stamp
) != 1)
4376 printf ("\tUnknown version.\n");
4381 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
4382 dp
= unw_decode (dp
, in_body
, & in_body
);
4387 slurp_ia64_unwind_table (FILE *file
,
4388 struct ia64_unw_aux_info
*aux
,
4389 Elf_Internal_Shdr
*sec
)
4391 unsigned long size
, nrelas
, i
;
4392 Elf_Internal_Phdr
*seg
;
4393 struct ia64_unw_table_entry
*tep
;
4394 Elf_Internal_Shdr
*relsec
;
4395 Elf_Internal_Rela
*rela
, *rp
;
4396 unsigned char *table
, *tp
;
4397 Elf_Internal_Sym
*sym
;
4398 const char *relname
;
4400 /* First, find the starting address of the segment that includes
4403 if (elf_header
.e_phnum
)
4405 if (! get_program_headers (file
))
4408 for (seg
= program_headers
;
4409 seg
< program_headers
+ elf_header
.e_phnum
;
4412 if (seg
->p_type
!= PT_LOAD
)
4415 if (sec
->sh_addr
>= seg
->p_vaddr
4416 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4418 aux
->seg_base
= seg
->p_vaddr
;
4424 /* Second, build the unwind table from the contents of the unwind section: */
4425 size
= sec
->sh_size
;
4426 table
= get_data (NULL
, file
, sec
->sh_offset
, size
, _("unwind table"));
4430 aux
->table
= xmalloc (size
/ (3 * eh_addr_size
) * sizeof (aux
->table
[0]));
4432 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * eh_addr_size
, ++tep
)
4434 tep
->start
.section
= SHN_UNDEF
;
4435 tep
->end
.section
= SHN_UNDEF
;
4436 tep
->info
.section
= SHN_UNDEF
;
4439 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4440 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4441 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
4445 tep
->start
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 0);
4446 tep
->end
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 8);
4447 tep
->info
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 16);
4449 tep
->start
.offset
+= aux
->seg_base
;
4450 tep
->end
.offset
+= aux
->seg_base
;
4451 tep
->info
.offset
+= aux
->seg_base
;
4455 /* Third, apply any relocations to the unwind table: */
4457 for (relsec
= section_headers
;
4458 relsec
< section_headers
+ elf_header
.e_shnum
;
4461 if (relsec
->sh_type
!= SHT_RELA
4462 || SECTION_HEADER (relsec
->sh_info
) != sec
)
4465 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
4469 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4473 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4474 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4478 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4479 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4482 if (! strneq (relname
, "R_IA64_SEGREL", 13))
4484 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4488 i
= rp
->r_offset
/ (3 * eh_addr_size
);
4490 switch (rp
->r_offset
/eh_addr_size
% 3)
4493 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4494 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
4497 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4498 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
4501 aux
->table
[i
].info
.section
= sym
->st_shndx
;
4502 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
4512 aux
->table_len
= size
/ (3 * eh_addr_size
);
4517 ia64_process_unwind (FILE *file
)
4519 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
4520 unsigned long i
, unwcount
= 0, unwstart
= 0;
4521 struct ia64_unw_aux_info aux
;
4523 memset (& aux
, 0, sizeof (aux
));
4525 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4527 if (sec
->sh_type
== SHT_SYMTAB
)
4529 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
4530 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
4532 strsec
= SECTION_HEADER (sec
->sh_link
);
4533 aux
.strtab_size
= strsec
->sh_size
;
4534 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4535 aux
.strtab_size
, _("string table"));
4537 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4542 printf (_("\nThere are no unwind sections in this file.\n"));
4544 while (unwcount
-- > 0)
4549 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
4550 i
< elf_header
.e_shnum
; ++i
, ++sec
)
4551 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4558 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
4560 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
4562 /* We need to find which section group it is in. */
4563 struct group_list
*g
= section_headers_groups
[i
]->root
;
4565 for (; g
!= NULL
; g
= g
->next
)
4567 sec
= SECTION_HEADER (g
->section_index
);
4569 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
4574 i
= elf_header
.e_shnum
;
4576 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
4578 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
4579 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
4580 suffix
= SECTION_NAME (unwsec
) + len
;
4581 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4583 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
4584 && streq (SECTION_NAME (sec
) + len2
, suffix
))
4589 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
4590 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
4591 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
4592 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
4594 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
4595 suffix
= SECTION_NAME (unwsec
) + len
;
4596 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4598 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
4599 && streq (SECTION_NAME (sec
) + len2
, suffix
))
4603 if (i
== elf_header
.e_shnum
)
4605 printf (_("\nCould not find unwind info section for "));
4607 if (string_table
== NULL
)
4608 printf ("%d", unwsec
->sh_name
);
4610 printf (_("'%s'"), SECTION_NAME (unwsec
));
4614 aux
.info_size
= sec
->sh_size
;
4615 aux
.info_addr
= sec
->sh_addr
;
4616 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, aux
.info_size
,
4619 printf (_("\nUnwind section "));
4621 if (string_table
== NULL
)
4622 printf ("%d", unwsec
->sh_name
);
4624 printf (_("'%s'"), SECTION_NAME (unwsec
));
4626 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4627 (unsigned long) unwsec
->sh_offset
,
4628 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
4630 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
4632 if (aux
.table_len
> 0)
4633 dump_ia64_unwind (& aux
);
4636 free ((char *) aux
.table
);
4638 free ((char *) aux
.info
);
4647 free ((char *) aux
.strtab
);
4652 struct hppa_unw_aux_info
4654 struct hppa_unw_table_entry
4656 struct absaddr start
;
4658 unsigned int Cannot_unwind
:1; /* 0 */
4659 unsigned int Millicode
:1; /* 1 */
4660 unsigned int Millicode_save_sr0
:1; /* 2 */
4661 unsigned int Region_description
:2; /* 3..4 */
4662 unsigned int reserved1
:1; /* 5 */
4663 unsigned int Entry_SR
:1; /* 6 */
4664 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
4665 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
4666 unsigned int Args_stored
:1; /* 16 */
4667 unsigned int Variable_Frame
:1; /* 17 */
4668 unsigned int Separate_Package_Body
:1; /* 18 */
4669 unsigned int Frame_Extension_Millicode
:1; /* 19 */
4670 unsigned int Stack_Overflow_Check
:1; /* 20 */
4671 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
4672 unsigned int Ada_Region
:1; /* 22 */
4673 unsigned int cxx_info
:1; /* 23 */
4674 unsigned int cxx_try_catch
:1; /* 24 */
4675 unsigned int sched_entry_seq
:1; /* 25 */
4676 unsigned int reserved2
:1; /* 26 */
4677 unsigned int Save_SP
:1; /* 27 */
4678 unsigned int Save_RP
:1; /* 28 */
4679 unsigned int Save_MRP_in_frame
:1; /* 29 */
4680 unsigned int extn_ptr_defined
:1; /* 30 */
4681 unsigned int Cleanup_defined
:1; /* 31 */
4683 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
4684 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
4685 unsigned int Large_frame
:1; /* 2 */
4686 unsigned int Pseudo_SP_Set
:1; /* 3 */
4687 unsigned int reserved4
:1; /* 4 */
4688 unsigned int Total_frame_size
:27; /* 5..31 */
4690 *table
; /* Unwind table. */
4691 unsigned long table_len
; /* Length of unwind table. */
4692 bfd_vma seg_base
; /* Starting address of segment. */
4693 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4694 unsigned long nsyms
; /* Number of symbols. */
4695 char *strtab
; /* The string table. */
4696 unsigned long strtab_size
; /* Size of string table. */
4700 dump_hppa_unwind (struct hppa_unw_aux_info
*aux
)
4702 struct hppa_unw_table_entry
*tp
;
4704 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4707 const char *procname
;
4709 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4710 aux
->strtab_size
, tp
->start
, &procname
,
4713 fputs ("\n<", stdout
);
4717 fputs (procname
, stdout
);
4720 printf ("+%lx", (unsigned long) offset
);
4723 fputs (">: [", stdout
);
4724 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4725 fputc ('-', stdout
);
4726 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4729 #define PF(_m) if (tp->_m) printf (#_m " ");
4730 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
4733 PF(Millicode_save_sr0
);
4734 /* PV(Region_description); */
4740 PF(Separate_Package_Body
);
4741 PF(Frame_Extension_Millicode
);
4742 PF(Stack_Overflow_Check
);
4743 PF(Two_Instruction_SP_Increment
);
4747 PF(sched_entry_seq
);
4750 PF(Save_MRP_in_frame
);
4751 PF(extn_ptr_defined
);
4752 PF(Cleanup_defined
);
4753 PF(MPE_XL_interrupt_marker
);
4754 PF(HP_UX_interrupt_marker
);
4757 PV(Total_frame_size
);
4766 slurp_hppa_unwind_table (FILE *file
,
4767 struct hppa_unw_aux_info
*aux
,
4768 Elf_Internal_Shdr
*sec
)
4770 unsigned long size
, unw_ent_size
, nrelas
, i
;
4771 Elf_Internal_Phdr
*seg
;
4772 struct hppa_unw_table_entry
*tep
;
4773 Elf_Internal_Shdr
*relsec
;
4774 Elf_Internal_Rela
*rela
, *rp
;
4775 unsigned char *table
, *tp
;
4776 Elf_Internal_Sym
*sym
;
4777 const char *relname
;
4779 /* First, find the starting address of the segment that includes
4782 if (elf_header
.e_phnum
)
4784 if (! get_program_headers (file
))
4787 for (seg
= program_headers
;
4788 seg
< program_headers
+ elf_header
.e_phnum
;
4791 if (seg
->p_type
!= PT_LOAD
)
4794 if (sec
->sh_addr
>= seg
->p_vaddr
4795 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4797 aux
->seg_base
= seg
->p_vaddr
;
4803 /* Second, build the unwind table from the contents of the unwind
4805 size
= sec
->sh_size
;
4806 table
= get_data (NULL
, file
, sec
->sh_offset
, size
, _("unwind table"));
4810 unw_ent_size
= 2 * eh_addr_size
+ 8;
4812 tep
= aux
->table
= xmalloc (size
/ unw_ent_size
* sizeof (aux
->table
[0]));
4814 for (tp
= table
; tp
< table
+ size
; tp
+= (2 * eh_addr_size
+ 8), ++tep
)
4816 unsigned int tmp1
, tmp2
;
4818 tep
->start
.section
= SHN_UNDEF
;
4819 tep
->end
.section
= SHN_UNDEF
;
4823 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4824 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4825 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
4826 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
4830 tep
->start
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 0);
4831 tep
->end
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 8);
4832 tmp1
= byte_get ((unsigned char *) tp
+ 16, 4);
4833 tmp2
= byte_get ((unsigned char *) tp
+ 20, 4);
4836 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
4837 tep
->Millicode
= (tmp1
>> 30) & 0x1;
4838 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
4839 tep
->Region_description
= (tmp1
>> 27) & 0x3;
4840 tep
->reserved1
= (tmp1
>> 26) & 0x1;
4841 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
4842 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
4843 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
4844 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
4845 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
4846 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
4847 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
4848 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
4849 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
4850 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
4851 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
4852 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
4853 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
4854 tep
->reserved2
= (tmp1
>> 5) & 0x1;
4855 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
4856 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
4857 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
4858 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
4859 tep
->Cleanup_defined
= tmp1
& 0x1;
4861 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
4862 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
4863 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
4864 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
4865 tep
->reserved4
= (tmp2
>> 27) & 0x1;
4866 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
4868 tep
->start
.offset
+= aux
->seg_base
;
4869 tep
->end
.offset
+= aux
->seg_base
;
4873 /* Third, apply any relocations to the unwind table. */
4875 for (relsec
= section_headers
;
4876 relsec
< section_headers
+ elf_header
.e_shnum
;
4879 if (relsec
->sh_type
!= SHT_RELA
4880 || SECTION_HEADER (relsec
->sh_info
) != sec
)
4883 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
4887 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4891 relname
= elf_hppa_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4892 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4896 relname
= elf_hppa_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4897 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4900 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
4901 if (strncmp (relname
, "R_PARISC_SEGREL", 15) != 0)
4903 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4907 i
= rp
->r_offset
/ unw_ent_size
;
4909 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
4912 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4913 aux
->table
[i
].start
.offset
+= sym
->st_value
+ rp
->r_addend
;
4916 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4917 aux
->table
[i
].end
.offset
+= sym
->st_value
+ rp
->r_addend
;
4927 aux
->table_len
= size
/ unw_ent_size
;
4933 hppa_process_unwind (FILE *file
)
4935 struct hppa_unw_aux_info aux
;
4936 Elf_Internal_Shdr
*unwsec
= NULL
;
4937 Elf_Internal_Shdr
*strsec
;
4938 Elf_Internal_Shdr
*sec
;
4941 memset (& aux
, 0, sizeof (aux
));
4943 assert (string_table
!= NULL
);
4945 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4947 if (sec
->sh_type
== SHT_SYMTAB
)
4949 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
4950 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
4952 strsec
= SECTION_HEADER (sec
->sh_link
);
4953 aux
.strtab_size
= strsec
->sh_size
;
4954 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4955 aux
.strtab_size
, _("string table"));
4957 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
4962 printf (_("\nThere are no unwind sections in this file.\n"));
4964 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4966 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
4968 printf (_("\nUnwind section "));
4969 printf (_("'%s'"), SECTION_NAME (sec
));
4971 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4972 (unsigned long) sec
->sh_offset
,
4973 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
4975 slurp_hppa_unwind_table (file
, &aux
, sec
);
4976 if (aux
.table_len
> 0)
4977 dump_hppa_unwind (&aux
);
4980 free ((char *) aux
.table
);
4988 free ((char *) aux
.strtab
);
4994 process_unwind (FILE *file
)
4996 struct unwind_handler
{
4998 int (*handler
)(FILE *file
);
5000 { EM_IA_64
, ia64_process_unwind
},
5001 { EM_PARISC
, hppa_process_unwind
},
5009 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5010 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5011 return handlers
[i
].handler (file
);
5013 printf (_("\nThere are no unwind sections in this file.\n"));
5018 dynamic_section_mips_val (Elf_Internal_Dyn
*entry
)
5020 switch (entry
->d_tag
)
5023 if (entry
->d_un
.d_val
== 0)
5027 static const char * opts
[] =
5029 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5030 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5031 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5032 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5037 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++cnt
)
5038 if (entry
->d_un
.d_val
& (1 << cnt
))
5040 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5047 case DT_MIPS_IVERSION
:
5048 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5049 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5051 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5054 case DT_MIPS_TIME_STAMP
:
5059 time_t time
= entry
->d_un
.d_val
;
5060 tmp
= gmtime (&time
);
5061 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
5062 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5063 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5064 printf ("Time Stamp: %s\n", timebuf
);
5068 case DT_MIPS_RLD_VERSION
:
5069 case DT_MIPS_LOCAL_GOTNO
:
5070 case DT_MIPS_CONFLICTNO
:
5071 case DT_MIPS_LIBLISTNO
:
5072 case DT_MIPS_SYMTABNO
:
5073 case DT_MIPS_UNREFEXTNO
:
5074 case DT_MIPS_HIPAGENO
:
5075 case DT_MIPS_DELTA_CLASS_NO
:
5076 case DT_MIPS_DELTA_INSTANCE_NO
:
5077 case DT_MIPS_DELTA_RELOC_NO
:
5078 case DT_MIPS_DELTA_SYM_NO
:
5079 case DT_MIPS_DELTA_CLASSSYM_NO
:
5080 case DT_MIPS_COMPACT_SIZE
:
5081 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5085 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
5091 dynamic_section_parisc_val (Elf_Internal_Dyn
*entry
)
5093 switch (entry
->d_tag
)
5095 case DT_HP_DLD_FLAGS
:
5104 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5105 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5106 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5107 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5108 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5109 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5110 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5111 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5112 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5113 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5114 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
5118 bfd_vma val
= entry
->d_un
.d_val
;
5120 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
5121 if (val
& flags
[cnt
].bit
)
5125 fputs (flags
[cnt
].str
, stdout
);
5127 val
^= flags
[cnt
].bit
;
5130 if (val
!= 0 || first
)
5134 print_vma (val
, HEX
);
5140 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5147 dynamic_section_ia64_val (Elf_Internal_Dyn
*entry
)
5149 switch (entry
->d_tag
)
5151 case DT_IA_64_PLT_RESERVE
:
5152 /* First 3 slots reserved. */
5153 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5155 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5159 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5166 get_32bit_dynamic_section (FILE *file
)
5168 Elf32_External_Dyn
*edyn
, *ext
;
5169 Elf_Internal_Dyn
*entry
;
5171 edyn
= get_data (NULL
, file
, dynamic_addr
, dynamic_size
,
5172 _("dynamic section"));
5176 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5177 might not have the luxury of section headers. Look for the DT_NULL
5178 terminator to determine the number of entries. */
5179 for (ext
= edyn
, dynamic_nent
= 0;
5180 (char *) ext
< (char *) edyn
+ dynamic_size
;
5184 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5188 dynamic_section
= malloc (dynamic_nent
* sizeof (*entry
));
5189 if (dynamic_section
== NULL
)
5191 error (_("Out of memory\n"));
5196 for (ext
= edyn
, entry
= dynamic_section
;
5197 entry
< dynamic_section
+ dynamic_nent
;
5200 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5201 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5210 get_64bit_dynamic_section (FILE *file
)
5212 Elf64_External_Dyn
*edyn
, *ext
;
5213 Elf_Internal_Dyn
*entry
;
5215 edyn
= get_data (NULL
, file
, dynamic_addr
, dynamic_size
,
5216 _("dynamic section"));
5220 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5221 might not have the luxury of section headers. Look for the DT_NULL
5222 terminator to determine the number of entries. */
5223 for (ext
= edyn
, dynamic_nent
= 0;
5224 (char *) ext
< (char *) edyn
+ dynamic_size
;
5228 if (BYTE_GET8 (ext
->d_tag
) == DT_NULL
)
5232 dynamic_section
= malloc (dynamic_nent
* sizeof (*entry
));
5233 if (dynamic_section
== NULL
)
5235 error (_("Out of memory\n"));
5240 for (ext
= edyn
, entry
= dynamic_section
;
5241 entry
< dynamic_section
+ dynamic_nent
;
5244 entry
->d_tag
= BYTE_GET8 (ext
->d_tag
);
5245 entry
->d_un
.d_val
= BYTE_GET8 (ext
->d_un
.d_val
);
5254 get_dynamic_flags (bfd_vma flags
)
5256 static char buff
[128];
5264 flag
= flags
& - flags
;
5272 case DF_ORIGIN
: strcpy (p
, "ORIGIN"); break;
5273 case DF_SYMBOLIC
: strcpy (p
, "SYMBOLIC"); break;
5274 case DF_TEXTREL
: strcpy (p
, "TEXTREL"); break;
5275 case DF_BIND_NOW
: strcpy (p
, "BIND_NOW"); break;
5276 case DF_STATIC_TLS
: strcpy (p
, "STATIC_TLS"); break;
5277 default: strcpy (p
, "unknown"); break;
5280 p
= strchr (p
, '\0');
5285 /* Parse and display the contents of the dynamic section. */
5288 process_dynamic_section (FILE *file
)
5290 Elf_Internal_Dyn
*entry
;
5292 if (dynamic_size
== 0)
5295 printf (_("\nThere is no dynamic section in this file.\n"));
5302 if (! get_32bit_dynamic_section (file
))
5305 else if (! get_64bit_dynamic_section (file
))
5308 /* Find the appropriate symbol table. */
5309 if (dynamic_symbols
== NULL
)
5311 for (entry
= dynamic_section
;
5312 entry
< dynamic_section
+ dynamic_nent
;
5315 Elf_Internal_Shdr section
;
5317 if (entry
->d_tag
!= DT_SYMTAB
)
5320 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
5322 /* Since we do not know how big the symbol table is,
5323 we default to reading in the entire file (!) and
5324 processing that. This is overkill, I know, but it
5326 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5328 if (archive_file_offset
!= 0)
5329 section
.sh_size
= archive_file_size
- section
.sh_offset
;
5332 if (fseek (file
, 0, SEEK_END
))
5333 error (_("Unable to seek to end of file!"));
5335 section
.sh_size
= ftell (file
) - section
.sh_offset
;
5339 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
5341 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
5343 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
5344 if (num_dynamic_syms
< 1)
5346 error (_("Unable to determine the number of symbols to load\n"));
5350 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
5354 /* Similarly find a string table. */
5355 if (dynamic_strings
== NULL
)
5357 for (entry
= dynamic_section
;
5358 entry
< dynamic_section
+ dynamic_nent
;
5361 unsigned long offset
;
5364 if (entry
->d_tag
!= DT_STRTAB
)
5367 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
5369 /* Since we do not know how big the string table is,
5370 we default to reading in the entire file (!) and
5371 processing that. This is overkill, I know, but it
5374 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5376 if (archive_file_offset
!= 0)
5377 str_tab_len
= archive_file_size
- offset
;
5380 if (fseek (file
, 0, SEEK_END
))
5381 error (_("Unable to seek to end of file\n"));
5382 str_tab_len
= ftell (file
) - offset
;
5385 if (str_tab_len
< 1)
5388 (_("Unable to determine the length of the dynamic string table\n"));
5392 dynamic_strings
= get_data (NULL
, file
, offset
, str_tab_len
,
5393 _("dynamic string table"));
5394 dynamic_strings_length
= str_tab_len
;
5399 /* And find the syminfo section if available. */
5400 if (dynamic_syminfo
== NULL
)
5402 unsigned long syminsz
= 0;
5404 for (entry
= dynamic_section
;
5405 entry
< dynamic_section
+ dynamic_nent
;
5408 if (entry
->d_tag
== DT_SYMINENT
)
5410 /* Note: these braces are necessary to avoid a syntax
5411 error from the SunOS4 C compiler. */
5412 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
5414 else if (entry
->d_tag
== DT_SYMINSZ
)
5415 syminsz
= entry
->d_un
.d_val
;
5416 else if (entry
->d_tag
== DT_SYMINFO
)
5417 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
5421 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
5423 Elf_External_Syminfo
*extsyminfo
, *extsym
;
5424 Elf_Internal_Syminfo
*syminfo
;
5426 /* There is a syminfo section. Read the data. */
5427 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, syminsz
,
5428 _("symbol information"));
5432 dynamic_syminfo
= malloc (syminsz
);
5433 if (dynamic_syminfo
== NULL
)
5435 error (_("Out of memory\n"));
5439 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
5440 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
5441 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
5442 ++syminfo
, ++extsym
)
5444 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
5445 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
5452 if (do_dynamic
&& dynamic_addr
)
5453 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
5454 dynamic_addr
, dynamic_nent
);
5456 printf (_(" Tag Type Name/Value\n"));
5458 for (entry
= dynamic_section
;
5459 entry
< dynamic_section
+ dynamic_nent
;
5467 print_vma (entry
->d_tag
, FULL_HEX
);
5468 dtype
= get_dynamic_type (entry
->d_tag
);
5469 printf (" (%s)%*s", dtype
,
5470 ((is_32bit_elf
? 27 : 19)
5471 - (int) strlen (dtype
)),
5475 switch (entry
->d_tag
)
5479 puts (get_dynamic_flags (entry
->d_un
.d_val
));
5489 switch (entry
->d_tag
)
5492 printf (_("Auxiliary library"));
5496 printf (_("Filter library"));
5500 printf (_("Configuration file"));
5504 printf (_("Dependency audit library"));
5508 printf (_("Audit library"));
5512 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5513 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5517 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5526 printf (_("Flags:"));
5528 if (entry
->d_un
.d_val
== 0)
5529 printf (_(" None\n"));
5532 unsigned long int val
= entry
->d_un
.d_val
;
5534 if (val
& DTF_1_PARINIT
)
5536 printf (" PARINIT");
5537 val
^= DTF_1_PARINIT
;
5539 if (val
& DTF_1_CONFEXP
)
5541 printf (" CONFEXP");
5542 val
^= DTF_1_CONFEXP
;
5545 printf (" %lx", val
);
5554 printf (_("Flags:"));
5556 if (entry
->d_un
.d_val
== 0)
5557 printf (_(" None\n"));
5560 unsigned long int val
= entry
->d_un
.d_val
;
5562 if (val
& DF_P1_LAZYLOAD
)
5564 printf (" LAZYLOAD");
5565 val
^= DF_P1_LAZYLOAD
;
5567 if (val
& DF_P1_GROUPPERM
)
5569 printf (" GROUPPERM");
5570 val
^= DF_P1_GROUPPERM
;
5573 printf (" %lx", val
);
5582 printf (_("Flags:"));
5583 if (entry
->d_un
.d_val
== 0)
5584 printf (_(" None\n"));
5587 unsigned long int val
= entry
->d_un
.d_val
;
5594 if (val
& DF_1_GLOBAL
)
5599 if (val
& DF_1_GROUP
)
5604 if (val
& DF_1_NODELETE
)
5606 printf (" NODELETE");
5607 val
^= DF_1_NODELETE
;
5609 if (val
& DF_1_LOADFLTR
)
5611 printf (" LOADFLTR");
5612 val
^= DF_1_LOADFLTR
;
5614 if (val
& DF_1_INITFIRST
)
5616 printf (" INITFIRST");
5617 val
^= DF_1_INITFIRST
;
5619 if (val
& DF_1_NOOPEN
)
5624 if (val
& DF_1_ORIGIN
)
5629 if (val
& DF_1_DIRECT
)
5634 if (val
& DF_1_TRANS
)
5639 if (val
& DF_1_INTERPOSE
)
5641 printf (" INTERPOSE");
5642 val
^= DF_1_INTERPOSE
;
5644 if (val
& DF_1_NODEFLIB
)
5646 printf (" NODEFLIB");
5647 val
^= DF_1_NODEFLIB
;
5649 if (val
& DF_1_NODUMP
)
5654 if (val
& DF_1_CONLFAT
)
5656 printf (" CONLFAT");
5657 val
^= DF_1_CONLFAT
;
5660 printf (" %lx", val
);
5667 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5669 puts (get_dynamic_type (entry
->d_un
.d_val
));
5689 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5695 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5696 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
5702 switch (entry
->d_tag
)
5705 printf (_("Shared library: [%s]"), name
);
5707 if (streq (name
, program_interpreter
))
5708 printf (_(" program interpreter"));
5712 printf (_("Library soname: [%s]"), name
);
5716 printf (_("Library rpath: [%s]"), name
);
5720 printf (_("Library runpath: [%s]"), name
);
5724 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5729 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5742 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5746 case DT_INIT_ARRAYSZ
:
5747 case DT_FINI_ARRAYSZ
:
5748 case DT_GNU_CONFLICTSZ
:
5749 case DT_GNU_LIBLISTSZ
:
5752 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5753 printf (" (bytes)\n");
5763 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5776 if (entry
->d_tag
== DT_USED
5777 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5779 char *name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
5783 printf (_("Not needed object: [%s]\n"), name
);
5788 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5794 /* The value of this entry is ignored. */
5799 case DT_GNU_PRELINKED
:
5803 time_t time
= entry
->d_un
.d_val
;
5805 tmp
= gmtime (&time
);
5806 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
5807 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5808 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5814 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
5815 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
5820 switch (elf_header
.e_machine
)
5823 case EM_MIPS_RS3_LE
:
5824 dynamic_section_mips_val (entry
);
5827 dynamic_section_parisc_val (entry
);
5830 dynamic_section_ia64_val (entry
);
5833 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5845 get_ver_flags (unsigned int flags
)
5847 static char buff
[32];
5854 if (flags
& VER_FLG_BASE
)
5855 strcat (buff
, "BASE ");
5857 if (flags
& VER_FLG_WEAK
)
5859 if (flags
& VER_FLG_BASE
)
5860 strcat (buff
, "| ");
5862 strcat (buff
, "WEAK ");
5865 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
5866 strcat (buff
, "| <unknown>");
5871 /* Display the contents of the version sections. */
5873 process_version_sections (FILE *file
)
5875 Elf_Internal_Shdr
*section
;
5882 for (i
= 0, section
= section_headers
;
5883 i
< elf_header
.e_shnum
;
5886 switch (section
->sh_type
)
5888 case SHT_GNU_verdef
:
5890 Elf_External_Verdef
*edefs
;
5897 (_("\nVersion definition section '%s' contains %ld entries:\n"),
5898 SECTION_NAME (section
), section
->sh_info
);
5900 printf (_(" Addr: 0x"));
5901 printf_vma (section
->sh_addr
);
5902 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5903 (unsigned long) section
->sh_offset
, section
->sh_link
,
5904 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
5906 edefs
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
5907 _("version definition section"));
5911 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
5914 Elf_External_Verdef
*edef
;
5915 Elf_Internal_Verdef ent
;
5916 Elf_External_Verdaux
*eaux
;
5917 Elf_Internal_Verdaux aux
;
5921 vstart
= ((char *) edefs
) + idx
;
5923 edef
= (Elf_External_Verdef
*) vstart
;
5925 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
5926 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
5927 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
5928 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
5929 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
5930 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
5931 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
5933 printf (_(" %#06x: Rev: %d Flags: %s"),
5934 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
5936 printf (_(" Index: %d Cnt: %d "),
5937 ent
.vd_ndx
, ent
.vd_cnt
);
5939 vstart
+= ent
.vd_aux
;
5941 eaux
= (Elf_External_Verdaux
*) vstart
;
5943 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
5944 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
5946 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
5947 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
5949 printf (_("Name index: %ld\n"), aux
.vda_name
);
5951 isum
= idx
+ ent
.vd_aux
;
5953 for (j
= 1; j
< ent
.vd_cnt
; j
++)
5955 isum
+= aux
.vda_next
;
5956 vstart
+= aux
.vda_next
;
5958 eaux
= (Elf_External_Verdaux
*) vstart
;
5960 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
5961 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
5963 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
5964 printf (_(" %#06x: Parent %d: %s\n"),
5965 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
5967 printf (_(" %#06x: Parent %d, name index: %ld\n"),
5968 isum
, j
, aux
.vda_name
);
5978 case SHT_GNU_verneed
:
5980 Elf_External_Verneed
*eneed
;
5986 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
5987 SECTION_NAME (section
), section
->sh_info
);
5989 printf (_(" Addr: 0x"));
5990 printf_vma (section
->sh_addr
);
5991 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
5992 (unsigned long) section
->sh_offset
, section
->sh_link
,
5993 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
5995 eneed
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
5996 _("version need section"));
6000 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6002 Elf_External_Verneed
*entry
;
6003 Elf_Internal_Verneed ent
;
6008 vstart
= ((char *) eneed
) + idx
;
6010 entry
= (Elf_External_Verneed
*) vstart
;
6012 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6013 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6014 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6015 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6016 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6018 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6020 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6021 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6023 printf (_(" File: %lx"), ent
.vn_file
);
6025 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6027 vstart
+= ent
.vn_aux
;
6029 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6031 Elf_External_Vernaux
*eaux
;
6032 Elf_Internal_Vernaux aux
;
6034 eaux
= (Elf_External_Vernaux
*) vstart
;
6036 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6037 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6038 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6039 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6040 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6042 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6043 printf (_(" %#06x: Name: %s"),
6044 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6046 printf (_(" %#06x: Name index: %lx"),
6047 isum
, aux
.vna_name
);
6049 printf (_(" Flags: %s Version: %d\n"),
6050 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6052 isum
+= aux
.vna_next
;
6053 vstart
+= aux
.vna_next
;
6063 case SHT_GNU_versym
:
6065 Elf_Internal_Shdr
*link_section
;
6068 unsigned char *edata
;
6069 unsigned short *data
;
6071 Elf_Internal_Sym
*symbols
;
6072 Elf_Internal_Shdr
*string_sec
;
6075 link_section
= SECTION_HEADER (section
->sh_link
);
6076 total
= section
->sh_size
/ section
->sh_entsize
;
6080 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6082 string_sec
= SECTION_HEADER (link_section
->sh_link
);
6084 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
6085 string_sec
->sh_size
, _("version string table"));
6089 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6090 SECTION_NAME (section
), total
);
6092 printf (_(" Addr: "));
6093 printf_vma (section
->sh_addr
);
6094 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6095 (unsigned long) section
->sh_offset
, section
->sh_link
,
6096 SECTION_NAME (link_section
));
6098 off
= offset_from_vma (file
,
6099 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6100 total
* sizeof (short));
6101 edata
= get_data (NULL
, file
, off
, total
* sizeof (short),
6102 _("version symbol data"));
6109 data
= malloc (total
* sizeof (short));
6111 for (cnt
= total
; cnt
--;)
6112 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6117 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6120 int check_def
, check_need
;
6123 printf (" %03x:", cnt
);
6125 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6126 switch (data
[cnt
+ j
])
6129 fputs (_(" 0 (*local*) "), stdout
);
6133 fputs (_(" 1 (*global*) "), stdout
);
6137 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
6138 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
6142 if (SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
6145 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6152 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6154 Elf_Internal_Verneed ivn
;
6155 unsigned long offset
;
6157 offset
= offset_from_vma
6158 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6159 sizeof (Elf_External_Verneed
));
6163 Elf_Internal_Vernaux ivna
;
6164 Elf_External_Verneed evn
;
6165 Elf_External_Vernaux evna
;
6166 unsigned long a_off
;
6168 get_data (&evn
, file
, offset
, sizeof (evn
),
6171 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6172 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6174 a_off
= offset
+ ivn
.vn_aux
;
6178 get_data (&evna
, file
, a_off
, sizeof (evna
),
6179 _("version need aux (2)"));
6181 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6182 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6184 a_off
+= ivna
.vna_next
;
6186 while (ivna
.vna_other
!= data
[cnt
+ j
]
6187 && ivna
.vna_next
!= 0);
6189 if (ivna
.vna_other
== data
[cnt
+ j
])
6191 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6193 name
= strtab
+ ivna
.vna_name
;
6194 nn
+= printf ("(%s%-*s",
6196 12 - (int) strlen (name
),
6202 offset
+= ivn
.vn_next
;
6204 while (ivn
.vn_next
);
6207 if (check_def
&& data
[cnt
+ j
] != 0x8001
6208 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6210 Elf_Internal_Verdef ivd
;
6211 Elf_External_Verdef evd
;
6212 unsigned long offset
;
6214 offset
= offset_from_vma
6215 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6220 get_data (&evd
, file
, offset
, sizeof (evd
),
6223 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6224 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6226 offset
+= ivd
.vd_next
;
6228 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
6229 && ivd
.vd_next
!= 0);
6231 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
6233 Elf_External_Verdaux evda
;
6234 Elf_Internal_Verdaux ivda
;
6236 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6238 get_data (&evda
, file
,
6239 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
6240 sizeof (evda
), _("version def aux"));
6242 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6244 name
= strtab
+ ivda
.vda_name
;
6245 nn
+= printf ("(%s%-*s",
6247 12 - (int) strlen (name
),
6253 printf ("%*c", 18 - nn
, ' ');
6271 printf (_("\nNo version information found in this file.\n"));
6277 get_symbol_binding (unsigned int binding
)
6279 static char buff
[32];
6283 case STB_LOCAL
: return "LOCAL";
6284 case STB_GLOBAL
: return "GLOBAL";
6285 case STB_WEAK
: return "WEAK";
6287 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
6288 sprintf (buff
, _("<processor specific>: %d"), binding
);
6289 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
6290 sprintf (buff
, _("<OS specific>: %d"), binding
);
6292 sprintf (buff
, _("<unknown>: %d"), binding
);
6298 get_symbol_type (unsigned int type
)
6300 static char buff
[32];
6304 case STT_NOTYPE
: return "NOTYPE";
6305 case STT_OBJECT
: return "OBJECT";
6306 case STT_FUNC
: return "FUNC";
6307 case STT_SECTION
: return "SECTION";
6308 case STT_FILE
: return "FILE";
6309 case STT_COMMON
: return "COMMON";
6310 case STT_TLS
: return "TLS";
6312 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
6314 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
6315 return "THUMB_FUNC";
6317 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
6320 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
6321 return "PARISC_MILLI";
6323 sprintf (buff
, _("<processor specific>: %d"), type
);
6325 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
6327 if (elf_header
.e_machine
== EM_PARISC
)
6329 if (type
== STT_HP_OPAQUE
)
6331 if (type
== STT_HP_STUB
)
6335 sprintf (buff
, _("<OS specific>: %d"), type
);
6338 sprintf (buff
, _("<unknown>: %d"), type
);
6344 get_symbol_visibility (unsigned int visibility
)
6348 case STV_DEFAULT
: return "DEFAULT";
6349 case STV_INTERNAL
: return "INTERNAL";
6350 case STV_HIDDEN
: return "HIDDEN";
6351 case STV_PROTECTED
: return "PROTECTED";
6357 get_symbol_index_type (unsigned int type
)
6359 static char buff
[32];
6363 case SHN_UNDEF
: return "UND";
6364 case SHN_ABS
: return "ABS";
6365 case SHN_COMMON
: return "COM";
6367 if (type
== SHN_IA_64_ANSI_COMMON
6368 && elf_header
.e_machine
== EM_IA_64
6369 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
6371 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
6372 sprintf (buff
, "PRC[0x%04x]", type
);
6373 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
6374 sprintf (buff
, "OS [0x%04x]", type
);
6375 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
6376 sprintf (buff
, "RSV[0x%04x]", type
);
6378 sprintf (buff
, "%3d", type
);
6386 get_dynamic_data (FILE *file
, unsigned int number
)
6388 unsigned char *e_data
;
6391 e_data
= malloc (number
* 4);
6395 error (_("Out of memory\n"));
6399 if (fread (e_data
, 4, number
, file
) != number
)
6401 error (_("Unable to read in dynamic data\n"));
6405 i_data
= malloc (number
* sizeof (*i_data
));
6409 error (_("Out of memory\n"));
6415 i_data
[number
] = byte_get (e_data
+ number
* 4, 4);
6422 /* Dump the symbol table. */
6424 process_symbol_table (FILE *file
)
6426 Elf_Internal_Shdr
*section
;
6427 unsigned char nb
[4];
6428 unsigned char nc
[4];
6431 int *buckets
= NULL
;
6434 if (! do_syms
&& !do_histogram
)
6437 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
6441 (archive_file_offset
6442 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
6443 sizeof nb
+ sizeof nc
)),
6446 error (_("Unable to seek to start of dynamic information"));
6450 if (fread (nb
, sizeof (nb
), 1, file
) != 1)
6452 error (_("Failed to read in number of buckets\n"));
6456 if (fread (nc
, sizeof (nc
), 1, file
) != 1)
6458 error (_("Failed to read in number of chains\n"));
6462 nbuckets
= byte_get (nb
, 4);
6463 nchains
= byte_get (nc
, 4);
6465 buckets
= get_dynamic_data (file
, nbuckets
);
6466 chains
= get_dynamic_data (file
, nchains
);
6468 if (buckets
== NULL
|| chains
== NULL
)
6473 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
6478 printf (_("\nSymbol table for image:\n"));
6480 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6482 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6484 for (hn
= 0; hn
< nbuckets
; hn
++)
6489 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
6491 Elf_Internal_Sym
*psym
;
6493 psym
= dynamic_symbols
+ si
;
6495 printf (" %3d %3d: ", si
, hn
);
6496 print_vma (psym
->st_value
, LONG_HEX
);
6498 print_vma (psym
->st_size
, DEC_5
);
6500 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6501 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6502 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6503 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
6504 if (VALID_DYNAMIC_NAME (psym
->st_name
))
6505 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
6507 printf (" <corrupt: %14ld>", psym
->st_name
);
6512 else if (do_syms
&& !do_using_dynamic
)
6516 for (i
= 0, section
= section_headers
;
6517 i
< elf_header
.e_shnum
;
6522 Elf_Internal_Sym
*symtab
;
6523 Elf_Internal_Sym
*psym
;
6526 if ( section
->sh_type
!= SHT_SYMTAB
6527 && section
->sh_type
!= SHT_DYNSYM
)
6530 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
6531 SECTION_NAME (section
),
6532 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
6534 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6536 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6538 symtab
= GET_ELF_SYMBOLS (file
, section
);
6542 if (section
->sh_link
== elf_header
.e_shstrndx
)
6543 strtab
= string_table
;
6546 Elf_Internal_Shdr
*string_sec
;
6548 string_sec
= SECTION_HEADER (section
->sh_link
);
6550 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
6551 string_sec
->sh_size
, _("string table"));
6554 for (si
= 0, psym
= symtab
;
6555 si
< section
->sh_size
/ section
->sh_entsize
;
6558 printf ("%6d: ", si
);
6559 print_vma (psym
->st_value
, LONG_HEX
);
6561 print_vma (psym
->st_size
, DEC_5
);
6562 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6563 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6564 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6565 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
6566 print_symbol (25, strtab
+ psym
->st_name
);
6568 if (section
->sh_type
== SHT_DYNSYM
&&
6569 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
6571 unsigned char data
[2];
6572 unsigned short vers_data
;
6573 unsigned long offset
;
6577 offset
= offset_from_vma
6578 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6579 sizeof data
+ si
* sizeof (vers_data
));
6581 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
6582 sizeof (data
), _("version data"));
6584 vers_data
= byte_get (data
, 2);
6586 is_nobits
= (SECTION_HEADER (psym
->st_shndx
)->sh_type
6589 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
6591 if ((vers_data
& 0x8000) || vers_data
> 1)
6593 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
6594 && (is_nobits
|| ! check_def
))
6596 Elf_External_Verneed evn
;
6597 Elf_Internal_Verneed ivn
;
6598 Elf_Internal_Vernaux ivna
;
6600 /* We must test both. */
6601 offset
= offset_from_vma
6602 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6607 unsigned long vna_off
;
6609 get_data (&evn
, file
, offset
, sizeof (evn
),
6612 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6613 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6615 vna_off
= offset
+ ivn
.vn_aux
;
6619 Elf_External_Vernaux evna
;
6621 get_data (&evna
, file
, vna_off
,
6623 _("version need aux (3)"));
6625 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6626 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6627 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6629 vna_off
+= ivna
.vna_next
;
6631 while (ivna
.vna_other
!= vers_data
6632 && ivna
.vna_next
!= 0);
6634 if (ivna
.vna_other
== vers_data
)
6637 offset
+= ivn
.vn_next
;
6639 while (ivn
.vn_next
!= 0);
6641 if (ivna
.vna_other
== vers_data
)
6644 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
6647 else if (! is_nobits
)
6648 error (_("bad dynamic symbol"));
6655 if (vers_data
!= 0x8001
6656 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6658 Elf_Internal_Verdef ivd
;
6659 Elf_Internal_Verdaux ivda
;
6660 Elf_External_Verdaux evda
;
6661 unsigned long offset
;
6663 offset
= offset_from_vma
6665 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6666 sizeof (Elf_External_Verdef
));
6670 Elf_External_Verdef evd
;
6672 get_data (&evd
, file
, offset
, sizeof (evd
),
6675 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6676 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6677 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6679 offset
+= ivd
.vd_next
;
6681 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
6682 && ivd
.vd_next
!= 0);
6684 offset
-= ivd
.vd_next
;
6685 offset
+= ivd
.vd_aux
;
6687 get_data (&evda
, file
, offset
, sizeof (evda
),
6688 _("version def aux"));
6690 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6692 if (psym
->st_name
!= ivda
.vda_name
)
6693 printf ((vers_data
& 0x8000)
6695 strtab
+ ivda
.vda_name
);
6705 if (strtab
!= string_table
)
6711 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
6713 if (do_histogram
&& buckets
!= NULL
)
6720 int nzero_counts
= 0;
6723 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
6725 printf (_(" Length Number %% of total Coverage\n"));
6727 lengths
= calloc (nbuckets
, sizeof (int));
6728 if (lengths
== NULL
)
6730 error (_("Out of memory"));
6733 for (hn
= 0; hn
< nbuckets
; ++hn
)
6738 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
6741 if (maxlength
< ++lengths
[hn
])
6746 counts
= calloc (maxlength
+ 1, sizeof (int));
6749 error (_("Out of memory"));
6753 for (hn
= 0; hn
< nbuckets
; ++hn
)
6754 ++counts
[lengths
[hn
]];
6758 printf (" 0 %-10d (%5.1f%%)\n",
6759 counts
[0], (counts
[0] * 100.0) / nbuckets
);
6760 for (si
= 1; si
<= maxlength
; ++si
)
6762 nzero_counts
+= counts
[si
] * si
;
6763 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
6764 si
, counts
[si
], (counts
[si
] * 100.0) / nbuckets
,
6765 (nzero_counts
* 100.0) / nsyms
);
6773 if (buckets
!= NULL
)
6783 process_syminfo (FILE *file ATTRIBUTE_UNUSED
)
6787 if (dynamic_syminfo
== NULL
6789 /* No syminfo, this is ok. */
6792 /* There better should be a dynamic symbol section. */
6793 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
6797 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
6798 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
6800 printf (_(" Num: Name BoundTo Flags\n"));
6801 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
6803 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
6805 printf ("%4d: ", i
);
6806 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
6807 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
6809 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
6812 switch (dynamic_syminfo
[i
].si_boundto
)
6814 case SYMINFO_BT_SELF
:
6815 fputs ("SELF ", stdout
);
6817 case SYMINFO_BT_PARENT
:
6818 fputs ("PARENT ", stdout
);
6821 if (dynamic_syminfo
[i
].si_boundto
> 0
6822 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
6823 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
6825 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
6829 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
6833 if (flags
& SYMINFO_FLG_DIRECT
)
6835 if (flags
& SYMINFO_FLG_PASSTHRU
)
6836 printf (" PASSTHRU");
6837 if (flags
& SYMINFO_FLG_COPY
)
6839 if (flags
& SYMINFO_FLG_LAZYLOAD
)
6840 printf (" LAZYLOAD");
6848 #ifdef SUPPORT_DISASSEMBLY
6850 disassemble_section (Elf_Internal_Shdr
*section
, FILE *file
)
6852 printf (_("\nAssembly dump of section %s\n"),
6853 SECTION_NAME (section
));
6855 /* XXX -- to be done --- XXX */
6862 dump_section (Elf_Internal_Shdr
*section
, FILE *file
)
6864 bfd_size_type bytes
;
6866 unsigned char *data
;
6867 unsigned char *start
;
6869 bytes
= section
->sh_size
;
6871 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
6873 printf (_("\nSection '%s' has no data to dump.\n"),
6874 SECTION_NAME (section
));
6878 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
6880 addr
= section
->sh_addr
;
6882 start
= get_data (NULL
, file
, section
->sh_offset
, bytes
, _("section data"));
6894 lbytes
= (bytes
> 16 ? 16 : bytes
);
6896 printf (" 0x%8.8lx ", (unsigned long) addr
);
6898 switch (elf_header
.e_ident
[EI_DATA
])
6902 for (j
= 15; j
>= 0; j
--)
6905 printf ("%2.2x", data
[j
]);
6915 for (j
= 0; j
< 16; j
++)
6918 printf ("%2.2x", data
[j
]);
6928 for (j
= 0; j
< lbytes
; j
++)
6931 if (k
>= ' ' && k
< 0x7f)
6950 static unsigned long int
6951 read_leb128 (unsigned char *data
, int *length_return
, int sign
)
6953 unsigned long int result
= 0;
6954 unsigned int num_read
= 0;
6955 unsigned int shift
= 0;
6963 result
|= ((unsigned long int) (byte
& 0x7f)) << shift
;
6968 while (byte
& 0x80);
6970 if (length_return
!= NULL
)
6971 *length_return
= num_read
;
6973 if (sign
&& (shift
< 8 * sizeof (result
)) && (byte
& 0x40))
6974 result
|= -1L << shift
;
6979 typedef struct State_Machine_Registers
6981 unsigned long address
;
6984 unsigned int column
;
6988 /* This variable hold the number of the last entry seen
6989 in the File Table. */
6990 unsigned int last_file_entry
;
6993 static SMR state_machine_regs
;
6996 reset_state_machine (int is_stmt
)
6998 state_machine_regs
.address
= 0;
6999 state_machine_regs
.file
= 1;
7000 state_machine_regs
.line
= 1;
7001 state_machine_regs
.column
= 0;
7002 state_machine_regs
.is_stmt
= is_stmt
;
7003 state_machine_regs
.basic_block
= 0;
7004 state_machine_regs
.end_sequence
= 0;
7005 state_machine_regs
.last_file_entry
= 0;
7008 /* Handled an extend line op. Returns true if this is the end
7012 process_extended_line_op (unsigned char *data
, int is_stmt
, int pointer_size
)
7014 unsigned char op_code
;
7017 unsigned char *name
;
7020 len
= read_leb128 (data
, & bytes_read
, 0);
7025 warn (_("badly formed extended line op encountered!\n"));
7032 printf (_(" Extended opcode %d: "), op_code
);
7036 case DW_LNE_end_sequence
:
7037 printf (_("End of Sequence\n\n"));
7038 reset_state_machine (is_stmt
);
7041 case DW_LNE_set_address
:
7042 adr
= byte_get (data
, pointer_size
);
7043 printf (_("set Address to 0x%lx\n"), adr
);
7044 state_machine_regs
.address
= adr
;
7047 case DW_LNE_define_file
:
7048 printf (_(" define new File Table entry\n"));
7049 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
7051 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
7053 data
+= strlen ((char *) data
) + 1;
7054 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7056 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7058 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7059 printf (_("%s\n\n"), name
);
7063 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
7070 static const char *debug_str_contents
;
7071 static bfd_vma debug_str_size
;
7074 load_debug_str (FILE *file
)
7076 Elf_Internal_Shdr
*sec
;
7078 /* If it is already loaded, do nothing. */
7079 if (debug_str_contents
!= NULL
)
7082 /* Locate the .debug_str section. */
7083 sec
= find_section (".debug_str");
7087 debug_str_size
= sec
->sh_size
;
7089 debug_str_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7090 _("debug_str section data"));
7094 free_debug_str (void)
7096 if (debug_str_contents
== NULL
)
7099 free ((char *) debug_str_contents
);
7100 debug_str_contents
= NULL
;
7105 fetch_indirect_string (unsigned long offset
)
7107 if (debug_str_contents
== NULL
)
7108 return _("<no .debug_str section>");
7110 if (offset
> debug_str_size
)
7111 return _("<offset is too big>");
7113 return debug_str_contents
+ offset
;
7116 static const char *debug_loc_contents
;
7117 static bfd_vma debug_loc_size
;
7120 load_debug_loc (FILE *file
)
7122 Elf_Internal_Shdr
*sec
;
7124 /* If it is already loaded, do nothing. */
7125 if (debug_loc_contents
!= NULL
)
7128 /* Locate the .debug_loc section. */
7129 sec
= find_section (".debug_loc");
7133 debug_loc_size
= sec
->sh_size
;
7135 debug_loc_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7136 _("debug_loc section data"));
7140 free_debug_loc (void)
7142 if (debug_loc_contents
== NULL
)
7145 free ((char *) debug_loc_contents
);
7146 debug_loc_contents
= NULL
;
7150 static const char * debug_range_contents
;
7151 static unsigned long debug_range_size
;
7154 load_debug_range (FILE *file
)
7156 Elf_Internal_Shdr
*sec
;
7158 /* If it is already loaded, do nothing. */
7159 if (debug_range_contents
!= NULL
)
7162 /* Locate the .debug_str section. */
7163 sec
= find_section (".debug_ranges");
7167 debug_range_size
= sec
->sh_size
;
7169 debug_range_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7170 _("debug_range section data"));
7174 free_debug_range (void)
7176 if (debug_range_contents
== NULL
)
7179 free ((char *) debug_range_contents
);
7180 debug_range_contents
= NULL
;
7181 debug_range_size
= 0;
7184 /* Apply addends of RELA relocations. */
7187 debug_apply_rela_addends (FILE *file
,
7188 Elf_Internal_Shdr
*section
,
7190 unsigned char *sec_data
,
7191 unsigned char *start
,
7194 Elf_Internal_Shdr
*relsec
;
7196 if (end
- start
< reloc_size
)
7199 for (relsec
= section_headers
;
7200 relsec
< section_headers
+ elf_header
.e_shnum
;
7203 unsigned long nrelas
;
7204 Elf_Internal_Rela
*rela
, *rp
;
7205 Elf_Internal_Shdr
*symsec
;
7206 Elf_Internal_Sym
*symtab
;
7207 Elf_Internal_Sym
*sym
;
7209 if (relsec
->sh_type
!= SHT_RELA
7210 || SECTION_HEADER (relsec
->sh_info
) != section
7211 || relsec
->sh_size
== 0)
7214 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7218 symsec
= SECTION_HEADER (relsec
->sh_link
);
7219 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
7221 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7225 if (rp
->r_offset
>= (bfd_vma
) (start
- sec_data
)
7226 && rp
->r_offset
< (bfd_vma
) (end
- sec_data
) - reloc_size
)
7227 loc
= sec_data
+ rp
->r_offset
;
7233 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
7235 if (ELF32_R_SYM (rp
->r_info
) != 0
7236 && ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
7237 /* Relocations against object symbols can happen,
7238 eg when referencing a global array. For an
7239 example of this see the _clz.o binary in libgcc.a. */
7240 && ELF32_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7242 warn (_("%s: skipping unexpected symbol type %s in relocation in section .rela%s\n"),
7243 get_symbol_type (ELF32_ST_TYPE (sym
->st_info
)),
7244 SECTION_NAME (section
));
7250 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
7252 if (ELF64_R_SYM (rp
->r_info
) != 0
7253 && ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
7254 && ELF64_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7256 warn (_("skipping unexpected symbol type %s in relocation in section .rela.%s\n"),
7257 get_symbol_type (ELF64_ST_TYPE (sym
->st_info
)),
7258 SECTION_NAME (section
));
7263 byte_put (loc
, rp
->r_addend
, reloc_size
);
7273 /* FIXME: There are better and more efficient ways to handle
7274 these structures. For now though, I just want something that
7275 is simple to implement. */
7276 typedef struct abbrev_attr
7278 unsigned long attribute
;
7280 struct abbrev_attr
*next
;
7284 typedef struct abbrev_entry
7286 unsigned long entry
;
7289 struct abbrev_attr
*first_attr
;
7290 struct abbrev_attr
*last_attr
;
7291 struct abbrev_entry
*next
;
7295 static abbrev_entry
*first_abbrev
= NULL
;
7296 static abbrev_entry
*last_abbrev
= NULL
;
7301 abbrev_entry
*abbrev
;
7303 for (abbrev
= first_abbrev
; abbrev
;)
7305 abbrev_entry
*next
= abbrev
->next
;
7308 for (attr
= abbrev
->first_attr
; attr
;)
7310 abbrev_attr
*next
= attr
->next
;
7320 last_abbrev
= first_abbrev
= NULL
;
7324 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
7326 abbrev_entry
*entry
;
7328 entry
= malloc (sizeof (*entry
));
7334 entry
->entry
= number
;
7336 entry
->children
= children
;
7337 entry
->first_attr
= NULL
;
7338 entry
->last_attr
= NULL
;
7341 if (first_abbrev
== NULL
)
7342 first_abbrev
= entry
;
7344 last_abbrev
->next
= entry
;
7346 last_abbrev
= entry
;
7350 add_abbrev_attr (unsigned long attribute
, unsigned long form
)
7354 attr
= malloc (sizeof (*attr
));
7360 attr
->attribute
= attribute
;
7364 if (last_abbrev
->first_attr
== NULL
)
7365 last_abbrev
->first_attr
= attr
;
7367 last_abbrev
->last_attr
->next
= attr
;
7369 last_abbrev
->last_attr
= attr
;
7372 /* Processes the (partial) contents of a .debug_abbrev section.
7373 Returns NULL if the end of the section was encountered.
7374 Returns the address after the last byte read if the end of
7375 an abbreviation set was found. */
7377 static unsigned char *
7378 process_abbrev_section (unsigned char *start
, unsigned char *end
)
7380 if (first_abbrev
!= NULL
)
7386 unsigned long entry
;
7388 unsigned long attribute
;
7391 entry
= read_leb128 (start
, & bytes_read
, 0);
7392 start
+= bytes_read
;
7394 /* A single zero is supposed to end the section according
7395 to the standard. If there's more, then signal that to
7398 return start
== end
? NULL
: start
;
7400 tag
= read_leb128 (start
, & bytes_read
, 0);
7401 start
+= bytes_read
;
7403 children
= *start
++;
7405 add_abbrev (entry
, tag
, children
);
7411 attribute
= read_leb128 (start
, & bytes_read
, 0);
7412 start
+= bytes_read
;
7414 form
= read_leb128 (start
, & bytes_read
, 0);
7415 start
+= bytes_read
;
7418 add_abbrev_attr (attribute
, form
);
7420 while (attribute
!= 0);
7427 get_TAG_name (unsigned long tag
)
7431 case DW_TAG_padding
: return "DW_TAG_padding";
7432 case DW_TAG_array_type
: return "DW_TAG_array_type";
7433 case DW_TAG_class_type
: return "DW_TAG_class_type";
7434 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
7435 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
7436 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
7437 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
7438 case DW_TAG_label
: return "DW_TAG_label";
7439 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
7440 case DW_TAG_member
: return "DW_TAG_member";
7441 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
7442 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
7443 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
7444 case DW_TAG_string_type
: return "DW_TAG_string_type";
7445 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
7446 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
7447 case DW_TAG_typedef
: return "DW_TAG_typedef";
7448 case DW_TAG_union_type
: return "DW_TAG_union_type";
7449 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
7450 case DW_TAG_variant
: return "DW_TAG_variant";
7451 case DW_TAG_common_block
: return "DW_TAG_common_block";
7452 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
7453 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
7454 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
7455 case DW_TAG_module
: return "DW_TAG_module";
7456 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
7457 case DW_TAG_set_type
: return "DW_TAG_set_type";
7458 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
7459 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
7460 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
7461 case DW_TAG_base_type
: return "DW_TAG_base_type";
7462 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
7463 case DW_TAG_const_type
: return "DW_TAG_const_type";
7464 case DW_TAG_constant
: return "DW_TAG_constant";
7465 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
7466 case DW_TAG_file_type
: return "DW_TAG_file_type";
7467 case DW_TAG_friend
: return "DW_TAG_friend";
7468 case DW_TAG_namelist
: return "DW_TAG_namelist";
7469 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
7470 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
7471 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
7472 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
7473 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
7474 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
7475 case DW_TAG_try_block
: return "DW_TAG_try_block";
7476 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
7477 case DW_TAG_variable
: return "DW_TAG_variable";
7478 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
7479 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
7480 case DW_TAG_format_label
: return "DW_TAG_format_label";
7481 case DW_TAG_function_template
: return "DW_TAG_function_template";
7482 case DW_TAG_class_template
: return "DW_TAG_class_template";
7483 /* DWARF 2.1 values. */
7484 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
7485 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
7486 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
7487 case DW_TAG_namespace
: return "DW_TAG_namespace";
7488 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
7489 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
7490 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
7491 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
7493 case DW_TAG_upc_shared_type
: return "DW_TAG_upc_shared_type";
7494 case DW_TAG_upc_strict_type
: return "DW_TAG_upc_strict_type";
7495 case DW_TAG_upc_relaxed_type
: return "DW_TAG_upc_relaxed_type";
7498 static char buffer
[100];
7500 sprintf (buffer
, _("Unknown TAG value: %lx"), tag
);
7507 get_FORM_name (unsigned long form
)
7511 case DW_FORM_addr
: return "DW_FORM_addr";
7512 case DW_FORM_block2
: return "DW_FORM_block2";
7513 case DW_FORM_block4
: return "DW_FORM_block4";
7514 case DW_FORM_data2
: return "DW_FORM_data2";
7515 case DW_FORM_data4
: return "DW_FORM_data4";
7516 case DW_FORM_data8
: return "DW_FORM_data8";
7517 case DW_FORM_string
: return "DW_FORM_string";
7518 case DW_FORM_block
: return "DW_FORM_block";
7519 case DW_FORM_block1
: return "DW_FORM_block1";
7520 case DW_FORM_data1
: return "DW_FORM_data1";
7521 case DW_FORM_flag
: return "DW_FORM_flag";
7522 case DW_FORM_sdata
: return "DW_FORM_sdata";
7523 case DW_FORM_strp
: return "DW_FORM_strp";
7524 case DW_FORM_udata
: return "DW_FORM_udata";
7525 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
7526 case DW_FORM_ref1
: return "DW_FORM_ref1";
7527 case DW_FORM_ref2
: return "DW_FORM_ref2";
7528 case DW_FORM_ref4
: return "DW_FORM_ref4";
7529 case DW_FORM_ref8
: return "DW_FORM_ref8";
7530 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
7531 case DW_FORM_indirect
: return "DW_FORM_indirect";
7534 static char buffer
[100];
7536 sprintf (buffer
, _("Unknown FORM value: %lx"), form
);
7542 static unsigned char *
7543 display_block (unsigned char *data
, unsigned long length
)
7545 printf (_(" %lu byte block: "), length
);
7548 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
7554 decode_location_expression (unsigned char * data
,
7555 unsigned int pointer_size
,
7556 unsigned long length
,
7557 unsigned long cu_offset
)
7561 unsigned long uvalue
;
7562 unsigned char *end
= data
+ length
;
7563 int need_frame_base
= 0;
7572 printf ("DW_OP_addr: %lx",
7573 (unsigned long) byte_get (data
, pointer_size
));
7574 data
+= pointer_size
;
7577 printf ("DW_OP_deref");
7580 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
7583 printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data
++, 1));
7586 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
7590 printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data
, 2));
7594 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
7598 printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data
, 4));
7602 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
7603 (unsigned long) byte_get (data
+ 4, 4));
7607 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
7608 (long) byte_get (data
+ 4, 4));
7612 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
7616 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
7620 printf ("DW_OP_dup");
7623 printf ("DW_OP_drop");
7626 printf ("DW_OP_over");
7629 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
7632 printf ("DW_OP_swap");
7635 printf ("DW_OP_rot");
7638 printf ("DW_OP_xderef");
7641 printf ("DW_OP_abs");
7644 printf ("DW_OP_and");
7647 printf ("DW_OP_div");
7650 printf ("DW_OP_minus");
7653 printf ("DW_OP_mod");
7656 printf ("DW_OP_mul");
7659 printf ("DW_OP_neg");
7662 printf ("DW_OP_not");
7665 printf ("DW_OP_or");
7668 printf ("DW_OP_plus");
7670 case DW_OP_plus_uconst
:
7671 printf ("DW_OP_plus_uconst: %lu",
7672 read_leb128 (data
, &bytes_read
, 0));
7676 printf ("DW_OP_shl");
7679 printf ("DW_OP_shr");
7682 printf ("DW_OP_shra");
7685 printf ("DW_OP_xor");
7688 printf ("DW_OP_bra: %ld", (long) byte_get_signed (data
, 2));
7692 printf ("DW_OP_eq");
7695 printf ("DW_OP_ge");
7698 printf ("DW_OP_gt");
7701 printf ("DW_OP_le");
7704 printf ("DW_OP_lt");
7707 printf ("DW_OP_ne");
7710 printf ("DW_OP_skip: %ld", (long) byte_get_signed (data
, 2));
7746 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
7781 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
7816 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
7817 read_leb128 (data
, &bytes_read
, 1));
7822 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
7826 need_frame_base
= 1;
7827 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
7831 uvalue
= read_leb128 (data
, &bytes_read
, 0);
7833 printf ("DW_OP_bregx: %lu %ld", uvalue
,
7834 read_leb128 (data
, &bytes_read
, 1));
7838 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
7841 case DW_OP_deref_size
:
7842 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
7844 case DW_OP_xderef_size
:
7845 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
7848 printf ("DW_OP_nop");
7851 /* DWARF 3 extensions. */
7852 case DW_OP_push_object_address
:
7853 printf ("DW_OP_push_object_address");
7856 /* XXX: Strictly speaking for 64-bit DWARF3 files
7857 this ought to be an 8-byte wide computation. */
7858 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2) + cu_offset
);
7862 /* XXX: Strictly speaking for 64-bit DWARF3 files
7863 this ought to be an 8-byte wide computation. */
7864 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4) + cu_offset
);
7867 case DW_OP_call_ref
:
7868 printf ("DW_OP_call_ref");
7871 /* GNU extensions. */
7872 case DW_OP_GNU_push_tls_address
:
7873 printf ("DW_OP_GNU_push_tls_address");
7877 if (op
>= DW_OP_lo_user
7878 && op
<= DW_OP_hi_user
)
7879 printf (_("(User defined location op)"));
7881 printf (_("(Unknown location op)"));
7882 /* No way to tell where the next op is, so just bail. */
7883 return need_frame_base
;
7886 /* Separate the ops. */
7891 return need_frame_base
;
7894 /* This structure records the information that
7895 we extract from the.debug_info section. */
7898 unsigned int pointer_size
;
7899 unsigned long cu_offset
;
7900 unsigned long base_address
;
7901 /* This is an array of offsets to the location list table. */
7902 unsigned long *loc_offsets
;
7903 int *have_frame_base
;
7904 unsigned int num_loc_offsets
;
7905 unsigned int max_loc_offsets
;
7906 unsigned long *range_lists
;
7907 unsigned int num_range_lists
;
7908 unsigned int max_range_lists
;
7912 static debug_info
* debug_information
= NULL
;
7913 static unsigned int num_debug_info_entries
= 0;
7914 static unsigned int last_pointer_size
= 0;
7915 static int warned_about_missing_comp_units
= FALSE
;
7917 static unsigned char *
7918 read_and_display_attr_value (unsigned long attribute
,
7920 unsigned char *data
,
7921 unsigned long cu_offset
,
7922 unsigned long pointer_size
,
7923 unsigned long offset_size
,
7925 debug_info
*debug_info_p
,
7928 unsigned long uvalue
= 0;
7929 unsigned char *block_start
= NULL
;
7937 case DW_FORM_ref_addr
:
7938 if (dwarf_version
== 2)
7940 uvalue
= byte_get (data
, pointer_size
);
7941 data
+= pointer_size
;
7943 else if (dwarf_version
== 3)
7945 uvalue
= byte_get (data
, offset_size
);
7946 data
+= offset_size
;
7950 error (_("Internal error: DWARF version is not 2 or 3.\n"));
7955 uvalue
= byte_get (data
, pointer_size
);
7956 data
+= pointer_size
;
7960 uvalue
= byte_get (data
, offset_size
);
7961 data
+= offset_size
;
7967 uvalue
= byte_get (data
++, 1);
7972 uvalue
= byte_get (data
, 2);
7978 uvalue
= byte_get (data
, 4);
7983 uvalue
= read_leb128 (data
, & bytes_read
, 1);
7987 case DW_FORM_ref_udata
:
7989 uvalue
= read_leb128 (data
, & bytes_read
, 0);
7993 case DW_FORM_indirect
:
7994 form
= read_leb128 (data
, & bytes_read
, 0);
7997 printf (" %s", get_FORM_name (form
));
7998 return read_and_display_attr_value (attribute
, form
, data
,
7999 cu_offset
, pointer_size
,
8000 offset_size
, dwarf_version
,
8001 debug_info_p
, do_loc
);
8006 case DW_FORM_ref_addr
:
8008 printf (" <#%lx>", uvalue
);
8014 case DW_FORM_ref_udata
:
8016 printf (" <%lx>", uvalue
+ cu_offset
);
8022 printf (" %#lx", uvalue
);
8031 printf (" %ld", uvalue
);
8038 uvalue
= byte_get (data
, 4);
8039 printf (" %lx", uvalue
);
8040 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
8042 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8043 && num_debug_info_entries
== 0)
8045 if (sizeof (uvalue
) == 8)
8046 uvalue
= byte_get (data
, 8);
8048 error (_("DW_FORM_data8 is unsupported when sizeof (unsigned long) != 8\n"));
8053 case DW_FORM_string
:
8055 printf (" %s", data
);
8056 data
+= strlen ((char *) data
) + 1;
8060 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8061 block_start
= data
+ bytes_read
;
8063 data
= block_start
+ uvalue
;
8065 data
= display_block (block_start
, uvalue
);
8068 case DW_FORM_block1
:
8069 uvalue
= byte_get (data
, 1);
8070 block_start
= data
+ 1;
8072 data
= block_start
+ uvalue
;
8074 data
= display_block (block_start
, uvalue
);
8077 case DW_FORM_block2
:
8078 uvalue
= byte_get (data
, 2);
8079 block_start
= data
+ 2;
8081 data
= block_start
+ uvalue
;
8083 data
= display_block (block_start
, uvalue
);
8086 case DW_FORM_block4
:
8087 uvalue
= byte_get (data
, 4);
8088 block_start
= data
+ 4;
8090 data
= block_start
+ uvalue
;
8092 data
= display_block (block_start
, uvalue
);
8097 printf (_(" (indirect string, offset: 0x%lx): %s"),
8098 uvalue
, fetch_indirect_string (uvalue
));
8101 case DW_FORM_indirect
:
8102 /* Handled above. */
8106 warn (_("Unrecognized form: %d\n"), form
);
8110 /* For some attributes we can display further information. */
8111 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8112 && num_debug_info_entries
== 0)
8116 case DW_AT_frame_base
:
8117 have_frame_base
= 1;
8118 case DW_AT_location
:
8119 case DW_AT_data_member_location
:
8120 case DW_AT_vtable_elem_location
:
8121 case DW_AT_allocated
:
8122 case DW_AT_associated
:
8123 case DW_AT_data_location
:
8125 case DW_AT_upper_bound
:
8126 case DW_AT_lower_bound
:
8127 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8129 /* Process location list. */
8130 unsigned int max
= debug_info_p
->max_loc_offsets
;
8131 unsigned int num
= debug_info_p
->num_loc_offsets
;
8133 if (max
== 0 || num
>= max
)
8136 debug_info_p
->loc_offsets
8137 = xrealloc (debug_info_p
->loc_offsets
,
8138 max
* sizeof (*debug_info_p
->loc_offsets
));
8139 debug_info_p
->have_frame_base
8140 = xrealloc (debug_info_p
->have_frame_base
,
8141 max
* sizeof (*debug_info_p
->have_frame_base
));
8142 debug_info_p
->max_loc_offsets
= max
;
8144 debug_info_p
->loc_offsets
[num
] = uvalue
;
8145 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
8146 debug_info_p
->num_loc_offsets
++;
8151 if (need_base_address
)
8152 debug_info_p
->base_address
= uvalue
;
8156 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8158 /* Process range list. */
8159 unsigned int max
= debug_info_p
->max_range_lists
;
8160 unsigned int num
= debug_info_p
->num_range_lists
;
8162 if (max
== 0 || num
>= max
)
8165 debug_info_p
->range_lists
8166 = xrealloc (debug_info_p
->range_lists
,
8167 max
* sizeof (*debug_info_p
->range_lists
));
8168 debug_info_p
->max_range_lists
= max
;
8170 debug_info_p
->range_lists
[num
] = uvalue
;
8171 debug_info_p
->num_range_lists
++;
8190 case DW_INL_not_inlined
:
8191 printf (_("(not inlined)"));
8193 case DW_INL_inlined
:
8194 printf (_("(inlined)"));
8196 case DW_INL_declared_not_inlined
:
8197 printf (_("(declared as inline but ignored)"));
8199 case DW_INL_declared_inlined
:
8200 printf (_("(declared as inline and inlined)"));
8203 printf (_(" (Unknown inline attribute value: %lx)"), uvalue
);
8208 case DW_AT_language
:
8211 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
8212 case DW_LANG_C89
: printf ("(ANSI C)"); break;
8213 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
8214 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
8215 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
8216 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
8217 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
8218 case DW_LANG_Ada83
: printf ("(Ada)"); break;
8219 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
8220 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
8221 /* DWARF 2.1 values. */
8222 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
8223 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
8224 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
8225 /* MIPS extension. */
8226 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
8227 /* UPC extension. */
8228 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
8230 printf ("(Unknown: %lx)", uvalue
);
8235 case DW_AT_encoding
:
8238 case DW_ATE_void
: printf ("(void)"); break;
8239 case DW_ATE_address
: printf ("(machine address)"); break;
8240 case DW_ATE_boolean
: printf ("(boolean)"); break;
8241 case DW_ATE_complex_float
: printf ("(complex float)"); break;
8242 case DW_ATE_float
: printf ("(float)"); break;
8243 case DW_ATE_signed
: printf ("(signed)"); break;
8244 case DW_ATE_signed_char
: printf ("(signed char)"); break;
8245 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
8246 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
8247 /* DWARF 2.1 value. */
8248 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
8250 if (uvalue
>= DW_ATE_lo_user
8251 && uvalue
<= DW_ATE_hi_user
)
8252 printf ("(user defined type)");
8254 printf ("(unknown type)");
8259 case DW_AT_accessibility
:
8262 case DW_ACCESS_public
: printf ("(public)"); break;
8263 case DW_ACCESS_protected
: printf ("(protected)"); break;
8264 case DW_ACCESS_private
: printf ("(private)"); break;
8266 printf ("(unknown accessibility)");
8271 case DW_AT_visibility
:
8274 case DW_VIS_local
: printf ("(local)"); break;
8275 case DW_VIS_exported
: printf ("(exported)"); break;
8276 case DW_VIS_qualified
: printf ("(qualified)"); break;
8277 default: printf ("(unknown visibility)"); break;
8281 case DW_AT_virtuality
:
8284 case DW_VIRTUALITY_none
: printf ("(none)"); break;
8285 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
8286 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
8287 default: printf ("(unknown virtuality)"); break;
8291 case DW_AT_identifier_case
:
8294 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
8295 case DW_ID_up_case
: printf ("(up_case)"); break;
8296 case DW_ID_down_case
: printf ("(down_case)"); break;
8297 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
8298 default: printf ("(unknown case)"); break;
8302 case DW_AT_calling_convention
:
8305 case DW_CC_normal
: printf ("(normal)"); break;
8306 case DW_CC_program
: printf ("(program)"); break;
8307 case DW_CC_nocall
: printf ("(nocall)"); break;
8309 if (uvalue
>= DW_CC_lo_user
8310 && uvalue
<= DW_CC_hi_user
)
8311 printf ("(user defined)");
8313 printf ("(unknown convention)");
8317 case DW_AT_ordering
:
8320 case -1: printf ("(undefined)"); break;
8321 case 0: printf ("(row major)"); break;
8322 case 1: printf ("(column major)"); break;
8326 case DW_AT_frame_base
:
8327 have_frame_base
= 1;
8328 case DW_AT_location
:
8329 case DW_AT_data_member_location
:
8330 case DW_AT_vtable_elem_location
:
8331 case DW_AT_allocated
:
8332 case DW_AT_associated
:
8333 case DW_AT_data_location
:
8335 case DW_AT_upper_bound
:
8336 case DW_AT_lower_bound
:
8339 int need_frame_base
;
8342 need_frame_base
= decode_location_expression (block_start
,
8347 if (need_frame_base
&& !have_frame_base
)
8348 printf (_(" [without DW_AT_frame_base]"));
8350 else if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8351 printf (_("(location list)"));
8363 get_AT_name (unsigned long attribute
)
8367 case DW_AT_sibling
: return "DW_AT_sibling";
8368 case DW_AT_location
: return "DW_AT_location";
8369 case DW_AT_name
: return "DW_AT_name";
8370 case DW_AT_ordering
: return "DW_AT_ordering";
8371 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
8372 case DW_AT_byte_size
: return "DW_AT_byte_size";
8373 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
8374 case DW_AT_bit_size
: return "DW_AT_bit_size";
8375 case DW_AT_element_list
: return "DW_AT_element_list";
8376 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
8377 case DW_AT_low_pc
: return "DW_AT_low_pc";
8378 case DW_AT_high_pc
: return "DW_AT_high_pc";
8379 case DW_AT_language
: return "DW_AT_language";
8380 case DW_AT_member
: return "DW_AT_member";
8381 case DW_AT_discr
: return "DW_AT_discr";
8382 case DW_AT_discr_value
: return "DW_AT_discr_value";
8383 case DW_AT_visibility
: return "DW_AT_visibility";
8384 case DW_AT_import
: return "DW_AT_import";
8385 case DW_AT_string_length
: return "DW_AT_string_length";
8386 case DW_AT_common_reference
: return "DW_AT_common_reference";
8387 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
8388 case DW_AT_const_value
: return "DW_AT_const_value";
8389 case DW_AT_containing_type
: return "DW_AT_containing_type";
8390 case DW_AT_default_value
: return "DW_AT_default_value";
8391 case DW_AT_inline
: return "DW_AT_inline";
8392 case DW_AT_is_optional
: return "DW_AT_is_optional";
8393 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
8394 case DW_AT_producer
: return "DW_AT_producer";
8395 case DW_AT_prototyped
: return "DW_AT_prototyped";
8396 case DW_AT_return_addr
: return "DW_AT_return_addr";
8397 case DW_AT_start_scope
: return "DW_AT_start_scope";
8398 case DW_AT_stride_size
: return "DW_AT_stride_size";
8399 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
8400 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
8401 case DW_AT_accessibility
: return "DW_AT_accessibility";
8402 case DW_AT_address_class
: return "DW_AT_address_class";
8403 case DW_AT_artificial
: return "DW_AT_artificial";
8404 case DW_AT_base_types
: return "DW_AT_base_types";
8405 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
8406 case DW_AT_count
: return "DW_AT_count";
8407 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
8408 case DW_AT_decl_column
: return "DW_AT_decl_column";
8409 case DW_AT_decl_file
: return "DW_AT_decl_file";
8410 case DW_AT_decl_line
: return "DW_AT_decl_line";
8411 case DW_AT_declaration
: return "DW_AT_declaration";
8412 case DW_AT_discr_list
: return "DW_AT_discr_list";
8413 case DW_AT_encoding
: return "DW_AT_encoding";
8414 case DW_AT_external
: return "DW_AT_external";
8415 case DW_AT_frame_base
: return "DW_AT_frame_base";
8416 case DW_AT_friend
: return "DW_AT_friend";
8417 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
8418 case DW_AT_macro_info
: return "DW_AT_macro_info";
8419 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
8420 case DW_AT_priority
: return "DW_AT_priority";
8421 case DW_AT_segment
: return "DW_AT_segment";
8422 case DW_AT_specification
: return "DW_AT_specification";
8423 case DW_AT_static_link
: return "DW_AT_static_link";
8424 case DW_AT_type
: return "DW_AT_type";
8425 case DW_AT_use_location
: return "DW_AT_use_location";
8426 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
8427 case DW_AT_virtuality
: return "DW_AT_virtuality";
8428 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
8429 /* DWARF 2.1 values. */
8430 case DW_AT_allocated
: return "DW_AT_allocated";
8431 case DW_AT_associated
: return "DW_AT_associated";
8432 case DW_AT_data_location
: return "DW_AT_data_location";
8433 case DW_AT_stride
: return "DW_AT_stride";
8434 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
8435 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
8436 case DW_AT_extension
: return "DW_AT_extension";
8437 case DW_AT_ranges
: return "DW_AT_ranges";
8438 case DW_AT_trampoline
: return "DW_AT_trampoline";
8439 case DW_AT_call_column
: return "DW_AT_call_column";
8440 case DW_AT_call_file
: return "DW_AT_call_file";
8441 case DW_AT_call_line
: return "DW_AT_call_line";
8442 /* SGI/MIPS extensions. */
8443 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
8444 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
8445 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
8446 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
8447 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
8448 case DW_AT_MIPS_software_pipeline_depth
:
8449 return "DW_AT_MIPS_software_pipeline_depth";
8450 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
8451 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
8452 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
8453 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
8454 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
8455 /* GNU extensions. */
8456 case DW_AT_sf_names
: return "DW_AT_sf_names";
8457 case DW_AT_src_info
: return "DW_AT_src_info";
8458 case DW_AT_mac_info
: return "DW_AT_mac_info";
8459 case DW_AT_src_coords
: return "DW_AT_src_coords";
8460 case DW_AT_body_begin
: return "DW_AT_body_begin";
8461 case DW_AT_body_end
: return "DW_AT_body_end";
8462 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
8463 /* UPC extension. */
8464 case DW_AT_upc_threads_scaled
: return "DW_AT_upc_threads_scaled";
8467 static char buffer
[100];
8469 sprintf (buffer
, _("Unknown AT value: %lx"), attribute
);
8475 static unsigned char *
8476 read_and_display_attr (unsigned long attribute
,
8478 unsigned char *data
,
8479 unsigned long cu_offset
,
8480 unsigned long pointer_size
,
8481 unsigned long offset_size
,
8483 debug_info
*debug_info_p
,
8487 printf (" %-18s:", get_AT_name (attribute
));
8488 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
8489 pointer_size
, offset_size
,
8490 dwarf_version
, debug_info_p
,
8498 /* Process the contents of a .debug_info section. If do_loc is non-zero
8499 then we are scanning for location lists and we do not want to display
8500 anything to the user. */
8503 process_debug_info (Elf_Internal_Shdr
*section
, unsigned char *start
,
8504 FILE *file
, int do_loc
)
8506 unsigned char *end
= start
+ section
->sh_size
;
8507 unsigned char *section_begin
;
8509 unsigned int num_units
= 0;
8511 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8512 && num_debug_info_entries
== 0)
8514 unsigned long length
;
8516 /* First scan the section to get the number of comp units. */
8517 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
8520 /* Read the first 4 bytes. For a 32-bit DWARF section, this
8521 will be the length. For a 64-bit DWARF section, it'll be
8522 the escape code 0xffffffff followed by an 8 byte length. */
8523 length
= byte_get (section_begin
, 4);
8525 if (length
== 0xffffffff)
8527 length
= byte_get (section_begin
+ 4, 8);
8528 section_begin
+= length
+ 12;
8531 section_begin
+= length
+ 4;
8536 error (_("No comp units in .debug_info section ?"));
8540 /* Then allocate an array to hold the information. */
8541 debug_information
= malloc (num_units
*
8542 sizeof (* debug_information
));
8543 if (debug_information
== NULL
)
8545 error (_("Not enough memory for a debug info array of %u entries"),
8553 printf (_("The section %s contains:\n\n"),
8554 SECTION_NAME (section
));
8556 load_debug_str (file
);
8557 load_debug_loc (file
);
8558 load_debug_range (file
);
8561 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
8563 DWARF2_Internal_CompUnit compunit
;
8564 unsigned char *hdrptr
;
8565 unsigned char *cu_abbrev_offset_ptr
;
8566 unsigned char *tags
;
8568 unsigned long cu_offset
;
8570 int initial_length_size
;
8574 compunit
.cu_length
= byte_get (hdrptr
, 4);
8577 if (compunit
.cu_length
== 0xffffffff)
8579 compunit
.cu_length
= byte_get (hdrptr
, 8);
8582 initial_length_size
= 12;
8587 initial_length_size
= 4;
8590 compunit
.cu_version
= byte_get (hdrptr
, 2);
8593 cu_offset
= start
- section_begin
;
8594 start
+= compunit
.cu_length
+ initial_length_size
;
8596 if (elf_header
.e_type
== ET_REL
8597 && !debug_apply_rela_addends (file
, section
, offset_size
,
8598 section_begin
, hdrptr
, start
))
8601 cu_abbrev_offset_ptr
= hdrptr
;
8602 compunit
.cu_abbrev_offset
= byte_get (hdrptr
, offset_size
);
8603 hdrptr
+= offset_size
;
8605 compunit
.cu_pointer_size
= byte_get (hdrptr
, 1);
8607 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8608 && num_debug_info_entries
== 0)
8610 debug_information
[unit
].cu_offset
= cu_offset
;
8611 debug_information
[unit
].pointer_size
8612 = compunit
.cu_pointer_size
;
8613 debug_information
[unit
].base_address
= 0;
8614 debug_information
[unit
].loc_offsets
= NULL
;
8615 debug_information
[unit
].have_frame_base
= NULL
;
8616 debug_information
[unit
].max_loc_offsets
= 0;
8617 debug_information
[unit
].num_loc_offsets
= 0;
8618 debug_information
[unit
].range_lists
= NULL
;
8619 debug_information
[unit
].max_range_lists
= 0;
8620 debug_information
[unit
].num_range_lists
= 0;
8627 printf (_(" Compilation Unit @ %lx:\n"), cu_offset
);
8628 printf (_(" Length: %ld\n"), compunit
.cu_length
);
8629 printf (_(" Version: %d\n"), compunit
.cu_version
);
8630 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
8631 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
8634 if (compunit
.cu_version
!= 2 && compunit
.cu_version
!= 3)
8636 warn (_("Only version 2 and 3 DWARF debug information is currently supported.\n"));
8642 /* Read in the abbrevs used by this compilation unit. */
8644 Elf_Internal_Shdr
*sec
;
8645 unsigned char *begin
;
8647 /* Locate the .debug_abbrev section and process it. */
8648 sec
= find_section (".debug_abbrev");
8651 warn (_("Unable to locate .debug_abbrev section!\n"));
8655 begin
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
8656 _("debug_abbrev section data"));
8660 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
8661 begin
+ sec
->sh_size
);
8667 while (tags
< start
)
8670 unsigned long abbrev_number
;
8671 abbrev_entry
*entry
;
8674 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
8677 /* A null DIE marks the end of a list of children. */
8678 if (abbrev_number
== 0)
8684 /* Scan through the abbreviation list until we reach the
8686 for (entry
= first_abbrev
;
8687 entry
&& entry
->entry
!= abbrev_number
;
8688 entry
= entry
->next
)
8693 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
8699 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
8701 (unsigned long) (tags
- section_begin
8704 get_TAG_name (entry
->tag
));
8709 need_base_address
= 0;
8711 case DW_TAG_compile_unit
:
8712 need_base_address
= 1;
8714 case DW_TAG_entry_point
:
8715 case DW_TAG_inlined_subroutine
:
8716 case DW_TAG_subprogram
:
8717 need_base_address
= 0;
8718 /* Assuming that there is no DW_AT_frame_base. */
8719 have_frame_base
= 0;
8723 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
8724 tags
= read_and_display_attr (attr
->attribute
,
8727 compunit
.cu_pointer_size
,
8729 compunit
.cu_version
,
8730 &debug_information
[unit
],
8733 if (entry
->children
)
8738 /* Set num_debug_info_entries here so that it can be used to check if
8739 we need to proecess .debug_loc and .debug_ranges sections. */
8740 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8741 && num_debug_info_entries
== 0)
8742 num_debug_info_entries
= num_units
;
8746 free_debug_range ();
8756 /* Retrieve the pointer size associated with the given compilation unit.
8757 Optionally the offset of this unit into the .debug_info section is
8758 also retutned. If there is no .debug_info section then an error
8759 message is issued and 0 is returned. If the requested comp unit has
8760 not been defined in the .debug_info section then a warning message
8761 is issued and the last know pointer size is returned. This message
8762 is only issued once per section dumped per file dumped. */
8765 get_pointer_size_and_offset_of_comp_unit (unsigned int comp_unit
,
8766 const char * section_name
,
8767 unsigned long * offset_return
)
8769 unsigned long offset
= 0;
8771 if (num_debug_info_entries
== 0)
8772 error (_("%s section needs a populated .debug_info section\n"),
8775 else if (comp_unit
>= num_debug_info_entries
)
8777 if (!warned_about_missing_comp_units
)
8779 warn (_("%s section has more comp units than .debug_info section\n"),
8781 warn (_("assuming that the pointer size is %d, from the last comp unit in .debug_info\n\n"),
8783 warned_about_missing_comp_units
= TRUE
;
8788 last_pointer_size
= debug_information
[comp_unit
].pointer_size
;
8789 offset
= debug_information
[comp_unit
].cu_offset
;
8792 if (offset_return
!= NULL
)
8793 * offset_return
= offset
;
8795 return last_pointer_size
;
8798 /* Locate and scan the .debug_info section in the file and record the pointer
8799 sizes and offsets for the compilation units in it. Usually an executable
8800 will have just one pointer size, but this is not guaranteed, and so we try
8801 not to make any assumptions. Returns zero upon failure, or the number of
8802 compilation units upon success. */
8805 get_debug_info (FILE * file
)
8807 Elf_Internal_Shdr
* section
;
8808 unsigned char * start
;
8811 /* Reset the last pointer size so that we can issue correct error
8812 messages if we are displaying the contents of more than one section. */
8813 last_pointer_size
= 0;
8814 warned_about_missing_comp_units
= FALSE
;
8816 /* If we already have the information there is nothing else to do. */
8817 if (num_debug_info_entries
> 0)
8818 return num_debug_info_entries
;
8820 section
= find_section (".debug_info");
8821 if (section
== NULL
)
8824 start
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
8825 _("extracting information from .debug_info section"));
8829 ret
= process_debug_info (section
, start
, file
, 1);
8832 return ret
? num_debug_info_entries
: 0;
8836 display_debug_lines (Elf_Internal_Shdr
*section
,
8837 unsigned char *start
, FILE *file
)
8839 unsigned char *data
= start
;
8840 unsigned char *end
= start
+ section
->sh_size
;
8841 unsigned int comp_unit
= 0;
8843 printf (_("\nDump of debug contents of section %s:\n\n"),
8844 SECTION_NAME (section
));
8846 get_debug_info (file
);
8850 DWARF2_Internal_LineInfo info
;
8851 unsigned char *standard_opcodes
;
8852 unsigned char *end_of_sequence
;
8853 unsigned char *hdrptr
;
8854 unsigned int pointer_size
;
8855 int initial_length_size
;
8861 /* Check the length of the block. */
8862 info
.li_length
= byte_get (hdrptr
, 4);
8865 if (info
.li_length
== 0xffffffff)
8867 /* This section is 64-bit DWARF 3. */
8868 info
.li_length
= byte_get (hdrptr
, 8);
8871 initial_length_size
= 12;
8876 initial_length_size
= 4;
8879 if (info
.li_length
+ initial_length_size
> section
->sh_size
)
8882 (_("The line info appears to be corrupt - the section is too small\n"));
8886 /* Check its version number. */
8887 info
.li_version
= byte_get (hdrptr
, 2);
8889 if (info
.li_version
!= 2 && info
.li_version
!= 3)
8891 warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
8895 info
.li_prologue_length
= byte_get (hdrptr
, offset_size
);
8896 hdrptr
+= offset_size
;
8897 info
.li_min_insn_length
= byte_get (hdrptr
, 1);
8899 info
.li_default_is_stmt
= byte_get (hdrptr
, 1);
8901 info
.li_line_base
= byte_get (hdrptr
, 1);
8903 info
.li_line_range
= byte_get (hdrptr
, 1);
8905 info
.li_opcode_base
= byte_get (hdrptr
, 1);
8908 /* Sign extend the line base field. */
8909 info
.li_line_base
<<= 24;
8910 info
.li_line_base
>>= 24;
8912 /* Get the pointer size from the comp unit associated
8913 with this block of line number information. */
8914 pointer_size
= get_pointer_size_and_offset_of_comp_unit
8915 (comp_unit
, ".debug_lines", NULL
);
8918 printf (_(" Length: %ld\n"), info
.li_length
);
8919 printf (_(" DWARF Version: %d\n"), info
.li_version
);
8920 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
8921 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
8922 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
8923 printf (_(" Line Base: %d\n"), info
.li_line_base
);
8924 printf (_(" Line Range: %d\n"), info
.li_line_range
);
8925 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
8926 printf (_(" (Pointer size: %u)\n"), pointer_size
);
8928 end_of_sequence
= data
+ info
.li_length
+ initial_length_size
;
8930 reset_state_machine (info
.li_default_is_stmt
);
8932 /* Display the contents of the Opcodes table. */
8933 standard_opcodes
= hdrptr
;
8935 printf (_("\n Opcodes:\n"));
8937 for (i
= 1; i
< info
.li_opcode_base
; i
++)
8938 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
8940 /* Display the contents of the Directory table. */
8941 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
8944 printf (_("\n The Directory Table is empty.\n"));
8947 printf (_("\n The Directory Table:\n"));
8951 printf (_(" %s\n"), data
);
8953 data
+= strlen ((char *) data
) + 1;
8957 /* Skip the NUL at the end of the table. */
8960 /* Display the contents of the File Name table. */
8962 printf (_("\n The File Name Table is empty.\n"));
8965 printf (_("\n The File Name Table:\n"));
8966 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
8970 unsigned char *name
;
8973 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
8976 data
+= strlen ((char *) data
) + 1;
8978 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
8980 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
8982 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
8984 printf (_("%s\n"), name
);
8988 /* Skip the NUL at the end of the table. */
8991 /* Now display the statements. */
8992 printf (_("\n Line Number Statements:\n"));
8994 while (data
< end_of_sequence
)
8996 unsigned char op_code
;
9002 if (op_code
>= info
.li_opcode_base
)
9004 op_code
-= info
.li_opcode_base
;
9005 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
9006 state_machine_regs
.address
+= adv
;
9007 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
9008 op_code
, adv
, state_machine_regs
.address
);
9009 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
9010 state_machine_regs
.line
+= adv
;
9011 printf (_(" and Line by %d to %d\n"),
9012 adv
, state_machine_regs
.line
);
9014 else switch (op_code
)
9016 case DW_LNS_extended_op
:
9017 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
9022 printf (_(" Copy\n"));
9025 case DW_LNS_advance_pc
:
9026 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
9028 state_machine_regs
.address
+= adv
;
9029 printf (_(" Advance PC by %d to %lx\n"), adv
,
9030 state_machine_regs
.address
);
9033 case DW_LNS_advance_line
:
9034 adv
= read_leb128 (data
, & bytes_read
, 1);
9036 state_machine_regs
.line
+= adv
;
9037 printf (_(" Advance Line by %d to %d\n"), adv
,
9038 state_machine_regs
.line
);
9041 case DW_LNS_set_file
:
9042 adv
= read_leb128 (data
, & bytes_read
, 0);
9044 printf (_(" Set File Name to entry %d in the File Name Table\n"),
9046 state_machine_regs
.file
= adv
;
9049 case DW_LNS_set_column
:
9050 adv
= read_leb128 (data
, & bytes_read
, 0);
9052 printf (_(" Set column to %d\n"), adv
);
9053 state_machine_regs
.column
= adv
;
9056 case DW_LNS_negate_stmt
:
9057 adv
= state_machine_regs
.is_stmt
;
9059 printf (_(" Set is_stmt to %d\n"), adv
);
9060 state_machine_regs
.is_stmt
= adv
;
9063 case DW_LNS_set_basic_block
:
9064 printf (_(" Set basic block\n"));
9065 state_machine_regs
.basic_block
= 1;
9068 case DW_LNS_const_add_pc
:
9069 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
9070 * info
.li_min_insn_length
);
9071 state_machine_regs
.address
+= adv
;
9072 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
9073 state_machine_regs
.address
);
9076 case DW_LNS_fixed_advance_pc
:
9077 adv
= byte_get (data
, 2);
9079 state_machine_regs
.address
+= adv
;
9080 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
9081 adv
, state_machine_regs
.address
);
9084 case DW_LNS_set_prologue_end
:
9085 printf (_(" Set prologue_end to true\n"));
9088 case DW_LNS_set_epilogue_begin
:
9089 printf (_(" Set epilogue_begin to true\n"));
9092 case DW_LNS_set_isa
:
9093 adv
= read_leb128 (data
, & bytes_read
, 0);
9095 printf (_(" Set ISA to %d\n"), adv
);
9099 printf (_(" Unknown opcode %d with operands: "), op_code
);
9101 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
9103 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
9104 i
== 1 ? "" : ", ");
9118 display_debug_pubnames (Elf_Internal_Shdr
*section
,
9119 unsigned char *start
,
9120 FILE *file ATTRIBUTE_UNUSED
)
9122 DWARF2_Internal_PubNames pubnames
;
9125 end
= start
+ section
->sh_size
;
9127 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9131 unsigned char *data
;
9132 unsigned long offset
;
9133 int offset_size
, initial_length_size
;
9137 pubnames
.pn_length
= byte_get (data
, 4);
9139 if (pubnames
.pn_length
== 0xffffffff)
9141 pubnames
.pn_length
= byte_get (data
, 8);
9144 initial_length_size
= 12;
9149 initial_length_size
= 4;
9152 pubnames
.pn_version
= byte_get (data
, 2);
9154 pubnames
.pn_offset
= byte_get (data
, offset_size
);
9155 data
+= offset_size
;
9156 pubnames
.pn_size
= byte_get (data
, offset_size
);
9157 data
+= offset_size
;
9159 start
+= pubnames
.pn_length
+ initial_length_size
;
9161 if (pubnames
.pn_version
!= 2 && pubnames
.pn_version
!= 3)
9163 static int warned
= 0;
9167 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
9174 printf (_(" Length: %ld\n"),
9175 pubnames
.pn_length
);
9176 printf (_(" Version: %d\n"),
9177 pubnames
.pn_version
);
9178 printf (_(" Offset into .debug_info section: %ld\n"),
9179 pubnames
.pn_offset
);
9180 printf (_(" Size of area in .debug_info section: %ld\n"),
9183 printf (_("\n Offset\tName\n"));
9187 offset
= byte_get (data
, offset_size
);
9191 data
+= offset_size
;
9192 printf (" %-6ld\t\t%s\n", offset
, data
);
9193 data
+= strlen ((char *) data
) + 1;
9196 while (offset
!= 0);
9204 display_debug_macinfo (Elf_Internal_Shdr
*section
,
9205 unsigned char *start
,
9206 FILE *file ATTRIBUTE_UNUSED
)
9208 unsigned char *end
= start
+ section
->sh_size
;
9209 unsigned char *curr
= start
;
9210 unsigned int bytes_read
;
9211 enum dwarf_macinfo_record_type op
;
9213 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9217 unsigned int lineno
;
9225 case DW_MACINFO_start_file
:
9227 unsigned int filenum
;
9229 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9231 filenum
= read_leb128 (curr
, & bytes_read
, 0);
9234 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
9239 case DW_MACINFO_end_file
:
9240 printf (_(" DW_MACINFO_end_file\n"));
9243 case DW_MACINFO_define
:
9244 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9247 curr
+= strlen (string
) + 1;
9248 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
9252 case DW_MACINFO_undef
:
9253 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9256 curr
+= strlen (string
) + 1;
9257 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
9261 case DW_MACINFO_vendor_ext
:
9263 unsigned int constant
;
9265 constant
= read_leb128 (curr
, & bytes_read
, 0);
9268 curr
+= strlen (string
) + 1;
9269 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
9281 display_debug_abbrev (Elf_Internal_Shdr
*section
,
9282 unsigned char *start
,
9283 FILE *file ATTRIBUTE_UNUSED
)
9285 abbrev_entry
*entry
;
9286 unsigned char *end
= start
+ section
->sh_size
;
9288 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9292 start
= process_abbrev_section (start
, end
);
9294 if (first_abbrev
== NULL
)
9297 printf (_(" Number TAG\n"));
9299 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
9303 printf (_(" %ld %s [%s]\n"),
9305 get_TAG_name (entry
->tag
),
9306 entry
->children
? _("has children") : _("no children"));
9308 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
9309 printf (_(" %-18s %s\n"),
9310 get_AT_name (attr
->attribute
),
9311 get_FORM_name (attr
->form
));
9324 display_debug_loc (Elf_Internal_Shdr
*section
,
9325 unsigned char *start
, FILE *file
)
9327 unsigned char *section_end
;
9328 unsigned long bytes
;
9329 unsigned char *section_begin
= start
;
9330 unsigned int num_loc_list
= 0;
9331 unsigned long last_offset
= 0;
9332 unsigned int first
= 0;
9335 int seen_first_offset
= 0;
9336 int use_debug_info
= 1;
9337 unsigned char *next
;
9339 bytes
= section
->sh_size
;
9340 section_end
= start
+ bytes
;
9344 printf (_("\nThe .debug_loc section is empty.\n"));
9348 get_debug_info (file
);
9350 /* Check the order of location list in .debug_info section. If
9351 offsets of location lists are in the ascending order, we can
9352 use `debug_information' directly. */
9353 for (i
= 0; i
< num_debug_info_entries
; i
++)
9357 num
= debug_information
[i
].num_loc_offsets
;
9358 num_loc_list
+= num
;
9360 /* Check if we can use `debug_information' directly. */
9361 if (use_debug_info
&& num
!= 0)
9363 if (!seen_first_offset
)
9365 /* This is the first location list. */
9366 last_offset
= debug_information
[i
].loc_offsets
[0];
9368 seen_first_offset
= 1;
9374 for (; j
< num
; j
++)
9377 debug_information
[i
].loc_offsets
[j
])
9382 last_offset
= debug_information
[i
].loc_offsets
[j
];
9387 if (!use_debug_info
)
9388 /* FIXME: Should we handle this case? */
9389 error (_("Location lists in .debug_info section aren't in ascending order!\n"));
9391 if (!seen_first_offset
)
9392 error (_("No location lists in .debug_info section!\n"));
9394 if (debug_information
[first
].loc_offsets
[0] != 0)
9395 warn (_("Location lists in .debug_loc section start at 0x%lx\n"),
9396 debug_information
[first
].loc_offsets
[0]);
9398 printf (_("Contents of the .debug_loc section:\n\n"));
9399 printf (_(" Offset Begin End Expression\n"));
9401 seen_first_offset
= 0;
9402 for (i
= first
; i
< num_debug_info_entries
; i
++)
9404 unsigned long begin
;
9406 unsigned short length
;
9407 unsigned long offset
;
9408 unsigned int pointer_size
;
9409 unsigned long cu_offset
;
9410 unsigned long base_address
;
9411 int need_frame_base
;
9414 pointer_size
= debug_information
[i
].pointer_size
;
9415 cu_offset
= debug_information
[i
].cu_offset
;
9417 for (j
= 0; j
< debug_information
[i
].num_loc_offsets
; j
++)
9419 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
9420 offset
= debug_information
[i
].loc_offsets
[j
];
9421 next
= section_begin
+ offset
;
9422 base_address
= debug_information
[i
].base_address
;
9424 if (!seen_first_offset
)
9425 seen_first_offset
= 1;
9429 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
9430 start
- section_begin
, next
- section_begin
);
9431 else if (start
> next
)
9432 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
9433 start
- section_begin
, next
- section_begin
);
9439 begin
= byte_get (start
, pointer_size
);
9440 start
+= pointer_size
;
9441 end
= byte_get (start
, pointer_size
);
9442 start
+= pointer_size
;
9444 if (begin
== 0 && end
== 0)
9447 /* Check base address specifiers. */
9448 if (begin
== -1UL && end
!= -1UL)
9451 printf (" %8.8lx %8.8lx %8.8lx (base address)\n",
9452 offset
, begin
, end
);
9456 length
= byte_get (start
, 2);
9459 printf (" %8.8lx %8.8lx %8.8lx (",
9460 offset
, begin
+ base_address
, end
+ base_address
);
9461 need_frame_base
= decode_location_expression (start
,
9467 if (need_frame_base
&& !has_frame_base
)
9468 printf (_(" [without DW_AT_frame_base]"));
9471 fputs (_(" (start == end)"), stdout
);
9472 else if (begin
> end
)
9473 fputs (_(" (start > end)"), stdout
);
9480 fputs (_(" <End of list>\n"), stdout
);
9487 display_debug_str (Elf_Internal_Shdr
*section
,
9488 unsigned char *start
,
9489 FILE *file ATTRIBUTE_UNUSED
)
9491 unsigned long bytes
;
9494 addr
= section
->sh_addr
;
9495 bytes
= section
->sh_size
;
9499 printf (_("\nThe .debug_str section is empty.\n"));
9503 printf (_("Contents of the .debug_str section:\n\n"));
9511 lbytes
= (bytes
> 16 ? 16 : bytes
);
9513 printf (" 0x%8.8lx ", (unsigned long) addr
);
9515 for (j
= 0; j
< 16; j
++)
9518 printf ("%2.2x", start
[j
]);
9526 for (j
= 0; j
< lbytes
; j
++)
9529 if (k
>= ' ' && k
< 0x80)
9549 display_debug_info (Elf_Internal_Shdr
* section
,
9550 unsigned char * start
, FILE * file
)
9552 return process_debug_info (section
, start
, file
, 0);
9557 display_debug_aranges (Elf_Internal_Shdr
*section
,
9558 unsigned char *start
,
9559 FILE *file ATTRIBUTE_UNUSED
)
9561 unsigned char *end
= start
+ section
->sh_size
;
9563 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
9567 unsigned char *hdrptr
;
9568 DWARF2_Internal_ARange arange
;
9569 unsigned char *ranges
;
9570 unsigned long length
;
9571 unsigned long address
;
9574 int initial_length_size
;
9578 arange
.ar_length
= byte_get (hdrptr
, 4);
9581 if (arange
.ar_length
== 0xffffffff)
9583 arange
.ar_length
= byte_get (hdrptr
, 8);
9586 initial_length_size
= 12;
9591 initial_length_size
= 4;
9594 arange
.ar_version
= byte_get (hdrptr
, 2);
9597 arange
.ar_info_offset
= byte_get (hdrptr
, offset_size
);
9598 hdrptr
+= offset_size
;
9600 arange
.ar_pointer_size
= byte_get (hdrptr
, 1);
9603 arange
.ar_segment_size
= byte_get (hdrptr
, 1);
9606 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
9608 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
9612 printf (_(" Length: %ld\n"), arange
.ar_length
);
9613 printf (_(" Version: %d\n"), arange
.ar_version
);
9614 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
9615 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
9616 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
9618 printf (_("\n Address Length\n"));
9622 /* Must pad to an alignment boundary that is twice the pointer size. */
9623 excess
= (hdrptr
- start
) % (2 * arange
.ar_pointer_size
);
9625 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
9629 address
= byte_get (ranges
, arange
.ar_pointer_size
);
9631 ranges
+= arange
.ar_pointer_size
;
9633 length
= byte_get (ranges
, arange
.ar_pointer_size
);
9635 ranges
+= arange
.ar_pointer_size
;
9637 /* A pair of zeros marks the end of the list. */
9638 if (address
== 0 && length
== 0)
9641 printf (" %8.8lx %lu\n", address
, length
);
9644 start
+= arange
.ar_length
+ initial_length_size
;
9653 display_debug_ranges (Elf_Internal_Shdr
*section
,
9654 unsigned char *start
,
9655 FILE *file ATTRIBUTE_UNUSED
)
9657 unsigned char *section_end
;
9658 unsigned long bytes
;
9659 unsigned char *section_begin
= start
;
9660 unsigned int num_range_list
= 0;
9661 unsigned long last_offset
= 0;
9662 unsigned int first
= 0;
9665 int seen_first_offset
= 0;
9666 int use_debug_info
= 1;
9667 unsigned char *next
;
9669 bytes
= section
->sh_size
;
9670 section_end
= start
+ bytes
;
9674 printf (_("\nThe .debug_ranges section is empty.\n"));
9678 get_debug_info (file
);
9680 /* Check the order of range list in .debug_info section. If
9681 offsets of range lists are in the ascending order, we can
9682 use `debug_information' directly. */
9683 for (i
= 0; i
< num_debug_info_entries
; i
++)
9687 num
= debug_information
[i
].num_range_lists
;
9688 num_range_list
+= num
;
9690 /* Check if we can use `debug_information' directly. */
9691 if (use_debug_info
&& num
!= 0)
9693 if (!seen_first_offset
)
9695 /* This is the first range list. */
9696 last_offset
= debug_information
[i
].range_lists
[0];
9698 seen_first_offset
= 1;
9704 for (; j
< num
; j
++)
9707 debug_information
[i
].range_lists
[j
])
9712 last_offset
= debug_information
[i
].range_lists
[j
];
9717 if (!use_debug_info
)
9718 /* FIXME: Should we handle this case? */
9719 error (_("Range lists in .debug_info section aren't in ascending order!\n"));
9721 if (!seen_first_offset
)
9722 error (_("No range lists in .debug_info section!\n"));
9724 if (debug_information
[first
].range_lists
[0] != 0)
9725 warn (_("Range lists in .debug_ranges section start at 0x%lx\n"),
9726 debug_information
[first
].range_lists
[0]);
9728 printf (_("Contents of the .debug_ranges section:\n\n"));
9729 printf (_(" Offset Begin End\n"));
9731 seen_first_offset
= 0;
9732 for (i
= first
; i
< num_debug_info_entries
; i
++)
9734 unsigned long begin
;
9736 unsigned long offset
;
9737 unsigned int pointer_size
;
9738 unsigned long base_address
;
9740 pointer_size
= debug_information
[i
].pointer_size
;
9742 for (j
= 0; j
< debug_information
[i
].num_range_lists
; j
++)
9744 offset
= debug_information
[i
].range_lists
[j
];
9745 next
= section_begin
+ offset
;
9746 base_address
= debug_information
[i
].base_address
;
9748 if (!seen_first_offset
)
9749 seen_first_offset
= 1;
9753 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_ranges section.\n"),
9754 start
- section_begin
, next
- section_begin
);
9755 else if (start
> next
)
9756 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_ranges section.\n"),
9757 start
- section_begin
, next
- section_begin
);
9763 begin
= byte_get (start
, pointer_size
);
9764 start
+= pointer_size
;
9765 end
= byte_get (start
, pointer_size
);
9766 start
+= pointer_size
;
9768 if (begin
== 0 && end
== 0)
9771 /* Check base address specifiers. */
9772 if (begin
== -1UL && end
!= -1UL)
9775 printf (" %8.8lx %8.8lx %8.8lx (base address)\n",
9776 offset
, begin
, end
);
9780 printf (" %8.8lx %8.8lx %8.8lx",
9781 offset
, begin
+ base_address
, end
+ base_address
);
9784 fputs (_(" (start == end)"), stdout
);
9785 else if (begin
> end
)
9786 fputs (_(" (start > end)"), stdout
);
9790 fputs (_(" <End of list>\n"), stdout
);
9797 typedef struct Frame_Chunk
9799 struct Frame_Chunk
*next
;
9800 unsigned char *chunk_start
;
9802 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
9803 short int *col_type
;
9806 unsigned int code_factor
;
9808 unsigned long pc_begin
;
9809 unsigned long pc_range
;
9813 unsigned char fde_encoding
;
9814 unsigned char cfa_exp
;
9818 /* A marker for a col_type that means this column was never referenced
9819 in the frame info. */
9820 #define DW_CFA_unreferenced (-1)
9823 frame_need_space (Frame_Chunk
*fc
, int reg
)
9825 int prev
= fc
->ncols
;
9827 if (reg
< fc
->ncols
)
9830 fc
->ncols
= reg
+ 1;
9831 fc
->col_type
= xrealloc (fc
->col_type
, fc
->ncols
* sizeof (short int));
9832 fc
->col_offset
= xrealloc (fc
->col_offset
, fc
->ncols
* sizeof (int));
9834 while (prev
< fc
->ncols
)
9836 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
9837 fc
->col_offset
[prev
] = 0;
9843 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, int *max_regs
)
9848 if (*max_regs
< fc
->ncols
)
9849 *max_regs
= fc
->ncols
;
9851 if (*need_col_headers
)
9853 *need_col_headers
= 0;
9855 printf (" LOC CFA ");
9857 for (r
= 0; r
< *max_regs
; r
++)
9858 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
9863 printf ("r%-4d", r
);
9869 printf ("%08lx ", fc
->pc_begin
);
9871 strcpy (tmp
, "exp");
9873 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
9874 printf ("%-8s ", tmp
);
9876 for (r
= 0; r
< fc
->ncols
; r
++)
9878 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
9880 switch (fc
->col_type
[r
])
9882 case DW_CFA_undefined
:
9885 case DW_CFA_same_value
:
9889 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
9891 case DW_CFA_register
:
9892 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
9894 case DW_CFA_expression
:
9895 strcpy (tmp
, "exp");
9898 strcpy (tmp
, "n/a");
9901 printf ("%-5s", tmp
);
9908 size_of_encoded_value (int encoding
)
9910 switch (encoding
& 0x7)
9913 case 0: return eh_addr_size
;
9921 get_encoded_value (unsigned char *data
, int encoding
)
9923 int size
= size_of_encoded_value (encoding
);
9924 if (encoding
& DW_EH_PE_signed
)
9925 return byte_get_signed (data
, size
);
9927 return byte_get (data
, size
);
9930 #define GET(N) byte_get (start, N); start += N
9931 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
9932 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
9935 display_debug_frames (Elf_Internal_Shdr
*section
,
9936 unsigned char *start
,
9937 FILE *file ATTRIBUTE_UNUSED
)
9939 unsigned char *end
= start
+ section
->sh_size
;
9940 unsigned char *section_start
= start
;
9941 Frame_Chunk
*chunks
= 0;
9942 Frame_Chunk
*remembered_state
= 0;
9944 int is_eh
= streq (SECTION_NAME (section
), ".eh_frame");
9948 printf (_("The section %s contains:\n"), SECTION_NAME (section
));
9952 unsigned char *saved_start
;
9953 unsigned char *block_end
;
9954 unsigned long length
;
9955 unsigned long cie_id
;
9958 int need_col_headers
= 1;
9959 unsigned char *augmentation_data
= NULL
;
9960 unsigned long augmentation_data_len
= 0;
9961 int encoded_ptr_size
= eh_addr_size
;
9963 int initial_length_size
;
9965 saved_start
= start
;
9966 length
= byte_get (start
, 4); start
+= 4;
9970 printf ("\n%08lx ZERO terminator\n\n",
9971 (unsigned long)(saved_start
- section_start
));
9975 if (length
== 0xffffffff)
9977 length
= byte_get (start
, 8);
9980 initial_length_size
= 12;
9985 initial_length_size
= 4;
9988 block_end
= saved_start
+ length
+ initial_length_size
;
9989 cie_id
= byte_get (start
, offset_size
); start
+= offset_size
;
9991 if (elf_header
.e_type
== ET_REL
9992 && !debug_apply_rela_addends (file
, section
, offset_size
,
9993 section_start
, start
, block_end
))
9996 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
10000 fc
= xmalloc (sizeof (Frame_Chunk
));
10001 memset (fc
, 0, sizeof (Frame_Chunk
));
10005 fc
->chunk_start
= saved_start
;
10007 fc
->col_type
= xmalloc (sizeof (short int));
10008 fc
->col_offset
= xmalloc (sizeof (int));
10009 frame_need_space (fc
, max_regs
-1);
10011 version
= *start
++;
10013 fc
->augmentation
= start
;
10014 start
= strchr (start
, '\0') + 1;
10016 if (fc
->augmentation
[0] == 'z')
10018 fc
->code_factor
= LEB ();
10019 fc
->data_factor
= SLEB ();
10028 augmentation_data_len
= LEB ();
10029 augmentation_data
= start
;
10030 start
+= augmentation_data_len
;
10032 else if (streq (fc
->augmentation
, "eh"))
10034 start
+= eh_addr_size
;
10035 fc
->code_factor
= LEB ();
10036 fc
->data_factor
= SLEB ();
10048 fc
->code_factor
= LEB ();
10049 fc
->data_factor
= SLEB ();
10061 if (do_debug_frames_interp
)
10062 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
10063 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
10064 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
10068 printf ("\n%08lx %08lx %08lx CIE\n",
10069 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
10070 printf (" Version: %d\n", version
);
10071 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
10072 printf (" Code alignment factor: %u\n", fc
->code_factor
);
10073 printf (" Data alignment factor: %d\n", fc
->data_factor
);
10074 printf (" Return address column: %d\n", fc
->ra
);
10076 if (augmentation_data_len
)
10079 printf (" Augmentation data: ");
10080 for (i
= 0; i
< augmentation_data_len
; ++i
)
10081 printf (" %02x", augmentation_data
[i
]);
10087 if (augmentation_data_len
)
10089 unsigned char *p
, *q
;
10090 p
= fc
->augmentation
+ 1;
10091 q
= augmentation_data
;
10097 else if (*p
== 'P')
10098 q
+= 1 + size_of_encoded_value (*q
);
10099 else if (*p
== 'R')
10100 fc
->fde_encoding
= *q
++;
10106 if (fc
->fde_encoding
)
10107 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
10110 frame_need_space (fc
, fc
->ra
);
10114 unsigned char *look_for
;
10115 static Frame_Chunk fde_fc
;
10118 memset (fc
, 0, sizeof (Frame_Chunk
));
10120 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
10122 for (cie
= chunks
; cie
; cie
= cie
->next
)
10123 if (cie
->chunk_start
== look_for
)
10128 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
10129 cie_id
, saved_start
);
10132 fc
->col_type
= xmalloc (sizeof (short int));
10133 fc
->col_offset
= xmalloc (sizeof (int));
10134 frame_need_space (fc
, max_regs
- 1);
10136 fc
->augmentation
= "";
10137 fc
->fde_encoding
= 0;
10141 fc
->ncols
= cie
->ncols
;
10142 fc
->col_type
= xmalloc (fc
->ncols
* sizeof (short int));
10143 fc
->col_offset
= xmalloc (fc
->ncols
* sizeof (int));
10144 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
10145 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
10146 fc
->augmentation
= cie
->augmentation
;
10147 fc
->code_factor
= cie
->code_factor
;
10148 fc
->data_factor
= cie
->data_factor
;
10149 fc
->cfa_reg
= cie
->cfa_reg
;
10150 fc
->cfa_offset
= cie
->cfa_offset
;
10152 frame_need_space (fc
, max_regs
-1);
10153 fc
->fde_encoding
= cie
->fde_encoding
;
10156 if (fc
->fde_encoding
)
10157 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
10159 fc
->pc_begin
= get_encoded_value (start
, fc
->fde_encoding
);
10160 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
10161 /* Don't adjust for ET_REL since there's invariably a pcrel
10162 reloc here, which we haven't applied. */
10163 && elf_header
.e_type
!= ET_REL
)
10164 fc
->pc_begin
+= section
->sh_addr
+ (start
- section_start
);
10165 start
+= encoded_ptr_size
;
10166 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
10167 start
+= encoded_ptr_size
;
10169 if (cie
->augmentation
[0] == 'z')
10171 augmentation_data_len
= LEB ();
10172 augmentation_data
= start
;
10173 start
+= augmentation_data_len
;
10176 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
10177 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
10178 (unsigned long)(cie
->chunk_start
- section_start
),
10179 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
10180 if (! do_debug_frames_interp
&& augmentation_data_len
)
10184 printf (" Augmentation data: ");
10185 for (i
= 0; i
< augmentation_data_len
; ++i
)
10186 printf (" %02x", augmentation_data
[i
]);
10192 /* At this point, fc is the current chunk, cie (if any) is set, and
10193 we're about to interpret instructions for the chunk. */
10194 /* ??? At present we need to do this always, since this sizes the
10195 fc->col_type and fc->col_offset arrays, which we write into always.
10196 We should probably split the interpreted and non-interpreted bits
10197 into two different routines, since there's so much that doesn't
10198 really overlap between them. */
10199 if (1 || do_debug_frames_interp
)
10201 /* Start by making a pass over the chunk, allocating storage
10202 and taking note of what registers are used. */
10203 unsigned char *tmp
= start
;
10205 while (start
< block_end
)
10208 unsigned long reg
, tmp
;
10215 /* Warning: if you add any more cases to this switch, be
10216 sure to add them to the corresponding switch below. */
10219 case DW_CFA_advance_loc
:
10221 case DW_CFA_offset
:
10223 frame_need_space (fc
, opa
);
10224 fc
->col_type
[opa
] = DW_CFA_undefined
;
10226 case DW_CFA_restore
:
10227 frame_need_space (fc
, opa
);
10228 fc
->col_type
[opa
] = DW_CFA_undefined
;
10230 case DW_CFA_set_loc
:
10231 start
+= encoded_ptr_size
;
10233 case DW_CFA_advance_loc1
:
10236 case DW_CFA_advance_loc2
:
10239 case DW_CFA_advance_loc4
:
10242 case DW_CFA_offset_extended
:
10243 reg
= LEB (); LEB ();
10244 frame_need_space (fc
, reg
);
10245 fc
->col_type
[reg
] = DW_CFA_undefined
;
10247 case DW_CFA_restore_extended
:
10249 frame_need_space (fc
, reg
);
10250 fc
->col_type
[reg
] = DW_CFA_undefined
;
10252 case DW_CFA_undefined
:
10254 frame_need_space (fc
, reg
);
10255 fc
->col_type
[reg
] = DW_CFA_undefined
;
10257 case DW_CFA_same_value
:
10259 frame_need_space (fc
, reg
);
10260 fc
->col_type
[reg
] = DW_CFA_undefined
;
10262 case DW_CFA_register
:
10263 reg
= LEB (); LEB ();
10264 frame_need_space (fc
, reg
);
10265 fc
->col_type
[reg
] = DW_CFA_undefined
;
10267 case DW_CFA_def_cfa
:
10270 case DW_CFA_def_cfa_register
:
10273 case DW_CFA_def_cfa_offset
:
10276 case DW_CFA_def_cfa_expression
:
10280 case DW_CFA_expression
:
10284 frame_need_space (fc
, reg
);
10285 fc
->col_type
[reg
] = DW_CFA_undefined
;
10287 case DW_CFA_offset_extended_sf
:
10288 reg
= LEB (); SLEB ();
10289 frame_need_space (fc
, reg
);
10290 fc
->col_type
[reg
] = DW_CFA_undefined
;
10292 case DW_CFA_def_cfa_sf
:
10295 case DW_CFA_def_cfa_offset_sf
:
10298 case DW_CFA_MIPS_advance_loc8
:
10301 case DW_CFA_GNU_args_size
:
10304 case DW_CFA_GNU_negative_offset_extended
:
10305 reg
= LEB (); LEB ();
10306 frame_need_space (fc
, reg
);
10307 fc
->col_type
[reg
] = DW_CFA_undefined
;
10316 /* Now we know what registers are used, make a second pass over
10317 the chunk, this time actually printing out the info. */
10319 while (start
< block_end
)
10322 unsigned long ul
, reg
, roffs
;
10331 /* Warning: if you add any more cases to this switch, be
10332 sure to add them to the corresponding switch above. */
10335 case DW_CFA_advance_loc
:
10336 if (do_debug_frames_interp
)
10337 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10339 printf (" DW_CFA_advance_loc: %d to %08lx\n",
10340 opa
* fc
->code_factor
,
10341 fc
->pc_begin
+ opa
* fc
->code_factor
);
10342 fc
->pc_begin
+= opa
* fc
->code_factor
;
10345 case DW_CFA_offset
:
10347 if (! do_debug_frames_interp
)
10348 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
10349 opa
, roffs
* fc
->data_factor
);
10350 fc
->col_type
[opa
] = DW_CFA_offset
;
10351 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
10354 case DW_CFA_restore
:
10355 if (! do_debug_frames_interp
)
10356 printf (" DW_CFA_restore: r%d\n", opa
);
10357 fc
->col_type
[opa
] = cie
->col_type
[opa
];
10358 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
10361 case DW_CFA_set_loc
:
10362 vma
= get_encoded_value (start
, fc
->fde_encoding
);
10363 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
10364 && elf_header
.e_type
!= ET_REL
)
10365 vma
+= section
->sh_addr
+ (start
- section_start
);
10366 start
+= encoded_ptr_size
;
10367 if (do_debug_frames_interp
)
10368 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10370 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
10371 fc
->pc_begin
= vma
;
10374 case DW_CFA_advance_loc1
:
10375 ofs
= byte_get (start
, 1); start
+= 1;
10376 if (do_debug_frames_interp
)
10377 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10379 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
10380 ofs
* fc
->code_factor
,
10381 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10382 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10385 case DW_CFA_advance_loc2
:
10386 ofs
= byte_get (start
, 2); start
+= 2;
10387 if (do_debug_frames_interp
)
10388 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10390 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
10391 ofs
* fc
->code_factor
,
10392 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10393 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10396 case DW_CFA_advance_loc4
:
10397 ofs
= byte_get (start
, 4); start
+= 4;
10398 if (do_debug_frames_interp
)
10399 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10401 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
10402 ofs
* fc
->code_factor
,
10403 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10404 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10407 case DW_CFA_offset_extended
:
10410 if (! do_debug_frames_interp
)
10411 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
10412 reg
, roffs
* fc
->data_factor
);
10413 fc
->col_type
[reg
] = DW_CFA_offset
;
10414 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
10417 case DW_CFA_restore_extended
:
10419 if (! do_debug_frames_interp
)
10420 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
10421 fc
->col_type
[reg
] = cie
->col_type
[reg
];
10422 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
10425 case DW_CFA_undefined
:
10427 if (! do_debug_frames_interp
)
10428 printf (" DW_CFA_undefined: r%ld\n", reg
);
10429 fc
->col_type
[reg
] = DW_CFA_undefined
;
10430 fc
->col_offset
[reg
] = 0;
10433 case DW_CFA_same_value
:
10435 if (! do_debug_frames_interp
)
10436 printf (" DW_CFA_same_value: r%ld\n", reg
);
10437 fc
->col_type
[reg
] = DW_CFA_same_value
;
10438 fc
->col_offset
[reg
] = 0;
10441 case DW_CFA_register
:
10444 if (! do_debug_frames_interp
)
10445 printf (" DW_CFA_register: r%ld in r%ld\n", reg
, roffs
);
10446 fc
->col_type
[reg
] = DW_CFA_register
;
10447 fc
->col_offset
[reg
] = roffs
;
10450 case DW_CFA_remember_state
:
10451 if (! do_debug_frames_interp
)
10452 printf (" DW_CFA_remember_state\n");
10453 rs
= xmalloc (sizeof (Frame_Chunk
));
10454 rs
->ncols
= fc
->ncols
;
10455 rs
->col_type
= xmalloc (rs
->ncols
* sizeof (short int));
10456 rs
->col_offset
= xmalloc (rs
->ncols
* sizeof (int));
10457 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
10458 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
10459 rs
->next
= remembered_state
;
10460 remembered_state
= rs
;
10463 case DW_CFA_restore_state
:
10464 if (! do_debug_frames_interp
)
10465 printf (" DW_CFA_restore_state\n");
10466 rs
= remembered_state
;
10469 remembered_state
= rs
->next
;
10470 frame_need_space (fc
, rs
->ncols
-1);
10471 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
10472 memcpy (fc
->col_offset
, rs
->col_offset
,
10473 rs
->ncols
* sizeof (int));
10474 free (rs
->col_type
);
10475 free (rs
->col_offset
);
10478 else if (do_debug_frames_interp
)
10479 printf ("Mismatched DW_CFA_restore_state\n");
10482 case DW_CFA_def_cfa
:
10483 fc
->cfa_reg
= LEB ();
10484 fc
->cfa_offset
= LEB ();
10486 if (! do_debug_frames_interp
)
10487 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
10488 fc
->cfa_reg
, fc
->cfa_offset
);
10491 case DW_CFA_def_cfa_register
:
10492 fc
->cfa_reg
= LEB ();
10494 if (! do_debug_frames_interp
)
10495 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
10498 case DW_CFA_def_cfa_offset
:
10499 fc
->cfa_offset
= LEB ();
10500 if (! do_debug_frames_interp
)
10501 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
10505 if (! do_debug_frames_interp
)
10506 printf (" DW_CFA_nop\n");
10509 case DW_CFA_def_cfa_expression
:
10511 if (! do_debug_frames_interp
)
10513 printf (" DW_CFA_def_cfa_expression (");
10514 decode_location_expression (start
, eh_addr_size
, ul
, 0);
10521 case DW_CFA_expression
:
10524 if (! do_debug_frames_interp
)
10526 printf (" DW_CFA_expression: r%ld (", reg
);
10527 decode_location_expression (start
, eh_addr_size
, ul
, 0);
10530 fc
->col_type
[reg
] = DW_CFA_expression
;
10534 case DW_CFA_offset_extended_sf
:
10537 frame_need_space (fc
, reg
);
10538 if (! do_debug_frames_interp
)
10539 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
10540 reg
, l
* fc
->data_factor
);
10541 fc
->col_type
[reg
] = DW_CFA_offset
;
10542 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
10545 case DW_CFA_def_cfa_sf
:
10546 fc
->cfa_reg
= LEB ();
10547 fc
->cfa_offset
= SLEB ();
10549 if (! do_debug_frames_interp
)
10550 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
10551 fc
->cfa_reg
, fc
->cfa_offset
);
10554 case DW_CFA_def_cfa_offset_sf
:
10555 fc
->cfa_offset
= SLEB ();
10556 if (! do_debug_frames_interp
)
10557 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
10560 case DW_CFA_MIPS_advance_loc8
:
10561 ofs
= byte_get (start
, 8); start
+= 8;
10562 if (do_debug_frames_interp
)
10563 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10565 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
10566 ofs
* fc
->code_factor
,
10567 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10568 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10571 case DW_CFA_GNU_window_save
:
10572 if (! do_debug_frames_interp
)
10573 printf (" DW_CFA_GNU_window_save\n");
10576 case DW_CFA_GNU_args_size
:
10578 if (! do_debug_frames_interp
)
10579 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
10582 case DW_CFA_GNU_negative_offset_extended
:
10585 frame_need_space (fc
, reg
);
10586 if (! do_debug_frames_interp
)
10587 printf (" DW_CFA_GNU_negative_offset_extended: 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
;
10594 warn (_("unsupported or unknown DW_CFA_%d\n"), op
);
10599 if (do_debug_frames_interp
)
10600 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10615 display_debug_not_supported (Elf_Internal_Shdr
*section
,
10616 unsigned char *start ATTRIBUTE_UNUSED
,
10617 FILE *file ATTRIBUTE_UNUSED
)
10619 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
10620 SECTION_NAME (section
));
10625 /* A structure containing the name of a debug section
10626 and a pointer to a function that can decode it. */
10629 const char *const name
;
10630 int (*display
) (Elf_Internal_Shdr
*, unsigned char *, FILE *);
10634 { ".debug_abbrev", display_debug_abbrev
},
10635 { ".debug_aranges", display_debug_aranges
},
10636 { ".debug_frame", display_debug_frames
},
10637 { ".debug_info", display_debug_info
},
10638 { ".debug_line", display_debug_lines
},
10639 { ".debug_pubnames", display_debug_pubnames
},
10640 { ".eh_frame", display_debug_frames
},
10641 { ".debug_macinfo", display_debug_macinfo
},
10642 { ".debug_str", display_debug_str
},
10643 { ".debug_loc", display_debug_loc
},
10644 { ".debug_pubtypes", display_debug_pubnames
},
10645 { ".debug_ranges", display_debug_ranges
},
10646 { ".debug_static_func", display_debug_not_supported
},
10647 { ".debug_static_vars", display_debug_not_supported
},
10648 { ".debug_types", display_debug_not_supported
},
10649 { ".debug_weaknames", display_debug_not_supported
}
10653 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
10655 char *name
= SECTION_NAME (section
);
10656 bfd_size_type length
;
10660 length
= section
->sh_size
;
10663 printf (_("\nSection '%s' has no debugging data.\n"), name
);
10667 if (strneq (name
, ".gnu.linkonce.wi.", 17))
10668 name
= ".debug_info";
10670 /* See if we know how to display the contents of this section. */
10671 for (i
= NUM_ELEM (debug_displays
); i
--;)
10672 if (streq (debug_displays
[i
].name
, name
))
10674 unsigned char *start
;
10676 start
= get_data (NULL
, file
, section
->sh_offset
, length
,
10677 _("debug section data"));
10684 result
&= debug_displays
[i
].display (section
, start
, file
);
10687 /* If we loaded in the abbrev section
10688 at some point, we must release it here. */
10696 printf (_("Unrecognized debug section: %s\n"), name
);
10704 process_section_contents (FILE *file
)
10706 Elf_Internal_Shdr
*section
;
10712 for (i
= 0, section
= section_headers
;
10713 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
10716 #ifdef SUPPORT_DISASSEMBLY
10717 if (dump_sects
[i
] & DISASS_DUMP
)
10718 disassemble_section (section
, file
);
10720 if (dump_sects
[i
] & HEX_DUMP
)
10721 dump_section (section
, file
);
10723 if (dump_sects
[i
] & DEBUG_DUMP
)
10724 display_debug_section (section
, file
);
10727 /* Check to see if the user requested a
10728 dump of a section that does not exist. */
10729 while (i
++ < num_dump_sects
)
10731 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
10735 process_mips_fpe_exception (int mask
)
10740 if (mask
& OEX_FPU_INEX
)
10741 fputs ("INEX", stdout
), first
= 0;
10742 if (mask
& OEX_FPU_UFLO
)
10743 printf ("%sUFLO", first
? "" : "|"), first
= 0;
10744 if (mask
& OEX_FPU_OFLO
)
10745 printf ("%sOFLO", first
? "" : "|"), first
= 0;
10746 if (mask
& OEX_FPU_DIV0
)
10747 printf ("%sDIV0", first
? "" : "|"), first
= 0;
10748 if (mask
& OEX_FPU_INVAL
)
10749 printf ("%sINVAL", first
? "" : "|");
10752 fputs ("0", stdout
);
10756 process_mips_specific (FILE *file
)
10758 Elf_Internal_Dyn
*entry
;
10759 size_t liblist_offset
= 0;
10760 size_t liblistno
= 0;
10761 size_t conflictsno
= 0;
10762 size_t options_offset
= 0;
10763 size_t conflicts_offset
= 0;
10765 /* We have a lot of special sections. Thanks SGI! */
10766 if (dynamic_section
== NULL
)
10767 /* No information available. */
10770 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
10771 switch (entry
->d_tag
)
10773 case DT_MIPS_LIBLIST
:
10775 = offset_from_vma (file
, entry
->d_un
.d_val
,
10776 liblistno
* sizeof (Elf32_External_Lib
));
10778 case DT_MIPS_LIBLISTNO
:
10779 liblistno
= entry
->d_un
.d_val
;
10781 case DT_MIPS_OPTIONS
:
10782 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
10784 case DT_MIPS_CONFLICT
:
10786 = offset_from_vma (file
, entry
->d_un
.d_val
,
10787 conflictsno
* sizeof (Elf32_External_Conflict
));
10789 case DT_MIPS_CONFLICTNO
:
10790 conflictsno
= entry
->d_un
.d_val
;
10796 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
10798 Elf32_External_Lib
*elib
;
10801 elib
= get_data (NULL
, file
, liblist_offset
,
10802 liblistno
* sizeof (Elf32_External_Lib
),
10806 printf ("\nSection '.liblist' contains %lu entries:\n",
10807 (unsigned long) liblistno
);
10808 fputs (" Library Time Stamp Checksum Version Flags\n",
10811 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
10818 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
10819 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
10820 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
10821 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
10822 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
10824 tmp
= gmtime (&time
);
10825 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
10826 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10827 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10829 printf ("%3lu: ", (unsigned long) cnt
);
10830 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
10831 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
10833 printf ("<corrupt: %9ld>", liblist
.l_name
);
10834 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
10835 liblist
.l_version
);
10837 if (liblist
.l_flags
== 0)
10841 static const struct
10848 { " EXACT_MATCH", LL_EXACT_MATCH
},
10849 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
10850 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
10851 { " EXPORTS", LL_EXPORTS
},
10852 { " DELAY_LOAD", LL_DELAY_LOAD
},
10853 { " DELTA", LL_DELTA
}
10855 int flags
= liblist
.l_flags
;
10859 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
10861 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
10863 fputs (l_flags_vals
[fcnt
].name
, stdout
);
10864 flags
^= l_flags_vals
[fcnt
].bit
;
10867 printf (" %#x", (unsigned int) flags
);
10877 if (options_offset
!= 0)
10879 Elf_External_Options
*eopt
;
10880 Elf_Internal_Shdr
*sect
= section_headers
;
10881 Elf_Internal_Options
*iopt
;
10882 Elf_Internal_Options
*option
;
10886 /* Find the section header so that we get the size. */
10887 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
10890 eopt
= get_data (NULL
, file
, options_offset
, sect
->sh_size
,
10894 iopt
= malloc ((sect
->sh_size
/ sizeof (eopt
)) * sizeof (*iopt
));
10897 error (_("Out of memory"));
10904 while (offset
< sect
->sh_size
)
10906 Elf_External_Options
*eoption
;
10908 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
10910 option
->kind
= BYTE_GET (eoption
->kind
);
10911 option
->size
= BYTE_GET (eoption
->size
);
10912 option
->section
= BYTE_GET (eoption
->section
);
10913 option
->info
= BYTE_GET (eoption
->info
);
10915 offset
+= option
->size
;
10921 printf (_("\nSection '%s' contains %d entries:\n"),
10922 SECTION_NAME (sect
), cnt
);
10930 switch (option
->kind
)
10933 /* This shouldn't happen. */
10934 printf (" NULL %d %lx", option
->section
, option
->info
);
10937 printf (" REGINFO ");
10938 if (elf_header
.e_machine
== EM_MIPS
)
10941 Elf32_External_RegInfo
*ereg
;
10942 Elf32_RegInfo reginfo
;
10944 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
10945 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
10946 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
10947 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
10948 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
10949 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
10950 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
10952 printf ("GPR %08lx GP 0x%lx\n",
10953 reginfo
.ri_gprmask
,
10954 (unsigned long) reginfo
.ri_gp_value
);
10955 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
10956 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
10957 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
10962 Elf64_External_RegInfo
*ereg
;
10963 Elf64_Internal_RegInfo reginfo
;
10965 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
10966 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
10967 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
10968 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
10969 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
10970 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
10971 reginfo
.ri_gp_value
= BYTE_GET8 (ereg
->ri_gp_value
);
10973 printf ("GPR %08lx GP 0x",
10974 reginfo
.ri_gprmask
);
10975 printf_vma (reginfo
.ri_gp_value
);
10978 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
10979 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
10980 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
10984 case ODK_EXCEPTIONS
:
10985 fputs (" EXCEPTIONS fpe_min(", stdout
);
10986 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
10987 fputs (") fpe_max(", stdout
);
10988 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
10989 fputs (")", stdout
);
10991 if (option
->info
& OEX_PAGE0
)
10992 fputs (" PAGE0", stdout
);
10993 if (option
->info
& OEX_SMM
)
10994 fputs (" SMM", stdout
);
10995 if (option
->info
& OEX_FPDBUG
)
10996 fputs (" FPDBUG", stdout
);
10997 if (option
->info
& OEX_DISMISS
)
10998 fputs (" DISMISS", stdout
);
11001 fputs (" PAD ", stdout
);
11002 if (option
->info
& OPAD_PREFIX
)
11003 fputs (" PREFIX", stdout
);
11004 if (option
->info
& OPAD_POSTFIX
)
11005 fputs (" POSTFIX", stdout
);
11006 if (option
->info
& OPAD_SYMBOL
)
11007 fputs (" SYMBOL", stdout
);
11010 fputs (" HWPATCH ", stdout
);
11011 if (option
->info
& OHW_R4KEOP
)
11012 fputs (" R4KEOP", stdout
);
11013 if (option
->info
& OHW_R8KPFETCH
)
11014 fputs (" R8KPFETCH", stdout
);
11015 if (option
->info
& OHW_R5KEOP
)
11016 fputs (" R5KEOP", stdout
);
11017 if (option
->info
& OHW_R5KCVTL
)
11018 fputs (" R5KCVTL", stdout
);
11021 fputs (" FILL ", stdout
);
11022 /* XXX Print content of info word? */
11025 fputs (" TAGS ", stdout
);
11026 /* XXX Print content of info word? */
11029 fputs (" HWAND ", stdout
);
11030 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11031 fputs (" R4KEOP_CHECKED", stdout
);
11032 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11033 fputs (" R4KEOP_CLEAN", stdout
);
11036 fputs (" HWOR ", stdout
);
11037 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11038 fputs (" R4KEOP_CHECKED", stdout
);
11039 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11040 fputs (" R4KEOP_CLEAN", stdout
);
11043 printf (" GP_GROUP %#06lx self-contained %#06lx",
11044 option
->info
& OGP_GROUP
,
11045 (option
->info
& OGP_SELF
) >> 16);
11048 printf (" IDENT %#06lx self-contained %#06lx",
11049 option
->info
& OGP_GROUP
,
11050 (option
->info
& OGP_SELF
) >> 16);
11053 /* This shouldn't happen. */
11054 printf (" %3d ??? %d %lx",
11055 option
->kind
, option
->section
, option
->info
);
11059 len
= sizeof (*eopt
);
11060 while (len
< option
->size
)
11061 if (((char *) option
)[len
] >= ' '
11062 && ((char *) option
)[len
] < 0x7f)
11063 printf ("%c", ((char *) option
)[len
++]);
11065 printf ("\\%03o", ((char *) option
)[len
++]);
11067 fputs ("\n", stdout
);
11075 if (conflicts_offset
!= 0 && conflictsno
!= 0)
11077 Elf32_Conflict
*iconf
;
11080 if (dynamic_symbols
== NULL
)
11082 error (_("conflict list found without a dynamic symbol table"));
11086 iconf
= malloc (conflictsno
* sizeof (*iconf
));
11089 error (_("Out of memory"));
11095 Elf32_External_Conflict
*econf32
;
11097 econf32
= get_data (NULL
, file
, conflicts_offset
,
11098 conflictsno
* sizeof (*econf32
), _("conflict"));
11102 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11103 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
11109 Elf64_External_Conflict
*econf64
;
11111 econf64
= get_data (NULL
, file
, conflicts_offset
,
11112 conflictsno
* sizeof (*econf64
), _("conflict"));
11116 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11117 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
11122 printf (_("\nSection '.conflict' contains %lu entries:\n"),
11123 (unsigned long) conflictsno
);
11124 puts (_(" Num: Index Value Name"));
11126 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11128 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
11130 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
11131 print_vma (psym
->st_value
, FULL_HEX
);
11133 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11134 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11136 printf ("<corrupt: %14ld>", psym
->st_name
);
11147 process_gnu_liblist (FILE *file
)
11149 Elf_Internal_Shdr
*section
, *string_sec
;
11150 Elf32_External_Lib
*elib
;
11158 for (i
= 0, section
= section_headers
;
11159 i
< elf_header
.e_shnum
;
11162 switch (section
->sh_type
)
11164 case SHT_GNU_LIBLIST
:
11165 elib
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
11170 string_sec
= SECTION_HEADER (section
->sh_link
);
11172 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
11173 string_sec
->sh_size
, _("liblist string table"));
11176 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
11182 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
11183 SECTION_NAME (section
),
11184 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
11186 puts (" Library Time Stamp Checksum Version Flags");
11188 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
11196 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
11197 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
11198 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
11199 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
11200 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
11202 tmp
= gmtime (&time
);
11203 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
11204 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11205 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11207 printf ("%3lu: ", (unsigned long) cnt
);
11209 printf ("%-20s", strtab
+ liblist
.l_name
);
11211 printf ("%-20.20s", strtab
+ liblist
.l_name
);
11212 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
11213 liblist
.l_version
, liblist
.l_flags
);
11223 static const char *
11224 get_note_type (unsigned e_type
)
11226 static char buff
[64];
11228 if (elf_header
.e_type
== ET_CORE
)
11232 return _("NT_AUXV (auxiliary vector)");
11234 return _("NT_PRSTATUS (prstatus structure)");
11236 return _("NT_FPREGSET (floating point registers)");
11238 return _("NT_PRPSINFO (prpsinfo structure)");
11239 case NT_TASKSTRUCT
:
11240 return _("NT_TASKSTRUCT (task structure)");
11242 return _("NT_PRXFPREG (user_xfpregs structure)");
11244 return _("NT_PSTATUS (pstatus structure)");
11246 return _("NT_FPREGS (floating point registers)");
11248 return _("NT_PSINFO (psinfo structure)");
11250 return _("NT_LWPSTATUS (lwpstatus_t structure)");
11252 return _("NT_LWPSINFO (lwpsinfo_t structure)");
11253 case NT_WIN32PSTATUS
:
11254 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
11262 return _("NT_VERSION (version)");
11264 return _("NT_ARCH (architecture)");
11269 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
11273 static const char *
11274 get_netbsd_elfcore_note_type (unsigned e_type
)
11276 static char buff
[64];
11278 if (e_type
== NT_NETBSDCORE_PROCINFO
)
11280 /* NetBSD core "procinfo" structure. */
11281 return _("NetBSD procinfo structure");
11284 /* As of Jan 2002 there are no other machine-independent notes
11285 defined for NetBSD core files. If the note type is less
11286 than the start of the machine-dependent note types, we don't
11289 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
11291 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
11295 switch (elf_header
.e_machine
)
11297 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
11298 and PT_GETFPREGS == mach+2. */
11303 case EM_SPARC32PLUS
:
11307 case NT_NETBSDCORE_FIRSTMACH
+0:
11308 return _("PT_GETREGS (reg structure)");
11309 case NT_NETBSDCORE_FIRSTMACH
+2:
11310 return _("PT_GETFPREGS (fpreg structure)");
11316 /* On all other arch's, PT_GETREGS == mach+1 and
11317 PT_GETFPREGS == mach+3. */
11321 case NT_NETBSDCORE_FIRSTMACH
+1:
11322 return _("PT_GETREGS (reg structure)");
11323 case NT_NETBSDCORE_FIRSTMACH
+3:
11324 return _("PT_GETFPREGS (fpreg structure)");
11330 sprintf (buff
, _("PT_FIRSTMACH+%d"), e_type
- NT_NETBSDCORE_FIRSTMACH
);
11334 /* Note that by the ELF standard, the name field is already null byte
11335 terminated, and namesz includes the terminating null byte.
11336 I.E. the value of namesz for the name "FSF" is 4.
11338 If the value of namesz is zero, there is no name present. */
11340 process_note (Elf_Internal_Note
*pnote
)
11344 if (pnote
->namesz
== 0)
11345 /* If there is no note name, then use the default set of
11346 note type strings. */
11347 nt
= get_note_type (pnote
->type
);
11349 else if (strneq (pnote
->namedata
, "NetBSD-CORE", 11))
11350 /* NetBSD-specific core file notes. */
11351 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
11354 /* Don't recognize this note name; just use the default set of
11355 note type strings. */
11356 nt
= get_note_type (pnote
->type
);
11358 printf (" %s\t\t0x%08lx\t%s\n",
11359 pnote
->namesz
? pnote
->namedata
: "(NONE)",
11360 pnote
->descsz
, nt
);
11366 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
11368 Elf_External_Note
*pnotes
;
11369 Elf_External_Note
*external
;
11375 pnotes
= get_data (NULL
, file
, offset
, length
, _("notes"));
11381 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
11382 (unsigned long) offset
, (unsigned long) length
);
11383 printf (_(" Owner\t\tData size\tDescription\n"));
11385 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
11387 Elf_External_Note
*next
;
11388 Elf_Internal_Note inote
;
11391 inote
.type
= BYTE_GET (external
->type
);
11392 inote
.namesz
= BYTE_GET (external
->namesz
);
11393 inote
.namedata
= external
->name
;
11394 inote
.descsz
= BYTE_GET (external
->descsz
);
11395 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
11396 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
11398 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
11400 if (((char *) next
) > (((char *) pnotes
) + length
))
11402 warn (_("corrupt note found at offset %x into core notes\n"),
11403 ((char *) external
) - ((char *) pnotes
));
11404 warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
11405 inote
.type
, inote
.namesz
, inote
.descsz
);
11411 /* Verify that name is null terminated. It appears that at least
11412 one version of Linux (RedHat 6.0) generates corefiles that don't
11413 comply with the ELF spec by failing to include the null byte in
11415 if (inote
.namedata
[inote
.namesz
] != '\0')
11417 temp
= malloc (inote
.namesz
+ 1);
11421 error (_("Out of memory\n"));
11426 strncpy (temp
, inote
.namedata
, inote
.namesz
);
11427 temp
[inote
.namesz
] = 0;
11429 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
11430 inote
.namedata
= temp
;
11433 res
&= process_note (& inote
);
11448 process_corefile_note_segments (FILE *file
)
11450 Elf_Internal_Phdr
*segment
;
11454 if (! get_program_headers (file
))
11457 for (i
= 0, segment
= program_headers
;
11458 i
< elf_header
.e_phnum
;
11461 if (segment
->p_type
== PT_NOTE
)
11462 res
&= process_corefile_note_segment (file
,
11463 (bfd_vma
) segment
->p_offset
,
11464 (bfd_vma
) segment
->p_filesz
);
11471 process_note_sections (FILE *file
)
11473 Elf_Internal_Shdr
*section
;
11477 for (i
= 0, section
= section_headers
;
11478 i
< elf_header
.e_shnum
;
11480 if (section
->sh_type
== SHT_NOTE
)
11481 res
&= process_corefile_note_segment (file
,
11482 (bfd_vma
) section
->sh_offset
,
11483 (bfd_vma
) section
->sh_size
);
11489 process_notes (FILE *file
)
11491 /* If we have not been asked to display the notes then do nothing. */
11495 if (elf_header
.e_type
!= ET_CORE
)
11496 return process_note_sections (file
);
11498 /* No program headers means no NOTE segment. */
11499 if (elf_header
.e_phnum
> 0)
11500 return process_corefile_note_segments (file
);
11502 printf (_("No note segments present in the core file.\n"));
11507 process_arch_specific (FILE *file
)
11512 switch (elf_header
.e_machine
)
11515 case EM_MIPS_RS3_LE
:
11516 return process_mips_specific (file
);
11525 get_file_header (FILE *file
)
11527 /* Read in the identity array. */
11528 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
11531 /* Determine how to read the rest of the header. */
11532 switch (elf_header
.e_ident
[EI_DATA
])
11534 default: /* fall through */
11535 case ELFDATANONE
: /* fall through */
11537 byte_get
= byte_get_little_endian
;
11538 byte_put
= byte_put_little_endian
;
11541 byte_get
= byte_get_big_endian
;
11542 byte_put
= byte_put_big_endian
;
11546 /* For now we only support 32 bit and 64 bit ELF files. */
11547 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
11549 /* Read in the rest of the header. */
11552 Elf32_External_Ehdr ehdr32
;
11554 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
11557 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
11558 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
11559 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
11560 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
11561 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
11562 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
11563 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
11564 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
11565 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
11566 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
11567 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
11568 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
11569 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
11573 Elf64_External_Ehdr ehdr64
;
11575 /* If we have been compiled with sizeof (bfd_vma) == 4, then
11576 we will not be able to cope with the 64bit data found in
11577 64 ELF files. Detect this now and abort before we start
11578 overwriting things. */
11579 if (sizeof (bfd_vma
) < 8)
11581 error (_("This instance of readelf has been built without support for a\n\
11582 64 bit data type and so it cannot read 64 bit ELF files.\n"));
11586 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
11589 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
11590 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
11591 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
11592 elf_header
.e_entry
= BYTE_GET8 (ehdr64
.e_entry
);
11593 elf_header
.e_phoff
= BYTE_GET8 (ehdr64
.e_phoff
);
11594 elf_header
.e_shoff
= BYTE_GET8 (ehdr64
.e_shoff
);
11595 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
11596 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
11597 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
11598 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
11599 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
11600 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
11601 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
11604 if (elf_header
.e_shoff
)
11606 /* There may be some extensions in the first section header. Don't
11607 bomb if we can't read it. */
11609 get_32bit_section_headers (file
, 1);
11611 get_64bit_section_headers (file
, 1);
11617 /* Process one ELF object file according to the command line options.
11618 This file may actually be stored in an archive. The file is
11619 positioned at the start of the ELF object. */
11622 process_object (char *file_name
, FILE *file
)
11626 if (! get_file_header (file
))
11628 error (_("%s: Failed to read file header\n"), file_name
);
11632 /* Initialise per file variables. */
11633 for (i
= NUM_ELEM (version_info
); i
--;)
11634 version_info
[i
] = 0;
11636 for (i
= NUM_ELEM (dynamic_info
); i
--;)
11637 dynamic_info
[i
] = 0;
11639 /* Process the file. */
11641 printf (_("\nFile: %s\n"), file_name
);
11643 /* Initialise the dump_sects array from the cmdline_dump_sects array.
11644 Note we do this even if cmdline_dump_sects is empty because we
11645 must make sure that the dump_sets array is zeroed out before each
11646 object file is processed. */
11647 if (num_dump_sects
> num_cmdline_dump_sects
)
11648 memset (dump_sects
, 0, num_dump_sects
);
11650 if (num_cmdline_dump_sects
> 0)
11652 if (num_dump_sects
== 0)
11653 /* A sneaky way of allocating the dump_sects array. */
11654 request_dump (num_cmdline_dump_sects
, 0);
11656 assert (num_dump_sects
>= num_cmdline_dump_sects
);
11657 memcpy (dump_sects
, cmdline_dump_sects
, num_cmdline_dump_sects
);
11660 if (! process_file_header ())
11663 if (! process_section_headers (file
)
11664 || ! process_section_groups (file
))
11666 /* Without loaded section headers and section groups we
11667 cannot process lots of things. */
11668 do_unwind
= do_version
= do_dump
= do_arch
= 0;
11670 if (! do_using_dynamic
)
11671 do_syms
= do_reloc
= 0;
11674 if (process_program_headers (file
))
11675 process_dynamic_section (file
);
11677 process_relocs (file
);
11679 process_unwind (file
);
11681 process_symbol_table (file
);
11683 process_syminfo (file
);
11685 process_version_sections (file
);
11687 process_section_contents (file
);
11689 process_notes (file
);
11691 process_gnu_liblist (file
);
11693 process_arch_specific (file
);
11695 if (program_headers
)
11697 free (program_headers
);
11698 program_headers
= NULL
;
11701 if (section_headers
)
11703 free (section_headers
);
11704 section_headers
= NULL
;
11709 free (string_table
);
11710 string_table
= NULL
;
11711 string_table_length
= 0;
11714 if (dynamic_strings
)
11716 free (dynamic_strings
);
11717 dynamic_strings
= NULL
;
11718 dynamic_strings_length
= 0;
11721 if (dynamic_symbols
)
11723 free (dynamic_symbols
);
11724 dynamic_symbols
= NULL
;
11725 num_dynamic_syms
= 0;
11728 if (dynamic_syminfo
)
11730 free (dynamic_syminfo
);
11731 dynamic_syminfo
= NULL
;
11734 if (section_headers_groups
)
11736 free (section_headers_groups
);
11737 section_headers_groups
= NULL
;
11740 if (section_groups
)
11742 struct group_list
*g
, *next
;
11744 for (i
= 0; i
< group_count
; i
++)
11746 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
11753 free (section_groups
);
11754 section_groups
= NULL
;
11757 if (debug_information
)
11759 for (i
= 0; i
< num_debug_info_entries
; i
++)
11761 if (!debug_information
[i
].max_loc_offsets
)
11763 free (debug_information
[i
].loc_offsets
);
11764 free (debug_information
[i
].have_frame_base
);
11766 if (!debug_information
[i
].max_range_lists
)
11767 free (debug_information
[i
].range_lists
);
11769 free (debug_information
);
11770 debug_information
= NULL
;
11771 num_debug_info_entries
= 0;
11777 /* Process an ELF archive. The file is positioned just after the
11781 process_archive (char *file_name
, FILE *file
)
11783 struct ar_hdr arhdr
;
11785 unsigned long size
;
11786 char *longnames
= NULL
;
11787 unsigned long longnames_size
= 0;
11788 size_t file_name_size
;
11793 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
11794 if (got
!= sizeof arhdr
)
11799 error (_("%s: failed to read archive header\n"), file_name
);
11803 if (memcmp (arhdr
.ar_name
, "/ ", 16) == 0)
11805 /* This is the archive symbol table. Skip it.
11806 FIXME: We should have an option to dump it. */
11807 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
11808 if (fseek (file
, size
+ (size
& 1), SEEK_CUR
) != 0)
11810 error (_("%s: failed to skip archive symbol table\n"), file_name
);
11814 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
11815 if (got
!= sizeof arhdr
)
11820 error (_("%s: failed to read archive header\n"), file_name
);
11825 if (memcmp (arhdr
.ar_name
, "// ", 16) == 0)
11827 /* This is the archive string table holding long member
11830 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
11832 longnames
= malloc (longnames_size
);
11833 if (longnames
== NULL
)
11835 error (_("Out of memory\n"));
11839 if (fread (longnames
, longnames_size
, 1, file
) != 1)
11842 error (_("%s: failed to read string table\n"), file_name
);
11846 if ((longnames_size
& 1) != 0)
11849 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
11850 if (got
!= sizeof arhdr
)
11857 error (_("%s: failed to read archive header\n"), file_name
);
11862 file_name_size
= strlen (file_name
);
11871 if (arhdr
.ar_name
[0] == '/')
11875 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
11876 if (off
>= longnames_size
)
11878 error (_("%s: invalid archive string table offset %lu\n"), off
);
11883 name
= longnames
+ off
;
11884 nameend
= memchr (name
, '/', longnames_size
- off
);
11888 name
= arhdr
.ar_name
;
11889 nameend
= memchr (name
, '/', 16);
11892 if (nameend
== NULL
)
11894 error (_("%s: bad archive file name\n"));
11899 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
11900 if (namealc
== NULL
)
11902 error (_("Out of memory\n"));
11907 memcpy (namealc
, file_name
, file_name_size
);
11908 namealc
[file_name_size
] = '(';
11909 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
11910 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
11911 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
11913 archive_file_offset
= ftell (file
);
11914 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
11916 ret
|= process_object (namealc
, file
);
11921 (archive_file_offset
11922 + archive_file_size
11923 + (archive_file_size
& 1)),
11926 error (_("%s: failed to seek to next archive header\n"), file_name
);
11931 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
11932 if (got
!= sizeof arhdr
)
11937 error (_("%s: failed to read archive header\n"), file_name
);
11943 if (longnames
!= 0)
11950 process_file (char *file_name
)
11953 struct stat statbuf
;
11954 char armag
[SARMAG
];
11957 if (stat (file_name
, &statbuf
) < 0)
11959 if (errno
== ENOENT
)
11960 error (_("'%s': No such file\n"), file_name
);
11962 error (_("Could not locate '%s'. System error message: %s\n"),
11963 file_name
, strerror (errno
));
11967 if (! S_ISREG (statbuf
.st_mode
))
11969 error (_("'%s' is not an ordinary file\n"), file_name
);
11973 file
= fopen (file_name
, "rb");
11976 error (_("Input file '%s' is not readable.\n"), file_name
);
11980 if (fread (armag
, SARMAG
, 1, file
) != 1)
11982 error (_("%s: Failed to read file header\n"), file_name
);
11987 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
11988 ret
= process_archive (file_name
, file
);
11992 archive_file_size
= archive_file_offset
= 0;
11993 ret
= process_object (file_name
, file
);
12001 #ifdef SUPPORT_DISASSEMBLY
12002 /* Needed by the i386 disassembler. For extra credit, someone could
12003 fix this so that we insert symbolic addresses here, esp for GOT/PLT
12007 print_address (unsigned int addr
, FILE *outfile
)
12009 fprintf (outfile
,"0x%8.8x", addr
);
12012 /* Needed by the i386 disassembler. */
12014 db_task_printsym (unsigned int addr
)
12016 print_address (addr
, stderr
);
12021 main (int argc
, char **argv
)
12025 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
12026 setlocale (LC_MESSAGES
, "");
12028 #if defined (HAVE_SETLOCALE)
12029 setlocale (LC_CTYPE
, "");
12031 bindtextdomain (PACKAGE
, LOCALEDIR
);
12032 textdomain (PACKAGE
);
12034 parse_args (argc
, argv
);
12036 if (num_dump_sects
> 0)
12038 /* Make a copy of the dump_sects array. */
12039 cmdline_dump_sects
= malloc (num_dump_sects
);
12040 if (cmdline_dump_sects
== NULL
)
12041 error (_("Out of memory allocating dump request table."));
12044 memcpy (cmdline_dump_sects
, dump_sects
, num_dump_sects
);
12045 num_cmdline_dump_sects
= num_dump_sects
;
12049 if (optind
< (argc
- 1))
12053 while (optind
< argc
)
12054 err
|= process_file (argv
[optind
++]);
12056 if (dump_sects
!= NULL
)
12058 if (cmdline_dump_sects
!= NULL
)
12059 free (cmdline_dump_sects
);