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
;
174 struct group_list
*next
;
175 unsigned int section_index
;
180 struct group_list
*root
;
181 unsigned int group_index
;
184 struct group
*section_groups
;
185 size_t group_count
= 0;
187 struct group
**section_headers_groups
;
189 /* A dynamic array of flags indicating for which sections a hex dump
190 has been requested (via the -x switch) and/or a disassembly dump
191 (via the -i switch). */
192 char *cmdline_dump_sects
= NULL
;
193 unsigned num_cmdline_dump_sects
= 0;
195 /* A dynamic array of flags indicating for which sections a dump of
196 some kind has been requested. It is reset on a per-object file
197 basis and then initialised from the cmdline_dump_sects array and
198 the results of interpreting the -w switch. */
199 char *dump_sects
= NULL
;
200 unsigned int num_dump_sects
= 0;
202 #define HEX_DUMP (1 << 0)
203 #define DISASS_DUMP (1 << 1)
204 #define DEBUG_DUMP (1 << 2)
206 /* How to rpint a vma value. */
207 typedef enum print_mode
219 static bfd_vma (*byte_get
) (unsigned char *, int);
220 static void (*byte_put
) (unsigned char *, bfd_vma
, int);
224 #define SECTION_NAME(X) ((X) == NULL ? "<none>" : \
225 ((X)->sh_name >= string_table_length \
226 ? "<corrupt>" : string_table + (X)->sh_name))
228 /* Given st_shndx I, map to section_headers index. */
229 #define SECTION_HEADER_INDEX(I) \
230 ((I) < SHN_LORESERVE \
232 : ((I) <= SHN_HIRESERVE \
234 : (I) - (SHN_HIRESERVE + 1 - SHN_LORESERVE)))
236 /* Reverse of the above. */
237 #define SECTION_HEADER_NUM(N) \
238 ((N) < SHN_LORESERVE \
240 : (N) + (SHN_HIRESERVE + 1 - SHN_LORESERVE))
242 #define SECTION_HEADER(I) (section_headers + SECTION_HEADER_INDEX (I))
244 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
246 #define BYTE_GET(field) byte_get (field, sizeof (field))
248 /* If we can support a 64 bit data type then BFD64 should be defined
249 and sizeof (bfd_vma) == 8. In this case when translating from an
250 external 8 byte field to an internal field, we can assume that the
251 internal field is also 8 bytes wide and so we can extract all the data.
252 If, however, BFD64 is not defined, then we must assume that the
253 internal data structure only has 4 byte wide fields that are the
254 equivalent of the 8 byte wide external counterparts, and so we must
255 truncate the data. */
257 #define BYTE_GET8(field) byte_get (field, -8)
259 #define BYTE_GET8(field) byte_get (field, 8)
262 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
264 #define GET_ELF_SYMBOLS(file, section) \
265 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
266 : get_64bit_elf_symbols (file, section))
268 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
269 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
270 already been called and verified that the string exists. */
271 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
273 /* This is just a bit of syntatic sugar. */
274 #define streq(a,b) (strcmp ((a), (b)) == 0)
275 #define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
278 error (const char *message
, ...)
282 va_start (args
, message
);
283 fprintf (stderr
, _("%s: Error: "), program_name
);
284 vfprintf (stderr
, message
, args
);
289 warn (const char *message
, ...)
293 va_start (args
, message
);
294 fprintf (stderr
, _("%s: Warning: "), program_name
);
295 vfprintf (stderr
, message
, args
);
300 get_data (void *var
, FILE *file
, long offset
, size_t size
, const char *reason
)
307 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
309 error (_("Unable to seek to 0x%x for %s\n"),
310 archive_file_offset
+ offset
, reason
);
317 mvar
= malloc (size
);
321 error (_("Out of memory allocating 0x%x bytes for %s\n"),
327 if (fread (mvar
, size
, 1, file
) != 1)
329 error (_("Unable to read in 0x%x bytes of %s\n"), size
, reason
);
339 byte_get_little_endian (unsigned char *field
, int size
)
347 return ((unsigned int) (field
[0]))
348 | (((unsigned int) (field
[1])) << 8);
352 /* We want to extract data from an 8 byte wide field and
353 place it into a 4 byte wide field. Since this is a little
354 endian source we can just use the 4 byte extraction code. */
358 return ((unsigned long) (field
[0]))
359 | (((unsigned long) (field
[1])) << 8)
360 | (((unsigned long) (field
[2])) << 16)
361 | (((unsigned long) (field
[3])) << 24);
366 /* This is a special case, generated by the BYTE_GET8 macro.
367 It means that we are loading an 8 byte value from a field
368 in an external structure into an 8 byte value in a field
369 in an internal structure. */
370 return ((bfd_vma
) (field
[0]))
371 | (((bfd_vma
) (field
[1])) << 8)
372 | (((bfd_vma
) (field
[2])) << 16)
373 | (((bfd_vma
) (field
[3])) << 24)
374 | (((bfd_vma
) (field
[4])) << 32)
375 | (((bfd_vma
) (field
[5])) << 40)
376 | (((bfd_vma
) (field
[6])) << 48)
377 | (((bfd_vma
) (field
[7])) << 56);
380 error (_("Unhandled data length: %d\n"), size
);
386 byte_get_signed (unsigned char *field
, int size
)
388 bfd_vma x
= byte_get (field
, size
);
393 return (x
^ 0x80) - 0x80;
395 return (x
^ 0x8000) - 0x8000;
397 return (x
^ 0x80000000) - 0x80000000;
407 byte_put_little_endian (unsigned char *field
, bfd_vma value
, int size
)
412 field
[7] = (((value
>> 24) >> 24) >> 8) & 0xff;
413 field
[6] = ((value
>> 24) >> 24) & 0xff;
414 field
[5] = ((value
>> 24) >> 16) & 0xff;
415 field
[4] = ((value
>> 24) >> 8) & 0xff;
418 field
[3] = (value
>> 24) & 0xff;
419 field
[2] = (value
>> 16) & 0xff;
422 field
[1] = (value
>> 8) & 0xff;
425 field
[0] = value
& 0xff;
429 error (_("Unhandled data length: %d\n"), size
);
434 /* Print a VMA value. */
436 print_vma (bfd_vma vma
, print_mode mode
)
448 printf ("%8.8lx", (unsigned long) vma
);
454 printf ("%5ld", (long) vma
);
462 printf ("%lx", (unsigned long) vma
);
466 printf ("%ld", (unsigned long) vma
);
470 printf ("%lu", (unsigned long) vma
);
492 #if BFD_HOST_64BIT_LONG
495 if (_bfd_int64_high (vma
))
496 printf ("%lx%8.8lx", _bfd_int64_high (vma
), _bfd_int64_low (vma
));
498 printf ("%lx", _bfd_int64_low (vma
));
503 #if BFD_HOST_64BIT_LONG
506 if (_bfd_int64_high (vma
))
508 printf ("++%ld", _bfd_int64_low (vma
));
510 printf ("%ld", _bfd_int64_low (vma
));
515 #if BFD_HOST_64BIT_LONG
517 printf ("%5ld", vma
);
519 printf ("%#lx", vma
);
521 if (_bfd_int64_high (vma
))
523 printf ("++%ld", _bfd_int64_low (vma
));
524 else if (vma
<= 99999)
525 printf ("%5ld", _bfd_int64_low (vma
));
527 printf ("%#lx", _bfd_int64_low (vma
));
532 #if BFD_HOST_64BIT_LONG
535 if (_bfd_int64_high (vma
))
537 printf ("++%lu", _bfd_int64_low (vma
));
539 printf ("%lu", _bfd_int64_low (vma
));
547 /* Display a symbol on stdout. If do_wide is not true then
548 format the symbol to be at most WIDTH characters,
549 truncating as necessary. If WIDTH is negative then
550 format the string to be exactly - WIDTH characters,
551 truncating or padding as necessary. */
554 print_symbol (int width
, const char *symbol
)
557 printf ("%s", symbol
);
559 printf ("%-*.*s", width
, width
, symbol
);
561 printf ("%-.*s", width
, symbol
);
565 byte_get_big_endian (unsigned char *field
, int size
)
573 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
576 return ((unsigned long) (field
[3]))
577 | (((unsigned long) (field
[2])) << 8)
578 | (((unsigned long) (field
[1])) << 16)
579 | (((unsigned long) (field
[0])) << 24);
583 /* Although we are extracing data from an 8 byte wide field,
584 we are returning only 4 bytes of data. */
585 return ((unsigned long) (field
[7]))
586 | (((unsigned long) (field
[6])) << 8)
587 | (((unsigned long) (field
[5])) << 16)
588 | (((unsigned long) (field
[4])) << 24);
592 /* This is a special case, generated by the BYTE_GET8 macro.
593 It means that we are loading an 8 byte value from a field
594 in an external structure into an 8 byte value in a field
595 in an internal structure. */
596 return ((bfd_vma
) (field
[7]))
597 | (((bfd_vma
) (field
[6])) << 8)
598 | (((bfd_vma
) (field
[5])) << 16)
599 | (((bfd_vma
) (field
[4])) << 24)
600 | (((bfd_vma
) (field
[3])) << 32)
601 | (((bfd_vma
) (field
[2])) << 40)
602 | (((bfd_vma
) (field
[1])) << 48)
603 | (((bfd_vma
) (field
[0])) << 56);
607 error (_("Unhandled data length: %d\n"), size
);
613 byte_put_big_endian (unsigned char *field
, bfd_vma value
, int size
)
618 field
[7] = value
& 0xff;
619 field
[6] = (value
>> 8) & 0xff;
620 field
[5] = (value
>> 16) & 0xff;
621 field
[4] = (value
>> 24) & 0xff;
626 field
[3] = value
& 0xff;
627 field
[2] = (value
>> 8) & 0xff;
631 field
[1] = value
& 0xff;
635 field
[0] = value
& 0xff;
639 error (_("Unhandled data length: %d\n"), size
);
644 /* Guess the relocation size commonly used by the specific machines. */
647 guess_is_rela (unsigned long e_machine
)
651 /* Targets that use REL relocations. */
666 /* Targets that use RELA relocations. */
681 case EM_CYGNUS_MN10200
:
683 case EM_CYGNUS_MN10300
:
730 warn (_("Don't know about relocations on this machine architecture\n"));
736 slurp_rela_relocs (FILE *file
,
737 unsigned long rel_offset
,
738 unsigned long rel_size
,
739 Elf_Internal_Rela
**relasp
,
740 unsigned long *nrelasp
)
742 Elf_Internal_Rela
*relas
;
743 unsigned long nrelas
;
748 Elf32_External_Rela
*erelas
;
750 erelas
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
754 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
756 relas
= malloc (nrelas
* sizeof (Elf_Internal_Rela
));
760 error (_("out of memory parsing relocs"));
764 for (i
= 0; i
< nrelas
; i
++)
766 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
767 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
768 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
775 Elf64_External_Rela
*erelas
;
777 erelas
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
781 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
783 relas
= malloc (nrelas
* sizeof (Elf_Internal_Rela
));
787 error (_("out of memory parsing relocs"));
791 for (i
= 0; i
< nrelas
; i
++)
793 relas
[i
].r_offset
= BYTE_GET8 (erelas
[i
].r_offset
);
794 relas
[i
].r_info
= BYTE_GET8 (erelas
[i
].r_info
);
795 relas
[i
].r_addend
= BYTE_GET8 (erelas
[i
].r_addend
);
806 slurp_rel_relocs (FILE *file
,
807 unsigned long rel_offset
,
808 unsigned long rel_size
,
809 Elf_Internal_Rela
**relsp
,
810 unsigned long *nrelsp
)
812 Elf_Internal_Rela
*rels
;
818 Elf32_External_Rel
*erels
;
820 erels
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
824 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
826 rels
= malloc (nrels
* sizeof (Elf_Internal_Rela
));
830 error (_("out of memory parsing relocs"));
834 for (i
= 0; i
< nrels
; i
++)
836 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
837 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
838 rels
[i
].r_addend
= 0;
845 Elf64_External_Rel
*erels
;
847 erels
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
851 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
853 rels
= malloc (nrels
* sizeof (Elf_Internal_Rela
));
857 error (_("out of memory parsing relocs"));
861 for (i
= 0; i
< nrels
; i
++)
863 rels
[i
].r_offset
= BYTE_GET8 (erels
[i
].r_offset
);
864 rels
[i
].r_info
= BYTE_GET8 (erels
[i
].r_info
);
865 rels
[i
].r_addend
= 0;
875 /* Display the contents of the relocation data found at the specified
879 dump_relocations (FILE *file
,
880 unsigned long rel_offset
,
881 unsigned long rel_size
,
882 Elf_Internal_Sym
*symtab
,
885 unsigned long strtablen
,
889 Elf_Internal_Rela
*rels
;
892 if (is_rela
== UNKNOWN
)
893 is_rela
= guess_is_rela (elf_header
.e_machine
);
897 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
902 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
911 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
913 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
918 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
920 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
928 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
930 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
935 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
937 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
941 for (i
= 0; i
< rel_size
; i
++)
944 const char *rtype2
= NULL
;
945 const char *rtype3
= NULL
;
948 bfd_vma symtab_index
;
953 offset
= rels
[i
].r_offset
;
954 info
= rels
[i
].r_info
;
958 type
= ELF32_R_TYPE (info
);
959 symtab_index
= ELF32_R_SYM (info
);
963 /* The #ifdef BFD64 below is to prevent a compile time warning.
964 We know that if we do not have a 64 bit data type that we
965 will never execute this code anyway. */
967 if (elf_header
.e_machine
== EM_MIPS
)
969 /* In little-endian objects, r_info isn't really a 64-bit
970 little-endian value: it has a 32-bit little-endian
971 symbol index followed by four individual byte fields.
972 Reorder INFO accordingly. */
973 if (elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
974 info
= (((info
& 0xffffffff) << 32)
975 | ((info
>> 56) & 0xff)
976 | ((info
>> 40) & 0xff00)
977 | ((info
>> 24) & 0xff0000)
978 | ((info
>> 8) & 0xff000000));
979 type
= ELF64_MIPS_R_TYPE (info
);
980 type2
= ELF64_MIPS_R_TYPE2 (info
);
981 type3
= ELF64_MIPS_R_TYPE3 (info
);
983 else if (elf_header
.e_machine
== EM_SPARCV9
)
984 type
= ELF64_R_TYPE_ID (info
);
986 type
= ELF64_R_TYPE (info
);
988 symtab_index
= ELF64_R_SYM (info
);
994 #ifdef _bfd_int64_low
995 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset
), _bfd_int64_low (info
));
997 printf ("%8.8lx %8.8lx ", offset
, info
);
1002 #ifdef _bfd_int64_low
1004 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1005 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1006 _bfd_int64_high (offset
),
1007 _bfd_int64_low (offset
),
1008 _bfd_int64_high (info
),
1009 _bfd_int64_low (info
));
1012 ? "%16.16lx %16.16lx "
1013 : "%12.12lx %12.12lx ",
1018 switch (elf_header
.e_machine
)
1025 case EM_CYGNUS_M32R
:
1026 rtype
= elf_m32r_reloc_type (type
);
1031 rtype
= elf_i386_reloc_type (type
);
1036 rtype
= elf_m68hc11_reloc_type (type
);
1040 rtype
= elf_m68k_reloc_type (type
);
1044 rtype
= elf_i960_reloc_type (type
);
1049 rtype
= elf_avr_reloc_type (type
);
1052 case EM_OLD_SPARCV9
:
1053 case EM_SPARC32PLUS
:
1056 rtype
= elf_sparc_reloc_type (type
);
1060 case EM_CYGNUS_V850
:
1061 rtype
= v850_reloc_type (type
);
1065 case EM_CYGNUS_D10V
:
1066 rtype
= elf_d10v_reloc_type (type
);
1070 case EM_CYGNUS_D30V
:
1071 rtype
= elf_d30v_reloc_type (type
);
1075 rtype
= elf_dlx_reloc_type (type
);
1079 rtype
= elf_sh_reloc_type (type
);
1083 case EM_CYGNUS_MN10300
:
1084 rtype
= elf_mn10300_reloc_type (type
);
1088 case EM_CYGNUS_MN10200
:
1089 rtype
= elf_mn10200_reloc_type (type
);
1093 case EM_CYGNUS_FR30
:
1094 rtype
= elf_fr30_reloc_type (type
);
1098 rtype
= elf_frv_reloc_type (type
);
1102 rtype
= elf_mcore_reloc_type (type
);
1106 rtype
= elf_mmix_reloc_type (type
);
1111 rtype
= elf_msp430_reloc_type (type
);
1115 rtype
= elf_ppc_reloc_type (type
);
1119 rtype
= elf_ppc64_reloc_type (type
);
1123 case EM_MIPS_RS3_LE
:
1124 rtype
= elf_mips_reloc_type (type
);
1127 rtype2
= elf_mips_reloc_type (type2
);
1128 rtype3
= elf_mips_reloc_type (type3
);
1133 rtype
= elf_alpha_reloc_type (type
);
1137 rtype
= elf_arm_reloc_type (type
);
1141 rtype
= elf_arc_reloc_type (type
);
1145 rtype
= elf_hppa_reloc_type (type
);
1151 rtype
= elf_h8_reloc_type (type
);
1156 rtype
= elf_or32_reloc_type (type
);
1161 rtype
= elf_pj_reloc_type (type
);
1164 rtype
= elf_ia64_reloc_type (type
);
1168 rtype
= elf_cris_reloc_type (type
);
1172 rtype
= elf_i860_reloc_type (type
);
1176 rtype
= elf_x86_64_reloc_type (type
);
1180 rtype
= i370_reloc_type (type
);
1185 rtype
= elf_s390_reloc_type (type
);
1189 rtype
= elf_xstormy16_reloc_type (type
);
1193 rtype
= elf_crx_reloc_type (type
);
1197 rtype
= elf_vax_reloc_type (type
);
1202 rtype
= elf_ip2k_reloc_type (type
);
1206 rtype
= elf_iq2000_reloc_type (type
);
1211 rtype
= elf_xtensa_reloc_type (type
);
1216 #ifdef _bfd_int64_low
1217 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type
));
1219 printf (_("unrecognized: %-7lx"), type
);
1222 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1226 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1227 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1230 Elf_Internal_Sym
*psym
;
1232 psym
= symtab
+ symtab_index
;
1235 print_vma (psym
->st_value
, LONG_HEX
);
1236 printf (is_32bit_elf
? " " : " ");
1238 if (psym
->st_name
== 0)
1240 const char *sec_name
= "<null>";
1243 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1245 bfd_vma sec_index
= (bfd_vma
) -1;
1247 if (psym
->st_shndx
< SHN_LORESERVE
)
1248 sec_index
= psym
->st_shndx
;
1249 else if (psym
->st_shndx
> SHN_HIRESERVE
)
1250 sec_index
= psym
->st_shndx
- (SHN_HIRESERVE
+ 1
1253 if (sec_index
!= (bfd_vma
) -1)
1254 sec_name
= SECTION_NAME (section_headers
+ sec_index
);
1255 else if (psym
->st_shndx
== SHN_ABS
)
1257 else if (psym
->st_shndx
== SHN_COMMON
)
1258 sec_name
= "COMMON";
1259 else if (elf_header
.e_machine
== EM_IA_64
1260 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1261 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1262 sec_name
= "ANSI_COM";
1265 sprintf (name_buf
, "<section 0x%x>",
1266 (unsigned int) psym
->st_shndx
);
1267 sec_name
= name_buf
;
1270 print_symbol (22, sec_name
);
1272 else if (strtab
== NULL
)
1273 printf (_("<string table index: %3ld>"), psym
->st_name
);
1274 else if (psym
->st_name
> strtablen
)
1275 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1277 print_symbol (22, strtab
+ psym
->st_name
);
1280 printf (" + %lx", (unsigned long) rels
[i
].r_addend
);
1285 printf ("%*c", is_32bit_elf
?
1286 (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1287 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1290 if (elf_header
.e_machine
== EM_SPARCV9
1291 && streq (rtype
, "R_SPARC_OLO10"))
1292 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1296 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1298 printf (" Type2: ");
1301 #ifdef _bfd_int64_low
1302 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2
));
1304 printf (_("unrecognized: %-7lx"), type2
);
1307 printf ("%-17.17s", rtype2
);
1309 printf ("\n Type3: ");
1312 #ifdef _bfd_int64_low
1313 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3
));
1315 printf (_("unrecognized: %-7lx"), type3
);
1318 printf ("%-17.17s", rtype3
);
1330 get_mips_dynamic_type (unsigned long type
)
1334 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1335 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1336 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1337 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1338 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1339 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1340 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1341 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1342 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1343 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1344 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1345 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1346 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1347 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1348 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1349 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1350 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1351 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1352 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1353 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1354 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1355 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1356 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1357 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1358 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1359 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1360 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1361 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1362 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1363 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1364 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1365 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1366 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1367 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1368 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1369 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1370 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1371 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1372 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1373 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1374 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1375 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1376 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1383 get_sparc64_dynamic_type (unsigned long type
)
1387 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1394 get_ppc64_dynamic_type (unsigned long type
)
1398 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1399 case DT_PPC64_OPD
: return "PPC64_OPD";
1400 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1407 get_parisc_dynamic_type (unsigned long type
)
1411 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1412 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1413 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1414 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1415 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1416 case DT_HP_PREINIT
: return "HP_PREINIT";
1417 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1418 case DT_HP_NEEDED
: return "HP_NEEDED";
1419 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1420 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1421 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1422 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1423 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1430 get_ia64_dynamic_type (unsigned long type
)
1434 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1441 get_dynamic_type (unsigned long type
)
1443 static char buff
[32];
1447 case DT_NULL
: return "NULL";
1448 case DT_NEEDED
: return "NEEDED";
1449 case DT_PLTRELSZ
: return "PLTRELSZ";
1450 case DT_PLTGOT
: return "PLTGOT";
1451 case DT_HASH
: return "HASH";
1452 case DT_STRTAB
: return "STRTAB";
1453 case DT_SYMTAB
: return "SYMTAB";
1454 case DT_RELA
: return "RELA";
1455 case DT_RELASZ
: return "RELASZ";
1456 case DT_RELAENT
: return "RELAENT";
1457 case DT_STRSZ
: return "STRSZ";
1458 case DT_SYMENT
: return "SYMENT";
1459 case DT_INIT
: return "INIT";
1460 case DT_FINI
: return "FINI";
1461 case DT_SONAME
: return "SONAME";
1462 case DT_RPATH
: return "RPATH";
1463 case DT_SYMBOLIC
: return "SYMBOLIC";
1464 case DT_REL
: return "REL";
1465 case DT_RELSZ
: return "RELSZ";
1466 case DT_RELENT
: return "RELENT";
1467 case DT_PLTREL
: return "PLTREL";
1468 case DT_DEBUG
: return "DEBUG";
1469 case DT_TEXTREL
: return "TEXTREL";
1470 case DT_JMPREL
: return "JMPREL";
1471 case DT_BIND_NOW
: return "BIND_NOW";
1472 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1473 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1474 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1475 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1476 case DT_RUNPATH
: return "RUNPATH";
1477 case DT_FLAGS
: return "FLAGS";
1479 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1480 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1482 case DT_CHECKSUM
: return "CHECKSUM";
1483 case DT_PLTPADSZ
: return "PLTPADSZ";
1484 case DT_MOVEENT
: return "MOVEENT";
1485 case DT_MOVESZ
: return "MOVESZ";
1486 case DT_FEATURE
: return "FEATURE";
1487 case DT_POSFLAG_1
: return "POSFLAG_1";
1488 case DT_SYMINSZ
: return "SYMINSZ";
1489 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1491 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1492 case DT_CONFIG
: return "CONFIG";
1493 case DT_DEPAUDIT
: return "DEPAUDIT";
1494 case DT_AUDIT
: return "AUDIT";
1495 case DT_PLTPAD
: return "PLTPAD";
1496 case DT_MOVETAB
: return "MOVETAB";
1497 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1499 case DT_VERSYM
: return "VERSYM";
1501 case DT_RELACOUNT
: return "RELACOUNT";
1502 case DT_RELCOUNT
: return "RELCOUNT";
1503 case DT_FLAGS_1
: return "FLAGS_1";
1504 case DT_VERDEF
: return "VERDEF";
1505 case DT_VERDEFNUM
: return "VERDEFNUM";
1506 case DT_VERNEED
: return "VERNEED";
1507 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1509 case DT_AUXILIARY
: return "AUXILIARY";
1510 case DT_USED
: return "USED";
1511 case DT_FILTER
: return "FILTER";
1513 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1514 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1515 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1516 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1517 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1520 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1524 switch (elf_header
.e_machine
)
1527 case EM_MIPS_RS3_LE
:
1528 result
= get_mips_dynamic_type (type
);
1531 result
= get_sparc64_dynamic_type (type
);
1534 result
= get_ppc64_dynamic_type (type
);
1537 result
= get_ia64_dynamic_type (type
);
1547 sprintf (buff
, _("Processor Specific: %lx"), type
);
1549 else if ((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1553 switch (elf_header
.e_machine
)
1556 result
= get_parisc_dynamic_type (type
);
1566 sprintf (buff
, _("Operating System specific: %lx"), type
);
1569 sprintf (buff
, _("<unknown>: %lx"), type
);
1576 get_file_type (unsigned e_type
)
1578 static char buff
[32];
1582 case ET_NONE
: return _("NONE (None)");
1583 case ET_REL
: return _("REL (Relocatable file)");
1584 case ET_EXEC
: return _("EXEC (Executable file)");
1585 case ET_DYN
: return _("DYN (Shared object file)");
1586 case ET_CORE
: return _("CORE (Core file)");
1589 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1590 sprintf (buff
, _("Processor Specific: (%x)"), e_type
);
1591 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1592 sprintf (buff
, _("OS Specific: (%x)"), e_type
);
1594 sprintf (buff
, _("<unknown>: %x"), e_type
);
1600 get_machine_name (unsigned e_machine
)
1602 static char buff
[64]; /* XXX */
1606 case EM_NONE
: return _("None");
1607 case EM_M32
: return "WE32100";
1608 case EM_SPARC
: return "Sparc";
1609 case EM_386
: return "Intel 80386";
1610 case EM_68K
: return "MC68000";
1611 case EM_88K
: return "MC88000";
1612 case EM_486
: return "Intel 80486";
1613 case EM_860
: return "Intel 80860";
1614 case EM_MIPS
: return "MIPS R3000";
1615 case EM_S370
: return "IBM System/370";
1616 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1617 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1618 case EM_PARISC
: return "HPPA";
1619 case EM_PPC_OLD
: return "Power PC (old)";
1620 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1621 case EM_960
: return "Intel 90860";
1622 case EM_PPC
: return "PowerPC";
1623 case EM_PPC64
: return "PowerPC64";
1624 case EM_V800
: return "NEC V800";
1625 case EM_FR20
: return "Fujitsu FR20";
1626 case EM_RH32
: return "TRW RH32";
1627 case EM_MCORE
: return "MCORE";
1628 case EM_ARM
: return "ARM";
1629 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1630 case EM_SH
: return "Renesas / SuperH SH";
1631 case EM_SPARCV9
: return "Sparc v9";
1632 case EM_TRICORE
: return "Siemens Tricore";
1633 case EM_ARC
: return "ARC";
1634 case EM_H8_300
: return "Renesas H8/300";
1635 case EM_H8_300H
: return "Renesas H8/300H";
1636 case EM_H8S
: return "Renesas H8S";
1637 case EM_H8_500
: return "Renesas H8/500";
1638 case EM_IA_64
: return "Intel IA-64";
1639 case EM_MIPS_X
: return "Stanford MIPS-X";
1640 case EM_COLDFIRE
: return "Motorola Coldfire";
1641 case EM_68HC12
: return "Motorola M68HC12";
1642 case EM_ALPHA
: return "Alpha";
1643 case EM_CYGNUS_D10V
:
1644 case EM_D10V
: return "d10v";
1645 case EM_CYGNUS_D30V
:
1646 case EM_D30V
: return "d30v";
1647 case EM_CYGNUS_M32R
:
1648 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1649 case EM_CYGNUS_V850
:
1650 case EM_V850
: return "NEC v850";
1651 case EM_CYGNUS_MN10300
:
1652 case EM_MN10300
: return "mn10300";
1653 case EM_CYGNUS_MN10200
:
1654 case EM_MN10200
: return "mn10200";
1655 case EM_CYGNUS_FR30
:
1656 case EM_FR30
: return "Fujitsu FR30";
1657 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1659 case EM_PJ
: return "picoJava";
1660 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1661 case EM_PCP
: return "Siemens PCP";
1662 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1663 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1664 case EM_STARCORE
: return "Motorola Star*Core processor";
1665 case EM_ME16
: return "Toyota ME16 processor";
1666 case EM_ST100
: return "STMicroelectronics ST100 processor";
1667 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1668 case EM_FX66
: return "Siemens FX66 microcontroller";
1669 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1670 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1671 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1672 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1673 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1674 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1675 case EM_SVX
: return "Silicon Graphics SVx";
1676 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1677 case EM_VAX
: return "Digital VAX";
1679 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1680 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1681 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1682 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1683 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1684 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1685 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1686 case EM_PRISM
: return "Vitesse Prism";
1687 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1689 case EM_S390
: return "IBM S/390";
1690 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1692 case EM_OR32
: return "OpenRISC";
1693 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1694 case EM_DLX
: return "OpenDLX";
1696 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1697 case EM_IQ2000
: return "Vitesse IQ2000";
1699 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1701 sprintf (buff
, _("<unknown>: %x"), e_machine
);
1707 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
1712 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1713 e_flags
&= ~ EF_ARM_EABIMASK
;
1715 /* Handle "generic" ARM flags. */
1716 if (e_flags
& EF_ARM_RELEXEC
)
1718 strcat (buf
, ", relocatable executable");
1719 e_flags
&= ~ EF_ARM_RELEXEC
;
1722 if (e_flags
& EF_ARM_HASENTRY
)
1724 strcat (buf
, ", has entry point");
1725 e_flags
&= ~ EF_ARM_HASENTRY
;
1728 /* Now handle EABI specific flags. */
1732 strcat (buf
, ", <unrecognized EABI>");
1737 case EF_ARM_EABI_VER1
:
1738 strcat (buf
, ", Version1 EABI");
1743 /* Process flags one bit at a time. */
1744 flag
= e_flags
& - e_flags
;
1749 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1750 strcat (buf
, ", sorted symbol tables");
1760 case EF_ARM_EABI_VER2
:
1761 strcat (buf
, ", Version2 EABI");
1766 /* Process flags one bit at a time. */
1767 flag
= e_flags
& - e_flags
;
1772 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1773 strcat (buf
, ", sorted symbol tables");
1776 case EF_ARM_DYNSYMSUSESEGIDX
:
1777 strcat (buf
, ", dynamic symbols use segment index");
1780 case EF_ARM_MAPSYMSFIRST
:
1781 strcat (buf
, ", mapping symbols precede others");
1791 case EF_ARM_EABI_VER3
:
1792 strcat (buf
, ", Version3 EABI");
1795 case EF_ARM_EABI_VER4
:
1796 strcat (buf
, ", Version4 EABI");
1801 /* Process flags one bit at a time. */
1802 flag
= e_flags
& - e_flags
;
1808 strcat (buf
, ", BE8");
1812 strcat (buf
, ", LE8");
1822 case EF_ARM_EABI_UNKNOWN
:
1823 strcat (buf
, ", GNU EABI");
1828 /* Process flags one bit at a time. */
1829 flag
= e_flags
& - e_flags
;
1834 case EF_ARM_INTERWORK
:
1835 strcat (buf
, ", interworking enabled");
1838 case EF_ARM_APCS_26
:
1839 strcat (buf
, ", uses APCS/26");
1842 case EF_ARM_APCS_FLOAT
:
1843 strcat (buf
, ", uses APCS/float");
1847 strcat (buf
, ", position independent");
1851 strcat (buf
, ", 8 bit structure alignment");
1854 case EF_ARM_NEW_ABI
:
1855 strcat (buf
, ", uses new ABI");
1858 case EF_ARM_OLD_ABI
:
1859 strcat (buf
, ", uses old ABI");
1862 case EF_ARM_SOFT_FLOAT
:
1863 strcat (buf
, ", software FP");
1866 case EF_ARM_VFP_FLOAT
:
1867 strcat (buf
, ", VFP");
1870 case EF_ARM_MAVERICK_FLOAT
:
1871 strcat (buf
, ", Maverick FP");
1882 strcat (buf
,", <unknown>");
1886 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
1888 static char buf
[1024];
1900 decode_ARM_machine_flags (e_flags
, buf
);
1904 switch (e_flags
& EF_FRV_CPU_MASK
)
1906 case EF_FRV_CPU_GENERIC
:
1910 strcat (buf
, ", fr???");
1913 case EF_FRV_CPU_FR300
:
1914 strcat (buf
, ", fr300");
1917 case EF_FRV_CPU_FR400
:
1918 strcat (buf
, ", fr400");
1920 case EF_FRV_CPU_FR405
:
1921 strcat (buf
, ", fr405");
1924 case EF_FRV_CPU_FR450
:
1925 strcat (buf
, ", fr450");
1928 case EF_FRV_CPU_FR500
:
1929 strcat (buf
, ", fr500");
1931 case EF_FRV_CPU_FR550
:
1932 strcat (buf
, ", fr550");
1935 case EF_FRV_CPU_SIMPLE
:
1936 strcat (buf
, ", simple");
1938 case EF_FRV_CPU_TOMCAT
:
1939 strcat (buf
, ", tomcat");
1945 if (e_flags
& EF_CPU32
)
1946 strcat (buf
, ", cpu32");
1947 if (e_flags
& EF_M68000
)
1948 strcat (buf
, ", m68000");
1952 if (e_flags
& EF_PPC_EMB
)
1953 strcat (buf
, ", emb");
1955 if (e_flags
& EF_PPC_RELOCATABLE
)
1956 strcat (buf
, ", relocatable");
1958 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
1959 strcat (buf
, ", relocatable-lib");
1963 case EM_CYGNUS_V850
:
1964 switch (e_flags
& EF_V850_ARCH
)
1967 strcat (buf
, ", v850e1");
1970 strcat (buf
, ", v850e");
1973 strcat (buf
, ", v850");
1976 strcat (buf
, ", unknown v850 architecture variant");
1982 case EM_CYGNUS_M32R
:
1983 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
1984 strcat (buf
, ", m32r");
1989 case EM_MIPS_RS3_LE
:
1990 if (e_flags
& EF_MIPS_NOREORDER
)
1991 strcat (buf
, ", noreorder");
1993 if (e_flags
& EF_MIPS_PIC
)
1994 strcat (buf
, ", pic");
1996 if (e_flags
& EF_MIPS_CPIC
)
1997 strcat (buf
, ", cpic");
1999 if (e_flags
& EF_MIPS_UCODE
)
2000 strcat (buf
, ", ugen_reserved");
2002 if (e_flags
& EF_MIPS_ABI2
)
2003 strcat (buf
, ", abi2");
2005 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2006 strcat (buf
, ", odk first");
2008 if (e_flags
& EF_MIPS_32BITMODE
)
2009 strcat (buf
, ", 32bitmode");
2011 switch ((e_flags
& EF_MIPS_MACH
))
2013 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2014 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2015 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2016 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2017 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2018 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2019 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2020 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2021 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2022 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2024 /* We simply ignore the field in this case to avoid confusion:
2025 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2028 default: strcat (buf
, ", unknown CPU"); break;
2031 switch ((e_flags
& EF_MIPS_ABI
))
2033 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2034 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2035 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2036 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2038 /* We simply ignore the field in this case to avoid confusion:
2039 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2040 This means it is likely to be an o32 file, but not for
2043 default: strcat (buf
, ", unknown ABI"); break;
2046 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2047 strcat (buf
, ", mdmx");
2049 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2050 strcat (buf
, ", mips16");
2052 switch ((e_flags
& EF_MIPS_ARCH
))
2054 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2055 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2056 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2057 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2058 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2059 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2060 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2061 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2062 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2063 default: strcat (buf
, ", unknown ISA"); break;
2069 switch ((e_flags
& EF_SH_MACH_MASK
))
2071 case EF_SH1
: strcat (buf
, ", sh1"); break;
2072 case EF_SH2
: strcat (buf
, ", sh2"); break;
2073 case EF_SH3
: strcat (buf
, ", sh3"); break;
2074 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2075 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2076 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2077 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2078 case EF_SH4
: strcat (buf
, ", sh4"); break;
2079 case EF_SH5
: strcat (buf
, ", sh5"); break;
2080 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2081 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2082 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2083 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2084 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2085 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2086 default: strcat (buf
, ", unknown ISA"); break;
2092 if (e_flags
& EF_SPARC_32PLUS
)
2093 strcat (buf
, ", v8+");
2095 if (e_flags
& EF_SPARC_SUN_US1
)
2096 strcat (buf
, ", ultrasparcI");
2098 if (e_flags
& EF_SPARC_SUN_US3
)
2099 strcat (buf
, ", ultrasparcIII");
2101 if (e_flags
& EF_SPARC_HAL_R1
)
2102 strcat (buf
, ", halr1");
2104 if (e_flags
& EF_SPARC_LEDATA
)
2105 strcat (buf
, ", ledata");
2107 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2108 strcat (buf
, ", tso");
2110 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2111 strcat (buf
, ", pso");
2113 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2114 strcat (buf
, ", rmo");
2118 switch (e_flags
& EF_PARISC_ARCH
)
2120 case EFA_PARISC_1_0
:
2121 strcpy (buf
, ", PA-RISC 1.0");
2123 case EFA_PARISC_1_1
:
2124 strcpy (buf
, ", PA-RISC 1.1");
2126 case EFA_PARISC_2_0
:
2127 strcpy (buf
, ", PA-RISC 2.0");
2132 if (e_flags
& EF_PARISC_TRAPNIL
)
2133 strcat (buf
, ", trapnil");
2134 if (e_flags
& EF_PARISC_EXT
)
2135 strcat (buf
, ", ext");
2136 if (e_flags
& EF_PARISC_LSB
)
2137 strcat (buf
, ", lsb");
2138 if (e_flags
& EF_PARISC_WIDE
)
2139 strcat (buf
, ", wide");
2140 if (e_flags
& EF_PARISC_NO_KABP
)
2141 strcat (buf
, ", no kabp");
2142 if (e_flags
& EF_PARISC_LAZYSWAP
)
2143 strcat (buf
, ", lazyswap");
2148 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2149 strcat (buf
, ", new calling convention");
2151 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2152 strcat (buf
, ", gnu calling convention");
2156 if ((e_flags
& EF_IA_64_ABI64
))
2157 strcat (buf
, ", 64-bit");
2159 strcat (buf
, ", 32-bit");
2160 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2161 strcat (buf
, ", reduced fp model");
2162 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2163 strcat (buf
, ", no function descriptors, constant gp");
2164 else if ((e_flags
& EF_IA_64_CONS_GP
))
2165 strcat (buf
, ", constant gp");
2166 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2167 strcat (buf
, ", absolute");
2171 if ((e_flags
& EF_VAX_NONPIC
))
2172 strcat (buf
, ", non-PIC");
2173 if ((e_flags
& EF_VAX_DFLOAT
))
2174 strcat (buf
, ", D-Float");
2175 if ((e_flags
& EF_VAX_GFLOAT
))
2176 strcat (buf
, ", G-Float");
2185 get_osabi_name (unsigned int osabi
)
2187 static char buff
[32];
2191 case ELFOSABI_NONE
: return "UNIX - System V";
2192 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2193 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2194 case ELFOSABI_LINUX
: return "UNIX - Linux";
2195 case ELFOSABI_HURD
: return "GNU/Hurd";
2196 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2197 case ELFOSABI_AIX
: return "UNIX - AIX";
2198 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2199 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2200 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2201 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2202 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2203 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2204 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2205 case ELFOSABI_AROS
: return "Amiga Research OS";
2206 case ELFOSABI_STANDALONE
: return _("Standalone App");
2207 case ELFOSABI_ARM
: return "ARM";
2209 sprintf (buff
, _("<unknown: %x>"), osabi
);
2215 get_mips_segment_type (unsigned long type
)
2219 case PT_MIPS_REGINFO
:
2221 case PT_MIPS_RTPROC
:
2223 case PT_MIPS_OPTIONS
:
2233 get_parisc_segment_type (unsigned long type
)
2237 case PT_HP_TLS
: return "HP_TLS";
2238 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2239 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2240 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2241 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2242 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2243 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2244 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2245 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2246 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2247 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2248 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2249 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2250 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2259 get_ia64_segment_type (unsigned long type
)
2263 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2264 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2265 case PT_HP_TLS
: return "HP_TLS";
2266 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2267 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2268 case PT_IA_64_HP_STACK
: return "HP_STACK";
2277 get_segment_type (unsigned long p_type
)
2279 static char buff
[32];
2283 case PT_NULL
: return "NULL";
2284 case PT_LOAD
: return "LOAD";
2285 case PT_DYNAMIC
: return "DYNAMIC";
2286 case PT_INTERP
: return "INTERP";
2287 case PT_NOTE
: return "NOTE";
2288 case PT_SHLIB
: return "SHLIB";
2289 case PT_PHDR
: return "PHDR";
2290 case PT_TLS
: return "TLS";
2292 case PT_GNU_EH_FRAME
:
2293 return "GNU_EH_FRAME";
2294 case PT_GNU_STACK
: return "GNU_STACK";
2295 case PT_GNU_RELRO
: return "GNU_RELRO";
2298 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2302 switch (elf_header
.e_machine
)
2305 case EM_MIPS_RS3_LE
:
2306 result
= get_mips_segment_type (p_type
);
2309 result
= get_parisc_segment_type (p_type
);
2312 result
= get_ia64_segment_type (p_type
);
2322 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2324 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2328 switch (elf_header
.e_machine
)
2331 result
= get_parisc_segment_type (p_type
);
2334 result
= get_ia64_segment_type (p_type
);
2344 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2347 sprintf (buff
, _("<unknown>: %lx"), p_type
);
2354 get_mips_section_type_name (unsigned int sh_type
)
2358 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2359 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2360 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2361 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2362 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2363 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2364 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2365 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2366 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2367 case SHT_MIPS_RELD
: return "MIPS_RELD";
2368 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2369 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2370 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2371 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2372 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2373 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2374 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2375 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2376 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2377 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2378 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2379 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2380 case SHT_MIPS_LINE
: return "MIPS_LINE";
2381 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2382 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2383 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2384 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2385 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2386 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2387 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2388 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2389 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2390 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2391 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2392 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2393 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2394 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2395 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2396 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2404 get_parisc_section_type_name (unsigned int sh_type
)
2408 case SHT_PARISC_EXT
: return "PARISC_EXT";
2409 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2410 case SHT_PARISC_DOC
: return "PARISC_DOC";
2418 get_ia64_section_type_name (unsigned int sh_type
)
2420 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2421 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2422 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2426 case SHT_IA_64_EXT
: return "IA_64_EXT";
2427 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2428 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2436 get_x86_64_section_type_name (unsigned int sh_type
)
2440 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2448 get_arm_section_type_name (unsigned int sh_type
)
2461 get_section_type_name (unsigned int sh_type
)
2463 static char buff
[32];
2467 case SHT_NULL
: return "NULL";
2468 case SHT_PROGBITS
: return "PROGBITS";
2469 case SHT_SYMTAB
: return "SYMTAB";
2470 case SHT_STRTAB
: return "STRTAB";
2471 case SHT_RELA
: return "RELA";
2472 case SHT_HASH
: return "HASH";
2473 case SHT_DYNAMIC
: return "DYNAMIC";
2474 case SHT_NOTE
: return "NOTE";
2475 case SHT_NOBITS
: return "NOBITS";
2476 case SHT_REL
: return "REL";
2477 case SHT_SHLIB
: return "SHLIB";
2478 case SHT_DYNSYM
: return "DYNSYM";
2479 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2480 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2481 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2482 case SHT_GROUP
: return "GROUP";
2483 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2484 case SHT_GNU_verdef
: return "VERDEF";
2485 case SHT_GNU_verneed
: return "VERNEED";
2486 case SHT_GNU_versym
: return "VERSYM";
2487 case 0x6ffffff0: return "VERSYM";
2488 case 0x6ffffffc: return "VERDEF";
2489 case 0x7ffffffd: return "AUXILIARY";
2490 case 0x7fffffff: return "FILTER";
2491 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2494 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2498 switch (elf_header
.e_machine
)
2501 case EM_MIPS_RS3_LE
:
2502 result
= get_mips_section_type_name (sh_type
);
2505 result
= get_parisc_section_type_name (sh_type
);
2508 result
= get_ia64_section_type_name (sh_type
);
2511 result
= get_x86_64_section_type_name (sh_type
);
2514 result
= get_arm_section_type_name (sh_type
);
2524 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2526 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2527 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2528 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2529 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2531 sprintf (buff
, _("<unknown>: %x"), sh_type
);
2537 #define OPTION_DEBUG_DUMP 512
2539 struct option options
[] =
2541 {"all", no_argument
, 0, 'a'},
2542 {"file-header", no_argument
, 0, 'h'},
2543 {"program-headers", no_argument
, 0, 'l'},
2544 {"headers", no_argument
, 0, 'e'},
2545 {"histogram", no_argument
, 0, 'I'},
2546 {"segments", no_argument
, 0, 'l'},
2547 {"sections", no_argument
, 0, 'S'},
2548 {"section-headers", no_argument
, 0, 'S'},
2549 {"section-groups", no_argument
, 0, 'g'},
2550 {"symbols", no_argument
, 0, 's'},
2551 {"syms", no_argument
, 0, 's'},
2552 {"relocs", no_argument
, 0, 'r'},
2553 {"notes", no_argument
, 0, 'n'},
2554 {"dynamic", no_argument
, 0, 'd'},
2555 {"arch-specific", no_argument
, 0, 'A'},
2556 {"version-info", no_argument
, 0, 'V'},
2557 {"use-dynamic", no_argument
, 0, 'D'},
2558 {"hex-dump", required_argument
, 0, 'x'},
2559 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2560 {"unwind", no_argument
, 0, 'u'},
2561 #ifdef SUPPORT_DISASSEMBLY
2562 {"instruction-dump", required_argument
, 0, 'i'},
2565 {"version", no_argument
, 0, 'v'},
2566 {"wide", no_argument
, 0, 'W'},
2567 {"help", no_argument
, 0, 'H'},
2568 {0, no_argument
, 0, 0}
2574 fprintf (stdout
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2575 fprintf (stdout
, _(" Display information about the contents of ELF format files\n"));
2576 fprintf (stdout
, _(" Options are:\n\
2577 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2578 -h --file-header Display the ELF file header\n\
2579 -l --program-headers Display the program headers\n\
2580 --segments An alias for --program-headers\n\
2581 -S --section-headers Display the sections' header\n\
2582 --sections An alias for --section-headers\n\
2583 -g --section-groups Display the section groups\n\
2584 -e --headers Equivalent to: -h -l -S\n\
2585 -s --syms Display the symbol table\n\
2586 --symbols An alias for --syms\n\
2587 -n --notes Display the core notes (if present)\n\
2588 -r --relocs Display the relocations (if present)\n\
2589 -u --unwind Display the unwind info (if present)\n\
2590 -d --dynamic Display the dynamic section (if present)\n\
2591 -V --version-info Display the version sections (if present)\n\
2592 -A --arch-specific Display architecture specific information (if any).\n\
2593 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2594 -x --hex-dump=<number> Dump the contents of section <number>\n\
2595 -w[liaprmfFsoR] or\n\
2596 --debug-dump[=line,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
2597 Display the contents of DWARF2 debug sections\n"));
2598 #ifdef SUPPORT_DISASSEMBLY
2599 fprintf (stdout
, _("\
2600 -i --instruction-dump=<number>\n\
2601 Disassemble the contents of section <number>\n"));
2603 fprintf (stdout
, _("\
2604 -I --histogram Display histogram of bucket list lengths\n\
2605 -W --wide Allow output width to exceed 80 characters\n\
2606 -H --help Display this information\n\
2607 -v --version Display the version number of readelf\n"));
2608 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2613 /* Record the fact that the user wants the contents of section number
2614 SECTION to be displayed using the method(s) encoded as flags bits
2615 in TYPE. Note, TYPE can be zero if we are creating the array for
2619 request_dump (unsigned int section
, int type
)
2621 if (section
>= num_dump_sects
)
2623 char *new_dump_sects
;
2625 new_dump_sects
= calloc (section
+ 1, 1);
2627 if (new_dump_sects
== NULL
)
2628 error (_("Out of memory allocating dump request table."));
2631 /* Copy current flag settings. */
2632 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2636 dump_sects
= new_dump_sects
;
2637 num_dump_sects
= section
+ 1;
2642 dump_sects
[section
] |= type
;
2648 parse_args (int argc
, char **argv
)
2655 while ((c
= getopt_long
2656 (argc
, argv
, "ersuahnldSDAIgw::x:i:vVWH", options
, NULL
)) != EOF
)
2677 do_section_groups
++;
2685 do_section_groups
++;
2727 section
= strtoul (optarg
, & cp
, 0);
2728 if (! *cp
&& section
>= 0)
2730 request_dump (section
, HEX_DUMP
);
2740 unsigned int index
= 0;
2744 while (optarg
[index
])
2745 switch (optarg
[index
++])
2754 do_debug_abbrevs
= 1;
2764 do_debug_pubnames
= 1;
2768 do_debug_aranges
= 1;
2772 do_debug_ranges
= 1;
2776 do_debug_frames_interp
= 1;
2778 do_debug_frames
= 1;
2783 do_debug_macinfo
= 1;
2797 warn (_("Unrecognized debug option '%s'\n"), optarg
);
2802 case OPTION_DEBUG_DUMP
:
2810 const char * option
;
2813 debug_dump_long_opts
;
2815 debug_dump_long_opts opts_table
[] =
2817 /* Please keep this table alpha- sorted. */
2818 { "Ranges", & do_debug_ranges
},
2819 { "abbrev", & do_debug_abbrevs
},
2820 { "aranges", & do_debug_aranges
},
2821 { "frames", & do_debug_frames
},
2822 { "frames-interp", & do_debug_frames_interp
},
2823 { "info", & do_debug_info
},
2824 { "line", & do_debug_lines
},
2825 { "loc", & do_debug_loc
},
2826 { "macro", & do_debug_macinfo
},
2827 { "pubnames", & do_debug_pubnames
},
2828 /* This entry is for compatability
2829 with earlier versions of readelf. */
2830 { "ranges", & do_debug_aranges
},
2831 { "str", & do_debug_str
},
2842 debug_dump_long_opts
* entry
;
2844 for (entry
= opts_table
; entry
->option
; entry
++)
2846 size_t len
= strlen (entry
->option
);
2848 if (strneq (p
, entry
->option
, len
)
2849 && (p
[len
] == ',' || p
[len
] == '\0'))
2851 * entry
->variable
= 1;
2853 /* The --debug-dump=frames-interp option also
2854 enables the --debug-dump=frames option. */
2855 if (do_debug_frames_interp
)
2856 do_debug_frames
= 1;
2863 if (entry
->option
== NULL
)
2865 warn (_("Unrecognized debug option '%s'\n"), p
);
2866 p
= strchr (p
, ',');
2876 #ifdef SUPPORT_DISASSEMBLY
2879 section
= strtoul (optarg
, & cp
, 0);
2880 if (! *cp
&& section
>= 0)
2882 request_dump (section
, DISASS_DUMP
);
2888 print_version (program_name
);
2898 /* xgettext:c-format */
2899 error (_("Invalid option '-%c'\n"), c
);
2906 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
2907 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
2908 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
2909 && !do_section_groups
)
2913 warn (_("Nothing to do.\n"));
2919 get_elf_class (unsigned int elf_class
)
2921 static char buff
[32];
2925 case ELFCLASSNONE
: return _("none");
2926 case ELFCLASS32
: return "ELF32";
2927 case ELFCLASS64
: return "ELF64";
2929 sprintf (buff
, _("<unknown: %x>"), elf_class
);
2935 get_data_encoding (unsigned int encoding
)
2937 static char buff
[32];
2941 case ELFDATANONE
: return _("none");
2942 case ELFDATA2LSB
: return _("2's complement, little endian");
2943 case ELFDATA2MSB
: return _("2's complement, big endian");
2945 sprintf (buff
, _("<unknown: %x>"), encoding
);
2950 /* Decode the data held in 'elf_header'. */
2953 process_file_header (void)
2955 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
2956 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
2957 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
2958 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
2961 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2969 printf (_("ELF Header:\n"));
2970 printf (_(" Magic: "));
2971 for (i
= 0; i
< EI_NIDENT
; i
++)
2972 printf ("%2.2x ", elf_header
.e_ident
[i
]);
2974 printf (_(" Class: %s\n"),
2975 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
2976 printf (_(" Data: %s\n"),
2977 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
2978 printf (_(" Version: %d %s\n"),
2979 elf_header
.e_ident
[EI_VERSION
],
2980 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
2982 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
2985 printf (_(" OS/ABI: %s\n"),
2986 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
2987 printf (_(" ABI Version: %d\n"),
2988 elf_header
.e_ident
[EI_ABIVERSION
]);
2989 printf (_(" Type: %s\n"),
2990 get_file_type (elf_header
.e_type
));
2991 printf (_(" Machine: %s\n"),
2992 get_machine_name (elf_header
.e_machine
));
2993 printf (_(" Version: 0x%lx\n"),
2994 (unsigned long) elf_header
.e_version
);
2996 printf (_(" Entry point address: "));
2997 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2998 printf (_("\n Start of program headers: "));
2999 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3000 printf (_(" (bytes into file)\n Start of section headers: "));
3001 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3002 printf (_(" (bytes into file)\n"));
3004 printf (_(" Flags: 0x%lx%s\n"),
3005 (unsigned long) elf_header
.e_flags
,
3006 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3007 printf (_(" Size of this header: %ld (bytes)\n"),
3008 (long) elf_header
.e_ehsize
);
3009 printf (_(" Size of program headers: %ld (bytes)\n"),
3010 (long) elf_header
.e_phentsize
);
3011 printf (_(" Number of program headers: %ld\n"),
3012 (long) elf_header
.e_phnum
);
3013 printf (_(" Size of section headers: %ld (bytes)\n"),
3014 (long) elf_header
.e_shentsize
);
3015 printf (_(" Number of section headers: %ld"),
3016 (long) elf_header
.e_shnum
);
3017 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
3018 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3019 putc ('\n', stdout
);
3020 printf (_(" Section header string table index: %ld"),
3021 (long) elf_header
.e_shstrndx
);
3022 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
3023 printf (" (%ld)", (long) section_headers
[0].sh_link
);
3024 putc ('\n', stdout
);
3027 if (section_headers
!= NULL
)
3029 if (elf_header
.e_shnum
== 0)
3030 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3031 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
3032 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3033 free (section_headers
);
3034 section_headers
= NULL
;
3042 get_32bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3044 Elf32_External_Phdr
*phdrs
;
3045 Elf32_External_Phdr
*external
;
3046 Elf_Internal_Phdr
*internal
;
3049 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3050 elf_header
.e_phentsize
* elf_header
.e_phnum
,
3051 _("program headers"));
3055 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3056 i
< elf_header
.e_phnum
;
3057 i
++, internal
++, external
++)
3059 internal
->p_type
= BYTE_GET (external
->p_type
);
3060 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3061 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3062 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3063 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3064 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3065 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3066 internal
->p_align
= BYTE_GET (external
->p_align
);
3075 get_64bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3077 Elf64_External_Phdr
*phdrs
;
3078 Elf64_External_Phdr
*external
;
3079 Elf_Internal_Phdr
*internal
;
3082 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3083 elf_header
.e_phentsize
* elf_header
.e_phnum
,
3084 _("program headers"));
3088 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3089 i
< elf_header
.e_phnum
;
3090 i
++, internal
++, external
++)
3092 internal
->p_type
= BYTE_GET (external
->p_type
);
3093 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3094 internal
->p_offset
= BYTE_GET8 (external
->p_offset
);
3095 internal
->p_vaddr
= BYTE_GET8 (external
->p_vaddr
);
3096 internal
->p_paddr
= BYTE_GET8 (external
->p_paddr
);
3097 internal
->p_filesz
= BYTE_GET8 (external
->p_filesz
);
3098 internal
->p_memsz
= BYTE_GET8 (external
->p_memsz
);
3099 internal
->p_align
= BYTE_GET8 (external
->p_align
);
3107 /* Returns 1 if the program headers were read into `program_headers'. */
3110 get_program_headers (FILE *file
)
3112 Elf_Internal_Phdr
*phdrs
;
3114 /* Check cache of prior read. */
3115 if (program_headers
!= NULL
)
3118 phdrs
= malloc (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
3122 error (_("Out of memory\n"));
3127 ? get_32bit_program_headers (file
, phdrs
)
3128 : get_64bit_program_headers (file
, phdrs
))
3130 program_headers
= phdrs
;
3138 /* Returns 1 if the program headers were loaded. */
3141 process_program_headers (FILE *file
)
3143 Elf_Internal_Phdr
*segment
;
3146 if (elf_header
.e_phnum
== 0)
3149 printf (_("\nThere are no program headers in this file.\n"));
3153 if (do_segments
&& !do_header
)
3155 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3156 printf (_("Entry point "));
3157 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3158 printf (_("\nThere are %d program headers, starting at offset "),
3159 elf_header
.e_phnum
);
3160 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3164 if (! get_program_headers (file
))
3169 if (elf_header
.e_phnum
> 1)
3170 printf (_("\nProgram Headers:\n"));
3172 printf (_("\nProgram Headers:\n"));
3176 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3179 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3183 (_(" Type Offset VirtAddr PhysAddr\n"));
3185 (_(" FileSiz MemSiz Flags Align\n"));
3192 for (i
= 0, segment
= program_headers
;
3193 i
< elf_header
.e_phnum
;
3198 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3202 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3203 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3204 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3205 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3206 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3208 (segment
->p_flags
& PF_R
? 'R' : ' '),
3209 (segment
->p_flags
& PF_W
? 'W' : ' '),
3210 (segment
->p_flags
& PF_X
? 'E' : ' '));
3211 printf ("%#lx", (unsigned long) segment
->p_align
);
3215 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3216 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3219 print_vma (segment
->p_offset
, FULL_HEX
);
3223 print_vma (segment
->p_vaddr
, FULL_HEX
);
3225 print_vma (segment
->p_paddr
, FULL_HEX
);
3228 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3229 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3232 print_vma (segment
->p_filesz
, FULL_HEX
);
3236 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3237 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3240 print_vma (segment
->p_offset
, FULL_HEX
);
3244 (segment
->p_flags
& PF_R
? 'R' : ' '),
3245 (segment
->p_flags
& PF_W
? 'W' : ' '),
3246 (segment
->p_flags
& PF_X
? 'E' : ' '));
3248 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3249 printf ("%#lx", (unsigned long) segment
->p_align
);
3252 print_vma (segment
->p_align
, PREFIX_HEX
);
3257 print_vma (segment
->p_offset
, FULL_HEX
);
3259 print_vma (segment
->p_vaddr
, FULL_HEX
);
3261 print_vma (segment
->p_paddr
, FULL_HEX
);
3263 print_vma (segment
->p_filesz
, FULL_HEX
);
3265 print_vma (segment
->p_memsz
, FULL_HEX
);
3267 (segment
->p_flags
& PF_R
? 'R' : ' '),
3268 (segment
->p_flags
& PF_W
? 'W' : ' '),
3269 (segment
->p_flags
& PF_X
? 'E' : ' '));
3270 print_vma (segment
->p_align
, HEX
);
3274 switch (segment
->p_type
)
3278 error (_("more than one dynamic segment\n"));
3280 /* Try to locate the .dynamic section. If there is
3281 a section header table, we can easily locate it. */
3282 if (section_headers
!= NULL
)
3284 Elf_Internal_Shdr
*sec
;
3287 for (j
= 0, sec
= section_headers
;
3288 j
< elf_header
.e_shnum
;
3290 if (streq (SECTION_NAME (sec
), ".dynamic"))
3293 if (j
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
3295 error (_("no .dynamic section in the dynamic segment"));
3299 dynamic_addr
= sec
->sh_offset
;
3300 dynamic_size
= sec
->sh_size
;
3302 if (dynamic_addr
< segment
->p_offset
3303 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3304 warn (_("the .dynamic section is not contained within the dynamic segment"));
3305 else if (dynamic_addr
> segment
->p_offset
)
3306 warn (_("the .dynamic section is not the first section in the dynamic segment."));
3310 /* Otherwise, we can only assume that the .dynamic
3311 section is the first section in the DYNAMIC segment. */
3312 dynamic_addr
= segment
->p_offset
;
3313 dynamic_size
= segment
->p_filesz
;
3318 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3320 error (_("Unable to find program interpreter name\n"));
3323 program_interpreter
[0] = 0;
3324 fscanf (file
, "%63s", program_interpreter
);
3327 printf (_("\n [Requesting program interpreter: %s]"),
3328 program_interpreter
);
3334 putc ('\n', stdout
);
3337 if (do_segments
&& section_headers
!= NULL
)
3339 printf (_("\n Section to Segment mapping:\n"));
3340 printf (_(" Segment Sections...\n"));
3342 assert (string_table
!= NULL
);
3344 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3347 Elf_Internal_Shdr
*section
;
3349 segment
= program_headers
+ i
;
3350 section
= section_headers
;
3352 printf (" %2.2d ", i
);
3354 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3356 if (section
->sh_size
> 0
3357 /* Compare allocated sections by VMA, unallocated
3358 sections by file offset. */
3359 && (section
->sh_flags
& SHF_ALLOC
3360 ? (section
->sh_addr
>= segment
->p_vaddr
3361 && section
->sh_addr
+ section
->sh_size
3362 <= segment
->p_vaddr
+ segment
->p_memsz
)
3363 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
3364 && (section
->sh_offset
+ section
->sh_size
3365 <= segment
->p_offset
+ segment
->p_filesz
)))
3366 /* .tbss is special. It doesn't contribute memory space
3367 to normal segments. */
3368 && (!((section
->sh_flags
& SHF_TLS
) != 0
3369 && section
->sh_type
== SHT_NOBITS
)
3370 || segment
->p_type
== PT_TLS
))
3371 printf ("%s ", SECTION_NAME (section
));
3382 /* Find the file offset corresponding to VMA by using the program headers. */
3385 offset_from_vma (FILE *file
, bfd_vma vma
, bfd_size_type size
)
3387 Elf_Internal_Phdr
*seg
;
3389 if (! get_program_headers (file
))
3391 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3395 for (seg
= program_headers
;
3396 seg
< program_headers
+ elf_header
.e_phnum
;
3399 if (seg
->p_type
!= PT_LOAD
)
3402 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3403 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3404 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3407 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3414 get_32bit_section_headers (FILE *file
, unsigned int num
)
3416 Elf32_External_Shdr
*shdrs
;
3417 Elf_Internal_Shdr
*internal
;
3420 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3421 elf_header
.e_shentsize
* num
, _("section headers"));
3425 section_headers
= malloc (num
* sizeof (Elf_Internal_Shdr
));
3427 if (section_headers
== NULL
)
3429 error (_("Out of memory\n"));
3433 for (i
= 0, internal
= section_headers
;
3437 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3438 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3439 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3440 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3441 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3442 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3443 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3444 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3445 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3446 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3455 get_64bit_section_headers (FILE *file
, unsigned int num
)
3457 Elf64_External_Shdr
*shdrs
;
3458 Elf_Internal_Shdr
*internal
;
3461 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3462 elf_header
.e_shentsize
* num
, _("section headers"));
3466 section_headers
= malloc (num
* sizeof (Elf_Internal_Shdr
));
3468 if (section_headers
== NULL
)
3470 error (_("Out of memory\n"));
3474 for (i
= 0, internal
= section_headers
;
3478 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3479 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3480 internal
->sh_flags
= BYTE_GET8 (shdrs
[i
].sh_flags
);
3481 internal
->sh_addr
= BYTE_GET8 (shdrs
[i
].sh_addr
);
3482 internal
->sh_size
= BYTE_GET8 (shdrs
[i
].sh_size
);
3483 internal
->sh_entsize
= BYTE_GET8 (shdrs
[i
].sh_entsize
);
3484 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3485 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3486 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3487 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3495 static Elf_Internal_Sym
*
3496 get_32bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3498 unsigned long number
;
3499 Elf32_External_Sym
*esyms
;
3500 Elf_External_Sym_Shndx
*shndx
;
3501 Elf_Internal_Sym
*isyms
;
3502 Elf_Internal_Sym
*psym
;
3505 esyms
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
3511 if (symtab_shndx_hdr
!= NULL
3512 && (symtab_shndx_hdr
->sh_link
3513 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3515 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3516 symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3524 number
= section
->sh_size
/ section
->sh_entsize
;
3525 isyms
= malloc (number
* sizeof (Elf_Internal_Sym
));
3529 error (_("Out of memory\n"));
3536 for (j
= 0, psym
= isyms
;
3540 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3541 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3542 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3543 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3544 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3546 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3547 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3548 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3558 static Elf_Internal_Sym
*
3559 get_64bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3561 unsigned long number
;
3562 Elf64_External_Sym
*esyms
;
3563 Elf_External_Sym_Shndx
*shndx
;
3564 Elf_Internal_Sym
*isyms
;
3565 Elf_Internal_Sym
*psym
;
3568 esyms
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
3574 if (symtab_shndx_hdr
!= NULL
3575 && (symtab_shndx_hdr
->sh_link
3576 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3578 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3579 symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3587 number
= section
->sh_size
/ section
->sh_entsize
;
3588 isyms
= malloc (number
* sizeof (Elf_Internal_Sym
));
3592 error (_("Out of memory\n"));
3599 for (j
= 0, psym
= isyms
;
3603 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3604 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3605 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3606 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3607 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3609 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3610 psym
->st_value
= BYTE_GET8 (esyms
[j
].st_value
);
3611 psym
->st_size
= BYTE_GET8 (esyms
[j
].st_size
);
3622 get_elf_section_flags (bfd_vma sh_flags
)
3624 static char buff
[32];
3632 flag
= sh_flags
& - sh_flags
;
3637 case SHF_WRITE
: strcat (buff
, "W"); break;
3638 case SHF_ALLOC
: strcat (buff
, "A"); break;
3639 case SHF_EXECINSTR
: strcat (buff
, "X"); break;
3640 case SHF_MERGE
: strcat (buff
, "M"); break;
3641 case SHF_STRINGS
: strcat (buff
, "S"); break;
3642 case SHF_INFO_LINK
: strcat (buff
, "I"); break;
3643 case SHF_LINK_ORDER
: strcat (buff
, "L"); break;
3644 case SHF_OS_NONCONFORMING
: strcat (buff
, "O"); break;
3645 case SHF_GROUP
: strcat (buff
, "G"); break;
3646 case SHF_TLS
: strcat (buff
, "T"); break;
3649 if (flag
& SHF_MASKOS
)
3652 sh_flags
&= ~ SHF_MASKOS
;
3654 else if (flag
& SHF_MASKPROC
)
3657 sh_flags
&= ~ SHF_MASKPROC
;
3669 process_section_headers (FILE *file
)
3671 Elf_Internal_Shdr
*section
;
3674 section_headers
= NULL
;
3676 if (elf_header
.e_shnum
== 0)
3679 printf (_("\nThere are no sections in this file.\n"));
3684 if (do_sections
&& !do_header
)
3685 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3686 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
3690 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
3693 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
3696 /* Read in the string table, so that we have names to display. */
3697 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
3699 if (section
->sh_size
!= 0)
3701 string_table
= get_data (NULL
, file
, section
->sh_offset
,
3702 section
->sh_size
, _("string table"));
3704 if (string_table
== NULL
)
3707 string_table_length
= section
->sh_size
;
3710 /* Scan the sections for the dynamic symbol table
3711 and dynamic string table and debug sections. */
3712 dynamic_symbols
= NULL
;
3713 dynamic_strings
= NULL
;
3714 dynamic_syminfo
= NULL
;
3715 symtab_shndx_hdr
= NULL
;
3717 for (i
= 0, section
= section_headers
;
3718 i
< elf_header
.e_shnum
;
3721 char *name
= SECTION_NAME (section
);
3723 if (section
->sh_type
== SHT_DYNSYM
)
3725 if (dynamic_symbols
!= NULL
)
3727 error (_("File contains multiple dynamic symbol tables\n"));
3731 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
3732 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
3734 else if (section
->sh_type
== SHT_STRTAB
3735 && streq (name
, ".dynstr"))
3737 if (dynamic_strings
!= NULL
)
3739 error (_("File contains multiple dynamic string tables\n"));
3743 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
3744 section
->sh_size
, _("dynamic strings"));
3745 dynamic_strings_length
= section
->sh_size
;
3747 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
3749 if (symtab_shndx_hdr
!= NULL
)
3751 error (_("File contains multiple symtab shndx tables\n"));
3754 symtab_shndx_hdr
= section
;
3756 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
3757 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
3758 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
3759 || do_debug_loc
|| do_debug_ranges
)
3760 && strneq (name
, ".debug_", 7))
3765 || (do_debug_info
&& streq (name
, "info"))
3766 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
3767 || (do_debug_lines
&& streq (name
, "line"))
3768 || (do_debug_pubnames
&& streq (name
, "pubnames"))
3769 || (do_debug_aranges
&& streq (name
, "aranges"))
3770 || (do_debug_ranges
&& streq (name
, "ranges"))
3771 || (do_debug_frames
&& streq (name
, "frame"))
3772 || (do_debug_macinfo
&& streq (name
, "macinfo"))
3773 || (do_debug_str
&& streq (name
, "str"))
3774 || (do_debug_loc
&& streq (name
, "loc"))
3776 request_dump (i
, DEBUG_DUMP
);
3778 /* linkonce section to be combined with .debug_info at link time. */
3779 else if ((do_debugging
|| do_debug_info
)
3780 && strneq (name
, ".gnu.linkonce.wi.", 17))
3781 request_dump (i
, DEBUG_DUMP
);
3782 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
3783 request_dump (i
, DEBUG_DUMP
);
3789 if (elf_header
.e_shnum
> 1)
3790 printf (_("\nSection Headers:\n"));
3792 printf (_("\nSection Header:\n"));
3796 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
3799 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
3802 printf (_(" [Nr] Name Type Address Offset\n"));
3803 printf (_(" Size EntSize Flags Link Info Align\n"));
3806 for (i
= 0, section
= section_headers
;
3807 i
< elf_header
.e_shnum
;
3810 printf (" [%2u] %-17.17s %-15.15s ",
3811 SECTION_HEADER_NUM (i
),
3812 SECTION_NAME (section
),
3813 get_section_type_name (section
->sh_type
));
3817 print_vma (section
->sh_addr
, LONG_HEX
);
3819 printf ( " %6.6lx %6.6lx %2.2lx",
3820 (unsigned long) section
->sh_offset
,
3821 (unsigned long) section
->sh_size
,
3822 (unsigned long) section
->sh_entsize
);
3824 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3826 printf ("%2ld %3lu %2ld\n",
3827 (unsigned long) section
->sh_link
,
3828 (unsigned long) section
->sh_info
,
3829 (unsigned long) section
->sh_addralign
);
3833 print_vma (section
->sh_addr
, LONG_HEX
);
3835 if ((long) section
->sh_offset
== section
->sh_offset
)
3836 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
3840 print_vma (section
->sh_offset
, LONG_HEX
);
3843 if ((unsigned long) section
->sh_size
== section
->sh_size
)
3844 printf (" %6.6lx", (unsigned long) section
->sh_size
);
3848 print_vma (section
->sh_size
, LONG_HEX
);
3851 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
3852 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
3856 print_vma (section
->sh_entsize
, LONG_HEX
);
3859 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3861 printf ("%2ld %3lu ",
3862 (unsigned long) section
->sh_link
,
3863 (unsigned long) section
->sh_info
);
3865 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
3866 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
3869 print_vma (section
->sh_addralign
, DEC
);
3876 print_vma (section
->sh_addr
, LONG_HEX
);
3877 if ((long) section
->sh_offset
== section
->sh_offset
)
3878 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
3882 print_vma (section
->sh_offset
, LONG_HEX
);
3885 print_vma (section
->sh_size
, LONG_HEX
);
3887 print_vma (section
->sh_entsize
, LONG_HEX
);
3889 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3891 printf (" %2ld %3lu %ld\n",
3892 (unsigned long) section
->sh_link
,
3893 (unsigned long) section
->sh_info
,
3894 (unsigned long) section
->sh_addralign
);
3898 printf (_("Key to Flags:\n\
3899 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
3900 I (info), L (link order), G (group), x (unknown)\n\
3901 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3907 get_group_flags (unsigned int flags
)
3909 static char buff
[32];
3916 sprintf (buff
, _("[<unknown>: 0x%x]"), flags
);
3923 process_section_groups (FILE *file
)
3925 Elf_Internal_Shdr
*section
;
3927 struct group
*group
;
3929 if (elf_header
.e_shnum
== 0)
3931 if (do_section_groups
)
3932 printf (_("\nThere are no section groups in this file.\n"));
3937 if (section_headers
== NULL
)
3939 error (_("Section headers are not available!\n"));
3943 section_headers_groups
= calloc (elf_header
.e_shnum
,
3944 sizeof (struct group
*));
3946 if (section_headers_groups
== NULL
)
3948 error (_("Out of memory\n"));
3952 /* Scan the sections for the group section. */
3953 for (i
= 0, section
= section_headers
;
3954 i
< elf_header
.e_shnum
;
3956 if (section
->sh_type
== SHT_GROUP
)
3959 section_groups
= calloc (group_count
, sizeof (struct group
));
3961 if (section_groups
== NULL
)
3963 error (_("Out of memory\n"));
3967 for (i
= 0, section
= section_headers
, group
= section_groups
;
3968 i
< elf_header
.e_shnum
;
3971 if (section
->sh_type
== SHT_GROUP
)
3973 char *name
= SECTION_NAME (section
);
3974 char *group_name
, *strtab
, *start
, *indices
;
3975 unsigned int entry
, j
, size
;
3976 Elf_Internal_Sym
*sym
;
3977 Elf_Internal_Shdr
*symtab_sec
, *strtab_sec
, *sec
;
3978 Elf_Internal_Sym
*symtab
;
3980 /* Get the symbol table. */
3981 symtab_sec
= SECTION_HEADER (section
->sh_link
);
3982 if (symtab_sec
->sh_type
!= SHT_SYMTAB
)
3984 error (_("Bad sh_link in group section `%s'\n"), name
);
3987 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
3989 sym
= symtab
+ section
->sh_info
;
3991 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
3993 bfd_vma sec_index
= SECTION_HEADER_INDEX (sym
->st_shndx
);
3996 error (_("Bad sh_info in group section `%s'\n"), name
);
4000 group_name
= SECTION_NAME (section_headers
+ sec_index
);
4005 /* Get the string table. */
4006 strtab_sec
= SECTION_HEADER (symtab_sec
->sh_link
);
4007 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
4008 strtab_sec
->sh_size
,
4011 group_name
= strtab
+ sym
->st_name
;
4014 start
= get_data (NULL
, file
, section
->sh_offset
,
4015 section
->sh_size
, _("section data"));
4018 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4019 entry
= byte_get (indices
, 4);
4022 if (do_section_groups
)
4024 printf ("\n%s group section `%s' [%s] contains %u sections:\n",
4025 get_group_flags (entry
), name
, group_name
, size
);
4027 printf (_(" [Index] Name\n"));
4030 group
->group_index
= i
;
4032 for (j
= 0; j
< size
; j
++)
4034 struct group_list
*g
;
4036 entry
= byte_get (indices
, 4);
4039 if (section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4042 error (_("section [%5u] already in group section [%5u]\n"),
4043 entry
, section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4047 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4050 if (do_section_groups
)
4052 sec
= SECTION_HEADER (entry
);
4053 printf (" [%5u] %s\n",
4054 entry
, SECTION_NAME (sec
));
4057 g
= xmalloc (sizeof (struct group_list
));
4058 g
->section_index
= entry
;
4059 g
->next
= group
->root
;
4083 } dynamic_relocations
[] =
4085 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4086 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4087 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4090 /* Process the reloc section. */
4093 process_relocs (FILE *file
)
4095 unsigned long rel_size
;
4096 unsigned long rel_offset
;
4102 if (do_using_dynamic
)
4106 int has_dynamic_reloc
;
4109 has_dynamic_reloc
= 0;
4111 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4113 is_rela
= dynamic_relocations
[i
].rela
;
4114 name
= dynamic_relocations
[i
].name
;
4115 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4116 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4118 has_dynamic_reloc
|= rel_size
;
4120 if (is_rela
== UNKNOWN
)
4122 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4123 switch (dynamic_info
[DT_PLTREL
])
4137 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4138 name
, rel_offset
, rel_size
);
4140 dump_relocations (file
,
4141 offset_from_vma (file
, rel_offset
, rel_size
),
4143 dynamic_symbols
, num_dynamic_syms
,
4144 dynamic_strings
, dynamic_strings_length
, is_rela
);
4148 if (! has_dynamic_reloc
)
4149 printf (_("\nThere are no dynamic relocations in this file.\n"));
4153 Elf_Internal_Shdr
*section
;
4157 for (i
= 0, section
= section_headers
;
4158 i
< elf_header
.e_shnum
;
4161 if ( section
->sh_type
!= SHT_RELA
4162 && section
->sh_type
!= SHT_REL
)
4165 rel_offset
= section
->sh_offset
;
4166 rel_size
= section
->sh_size
;
4170 Elf_Internal_Shdr
*strsec
;
4173 printf (_("\nRelocation section "));
4175 if (string_table
== NULL
)
4176 printf ("%d", section
->sh_name
);
4178 printf (_("'%s'"), SECTION_NAME (section
));
4180 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4181 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4183 is_rela
= section
->sh_type
== SHT_RELA
;
4185 if (section
->sh_link
)
4187 Elf_Internal_Shdr
*symsec
;
4188 Elf_Internal_Sym
*symtab
;
4189 unsigned long nsyms
;
4190 unsigned long strtablen
;
4191 char *strtab
= NULL
;
4193 symsec
= SECTION_HEADER (section
->sh_link
);
4194 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4195 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4200 strsec
= SECTION_HEADER (symsec
->sh_link
);
4202 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4203 strsec
->sh_size
, _("string table"));
4204 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4206 dump_relocations (file
, rel_offset
, rel_size
,
4207 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4213 dump_relocations (file
, rel_offset
, rel_size
,
4214 NULL
, 0, NULL
, 0, is_rela
);
4221 printf (_("\nThere are no relocations in this file.\n"));
4227 /* Process the unwind section. */
4229 #include "unwind-ia64.h"
4231 /* An absolute address consists of a section and an offset. If the
4232 section is NULL, the offset itself is the address, otherwise, the
4233 address equals to LOAD_ADDRESS(section) + offset. */
4237 unsigned short section
;
4241 struct ia64_unw_aux_info
4243 struct ia64_unw_table_entry
4245 struct absaddr start
;
4247 struct absaddr info
;
4249 *table
; /* Unwind table. */
4250 unsigned long table_len
; /* Length of unwind table. */
4251 unsigned char *info
; /* Unwind info. */
4252 unsigned long info_size
; /* Size of unwind info. */
4253 bfd_vma info_addr
; /* starting address of unwind info. */
4254 bfd_vma seg_base
; /* Starting address of segment. */
4255 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4256 unsigned long nsyms
; /* Number of symbols. */
4257 char *strtab
; /* The string table. */
4258 unsigned long strtab_size
; /* Size of string table. */
4262 find_symbol_for_address (Elf_Internal_Sym
*symtab
,
4263 unsigned long nsyms
,
4265 unsigned long strtab_size
,
4266 struct absaddr addr
,
4267 const char **symname
,
4270 bfd_vma dist
= 0x100000;
4271 Elf_Internal_Sym
*sym
, *best
= NULL
;
4274 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
4276 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4277 && sym
->st_name
!= 0
4278 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4279 && addr
.offset
>= sym
->st_value
4280 && addr
.offset
- sym
->st_value
< dist
)
4283 dist
= addr
.offset
- sym
->st_value
;
4290 *symname
= (best
->st_name
>= strtab_size
4291 ? "<corrupt>" : strtab
+ best
->st_name
);
4296 *offset
= addr
.offset
;
4300 dump_ia64_unwind (struct ia64_unw_aux_info
*aux
)
4303 struct ia64_unw_table_entry
*tp
;
4306 addr_size
= is_32bit_elf
? 4 : 8;
4308 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4312 const unsigned char *dp
;
4313 const unsigned char *head
;
4314 const char *procname
;
4316 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4317 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
4319 fputs ("\n<", stdout
);
4323 fputs (procname
, stdout
);
4326 printf ("+%lx", (unsigned long) offset
);
4329 fputs (">: [", stdout
);
4330 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4331 fputc ('-', stdout
);
4332 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4333 printf ("], info at +0x%lx\n",
4334 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4336 head
= aux
->info
+ (tp
->info
.offset
- aux
->info_addr
);
4337 stamp
= BYTE_GET8 ((unsigned char *) head
);
4339 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4340 (unsigned) UNW_VER (stamp
),
4341 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4342 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4343 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4344 (unsigned long) (addr_size
* UNW_LENGTH (stamp
)));
4346 if (UNW_VER (stamp
) != 1)
4348 printf ("\tUnknown version.\n");
4353 for (dp
= head
+ 8; dp
< head
+ 8 + addr_size
* UNW_LENGTH (stamp
);)
4354 dp
= unw_decode (dp
, in_body
, & in_body
);
4359 slurp_ia64_unwind_table (FILE *file
,
4360 struct ia64_unw_aux_info
*aux
,
4361 Elf_Internal_Shdr
*sec
)
4363 unsigned long size
, addr_size
, nrelas
, i
;
4364 Elf_Internal_Phdr
*seg
;
4365 struct ia64_unw_table_entry
*tep
;
4366 Elf_Internal_Shdr
*relsec
;
4367 Elf_Internal_Rela
*rela
, *rp
;
4368 unsigned char *table
, *tp
;
4369 Elf_Internal_Sym
*sym
;
4370 const char *relname
;
4372 addr_size
= is_32bit_elf
? 4 : 8;
4374 /* First, find the starting address of the segment that includes
4377 if (elf_header
.e_phnum
)
4379 if (! get_program_headers (file
))
4382 for (seg
= program_headers
;
4383 seg
< program_headers
+ elf_header
.e_phnum
;
4386 if (seg
->p_type
!= PT_LOAD
)
4389 if (sec
->sh_addr
>= seg
->p_vaddr
4390 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4392 aux
->seg_base
= seg
->p_vaddr
;
4398 /* Second, build the unwind table from the contents of the unwind section: */
4399 size
= sec
->sh_size
;
4400 table
= get_data (NULL
, file
, sec
->sh_offset
, size
, _("unwind table"));
4404 tep
= aux
->table
= xmalloc (size
/ (3 * addr_size
) * sizeof (aux
->table
[0]));
4405 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * addr_size
, ++tep
)
4407 tep
->start
.section
= SHN_UNDEF
;
4408 tep
->end
.section
= SHN_UNDEF
;
4409 tep
->info
.section
= SHN_UNDEF
;
4412 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4413 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4414 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
4418 tep
->start
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 0);
4419 tep
->end
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 8);
4420 tep
->info
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 16);
4422 tep
->start
.offset
+= aux
->seg_base
;
4423 tep
->end
.offset
+= aux
->seg_base
;
4424 tep
->info
.offset
+= aux
->seg_base
;
4428 /* Third, apply any relocations to the unwind table: */
4430 for (relsec
= section_headers
;
4431 relsec
< section_headers
+ elf_header
.e_shnum
;
4434 if (relsec
->sh_type
!= SHT_RELA
4435 || SECTION_HEADER (relsec
->sh_info
) != sec
)
4438 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
4442 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4446 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4447 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4451 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4452 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4455 if (! strneq (relname
, "R_IA64_SEGREL", 13))
4457 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4461 i
= rp
->r_offset
/ (3 * addr_size
);
4463 switch (rp
->r_offset
/addr_size
% 3)
4466 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4467 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
4470 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4471 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
4474 aux
->table
[i
].info
.section
= sym
->st_shndx
;
4475 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
4485 aux
->table_len
= size
/ (3 * addr_size
);
4490 ia64_process_unwind (FILE *file
)
4492 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
4493 unsigned long i
, addr_size
, unwcount
= 0, unwstart
= 0;
4494 struct ia64_unw_aux_info aux
;
4496 memset (& aux
, 0, sizeof (aux
));
4498 addr_size
= is_32bit_elf
? 4 : 8;
4500 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4502 if (sec
->sh_type
== SHT_SYMTAB
)
4504 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
4505 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
4507 strsec
= SECTION_HEADER (sec
->sh_link
);
4508 aux
.strtab_size
= strsec
->sh_size
;
4509 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4510 aux
.strtab_size
, _("string table"));
4512 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4517 printf (_("\nThere are no unwind sections in this file.\n"));
4519 while (unwcount
-- > 0)
4524 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
4525 i
< elf_header
.e_shnum
; ++i
, ++sec
)
4526 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4533 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
4535 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
4537 /* We need to find which section group it is in. */
4538 struct group_list
*g
= section_headers_groups
[i
]->root
;
4540 for (; g
!= NULL
; g
= g
->next
)
4542 sec
= SECTION_HEADER (g
->section_index
);
4544 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
4549 i
= elf_header
.e_shnum
;
4551 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
4553 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
4554 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
4555 suffix
= SECTION_NAME (unwsec
) + len
;
4556 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4558 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
4559 && streq (SECTION_NAME (sec
) + len2
, suffix
))
4564 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
4565 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
4566 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
4567 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
4569 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
4570 suffix
= SECTION_NAME (unwsec
) + len
;
4571 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4573 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
4574 && streq (SECTION_NAME (sec
) + len2
, suffix
))
4578 if (i
== elf_header
.e_shnum
)
4580 printf (_("\nCould not find unwind info section for "));
4582 if (string_table
== NULL
)
4583 printf ("%d", unwsec
->sh_name
);
4585 printf (_("'%s'"), SECTION_NAME (unwsec
));
4589 aux
.info_size
= sec
->sh_size
;
4590 aux
.info_addr
= sec
->sh_addr
;
4591 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, aux
.info_size
,
4594 printf (_("\nUnwind section "));
4596 if (string_table
== NULL
)
4597 printf ("%d", unwsec
->sh_name
);
4599 printf (_("'%s'"), SECTION_NAME (unwsec
));
4601 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4602 (unsigned long) unwsec
->sh_offset
,
4603 (unsigned long) (unwsec
->sh_size
/ (3 * addr_size
)));
4605 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
4607 if (aux
.table_len
> 0)
4608 dump_ia64_unwind (& aux
);
4611 free ((char *) aux
.table
);
4613 free ((char *) aux
.info
);
4622 free ((char *) aux
.strtab
);
4627 struct hppa_unw_aux_info
4629 struct hppa_unw_table_entry
4631 struct absaddr start
;
4633 unsigned int Cannot_unwind
:1; /* 0 */
4634 unsigned int Millicode
:1; /* 1 */
4635 unsigned int Millicode_save_sr0
:1; /* 2 */
4636 unsigned int Region_description
:2; /* 3..4 */
4637 unsigned int reserved1
:1; /* 5 */
4638 unsigned int Entry_SR
:1; /* 6 */
4639 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
4640 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
4641 unsigned int Args_stored
:1; /* 16 */
4642 unsigned int Variable_Frame
:1; /* 17 */
4643 unsigned int Separate_Package_Body
:1; /* 18 */
4644 unsigned int Frame_Extension_Millicode
:1; /* 19 */
4645 unsigned int Stack_Overflow_Check
:1; /* 20 */
4646 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
4647 unsigned int Ada_Region
:1; /* 22 */
4648 unsigned int cxx_info
:1; /* 23 */
4649 unsigned int cxx_try_catch
:1; /* 24 */
4650 unsigned int sched_entry_seq
:1; /* 25 */
4651 unsigned int reserved2
:1; /* 26 */
4652 unsigned int Save_SP
:1; /* 27 */
4653 unsigned int Save_RP
:1; /* 28 */
4654 unsigned int Save_MRP_in_frame
:1; /* 29 */
4655 unsigned int extn_ptr_defined
:1; /* 30 */
4656 unsigned int Cleanup_defined
:1; /* 31 */
4658 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
4659 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
4660 unsigned int Large_frame
:1; /* 2 */
4661 unsigned int Pseudo_SP_Set
:1; /* 3 */
4662 unsigned int reserved4
:1; /* 4 */
4663 unsigned int Total_frame_size
:27; /* 5..31 */
4665 *table
; /* Unwind table. */
4666 unsigned long table_len
; /* Length of unwind table. */
4667 bfd_vma seg_base
; /* Starting address of segment. */
4668 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4669 unsigned long nsyms
; /* Number of symbols. */
4670 char *strtab
; /* The string table. */
4671 unsigned long strtab_size
; /* Size of string table. */
4675 dump_hppa_unwind (struct hppa_unw_aux_info
*aux
)
4678 struct hppa_unw_table_entry
*tp
;
4680 addr_size
= is_32bit_elf
? 4 : 8;
4681 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4684 const char *procname
;
4686 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4687 aux
->strtab_size
, tp
->start
, &procname
,
4690 fputs ("\n<", stdout
);
4694 fputs (procname
, stdout
);
4697 printf ("+%lx", (unsigned long) offset
);
4700 fputs (">: [", stdout
);
4701 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4702 fputc ('-', stdout
);
4703 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4706 #define PF(_m) if (tp->_m) printf (#_m " ");
4707 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
4710 PF(Millicode_save_sr0
);
4711 /* PV(Region_description); */
4717 PF(Separate_Package_Body
);
4718 PF(Frame_Extension_Millicode
);
4719 PF(Stack_Overflow_Check
);
4720 PF(Two_Instruction_SP_Increment
);
4724 PF(sched_entry_seq
);
4727 PF(Save_MRP_in_frame
);
4728 PF(extn_ptr_defined
);
4729 PF(Cleanup_defined
);
4730 PF(MPE_XL_interrupt_marker
);
4731 PF(HP_UX_interrupt_marker
);
4734 PV(Total_frame_size
);
4743 slurp_hppa_unwind_table (FILE *file
,
4744 struct hppa_unw_aux_info
*aux
,
4745 Elf_Internal_Shdr
*sec
)
4747 unsigned long size
, unw_ent_size
, addr_size
, nrelas
, i
;
4748 Elf_Internal_Phdr
*seg
;
4749 struct hppa_unw_table_entry
*tep
;
4750 Elf_Internal_Shdr
*relsec
;
4751 Elf_Internal_Rela
*rela
, *rp
;
4752 unsigned char *table
, *tp
;
4753 Elf_Internal_Sym
*sym
;
4754 const char *relname
;
4756 addr_size
= is_32bit_elf
? 4 : 8;
4758 /* First, find the starting address of the segment that includes
4761 if (elf_header
.e_phnum
)
4763 if (! get_program_headers (file
))
4766 for (seg
= program_headers
;
4767 seg
< program_headers
+ elf_header
.e_phnum
;
4770 if (seg
->p_type
!= PT_LOAD
)
4773 if (sec
->sh_addr
>= seg
->p_vaddr
4774 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4776 aux
->seg_base
= seg
->p_vaddr
;
4782 /* Second, build the unwind table from the contents of the unwind
4784 size
= sec
->sh_size
;
4785 table
= get_data (NULL
, file
, sec
->sh_offset
, size
, _("unwind table"));
4789 unw_ent_size
= 2 * addr_size
+ 8;
4791 tep
= aux
->table
= xmalloc (size
/ unw_ent_size
* sizeof (aux
->table
[0]));
4793 for (tp
= table
; tp
< table
+ size
; tp
+= (2 * addr_size
+ 8), ++tep
)
4795 unsigned int tmp1
, tmp2
;
4797 tep
->start
.section
= SHN_UNDEF
;
4798 tep
->end
.section
= SHN_UNDEF
;
4802 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4803 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4804 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
4805 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
4809 tep
->start
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 0);
4810 tep
->end
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 8);
4811 tmp1
= byte_get ((unsigned char *) tp
+ 16, 4);
4812 tmp2
= byte_get ((unsigned char *) tp
+ 20, 4);
4815 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
4816 tep
->Millicode
= (tmp1
>> 30) & 0x1;
4817 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
4818 tep
->Region_description
= (tmp1
>> 27) & 0x3;
4819 tep
->reserved1
= (tmp1
>> 26) & 0x1;
4820 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
4821 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
4822 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
4823 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
4824 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
4825 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
4826 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
4827 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
4828 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
4829 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
4830 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
4831 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
4832 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
4833 tep
->reserved2
= (tmp1
>> 5) & 0x1;
4834 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
4835 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
4836 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
4837 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
4838 tep
->Cleanup_defined
= tmp1
& 0x1;
4840 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
4841 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
4842 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
4843 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
4844 tep
->reserved4
= (tmp2
>> 27) & 0x1;
4845 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
4847 tep
->start
.offset
+= aux
->seg_base
;
4848 tep
->end
.offset
+= aux
->seg_base
;
4852 /* Third, apply any relocations to the unwind table. */
4854 for (relsec
= section_headers
;
4855 relsec
< section_headers
+ elf_header
.e_shnum
;
4858 if (relsec
->sh_type
!= SHT_RELA
4859 || SECTION_HEADER (relsec
->sh_info
) != sec
)
4862 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
4866 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4870 relname
= elf_hppa_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4871 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4875 relname
= elf_hppa_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4876 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4879 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
4880 if (strncmp (relname
, "R_PARISC_SEGREL", 15) != 0)
4882 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4886 i
= rp
->r_offset
/ unw_ent_size
;
4888 switch ((rp
->r_offset
% unw_ent_size
) / addr_size
)
4891 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4892 aux
->table
[i
].start
.offset
+= sym
->st_value
+ rp
->r_addend
;
4895 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4896 aux
->table
[i
].end
.offset
+= sym
->st_value
+ rp
->r_addend
;
4906 aux
->table_len
= size
/ unw_ent_size
;
4912 hppa_process_unwind (FILE *file
)
4914 struct hppa_unw_aux_info aux
;
4915 Elf_Internal_Shdr
*unwsec
= NULL
;
4916 Elf_Internal_Shdr
*strsec
;
4917 Elf_Internal_Shdr
*sec
;
4918 unsigned long addr_size
;
4921 memset (& aux
, 0, sizeof (aux
));
4923 assert (string_table
!= NULL
);
4924 addr_size
= is_32bit_elf
? 4 : 8;
4926 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4928 if (sec
->sh_type
== SHT_SYMTAB
)
4930 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
4931 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
4933 strsec
= SECTION_HEADER (sec
->sh_link
);
4934 aux
.strtab_size
= strsec
->sh_size
;
4935 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4936 aux
.strtab_size
, _("string table"));
4938 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
4943 printf (_("\nThere are no unwind sections in this file.\n"));
4945 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4947 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
4949 printf (_("\nUnwind section "));
4950 printf (_("'%s'"), SECTION_NAME (sec
));
4952 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4953 (unsigned long) sec
->sh_offset
,
4954 (unsigned long) (sec
->sh_size
/ (2 * addr_size
+ 8)));
4956 slurp_hppa_unwind_table (file
, &aux
, sec
);
4957 if (aux
.table_len
> 0)
4958 dump_hppa_unwind (&aux
);
4961 free ((char *) aux
.table
);
4969 free ((char *) aux
.strtab
);
4975 process_unwind (FILE *file
)
4977 struct unwind_handler
{
4979 int (*handler
)(FILE *file
);
4981 { EM_IA_64
, ia64_process_unwind
},
4982 { EM_PARISC
, hppa_process_unwind
},
4990 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
4991 if (elf_header
.e_machine
== handlers
[i
].machtype
)
4992 return handlers
[i
].handler (file
);
4994 printf (_("\nThere are no unwind sections in this file.\n"));
4999 dynamic_section_mips_val (Elf_Internal_Dyn
*entry
)
5001 switch (entry
->d_tag
)
5004 if (entry
->d_un
.d_val
== 0)
5008 static const char * opts
[] =
5010 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5011 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5012 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5013 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5018 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++cnt
)
5019 if (entry
->d_un
.d_val
& (1 << cnt
))
5021 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5028 case DT_MIPS_IVERSION
:
5029 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5030 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5032 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5035 case DT_MIPS_TIME_STAMP
:
5040 time_t time
= entry
->d_un
.d_val
;
5041 tmp
= gmtime (&time
);
5042 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
5043 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5044 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5045 printf ("Time Stamp: %s\n", timebuf
);
5049 case DT_MIPS_RLD_VERSION
:
5050 case DT_MIPS_LOCAL_GOTNO
:
5051 case DT_MIPS_CONFLICTNO
:
5052 case DT_MIPS_LIBLISTNO
:
5053 case DT_MIPS_SYMTABNO
:
5054 case DT_MIPS_UNREFEXTNO
:
5055 case DT_MIPS_HIPAGENO
:
5056 case DT_MIPS_DELTA_CLASS_NO
:
5057 case DT_MIPS_DELTA_INSTANCE_NO
:
5058 case DT_MIPS_DELTA_RELOC_NO
:
5059 case DT_MIPS_DELTA_SYM_NO
:
5060 case DT_MIPS_DELTA_CLASSSYM_NO
:
5061 case DT_MIPS_COMPACT_SIZE
:
5062 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5066 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
5072 dynamic_section_parisc_val (Elf_Internal_Dyn
*entry
)
5074 switch (entry
->d_tag
)
5076 case DT_HP_DLD_FLAGS
:
5085 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5086 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5087 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5088 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5089 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5090 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5091 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5092 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5093 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5094 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5095 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
5099 bfd_vma val
= entry
->d_un
.d_val
;
5101 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
5102 if (val
& flags
[cnt
].bit
)
5106 fputs (flags
[cnt
].str
, stdout
);
5108 val
^= flags
[cnt
].bit
;
5111 if (val
!= 0 || first
)
5115 print_vma (val
, HEX
);
5121 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5128 dynamic_section_ia64_val (Elf_Internal_Dyn
*entry
)
5130 switch (entry
->d_tag
)
5132 case DT_IA_64_PLT_RESERVE
:
5133 /* First 3 slots reserved. */
5134 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5136 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5140 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5147 get_32bit_dynamic_section (FILE *file
)
5149 Elf32_External_Dyn
*edyn
, *ext
;
5150 Elf_Internal_Dyn
*entry
;
5152 edyn
= get_data (NULL
, file
, dynamic_addr
, dynamic_size
,
5153 _("dynamic section"));
5157 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5158 might not have the luxury of section headers. Look for the DT_NULL
5159 terminator to determine the number of entries. */
5160 for (ext
= edyn
, dynamic_nent
= 0;
5161 (char *) ext
< (char *) edyn
+ dynamic_size
;
5165 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5169 dynamic_section
= malloc (dynamic_nent
* sizeof (*entry
));
5170 if (dynamic_section
== NULL
)
5172 error (_("Out of memory\n"));
5177 for (ext
= edyn
, entry
= dynamic_section
;
5178 entry
< dynamic_section
+ dynamic_nent
;
5181 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5182 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5191 get_64bit_dynamic_section (FILE *file
)
5193 Elf64_External_Dyn
*edyn
, *ext
;
5194 Elf_Internal_Dyn
*entry
;
5196 edyn
= get_data (NULL
, file
, dynamic_addr
, dynamic_size
,
5197 _("dynamic section"));
5201 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5202 might not have the luxury of section headers. Look for the DT_NULL
5203 terminator to determine the number of entries. */
5204 for (ext
= edyn
, dynamic_nent
= 0;
5205 (char *) ext
< (char *) edyn
+ dynamic_size
;
5209 if (BYTE_GET8 (ext
->d_tag
) == DT_NULL
)
5213 dynamic_section
= malloc (dynamic_nent
* sizeof (*entry
));
5214 if (dynamic_section
== NULL
)
5216 error (_("Out of memory\n"));
5221 for (ext
= edyn
, entry
= dynamic_section
;
5222 entry
< dynamic_section
+ dynamic_nent
;
5225 entry
->d_tag
= BYTE_GET8 (ext
->d_tag
);
5226 entry
->d_un
.d_val
= BYTE_GET8 (ext
->d_un
.d_val
);
5235 get_dynamic_flags (bfd_vma flags
)
5237 static char buff
[128];
5245 flag
= flags
& - flags
;
5253 case DF_ORIGIN
: strcpy (p
, "ORIGIN"); break;
5254 case DF_SYMBOLIC
: strcpy (p
, "SYMBOLIC"); break;
5255 case DF_TEXTREL
: strcpy (p
, "TEXTREL"); break;
5256 case DF_BIND_NOW
: strcpy (p
, "BIND_NOW"); break;
5257 case DF_STATIC_TLS
: strcpy (p
, "STATIC_TLS"); break;
5258 default: strcpy (p
, "unknown"); break;
5261 p
= strchr (p
, '\0');
5266 /* Parse and display the contents of the dynamic section. */
5269 process_dynamic_section (FILE *file
)
5271 Elf_Internal_Dyn
*entry
;
5273 if (dynamic_size
== 0)
5276 printf (_("\nThere is no dynamic section in this file.\n"));
5283 if (! get_32bit_dynamic_section (file
))
5286 else if (! get_64bit_dynamic_section (file
))
5289 /* Find the appropriate symbol table. */
5290 if (dynamic_symbols
== NULL
)
5292 for (entry
= dynamic_section
;
5293 entry
< dynamic_section
+ dynamic_nent
;
5296 Elf_Internal_Shdr section
;
5298 if (entry
->d_tag
!= DT_SYMTAB
)
5301 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
5303 /* Since we do not know how big the symbol table is,
5304 we default to reading in the entire file (!) and
5305 processing that. This is overkill, I know, but it
5307 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5309 if (archive_file_offset
!= 0)
5310 section
.sh_size
= archive_file_size
- section
.sh_offset
;
5313 if (fseek (file
, 0, SEEK_END
))
5314 error (_("Unable to seek to end of file!"));
5316 section
.sh_size
= ftell (file
) - section
.sh_offset
;
5320 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
5322 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
5324 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
5325 if (num_dynamic_syms
< 1)
5327 error (_("Unable to determine the number of symbols to load\n"));
5331 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
5335 /* Similarly find a string table. */
5336 if (dynamic_strings
== NULL
)
5338 for (entry
= dynamic_section
;
5339 entry
< dynamic_section
+ dynamic_nent
;
5342 unsigned long offset
;
5345 if (entry
->d_tag
!= DT_STRTAB
)
5348 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
5350 /* Since we do not know how big the string table is,
5351 we default to reading in the entire file (!) and
5352 processing that. This is overkill, I know, but it
5355 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5357 if (archive_file_offset
!= 0)
5358 str_tab_len
= archive_file_size
- offset
;
5361 if (fseek (file
, 0, SEEK_END
))
5362 error (_("Unable to seek to end of file\n"));
5363 str_tab_len
= ftell (file
) - offset
;
5366 if (str_tab_len
< 1)
5369 (_("Unable to determine the length of the dynamic string table\n"));
5373 dynamic_strings
= get_data (NULL
, file
, offset
, str_tab_len
,
5374 _("dynamic string table"));
5375 dynamic_strings_length
= str_tab_len
;
5380 /* And find the syminfo section if available. */
5381 if (dynamic_syminfo
== NULL
)
5383 unsigned long syminsz
= 0;
5385 for (entry
= dynamic_section
;
5386 entry
< dynamic_section
+ dynamic_nent
;
5389 if (entry
->d_tag
== DT_SYMINENT
)
5391 /* Note: these braces are necessary to avoid a syntax
5392 error from the SunOS4 C compiler. */
5393 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
5395 else if (entry
->d_tag
== DT_SYMINSZ
)
5396 syminsz
= entry
->d_un
.d_val
;
5397 else if (entry
->d_tag
== DT_SYMINFO
)
5398 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
5402 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
5404 Elf_External_Syminfo
*extsyminfo
, *extsym
;
5405 Elf_Internal_Syminfo
*syminfo
;
5407 /* There is a syminfo section. Read the data. */
5408 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, syminsz
,
5409 _("symbol information"));
5413 dynamic_syminfo
= malloc (syminsz
);
5414 if (dynamic_syminfo
== NULL
)
5416 error (_("Out of memory\n"));
5420 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
5421 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
5422 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
5423 ++syminfo
, ++extsym
)
5425 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
5426 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
5433 if (do_dynamic
&& dynamic_addr
)
5434 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
5435 dynamic_addr
, dynamic_nent
);
5437 printf (_(" Tag Type Name/Value\n"));
5439 for (entry
= dynamic_section
;
5440 entry
< dynamic_section
+ dynamic_nent
;
5448 print_vma (entry
->d_tag
, FULL_HEX
);
5449 dtype
= get_dynamic_type (entry
->d_tag
);
5450 printf (" (%s)%*s", dtype
,
5451 ((is_32bit_elf
? 27 : 19)
5452 - (int) strlen (dtype
)),
5456 switch (entry
->d_tag
)
5460 puts (get_dynamic_flags (entry
->d_un
.d_val
));
5470 switch (entry
->d_tag
)
5473 printf (_("Auxiliary library"));
5477 printf (_("Filter library"));
5481 printf (_("Configuration file"));
5485 printf (_("Dependency audit library"));
5489 printf (_("Audit library"));
5493 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5494 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5498 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5507 printf (_("Flags:"));
5509 if (entry
->d_un
.d_val
== 0)
5510 printf (_(" None\n"));
5513 unsigned long int val
= entry
->d_un
.d_val
;
5515 if (val
& DTF_1_PARINIT
)
5517 printf (" PARINIT");
5518 val
^= DTF_1_PARINIT
;
5520 if (val
& DTF_1_CONFEXP
)
5522 printf (" CONFEXP");
5523 val
^= DTF_1_CONFEXP
;
5526 printf (" %lx", val
);
5535 printf (_("Flags:"));
5537 if (entry
->d_un
.d_val
== 0)
5538 printf (_(" None\n"));
5541 unsigned long int val
= entry
->d_un
.d_val
;
5543 if (val
& DF_P1_LAZYLOAD
)
5545 printf (" LAZYLOAD");
5546 val
^= DF_P1_LAZYLOAD
;
5548 if (val
& DF_P1_GROUPPERM
)
5550 printf (" GROUPPERM");
5551 val
^= DF_P1_GROUPPERM
;
5554 printf (" %lx", val
);
5563 printf (_("Flags:"));
5564 if (entry
->d_un
.d_val
== 0)
5565 printf (_(" None\n"));
5568 unsigned long int val
= entry
->d_un
.d_val
;
5575 if (val
& DF_1_GLOBAL
)
5580 if (val
& DF_1_GROUP
)
5585 if (val
& DF_1_NODELETE
)
5587 printf (" NODELETE");
5588 val
^= DF_1_NODELETE
;
5590 if (val
& DF_1_LOADFLTR
)
5592 printf (" LOADFLTR");
5593 val
^= DF_1_LOADFLTR
;
5595 if (val
& DF_1_INITFIRST
)
5597 printf (" INITFIRST");
5598 val
^= DF_1_INITFIRST
;
5600 if (val
& DF_1_NOOPEN
)
5605 if (val
& DF_1_ORIGIN
)
5610 if (val
& DF_1_DIRECT
)
5615 if (val
& DF_1_TRANS
)
5620 if (val
& DF_1_INTERPOSE
)
5622 printf (" INTERPOSE");
5623 val
^= DF_1_INTERPOSE
;
5625 if (val
& DF_1_NODEFLIB
)
5627 printf (" NODEFLIB");
5628 val
^= DF_1_NODEFLIB
;
5630 if (val
& DF_1_NODUMP
)
5635 if (val
& DF_1_CONLFAT
)
5637 printf (" CONLFAT");
5638 val
^= DF_1_CONLFAT
;
5641 printf (" %lx", val
);
5648 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5650 puts (get_dynamic_type (entry
->d_un
.d_val
));
5670 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5676 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5677 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
5683 switch (entry
->d_tag
)
5686 printf (_("Shared library: [%s]"), name
);
5688 if (streq (name
, program_interpreter
))
5689 printf (_(" program interpreter"));
5693 printf (_("Library soname: [%s]"), name
);
5697 printf (_("Library rpath: [%s]"), name
);
5701 printf (_("Library runpath: [%s]"), name
);
5705 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5710 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5723 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5727 case DT_INIT_ARRAYSZ
:
5728 case DT_FINI_ARRAYSZ
:
5729 case DT_GNU_CONFLICTSZ
:
5730 case DT_GNU_LIBLISTSZ
:
5733 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5734 printf (" (bytes)\n");
5744 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5757 if (entry
->d_tag
== DT_USED
5758 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5760 char *name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
5764 printf (_("Not needed object: [%s]\n"), name
);
5769 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5775 /* The value of this entry is ignored. */
5780 case DT_GNU_PRELINKED
:
5784 time_t time
= entry
->d_un
.d_val
;
5786 tmp
= gmtime (&time
);
5787 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
5788 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5789 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5795 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
5796 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
5801 switch (elf_header
.e_machine
)
5804 case EM_MIPS_RS3_LE
:
5805 dynamic_section_mips_val (entry
);
5808 dynamic_section_parisc_val (entry
);
5811 dynamic_section_ia64_val (entry
);
5814 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5826 get_ver_flags (unsigned int flags
)
5828 static char buff
[32];
5835 if (flags
& VER_FLG_BASE
)
5836 strcat (buff
, "BASE ");
5838 if (flags
& VER_FLG_WEAK
)
5840 if (flags
& VER_FLG_BASE
)
5841 strcat (buff
, "| ");
5843 strcat (buff
, "WEAK ");
5846 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
5847 strcat (buff
, "| <unknown>");
5852 /* Display the contents of the version sections. */
5854 process_version_sections (FILE *file
)
5856 Elf_Internal_Shdr
*section
;
5863 for (i
= 0, section
= section_headers
;
5864 i
< elf_header
.e_shnum
;
5867 switch (section
->sh_type
)
5869 case SHT_GNU_verdef
:
5871 Elf_External_Verdef
*edefs
;
5878 (_("\nVersion definition section '%s' contains %ld entries:\n"),
5879 SECTION_NAME (section
), section
->sh_info
);
5881 printf (_(" Addr: 0x"));
5882 printf_vma (section
->sh_addr
);
5883 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5884 (unsigned long) section
->sh_offset
, section
->sh_link
,
5885 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
5887 edefs
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
5888 _("version definition section"));
5892 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
5895 Elf_External_Verdef
*edef
;
5896 Elf_Internal_Verdef ent
;
5897 Elf_External_Verdaux
*eaux
;
5898 Elf_Internal_Verdaux aux
;
5902 vstart
= ((char *) edefs
) + idx
;
5904 edef
= (Elf_External_Verdef
*) vstart
;
5906 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
5907 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
5908 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
5909 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
5910 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
5911 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
5912 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
5914 printf (_(" %#06x: Rev: %d Flags: %s"),
5915 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
5917 printf (_(" Index: %d Cnt: %d "),
5918 ent
.vd_ndx
, ent
.vd_cnt
);
5920 vstart
+= ent
.vd_aux
;
5922 eaux
= (Elf_External_Verdaux
*) vstart
;
5924 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
5925 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
5927 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
5928 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
5930 printf (_("Name index: %ld\n"), aux
.vda_name
);
5932 isum
= idx
+ ent
.vd_aux
;
5934 for (j
= 1; j
< ent
.vd_cnt
; j
++)
5936 isum
+= aux
.vda_next
;
5937 vstart
+= aux
.vda_next
;
5939 eaux
= (Elf_External_Verdaux
*) vstart
;
5941 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
5942 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
5944 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
5945 printf (_(" %#06x: Parent %d: %s\n"),
5946 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
5948 printf (_(" %#06x: Parent %d, name index: %ld\n"),
5949 isum
, j
, aux
.vda_name
);
5959 case SHT_GNU_verneed
:
5961 Elf_External_Verneed
*eneed
;
5967 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
5968 SECTION_NAME (section
), section
->sh_info
);
5970 printf (_(" Addr: 0x"));
5971 printf_vma (section
->sh_addr
);
5972 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
5973 (unsigned long) section
->sh_offset
, section
->sh_link
,
5974 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
5976 eneed
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
5977 _("version need section"));
5981 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
5983 Elf_External_Verneed
*entry
;
5984 Elf_Internal_Verneed ent
;
5989 vstart
= ((char *) eneed
) + idx
;
5991 entry
= (Elf_External_Verneed
*) vstart
;
5993 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
5994 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
5995 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
5996 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
5997 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
5999 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6001 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6002 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6004 printf (_(" File: %lx"), ent
.vn_file
);
6006 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6008 vstart
+= ent
.vn_aux
;
6010 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6012 Elf_External_Vernaux
*eaux
;
6013 Elf_Internal_Vernaux aux
;
6015 eaux
= (Elf_External_Vernaux
*) vstart
;
6017 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6018 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6019 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6020 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6021 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6023 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6024 printf (_(" %#06x: Name: %s"),
6025 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6027 printf (_(" %#06x: Name index: %lx"),
6028 isum
, aux
.vna_name
);
6030 printf (_(" Flags: %s Version: %d\n"),
6031 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6033 isum
+= aux
.vna_next
;
6034 vstart
+= aux
.vna_next
;
6044 case SHT_GNU_versym
:
6046 Elf_Internal_Shdr
*link_section
;
6049 unsigned char *edata
;
6050 unsigned short *data
;
6052 Elf_Internal_Sym
*symbols
;
6053 Elf_Internal_Shdr
*string_sec
;
6056 link_section
= SECTION_HEADER (section
->sh_link
);
6057 total
= section
->sh_size
/ section
->sh_entsize
;
6061 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6063 string_sec
= SECTION_HEADER (link_section
->sh_link
);
6065 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
6066 string_sec
->sh_size
, _("version string table"));
6070 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6071 SECTION_NAME (section
), total
);
6073 printf (_(" Addr: "));
6074 printf_vma (section
->sh_addr
);
6075 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6076 (unsigned long) section
->sh_offset
, section
->sh_link
,
6077 SECTION_NAME (link_section
));
6079 off
= offset_from_vma (file
,
6080 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6081 total
* sizeof (short));
6082 edata
= get_data (NULL
, file
, off
, total
* sizeof (short),
6083 _("version symbol data"));
6090 data
= malloc (total
* sizeof (short));
6092 for (cnt
= total
; cnt
--;)
6093 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6098 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6101 int check_def
, check_need
;
6104 printf (" %03x:", cnt
);
6106 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6107 switch (data
[cnt
+ j
])
6110 fputs (_(" 0 (*local*) "), stdout
);
6114 fputs (_(" 1 (*global*) "), stdout
);
6118 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
6119 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
6123 if (SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
6126 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6133 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6135 Elf_Internal_Verneed ivn
;
6136 unsigned long offset
;
6138 offset
= offset_from_vma
6139 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6140 sizeof (Elf_External_Verneed
));
6144 Elf_Internal_Vernaux ivna
;
6145 Elf_External_Verneed evn
;
6146 Elf_External_Vernaux evna
;
6147 unsigned long a_off
;
6149 get_data (&evn
, file
, offset
, sizeof (evn
),
6152 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6153 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6155 a_off
= offset
+ ivn
.vn_aux
;
6159 get_data (&evna
, file
, a_off
, sizeof (evna
),
6160 _("version need aux (2)"));
6162 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6163 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6165 a_off
+= ivna
.vna_next
;
6167 while (ivna
.vna_other
!= data
[cnt
+ j
]
6168 && ivna
.vna_next
!= 0);
6170 if (ivna
.vna_other
== data
[cnt
+ j
])
6172 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6174 name
= strtab
+ ivna
.vna_name
;
6175 nn
+= printf ("(%s%-*s",
6177 12 - (int) strlen (name
),
6183 offset
+= ivn
.vn_next
;
6185 while (ivn
.vn_next
);
6188 if (check_def
&& data
[cnt
+ j
] != 0x8001
6189 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6191 Elf_Internal_Verdef ivd
;
6192 Elf_External_Verdef evd
;
6193 unsigned long offset
;
6195 offset
= offset_from_vma
6196 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6201 get_data (&evd
, file
, offset
, sizeof (evd
),
6204 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6205 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6207 offset
+= ivd
.vd_next
;
6209 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
6210 && ivd
.vd_next
!= 0);
6212 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
6214 Elf_External_Verdaux evda
;
6215 Elf_Internal_Verdaux ivda
;
6217 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6219 get_data (&evda
, file
,
6220 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
6221 sizeof (evda
), _("version def aux"));
6223 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6225 name
= strtab
+ ivda
.vda_name
;
6226 nn
+= printf ("(%s%-*s",
6228 12 - (int) strlen (name
),
6234 printf ("%*c", 18 - nn
, ' ');
6252 printf (_("\nNo version information found in this file.\n"));
6258 get_symbol_binding (unsigned int binding
)
6260 static char buff
[32];
6264 case STB_LOCAL
: return "LOCAL";
6265 case STB_GLOBAL
: return "GLOBAL";
6266 case STB_WEAK
: return "WEAK";
6268 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
6269 sprintf (buff
, _("<processor specific>: %d"), binding
);
6270 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
6271 sprintf (buff
, _("<OS specific>: %d"), binding
);
6273 sprintf (buff
, _("<unknown>: %d"), binding
);
6279 get_symbol_type (unsigned int type
)
6281 static char buff
[32];
6285 case STT_NOTYPE
: return "NOTYPE";
6286 case STT_OBJECT
: return "OBJECT";
6287 case STT_FUNC
: return "FUNC";
6288 case STT_SECTION
: return "SECTION";
6289 case STT_FILE
: return "FILE";
6290 case STT_COMMON
: return "COMMON";
6291 case STT_TLS
: return "TLS";
6293 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
6295 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
6296 return "THUMB_FUNC";
6298 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
6301 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
6302 return "PARISC_MILLI";
6304 sprintf (buff
, _("<processor specific>: %d"), type
);
6306 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
6308 if (elf_header
.e_machine
== EM_PARISC
)
6310 if (type
== STT_HP_OPAQUE
)
6312 if (type
== STT_HP_STUB
)
6316 sprintf (buff
, _("<OS specific>: %d"), type
);
6319 sprintf (buff
, _("<unknown>: %d"), type
);
6325 get_symbol_visibility (unsigned int visibility
)
6329 case STV_DEFAULT
: return "DEFAULT";
6330 case STV_INTERNAL
: return "INTERNAL";
6331 case STV_HIDDEN
: return "HIDDEN";
6332 case STV_PROTECTED
: return "PROTECTED";
6338 get_symbol_index_type (unsigned int type
)
6340 static char buff
[32];
6344 case SHN_UNDEF
: return "UND";
6345 case SHN_ABS
: return "ABS";
6346 case SHN_COMMON
: return "COM";
6348 if (type
== SHN_IA_64_ANSI_COMMON
6349 && elf_header
.e_machine
== EM_IA_64
6350 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
6352 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
6353 sprintf (buff
, "PRC[0x%04x]", type
);
6354 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
6355 sprintf (buff
, "OS [0x%04x]", type
);
6356 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
6357 sprintf (buff
, "RSV[0x%04x]", type
);
6359 sprintf (buff
, "%3d", type
);
6367 get_dynamic_data (FILE *file
, unsigned int number
)
6369 unsigned char *e_data
;
6372 e_data
= malloc (number
* 4);
6376 error (_("Out of memory\n"));
6380 if (fread (e_data
, 4, number
, file
) != number
)
6382 error (_("Unable to read in dynamic data\n"));
6386 i_data
= malloc (number
* sizeof (*i_data
));
6390 error (_("Out of memory\n"));
6396 i_data
[number
] = byte_get (e_data
+ number
* 4, 4);
6403 /* Dump the symbol table. */
6405 process_symbol_table (FILE *file
)
6407 Elf_Internal_Shdr
*section
;
6408 unsigned char nb
[4];
6409 unsigned char nc
[4];
6412 int *buckets
= NULL
;
6415 if (! do_syms
&& !do_histogram
)
6418 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
6422 (archive_file_offset
6423 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
6424 sizeof nb
+ sizeof nc
)),
6427 error (_("Unable to seek to start of dynamic information"));
6431 if (fread (nb
, sizeof (nb
), 1, file
) != 1)
6433 error (_("Failed to read in number of buckets\n"));
6437 if (fread (nc
, sizeof (nc
), 1, file
) != 1)
6439 error (_("Failed to read in number of chains\n"));
6443 nbuckets
= byte_get (nb
, 4);
6444 nchains
= byte_get (nc
, 4);
6446 buckets
= get_dynamic_data (file
, nbuckets
);
6447 chains
= get_dynamic_data (file
, nchains
);
6449 if (buckets
== NULL
|| chains
== NULL
)
6454 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
6459 printf (_("\nSymbol table for image:\n"));
6461 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6463 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6465 for (hn
= 0; hn
< nbuckets
; hn
++)
6470 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
6472 Elf_Internal_Sym
*psym
;
6474 psym
= dynamic_symbols
+ si
;
6476 printf (" %3d %3d: ", si
, hn
);
6477 print_vma (psym
->st_value
, LONG_HEX
);
6479 print_vma (psym
->st_size
, DEC_5
);
6481 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6482 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6483 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6484 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
6485 if (VALID_DYNAMIC_NAME (psym
->st_name
))
6486 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
6488 printf (" <corrupt: %14ld>", psym
->st_name
);
6493 else if (do_syms
&& !do_using_dynamic
)
6497 for (i
= 0, section
= section_headers
;
6498 i
< elf_header
.e_shnum
;
6503 Elf_Internal_Sym
*symtab
;
6504 Elf_Internal_Sym
*psym
;
6507 if ( section
->sh_type
!= SHT_SYMTAB
6508 && section
->sh_type
!= SHT_DYNSYM
)
6511 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
6512 SECTION_NAME (section
),
6513 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
6515 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6517 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6519 symtab
= GET_ELF_SYMBOLS (file
, section
);
6523 if (section
->sh_link
== elf_header
.e_shstrndx
)
6524 strtab
= string_table
;
6527 Elf_Internal_Shdr
*string_sec
;
6529 string_sec
= SECTION_HEADER (section
->sh_link
);
6531 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
6532 string_sec
->sh_size
, _("string table"));
6535 for (si
= 0, psym
= symtab
;
6536 si
< section
->sh_size
/ section
->sh_entsize
;
6539 printf ("%6d: ", si
);
6540 print_vma (psym
->st_value
, LONG_HEX
);
6542 print_vma (psym
->st_size
, DEC_5
);
6543 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6544 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6545 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6546 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
6547 print_symbol (25, strtab
+ psym
->st_name
);
6549 if (section
->sh_type
== SHT_DYNSYM
&&
6550 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
6552 unsigned char data
[2];
6553 unsigned short vers_data
;
6554 unsigned long offset
;
6558 offset
= offset_from_vma
6559 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6560 sizeof data
+ si
* sizeof (vers_data
));
6562 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
6563 sizeof (data
), _("version data"));
6565 vers_data
= byte_get (data
, 2);
6567 is_nobits
= (SECTION_HEADER (psym
->st_shndx
)->sh_type
6570 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
6572 if ((vers_data
& 0x8000) || vers_data
> 1)
6574 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
6575 && (is_nobits
|| ! check_def
))
6577 Elf_External_Verneed evn
;
6578 Elf_Internal_Verneed ivn
;
6579 Elf_Internal_Vernaux ivna
;
6581 /* We must test both. */
6582 offset
= offset_from_vma
6583 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6588 unsigned long vna_off
;
6590 get_data (&evn
, file
, offset
, sizeof (evn
),
6593 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6594 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6596 vna_off
= offset
+ ivn
.vn_aux
;
6600 Elf_External_Vernaux evna
;
6602 get_data (&evna
, file
, vna_off
,
6604 _("version need aux (3)"));
6606 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6607 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6608 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6610 vna_off
+= ivna
.vna_next
;
6612 while (ivna
.vna_other
!= vers_data
6613 && ivna
.vna_next
!= 0);
6615 if (ivna
.vna_other
== vers_data
)
6618 offset
+= ivn
.vn_next
;
6620 while (ivn
.vn_next
!= 0);
6622 if (ivna
.vna_other
== vers_data
)
6625 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
6628 else if (! is_nobits
)
6629 error (_("bad dynamic symbol"));
6636 if (vers_data
!= 0x8001
6637 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6639 Elf_Internal_Verdef ivd
;
6640 Elf_Internal_Verdaux ivda
;
6641 Elf_External_Verdaux evda
;
6642 unsigned long offset
;
6644 offset
= offset_from_vma
6646 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6647 sizeof (Elf_External_Verdef
));
6651 Elf_External_Verdef evd
;
6653 get_data (&evd
, file
, offset
, sizeof (evd
),
6656 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6657 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6658 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6660 offset
+= ivd
.vd_next
;
6662 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
6663 && ivd
.vd_next
!= 0);
6665 offset
-= ivd
.vd_next
;
6666 offset
+= ivd
.vd_aux
;
6668 get_data (&evda
, file
, offset
, sizeof (evda
),
6669 _("version def aux"));
6671 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6673 if (psym
->st_name
!= ivda
.vda_name
)
6674 printf ((vers_data
& 0x8000)
6676 strtab
+ ivda
.vda_name
);
6686 if (strtab
!= string_table
)
6692 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
6694 if (do_histogram
&& buckets
!= NULL
)
6701 int nzero_counts
= 0;
6704 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
6706 printf (_(" Length Number %% of total Coverage\n"));
6708 lengths
= calloc (nbuckets
, sizeof (int));
6709 if (lengths
== NULL
)
6711 error (_("Out of memory"));
6714 for (hn
= 0; hn
< nbuckets
; ++hn
)
6719 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
6722 if (maxlength
< ++lengths
[hn
])
6727 counts
= calloc (maxlength
+ 1, sizeof (int));
6730 error (_("Out of memory"));
6734 for (hn
= 0; hn
< nbuckets
; ++hn
)
6735 ++counts
[lengths
[hn
]];
6739 printf (" 0 %-10d (%5.1f%%)\n",
6740 counts
[0], (counts
[0] * 100.0) / nbuckets
);
6741 for (si
= 1; si
<= maxlength
; ++si
)
6743 nzero_counts
+= counts
[si
] * si
;
6744 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
6745 si
, counts
[si
], (counts
[si
] * 100.0) / nbuckets
,
6746 (nzero_counts
* 100.0) / nsyms
);
6754 if (buckets
!= NULL
)
6764 process_syminfo (FILE *file ATTRIBUTE_UNUSED
)
6768 if (dynamic_syminfo
== NULL
6770 /* No syminfo, this is ok. */
6773 /* There better should be a dynamic symbol section. */
6774 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
6778 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
6779 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
6781 printf (_(" Num: Name BoundTo Flags\n"));
6782 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
6784 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
6786 printf ("%4d: ", i
);
6787 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
6788 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
6790 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
6793 switch (dynamic_syminfo
[i
].si_boundto
)
6795 case SYMINFO_BT_SELF
:
6796 fputs ("SELF ", stdout
);
6798 case SYMINFO_BT_PARENT
:
6799 fputs ("PARENT ", stdout
);
6802 if (dynamic_syminfo
[i
].si_boundto
> 0
6803 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
6804 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
6806 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
6810 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
6814 if (flags
& SYMINFO_FLG_DIRECT
)
6816 if (flags
& SYMINFO_FLG_PASSTHRU
)
6817 printf (" PASSTHRU");
6818 if (flags
& SYMINFO_FLG_COPY
)
6820 if (flags
& SYMINFO_FLG_LAZYLOAD
)
6821 printf (" LAZYLOAD");
6829 #ifdef SUPPORT_DISASSEMBLY
6831 disassemble_section (Elf_Internal_Shdr
*section
, FILE *file
)
6833 printf (_("\nAssembly dump of section %s\n"),
6834 SECTION_NAME (section
));
6836 /* XXX -- to be done --- XXX */
6843 dump_section (Elf_Internal_Shdr
*section
, FILE *file
)
6845 bfd_size_type bytes
;
6847 unsigned char *data
;
6848 unsigned char *start
;
6850 bytes
= section
->sh_size
;
6852 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
6854 printf (_("\nSection '%s' has no data to dump.\n"),
6855 SECTION_NAME (section
));
6859 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
6861 addr
= section
->sh_addr
;
6863 start
= get_data (NULL
, file
, section
->sh_offset
, bytes
, _("section data"));
6875 lbytes
= (bytes
> 16 ? 16 : bytes
);
6877 printf (" 0x%8.8lx ", (unsigned long) addr
);
6879 switch (elf_header
.e_ident
[EI_DATA
])
6883 for (j
= 15; j
>= 0; j
--)
6886 printf ("%2.2x", data
[j
]);
6896 for (j
= 0; j
< 16; j
++)
6899 printf ("%2.2x", data
[j
]);
6909 for (j
= 0; j
< lbytes
; j
++)
6912 if (k
>= ' ' && k
< 0x7f)
6931 static unsigned long int
6932 read_leb128 (unsigned char *data
, int *length_return
, int sign
)
6934 unsigned long int result
= 0;
6935 unsigned int num_read
= 0;
6936 unsigned int shift
= 0;
6944 result
|= ((unsigned long int) (byte
& 0x7f)) << shift
;
6949 while (byte
& 0x80);
6951 if (length_return
!= NULL
)
6952 *length_return
= num_read
;
6954 if (sign
&& (shift
< 8 * sizeof (result
)) && (byte
& 0x40))
6955 result
|= -1L << shift
;
6960 typedef struct State_Machine_Registers
6962 unsigned long address
;
6965 unsigned int column
;
6969 /* This variable hold the number of the last entry seen
6970 in the File Table. */
6971 unsigned int last_file_entry
;
6974 static SMR state_machine_regs
;
6977 reset_state_machine (int is_stmt
)
6979 state_machine_regs
.address
= 0;
6980 state_machine_regs
.file
= 1;
6981 state_machine_regs
.line
= 1;
6982 state_machine_regs
.column
= 0;
6983 state_machine_regs
.is_stmt
= is_stmt
;
6984 state_machine_regs
.basic_block
= 0;
6985 state_machine_regs
.end_sequence
= 0;
6986 state_machine_regs
.last_file_entry
= 0;
6989 /* Handled an extend line op. Returns true if this is the end
6993 process_extended_line_op (unsigned char *data
, int is_stmt
, int pointer_size
)
6995 unsigned char op_code
;
6998 unsigned char *name
;
7001 len
= read_leb128 (data
, & bytes_read
, 0);
7006 warn (_("badly formed extended line op encountered!\n"));
7013 printf (_(" Extended opcode %d: "), op_code
);
7017 case DW_LNE_end_sequence
:
7018 printf (_("End of Sequence\n\n"));
7019 reset_state_machine (is_stmt
);
7022 case DW_LNE_set_address
:
7023 adr
= byte_get (data
, pointer_size
);
7024 printf (_("set Address to 0x%lx\n"), adr
);
7025 state_machine_regs
.address
= adr
;
7028 case DW_LNE_define_file
:
7029 printf (_(" define new File Table entry\n"));
7030 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
7032 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
7034 data
+= strlen ((char *) data
) + 1;
7035 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7037 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7039 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7040 printf (_("%s\n\n"), name
);
7044 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
7051 /* Finds section NAME inside FILE and returns a
7052 pointer to it, or NULL upon failure. */
7054 static Elf_Internal_Shdr
*
7055 find_section (const char * name
)
7057 Elf_Internal_Shdr
*sec
;
7060 for (i
= elf_header
.e_shnum
, sec
= section_headers
+ i
- 1;
7062 if (streq (SECTION_NAME (sec
), name
))
7065 if (i
&& sec
&& sec
->sh_size
!= 0)
7071 static const char *debug_str_contents
;
7072 static bfd_vma debug_str_size
;
7075 load_debug_str (FILE *file
)
7077 Elf_Internal_Shdr
*sec
;
7079 /* If it is already loaded, do nothing. */
7080 if (debug_str_contents
!= NULL
)
7083 /* Locate the .debug_str section. */
7084 sec
= find_section (".debug_str");
7088 debug_str_size
= sec
->sh_size
;
7090 debug_str_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7091 _("debug_str section data"));
7095 free_debug_str (void)
7097 if (debug_str_contents
== NULL
)
7100 free ((char *) debug_str_contents
);
7101 debug_str_contents
= NULL
;
7106 fetch_indirect_string (unsigned long offset
)
7108 if (debug_str_contents
== NULL
)
7109 return _("<no .debug_str section>");
7111 if (offset
> debug_str_size
)
7112 return _("<offset is too big>");
7114 return debug_str_contents
+ offset
;
7117 static const char *debug_loc_contents
;
7118 static bfd_vma debug_loc_size
;
7121 load_debug_loc (FILE *file
)
7123 Elf_Internal_Shdr
*sec
;
7125 /* If it is already loaded, do nothing. */
7126 if (debug_loc_contents
!= NULL
)
7129 /* Locate the .debug_loc section. */
7130 sec
= find_section (".debug_loc");
7134 debug_loc_size
= sec
->sh_size
;
7136 debug_loc_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7137 _("debug_loc section data"));
7141 free_debug_loc (void)
7143 if (debug_loc_contents
== NULL
)
7146 free ((char *) debug_loc_contents
);
7147 debug_loc_contents
= NULL
;
7151 static const char * debug_range_contents
;
7152 static unsigned long debug_range_size
;
7155 load_debug_range (FILE *file
)
7157 Elf_Internal_Shdr
*sec
;
7159 /* If it is already loaded, do nothing. */
7160 if (debug_range_contents
!= NULL
)
7163 /* Locate the .debug_str section. */
7164 sec
= find_section (".debug_ranges");
7168 debug_range_size
= sec
->sh_size
;
7170 debug_range_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7171 _("debug_range section data"));
7175 free_debug_range (void)
7177 if (debug_range_contents
== NULL
)
7180 free ((char *) debug_range_contents
);
7181 debug_range_contents
= NULL
;
7182 debug_range_size
= 0;
7185 /* Apply addends of RELA relocations. */
7188 debug_apply_rela_addends (FILE *file
,
7189 Elf_Internal_Shdr
*section
,
7191 unsigned char *sec_data
,
7192 unsigned char *start
,
7195 Elf_Internal_Shdr
*relsec
;
7197 if (end
- start
< reloc_size
)
7200 for (relsec
= section_headers
;
7201 relsec
< section_headers
+ elf_header
.e_shnum
;
7204 unsigned long nrelas
;
7205 Elf_Internal_Rela
*rela
, *rp
;
7206 Elf_Internal_Shdr
*symsec
;
7207 Elf_Internal_Sym
*symtab
;
7208 Elf_Internal_Sym
*sym
;
7210 if (relsec
->sh_type
!= SHT_RELA
7211 || SECTION_HEADER (relsec
->sh_info
) != section
7212 || relsec
->sh_size
== 0)
7215 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7219 symsec
= SECTION_HEADER (relsec
->sh_link
);
7220 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
7222 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7226 if (rp
->r_offset
>= (bfd_vma
) (start
- sec_data
)
7227 && rp
->r_offset
< (bfd_vma
) (end
- sec_data
) - reloc_size
)
7228 loc
= sec_data
+ rp
->r_offset
;
7234 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
7236 if (ELF32_R_SYM (rp
->r_info
) != 0
7237 && ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
7238 /* Relocations against object symbols can happen,
7239 eg when referencing a global array. For an
7240 example of this see the _clz.o binary in libgcc.a. */
7241 && ELF32_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7243 warn (_("%s: skipping unexpected symbol type %s in relocation in section .rela%s\n"),
7244 get_symbol_type (ELF32_ST_TYPE (sym
->st_info
)),
7245 SECTION_NAME (section
));
7251 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
7253 if (ELF64_R_SYM (rp
->r_info
) != 0
7254 && ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
7255 && ELF64_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7257 warn (_("skipping unexpected symbol type %s in relocation in section .rela.%s\n"),
7258 get_symbol_type (ELF64_ST_TYPE (sym
->st_info
)),
7259 SECTION_NAME (section
));
7264 byte_put (loc
, rp
->r_addend
, reloc_size
);
7274 /* FIXME: There are better and more efficient ways to handle
7275 these structures. For now though, I just want something that
7276 is simple to implement. */
7277 typedef struct abbrev_attr
7279 unsigned long attribute
;
7281 struct abbrev_attr
*next
;
7285 typedef struct abbrev_entry
7287 unsigned long entry
;
7290 struct abbrev_attr
*first_attr
;
7291 struct abbrev_attr
*last_attr
;
7292 struct abbrev_entry
*next
;
7296 static abbrev_entry
*first_abbrev
= NULL
;
7297 static abbrev_entry
*last_abbrev
= NULL
;
7302 abbrev_entry
*abbrev
;
7304 for (abbrev
= first_abbrev
; abbrev
;)
7306 abbrev_entry
*next
= abbrev
->next
;
7309 for (attr
= abbrev
->first_attr
; attr
;)
7311 abbrev_attr
*next
= attr
->next
;
7321 last_abbrev
= first_abbrev
= NULL
;
7325 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
7327 abbrev_entry
*entry
;
7329 entry
= malloc (sizeof (*entry
));
7335 entry
->entry
= number
;
7337 entry
->children
= children
;
7338 entry
->first_attr
= NULL
;
7339 entry
->last_attr
= NULL
;
7342 if (first_abbrev
== NULL
)
7343 first_abbrev
= entry
;
7345 last_abbrev
->next
= entry
;
7347 last_abbrev
= entry
;
7351 add_abbrev_attr (unsigned long attribute
, unsigned long form
)
7355 attr
= malloc (sizeof (*attr
));
7361 attr
->attribute
= attribute
;
7365 if (last_abbrev
->first_attr
== NULL
)
7366 last_abbrev
->first_attr
= attr
;
7368 last_abbrev
->last_attr
->next
= attr
;
7370 last_abbrev
->last_attr
= attr
;
7373 /* Processes the (partial) contents of a .debug_abbrev section.
7374 Returns NULL if the end of the section was encountered.
7375 Returns the address after the last byte read if the end of
7376 an abbreviation set was found. */
7378 static unsigned char *
7379 process_abbrev_section (unsigned char *start
, unsigned char *end
)
7381 if (first_abbrev
!= NULL
)
7387 unsigned long entry
;
7389 unsigned long attribute
;
7392 entry
= read_leb128 (start
, & bytes_read
, 0);
7393 start
+= bytes_read
;
7395 /* A single zero is supposed to end the section according
7396 to the standard. If there's more, then signal that to
7399 return start
== end
? NULL
: start
;
7401 tag
= read_leb128 (start
, & bytes_read
, 0);
7402 start
+= bytes_read
;
7404 children
= *start
++;
7406 add_abbrev (entry
, tag
, children
);
7412 attribute
= read_leb128 (start
, & bytes_read
, 0);
7413 start
+= bytes_read
;
7415 form
= read_leb128 (start
, & bytes_read
, 0);
7416 start
+= bytes_read
;
7419 add_abbrev_attr (attribute
, form
);
7421 while (attribute
!= 0);
7428 get_TAG_name (unsigned long tag
)
7432 case DW_TAG_padding
: return "DW_TAG_padding";
7433 case DW_TAG_array_type
: return "DW_TAG_array_type";
7434 case DW_TAG_class_type
: return "DW_TAG_class_type";
7435 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
7436 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
7437 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
7438 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
7439 case DW_TAG_label
: return "DW_TAG_label";
7440 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
7441 case DW_TAG_member
: return "DW_TAG_member";
7442 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
7443 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
7444 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
7445 case DW_TAG_string_type
: return "DW_TAG_string_type";
7446 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
7447 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
7448 case DW_TAG_typedef
: return "DW_TAG_typedef";
7449 case DW_TAG_union_type
: return "DW_TAG_union_type";
7450 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
7451 case DW_TAG_variant
: return "DW_TAG_variant";
7452 case DW_TAG_common_block
: return "DW_TAG_common_block";
7453 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
7454 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
7455 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
7456 case DW_TAG_module
: return "DW_TAG_module";
7457 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
7458 case DW_TAG_set_type
: return "DW_TAG_set_type";
7459 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
7460 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
7461 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
7462 case DW_TAG_base_type
: return "DW_TAG_base_type";
7463 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
7464 case DW_TAG_const_type
: return "DW_TAG_const_type";
7465 case DW_TAG_constant
: return "DW_TAG_constant";
7466 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
7467 case DW_TAG_file_type
: return "DW_TAG_file_type";
7468 case DW_TAG_friend
: return "DW_TAG_friend";
7469 case DW_TAG_namelist
: return "DW_TAG_namelist";
7470 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
7471 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
7472 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
7473 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
7474 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
7475 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
7476 case DW_TAG_try_block
: return "DW_TAG_try_block";
7477 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
7478 case DW_TAG_variable
: return "DW_TAG_variable";
7479 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
7480 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
7481 case DW_TAG_format_label
: return "DW_TAG_format_label";
7482 case DW_TAG_function_template
: return "DW_TAG_function_template";
7483 case DW_TAG_class_template
: return "DW_TAG_class_template";
7484 /* DWARF 2.1 values. */
7485 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
7486 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
7487 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
7488 case DW_TAG_namespace
: return "DW_TAG_namespace";
7489 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
7490 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
7491 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
7492 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
7494 case DW_TAG_upc_shared_type
: return "DW_TAG_upc_shared_type";
7495 case DW_TAG_upc_strict_type
: return "DW_TAG_upc_strict_type";
7496 case DW_TAG_upc_relaxed_type
: return "DW_TAG_upc_relaxed_type";
7499 static char buffer
[100];
7501 sprintf (buffer
, _("Unknown TAG value: %lx"), tag
);
7508 get_FORM_name (unsigned long form
)
7512 case DW_FORM_addr
: return "DW_FORM_addr";
7513 case DW_FORM_block2
: return "DW_FORM_block2";
7514 case DW_FORM_block4
: return "DW_FORM_block4";
7515 case DW_FORM_data2
: return "DW_FORM_data2";
7516 case DW_FORM_data4
: return "DW_FORM_data4";
7517 case DW_FORM_data8
: return "DW_FORM_data8";
7518 case DW_FORM_string
: return "DW_FORM_string";
7519 case DW_FORM_block
: return "DW_FORM_block";
7520 case DW_FORM_block1
: return "DW_FORM_block1";
7521 case DW_FORM_data1
: return "DW_FORM_data1";
7522 case DW_FORM_flag
: return "DW_FORM_flag";
7523 case DW_FORM_sdata
: return "DW_FORM_sdata";
7524 case DW_FORM_strp
: return "DW_FORM_strp";
7525 case DW_FORM_udata
: return "DW_FORM_udata";
7526 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
7527 case DW_FORM_ref1
: return "DW_FORM_ref1";
7528 case DW_FORM_ref2
: return "DW_FORM_ref2";
7529 case DW_FORM_ref4
: return "DW_FORM_ref4";
7530 case DW_FORM_ref8
: return "DW_FORM_ref8";
7531 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
7532 case DW_FORM_indirect
: return "DW_FORM_indirect";
7535 static char buffer
[100];
7537 sprintf (buffer
, _("Unknown FORM value: %lx"), form
);
7543 static unsigned char *
7544 display_block (unsigned char *data
, unsigned long length
)
7546 printf (_(" %lu byte block: "), length
);
7549 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
7555 decode_location_expression (unsigned char * data
,
7556 unsigned int pointer_size
,
7557 unsigned long length
,
7558 unsigned long cu_offset
)
7562 unsigned long uvalue
;
7563 unsigned char *end
= data
+ length
;
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 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
7830 uvalue
= read_leb128 (data
, &bytes_read
, 0);
7832 printf ("DW_OP_bregx: %lu %ld", uvalue
,
7833 read_leb128 (data
, &bytes_read
, 1));
7837 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
7840 case DW_OP_deref_size
:
7841 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
7843 case DW_OP_xderef_size
:
7844 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
7847 printf ("DW_OP_nop");
7850 /* DWARF 3 extensions. */
7851 case DW_OP_push_object_address
:
7852 printf ("DW_OP_push_object_address");
7855 /* XXX: Strictly speaking for 64-bit DWARF3 files
7856 this ought to be an 8-byte wide computation. */
7857 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2) + cu_offset
);
7861 /* XXX: Strictly speaking for 64-bit DWARF3 files
7862 this ought to be an 8-byte wide computation. */
7863 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4) + cu_offset
);
7866 case DW_OP_call_ref
:
7867 printf ("DW_OP_call_ref");
7870 /* GNU extensions. */
7871 case DW_OP_GNU_push_tls_address
:
7872 printf ("DW_OP_GNU_push_tls_address");
7876 if (op
>= DW_OP_lo_user
7877 && op
<= DW_OP_hi_user
)
7878 printf (_("(User defined location op)"));
7880 printf (_("(Unknown location op)"));
7881 /* No way to tell where the next op is, so just bail. */
7885 /* Separate the ops. */
7891 /* Decode a DW_AT_ranges attribute for 64bit DWARF3 . */
7894 decode_64bit_range (unsigned long offset
, bfd_vma base_address
)
7896 const char * start
= debug_range_contents
+ offset
;
7897 const char * end
= debug_range_contents
+ debug_range_size
;
7904 a
= byte_get ((unsigned char *) start
, 8);
7905 b
= byte_get ((unsigned char *) start
+ 8, 8);
7907 if (a
== 0xffffffff)
7911 else if (a
== 0 && b
== 0)
7914 printf (_(" [corrupt: start > end]"));
7918 print_vma (base_address
+ a
, PREFIX_HEX
);
7920 print_vma (base_address
+ b
, PREFIX_HEX
);
7926 while (start
< end
);
7929 /* Decode a DW_AT_ranges attribute. */
7932 decode_range (unsigned long offset
, bfd_vma base_address
)
7937 if (offset
>= (debug_range_size
- 8))
7939 printf (_("[corrupt: offset is outside the .debug_ranges section]"));
7943 /* Since all entries in the .debug_ranges section are pairs of either
7944 4-byte integers (32-bit DWARF3) or 8-byte integers (64-bit DWARF3)
7945 the offset should always be a multiple of 8 bytes. */
7948 printf (_("[corrupt: offset is not a multiple of 8]"));
7952 start
= debug_range_contents
+ offset
;
7955 /* Be paranoid - check to see if the previous
7956 two words were and end-of-range marker. */
7957 && (byte_get ((unsigned char *) start
- 4, 4) != 0
7958 || byte_get ((unsigned char *) start
- 8, 4) != 0))
7960 printf (_("[corrupt: offset is not at the start of a range]"));
7964 end
= debug_range_contents
+ debug_range_size
;
7972 a
= byte_get ((unsigned char *) start
, 4);
7973 b
= byte_get ((unsigned char *) start
+ 4, 4);
7975 if (a
== 0xffffffff)
7977 if (b
== 0xffffffff)
7979 decode_64bit_range (offset
, base_address
);
7985 else if (a
== 0 && b
== 0)
7988 printf (_("[corrupt: start > end]"));
7991 if (start
> debug_range_contents
+ offset
)
7994 printf (_("0x%lx - 0x%lx"),
7995 (unsigned long) base_address
+ a
,
7996 (unsigned long) base_address
+ b
);
8001 while (start
< end
);
8005 /* This structure records the information that
8006 we extract from the.debug_info section. */
8009 unsigned int pointer_size
;
8010 unsigned long cu_offset
;
8011 /* This is an array of offsets to the location list table. */
8012 unsigned long *loc_offsets
;
8013 unsigned int num_loc_offsets
;
8014 unsigned int max_loc_offsets
;
8018 static debug_info
* debug_information
= NULL
;
8019 static unsigned int num_debug_info_entries
= 0;
8020 static unsigned int last_pointer_size
= 0;
8021 static int warned_about_missing_comp_units
= FALSE
;
8023 static unsigned char *
8024 read_and_display_attr_value (unsigned long attribute
,
8026 unsigned char *data
,
8027 unsigned long cu_offset
,
8028 unsigned long pointer_size
,
8029 unsigned long offset_size
,
8031 debug_info
*debug_info_p
,
8034 static unsigned long saved_DW_AT_low_pc
= 0;
8035 unsigned long uvalue
= 0;
8036 unsigned char *block_start
= NULL
;
8044 case DW_FORM_ref_addr
:
8045 if (dwarf_version
== 2)
8047 uvalue
= byte_get (data
, pointer_size
);
8048 data
+= pointer_size
;
8050 else if (dwarf_version
== 3)
8052 uvalue
= byte_get (data
, offset_size
);
8053 data
+= offset_size
;
8057 error (_("Internal error: DWARF version is not 2 or 3.\n"));
8062 uvalue
= byte_get (data
, pointer_size
);
8063 data
+= pointer_size
;
8067 uvalue
= byte_get (data
, offset_size
);
8068 data
+= offset_size
;
8074 uvalue
= byte_get (data
++, 1);
8079 uvalue
= byte_get (data
, 2);
8085 uvalue
= byte_get (data
, 4);
8090 uvalue
= read_leb128 (data
, & bytes_read
, 1);
8094 case DW_FORM_ref_udata
:
8096 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8100 case DW_FORM_indirect
:
8101 form
= read_leb128 (data
, & bytes_read
, 0);
8104 printf (" %s", get_FORM_name (form
));
8105 return read_and_display_attr_value (attribute
, form
, data
,
8106 cu_offset
, pointer_size
,
8107 offset_size
, dwarf_version
,
8108 debug_info_p
, do_loc
);
8113 case DW_FORM_ref_addr
:
8115 printf (" <#%lx>", uvalue
);
8121 case DW_FORM_ref_udata
:
8123 printf (" <%lx>", uvalue
+ cu_offset
);
8129 printf (" %#lx", uvalue
);
8138 printf (" %ld", uvalue
);
8145 uvalue
= byte_get (data
, 4);
8146 printf (" %lx", uvalue
);
8147 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
8149 if ((do_loc
|| do_debug_loc
)
8150 && num_debug_info_entries
== 0)
8152 if (sizeof (uvalue
) == 8)
8153 uvalue
= byte_get (data
, 8);
8155 error (_("DW_FORM_data8 is unsupported when sizeof (unsigned long) != 8\n"));
8160 case DW_FORM_string
:
8162 printf (" %s", data
);
8163 data
+= strlen ((char *) data
) + 1;
8167 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8168 block_start
= data
+ bytes_read
;
8170 data
= block_start
+ uvalue
;
8172 data
= display_block (block_start
, uvalue
);
8175 case DW_FORM_block1
:
8176 uvalue
= byte_get (data
, 1);
8177 block_start
= data
+ 1;
8179 data
= block_start
+ uvalue
;
8181 data
= display_block (block_start
, uvalue
);
8184 case DW_FORM_block2
:
8185 uvalue
= byte_get (data
, 2);
8186 block_start
= data
+ 2;
8188 data
= block_start
+ uvalue
;
8190 data
= display_block (block_start
, uvalue
);
8193 case DW_FORM_block4
:
8194 uvalue
= byte_get (data
, 4);
8195 block_start
= data
+ 4;
8197 data
= block_start
+ uvalue
;
8199 data
= display_block (block_start
, uvalue
);
8204 printf (_(" (indirect string, offset: 0x%lx): %s"),
8205 uvalue
, fetch_indirect_string (uvalue
));
8208 case DW_FORM_indirect
:
8209 /* Handled above. */
8213 warn (_("Unrecognized form: %d\n"), form
);
8217 /* For some attributes we can display further information. */
8218 if ((do_loc
|| do_debug_loc
)
8219 && num_debug_info_entries
== 0)
8223 case DW_AT_frame_base
:
8224 case DW_AT_location
:
8225 case DW_AT_data_member_location
:
8226 case DW_AT_vtable_elem_location
:
8227 case DW_AT_allocated
:
8228 case DW_AT_associated
:
8229 case DW_AT_data_location
:
8231 case DW_AT_upper_bound
:
8232 case DW_AT_lower_bound
:
8233 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8235 /* Process location list. */
8236 unsigned int max
= debug_info_p
->max_loc_offsets
;
8237 unsigned int num
= debug_info_p
->num_loc_offsets
;
8239 if (max
== 0 || num
>= max
)
8242 debug_info_p
->loc_offsets
8243 = xrealloc (debug_info_p
->loc_offsets
,
8244 max
* sizeof (*debug_info_p
->loc_offsets
));
8245 debug_info_p
->max_loc_offsets
= max
;
8247 debug_info_p
->loc_offsets
[num
] = uvalue
;
8248 debug_info_p
->num_loc_offsets
++;
8267 case DW_INL_not_inlined
:
8268 printf (_("(not inlined)"));
8270 case DW_INL_inlined
:
8271 printf (_("(inlined)"));
8273 case DW_INL_declared_not_inlined
:
8274 printf (_("(declared as inline but ignored)"));
8276 case DW_INL_declared_inlined
:
8277 printf (_("(declared as inline and inlined)"));
8280 printf (_(" (Unknown inline attribute value: %lx)"), uvalue
);
8285 case DW_AT_language
:
8288 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
8289 case DW_LANG_C89
: printf ("(ANSI C)"); break;
8290 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
8291 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
8292 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
8293 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
8294 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
8295 case DW_LANG_Ada83
: printf ("(Ada)"); break;
8296 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
8297 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
8298 /* DWARF 2.1 values. */
8299 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
8300 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
8301 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
8302 /* MIPS extension. */
8303 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
8304 /* UPC extension. */
8305 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
8307 printf ("(Unknown: %lx)", uvalue
);
8312 case DW_AT_encoding
:
8315 case DW_ATE_void
: printf ("(void)"); break;
8316 case DW_ATE_address
: printf ("(machine address)"); break;
8317 case DW_ATE_boolean
: printf ("(boolean)"); break;
8318 case DW_ATE_complex_float
: printf ("(complex float)"); break;
8319 case DW_ATE_float
: printf ("(float)"); break;
8320 case DW_ATE_signed
: printf ("(signed)"); break;
8321 case DW_ATE_signed_char
: printf ("(signed char)"); break;
8322 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
8323 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
8324 /* DWARF 2.1 value. */
8325 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
8327 if (uvalue
>= DW_ATE_lo_user
8328 && uvalue
<= DW_ATE_hi_user
)
8329 printf ("(user defined type)");
8331 printf ("(unknown type)");
8336 case DW_AT_accessibility
:
8339 case DW_ACCESS_public
: printf ("(public)"); break;
8340 case DW_ACCESS_protected
: printf ("(protected)"); break;
8341 case DW_ACCESS_private
: printf ("(private)"); break;
8343 printf ("(unknown accessibility)");
8348 case DW_AT_visibility
:
8351 case DW_VIS_local
: printf ("(local)"); break;
8352 case DW_VIS_exported
: printf ("(exported)"); break;
8353 case DW_VIS_qualified
: printf ("(qualified)"); break;
8354 default: printf ("(unknown visibility)"); break;
8358 case DW_AT_virtuality
:
8361 case DW_VIRTUALITY_none
: printf ("(none)"); break;
8362 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
8363 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
8364 default: printf ("(unknown virtuality)"); break;
8368 case DW_AT_identifier_case
:
8371 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
8372 case DW_ID_up_case
: printf ("(up_case)"); break;
8373 case DW_ID_down_case
: printf ("(down_case)"); break;
8374 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
8375 default: printf ("(unknown case)"); break;
8379 case DW_AT_calling_convention
:
8382 case DW_CC_normal
: printf ("(normal)"); break;
8383 case DW_CC_program
: printf ("(program)"); break;
8384 case DW_CC_nocall
: printf ("(nocall)"); break;
8386 if (uvalue
>= DW_CC_lo_user
8387 && uvalue
<= DW_CC_hi_user
)
8388 printf ("(user defined)");
8390 printf ("(unknown convention)");
8394 case DW_AT_ordering
:
8397 case -1: printf ("(undefined)"); break;
8398 case 0: printf ("(row major)"); break;
8399 case 1: printf ("(column major)"); break;
8403 case DW_AT_frame_base
:
8404 case DW_AT_location
:
8405 case DW_AT_data_member_location
:
8406 case DW_AT_vtable_elem_location
:
8407 case DW_AT_allocated
:
8408 case DW_AT_associated
:
8409 case DW_AT_data_location
:
8411 case DW_AT_upper_bound
:
8412 case DW_AT_lower_bound
:
8416 decode_location_expression (block_start
, pointer_size
, uvalue
, cu_offset
);
8419 else if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8420 printf (_("(location list)"));
8425 /* This is a hack. We keep track of the DW_AT_low_pc attributes
8426 and use them when decoding DW_AT_ranges attributes. The
8427 assumption here is that we are decoding the attributes in order
8428 and so the correct base address for the range is the low_pc. */
8429 saved_DW_AT_low_pc
= uvalue
;
8433 decode_range (uvalue
, saved_DW_AT_low_pc
);
8444 get_AT_name (unsigned long attribute
)
8448 case DW_AT_sibling
: return "DW_AT_sibling";
8449 case DW_AT_location
: return "DW_AT_location";
8450 case DW_AT_name
: return "DW_AT_name";
8451 case DW_AT_ordering
: return "DW_AT_ordering";
8452 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
8453 case DW_AT_byte_size
: return "DW_AT_byte_size";
8454 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
8455 case DW_AT_bit_size
: return "DW_AT_bit_size";
8456 case DW_AT_element_list
: return "DW_AT_element_list";
8457 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
8458 case DW_AT_low_pc
: return "DW_AT_low_pc";
8459 case DW_AT_high_pc
: return "DW_AT_high_pc";
8460 case DW_AT_language
: return "DW_AT_language";
8461 case DW_AT_member
: return "DW_AT_member";
8462 case DW_AT_discr
: return "DW_AT_discr";
8463 case DW_AT_discr_value
: return "DW_AT_discr_value";
8464 case DW_AT_visibility
: return "DW_AT_visibility";
8465 case DW_AT_import
: return "DW_AT_import";
8466 case DW_AT_string_length
: return "DW_AT_string_length";
8467 case DW_AT_common_reference
: return "DW_AT_common_reference";
8468 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
8469 case DW_AT_const_value
: return "DW_AT_const_value";
8470 case DW_AT_containing_type
: return "DW_AT_containing_type";
8471 case DW_AT_default_value
: return "DW_AT_default_value";
8472 case DW_AT_inline
: return "DW_AT_inline";
8473 case DW_AT_is_optional
: return "DW_AT_is_optional";
8474 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
8475 case DW_AT_producer
: return "DW_AT_producer";
8476 case DW_AT_prototyped
: return "DW_AT_prototyped";
8477 case DW_AT_return_addr
: return "DW_AT_return_addr";
8478 case DW_AT_start_scope
: return "DW_AT_start_scope";
8479 case DW_AT_stride_size
: return "DW_AT_stride_size";
8480 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
8481 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
8482 case DW_AT_accessibility
: return "DW_AT_accessibility";
8483 case DW_AT_address_class
: return "DW_AT_address_class";
8484 case DW_AT_artificial
: return "DW_AT_artificial";
8485 case DW_AT_base_types
: return "DW_AT_base_types";
8486 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
8487 case DW_AT_count
: return "DW_AT_count";
8488 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
8489 case DW_AT_decl_column
: return "DW_AT_decl_column";
8490 case DW_AT_decl_file
: return "DW_AT_decl_file";
8491 case DW_AT_decl_line
: return "DW_AT_decl_line";
8492 case DW_AT_declaration
: return "DW_AT_declaration";
8493 case DW_AT_discr_list
: return "DW_AT_discr_list";
8494 case DW_AT_encoding
: return "DW_AT_encoding";
8495 case DW_AT_external
: return "DW_AT_external";
8496 case DW_AT_frame_base
: return "DW_AT_frame_base";
8497 case DW_AT_friend
: return "DW_AT_friend";
8498 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
8499 case DW_AT_macro_info
: return "DW_AT_macro_info";
8500 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
8501 case DW_AT_priority
: return "DW_AT_priority";
8502 case DW_AT_segment
: return "DW_AT_segment";
8503 case DW_AT_specification
: return "DW_AT_specification";
8504 case DW_AT_static_link
: return "DW_AT_static_link";
8505 case DW_AT_type
: return "DW_AT_type";
8506 case DW_AT_use_location
: return "DW_AT_use_location";
8507 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
8508 case DW_AT_virtuality
: return "DW_AT_virtuality";
8509 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
8510 /* DWARF 2.1 values. */
8511 case DW_AT_allocated
: return "DW_AT_allocated";
8512 case DW_AT_associated
: return "DW_AT_associated";
8513 case DW_AT_data_location
: return "DW_AT_data_location";
8514 case DW_AT_stride
: return "DW_AT_stride";
8515 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
8516 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
8517 case DW_AT_extension
: return "DW_AT_extension";
8518 case DW_AT_ranges
: return "DW_AT_ranges";
8519 case DW_AT_trampoline
: return "DW_AT_trampoline";
8520 case DW_AT_call_column
: return "DW_AT_call_column";
8521 case DW_AT_call_file
: return "DW_AT_call_file";
8522 case DW_AT_call_line
: return "DW_AT_call_line";
8523 /* SGI/MIPS extensions. */
8524 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
8525 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
8526 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
8527 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
8528 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
8529 case DW_AT_MIPS_software_pipeline_depth
:
8530 return "DW_AT_MIPS_software_pipeline_depth";
8531 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
8532 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
8533 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
8534 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
8535 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
8536 /* GNU extensions. */
8537 case DW_AT_sf_names
: return "DW_AT_sf_names";
8538 case DW_AT_src_info
: return "DW_AT_src_info";
8539 case DW_AT_mac_info
: return "DW_AT_mac_info";
8540 case DW_AT_src_coords
: return "DW_AT_src_coords";
8541 case DW_AT_body_begin
: return "DW_AT_body_begin";
8542 case DW_AT_body_end
: return "DW_AT_body_end";
8543 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
8544 /* UPC extension. */
8545 case DW_AT_upc_threads_scaled
: return "DW_AT_upc_threads_scaled";
8548 static char buffer
[100];
8550 sprintf (buffer
, _("Unknown AT value: %lx"), attribute
);
8556 static unsigned char *
8557 read_and_display_attr (unsigned long attribute
,
8559 unsigned char *data
,
8560 unsigned long cu_offset
,
8561 unsigned long pointer_size
,
8562 unsigned long offset_size
,
8564 debug_info
*debug_info_p
,
8568 printf (" %-18s:", get_AT_name (attribute
));
8569 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
8570 pointer_size
, offset_size
,
8571 dwarf_version
, debug_info_p
,
8579 /* Process the contents of a .debug_info section. If do_loc is non-zero
8580 then we are scanning for location lists and we do not want to display
8581 anything to the user. */
8584 process_debug_info (Elf_Internal_Shdr
*section
, unsigned char *start
,
8585 FILE *file
, int do_loc
)
8587 unsigned char *end
= start
+ section
->sh_size
;
8588 unsigned char *section_begin
;
8590 unsigned int num_units
= 0;
8592 if ((do_loc
|| do_debug_loc
)
8593 && num_debug_info_entries
== 0)
8595 unsigned long length
;
8597 /* First scan the section to get the number of comp units. */
8598 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
8601 /* Read the first 4 bytes. For a 32-bit DWARF section, this
8602 will be the length. For a 64-bit DWARF section, it'll be
8603 the escape code 0xffffffff followed by an 8 byte length. */
8604 length
= byte_get (section_begin
, 4);
8606 if (length
== 0xffffffff)
8608 length
= byte_get (section_begin
+ 4, 8);
8609 section_begin
+= length
+ 12;
8612 section_begin
+= length
+ 4;
8617 error (_("No comp units in .debug_info section ?"));
8621 /* Then allocate an array to hold the information. */
8622 debug_information
= malloc (num_units
*
8623 sizeof (* debug_information
));
8624 if (debug_information
== NULL
)
8626 error (_("Not enough memory for a debug info array of %u entries"),
8634 printf (_("The section %s contains:\n\n"),
8635 SECTION_NAME (section
));
8637 load_debug_str (file
);
8638 load_debug_loc (file
);
8639 load_debug_range (file
);
8642 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
8644 DWARF2_Internal_CompUnit compunit
;
8645 unsigned char *hdrptr
;
8646 unsigned char *cu_abbrev_offset_ptr
;
8647 unsigned char *tags
;
8649 unsigned long cu_offset
;
8651 int initial_length_size
;
8655 compunit
.cu_length
= byte_get (hdrptr
, 4);
8658 if (compunit
.cu_length
== 0xffffffff)
8660 compunit
.cu_length
= byte_get (hdrptr
, 8);
8663 initial_length_size
= 12;
8668 initial_length_size
= 4;
8671 compunit
.cu_version
= byte_get (hdrptr
, 2);
8674 cu_offset
= start
- section_begin
;
8675 start
+= compunit
.cu_length
+ initial_length_size
;
8677 if (elf_header
.e_type
== ET_REL
8678 && !debug_apply_rela_addends (file
, section
, offset_size
,
8679 section_begin
, hdrptr
, start
))
8682 cu_abbrev_offset_ptr
= hdrptr
;
8683 compunit
.cu_abbrev_offset
= byte_get (hdrptr
, offset_size
);
8684 hdrptr
+= offset_size
;
8686 compunit
.cu_pointer_size
= byte_get (hdrptr
, 1);
8688 if ((do_loc
|| do_debug_loc
)
8689 && num_debug_info_entries
== 0)
8691 debug_information
[unit
].cu_offset
= cu_offset
;
8692 debug_information
[unit
].pointer_size
8693 = compunit
.cu_pointer_size
;
8694 debug_information
[unit
].loc_offsets
= NULL
;
8695 debug_information
[unit
].max_loc_offsets
= 0;
8696 debug_information
[unit
].num_loc_offsets
= 0;
8703 printf (_(" Compilation Unit @ %lx:\n"), cu_offset
);
8704 printf (_(" Length: %ld\n"), compunit
.cu_length
);
8705 printf (_(" Version: %d\n"), compunit
.cu_version
);
8706 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
8707 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
8710 if (compunit
.cu_version
!= 2 && compunit
.cu_version
!= 3)
8712 warn (_("Only version 2 and 3 DWARF debug information is currently supported.\n"));
8718 /* Read in the abbrevs used by this compilation unit. */
8720 Elf_Internal_Shdr
*sec
;
8721 unsigned char *begin
;
8723 /* Locate the .debug_abbrev section and process it. */
8724 sec
= find_section (".debug_abbrev");
8727 warn (_("Unable to locate .debug_abbrev section!\n"));
8731 begin
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
8732 _("debug_abbrev section data"));
8736 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
8737 begin
+ sec
->sh_size
);
8743 while (tags
< start
)
8746 unsigned long abbrev_number
;
8747 abbrev_entry
*entry
;
8750 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
8753 /* A null DIE marks the end of a list of children. */
8754 if (abbrev_number
== 0)
8760 /* Scan through the abbreviation list until we reach the
8762 for (entry
= first_abbrev
;
8763 entry
&& entry
->entry
!= abbrev_number
;
8764 entry
= entry
->next
)
8769 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
8775 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
8777 (unsigned long) (tags
- section_begin
8780 get_TAG_name (entry
->tag
));
8782 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
8783 tags
= read_and_display_attr (attr
->attribute
,
8786 compunit
.cu_pointer_size
,
8788 compunit
.cu_version
,
8789 &debug_information
[unit
],
8792 if (entry
->children
)
8797 /* Set num_debug_info_entries here so that it can be used
8798 to check if we need to proecess .debug_loc section. */
8799 if ((do_loc
|| do_debug_loc
)
8800 && num_debug_info_entries
== 0)
8801 num_debug_info_entries
= num_units
;
8805 free_debug_range ();
8815 /* Retrieve the pointer size associated with the given compilation unit.
8816 Optionally the offset of this unit into the .debug_info section is
8817 also retutned. If there is no .debug_info section then an error
8818 message is issued and 0 is returned. If the requested comp unit has
8819 not been defined in the .debug_info section then a warning message
8820 is issued and the last know pointer size is returned. This message
8821 is only issued once per section dumped per file dumped. */
8824 get_pointer_size_and_offset_of_comp_unit (unsigned int comp_unit
,
8825 const char * section_name
,
8826 unsigned long * offset_return
)
8828 unsigned long offset
= 0;
8830 if (num_debug_info_entries
== 0)
8831 error (_("%s section needs a populated .debug_info section\n"),
8834 else if (comp_unit
>= num_debug_info_entries
)
8836 if (!warned_about_missing_comp_units
)
8838 warn (_("%s section has more comp units than .debug_info section\n"),
8840 warn (_("assuming that the pointer size is %d, from the last comp unit in .debug_info\n\n"),
8842 warned_about_missing_comp_units
= TRUE
;
8847 last_pointer_size
= debug_information
[comp_unit
].pointer_size
;
8848 offset
= debug_information
[comp_unit
].cu_offset
;
8851 if (offset_return
!= NULL
)
8852 * offset_return
= offset
;
8854 return last_pointer_size
;
8857 /* Locate and scan the .debug_info section in the file and record the pointer
8858 sizes and offsets for the compilation units in it. Usually an executable
8859 will have just one pointer size, but this is not guaranteed, and so we try
8860 not to make any assumptions. Returns zero upon failure, or the number of
8861 compilation units upon success. */
8864 get_debug_info (FILE * file
)
8866 Elf_Internal_Shdr
* section
;
8867 unsigned char * start
;
8870 /* Reset the last pointer size so that we can issue correct error
8871 messages if we are displaying the contents of more than one section. */
8872 last_pointer_size
= 0;
8873 warned_about_missing_comp_units
= FALSE
;
8875 /* If we already have the information there is nothing else to do. */
8876 if (num_debug_info_entries
> 0)
8877 return num_debug_info_entries
;
8879 section
= find_section (".debug_info");
8880 if (section
== NULL
)
8883 start
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
8884 _("extracting information from .debug_info section"));
8888 ret
= process_debug_info (section
, start
, file
, 1);
8891 return ret
? num_debug_info_entries
: 0;
8895 display_debug_lines (Elf_Internal_Shdr
*section
,
8896 unsigned char *start
, FILE *file
)
8898 unsigned char *data
= start
;
8899 unsigned char *end
= start
+ section
->sh_size
;
8900 unsigned int comp_unit
= 0;
8902 printf (_("\nDump of debug contents of section %s:\n\n"),
8903 SECTION_NAME (section
));
8905 get_debug_info (file
);
8909 DWARF2_Internal_LineInfo info
;
8910 unsigned char *standard_opcodes
;
8911 unsigned char *end_of_sequence
;
8912 unsigned char *hdrptr
;
8913 unsigned int pointer_size
;
8914 int initial_length_size
;
8920 /* Check the length of the block. */
8921 info
.li_length
= byte_get (hdrptr
, 4);
8924 if (info
.li_length
== 0xffffffff)
8926 /* This section is 64-bit DWARF 3. */
8927 info
.li_length
= byte_get (hdrptr
, 8);
8930 initial_length_size
= 12;
8935 initial_length_size
= 4;
8938 if (info
.li_length
+ initial_length_size
> section
->sh_size
)
8941 (_("The line info appears to be corrupt - the section is too small\n"));
8945 /* Check its version number. */
8946 info
.li_version
= byte_get (hdrptr
, 2);
8948 if (info
.li_version
!= 2 && info
.li_version
!= 3)
8950 warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
8954 info
.li_prologue_length
= byte_get (hdrptr
, offset_size
);
8955 hdrptr
+= offset_size
;
8956 info
.li_min_insn_length
= byte_get (hdrptr
, 1);
8958 info
.li_default_is_stmt
= byte_get (hdrptr
, 1);
8960 info
.li_line_base
= byte_get (hdrptr
, 1);
8962 info
.li_line_range
= byte_get (hdrptr
, 1);
8964 info
.li_opcode_base
= byte_get (hdrptr
, 1);
8967 /* Sign extend the line base field. */
8968 info
.li_line_base
<<= 24;
8969 info
.li_line_base
>>= 24;
8971 /* Get the pointer size from the comp unit associated
8972 with this block of line number information. */
8973 pointer_size
= get_pointer_size_and_offset_of_comp_unit
8974 (comp_unit
, ".debug_lines", NULL
);
8977 printf (_(" Length: %ld\n"), info
.li_length
);
8978 printf (_(" DWARF Version: %d\n"), info
.li_version
);
8979 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
8980 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
8981 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
8982 printf (_(" Line Base: %d\n"), info
.li_line_base
);
8983 printf (_(" Line Range: %d\n"), info
.li_line_range
);
8984 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
8985 printf (_(" (Pointer size: %u)\n"), pointer_size
);
8987 end_of_sequence
= data
+ info
.li_length
+ initial_length_size
;
8989 reset_state_machine (info
.li_default_is_stmt
);
8991 /* Display the contents of the Opcodes table. */
8992 standard_opcodes
= hdrptr
;
8994 printf (_("\n Opcodes:\n"));
8996 for (i
= 1; i
< info
.li_opcode_base
; i
++)
8997 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
8999 /* Display the contents of the Directory table. */
9000 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
9003 printf (_("\n The Directory Table is empty.\n"));
9006 printf (_("\n The Directory Table:\n"));
9010 printf (_(" %s\n"), data
);
9012 data
+= strlen ((char *) data
) + 1;
9016 /* Skip the NUL at the end of the table. */
9019 /* Display the contents of the File Name table. */
9021 printf (_("\n The File Name Table is empty.\n"));
9024 printf (_("\n The File Name Table:\n"));
9025 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
9029 unsigned char *name
;
9032 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
9035 data
+= strlen ((char *) data
) + 1;
9037 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9039 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9041 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9043 printf (_("%s\n"), name
);
9047 /* Skip the NUL at the end of the table. */
9050 /* Now display the statements. */
9051 printf (_("\n Line Number Statements:\n"));
9053 while (data
< end_of_sequence
)
9055 unsigned char op_code
;
9061 if (op_code
>= info
.li_opcode_base
)
9063 op_code
-= info
.li_opcode_base
;
9064 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
9065 state_machine_regs
.address
+= adv
;
9066 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
9067 op_code
, adv
, state_machine_regs
.address
);
9068 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
9069 state_machine_regs
.line
+= adv
;
9070 printf (_(" and Line by %d to %d\n"),
9071 adv
, state_machine_regs
.line
);
9073 else switch (op_code
)
9075 case DW_LNS_extended_op
:
9076 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
9081 printf (_(" Copy\n"));
9084 case DW_LNS_advance_pc
:
9085 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
9087 state_machine_regs
.address
+= adv
;
9088 printf (_(" Advance PC by %d to %lx\n"), adv
,
9089 state_machine_regs
.address
);
9092 case DW_LNS_advance_line
:
9093 adv
= read_leb128 (data
, & bytes_read
, 1);
9095 state_machine_regs
.line
+= adv
;
9096 printf (_(" Advance Line by %d to %d\n"), adv
,
9097 state_machine_regs
.line
);
9100 case DW_LNS_set_file
:
9101 adv
= read_leb128 (data
, & bytes_read
, 0);
9103 printf (_(" Set File Name to entry %d in the File Name Table\n"),
9105 state_machine_regs
.file
= adv
;
9108 case DW_LNS_set_column
:
9109 adv
= read_leb128 (data
, & bytes_read
, 0);
9111 printf (_(" Set column to %d\n"), adv
);
9112 state_machine_regs
.column
= adv
;
9115 case DW_LNS_negate_stmt
:
9116 adv
= state_machine_regs
.is_stmt
;
9118 printf (_(" Set is_stmt to %d\n"), adv
);
9119 state_machine_regs
.is_stmt
= adv
;
9122 case DW_LNS_set_basic_block
:
9123 printf (_(" Set basic block\n"));
9124 state_machine_regs
.basic_block
= 1;
9127 case DW_LNS_const_add_pc
:
9128 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
9129 * info
.li_min_insn_length
);
9130 state_machine_regs
.address
+= adv
;
9131 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
9132 state_machine_regs
.address
);
9135 case DW_LNS_fixed_advance_pc
:
9136 adv
= byte_get (data
, 2);
9138 state_machine_regs
.address
+= adv
;
9139 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
9140 adv
, state_machine_regs
.address
);
9143 case DW_LNS_set_prologue_end
:
9144 printf (_(" Set prologue_end to true\n"));
9147 case DW_LNS_set_epilogue_begin
:
9148 printf (_(" Set epilogue_begin to true\n"));
9151 case DW_LNS_set_isa
:
9152 adv
= read_leb128 (data
, & bytes_read
, 0);
9154 printf (_(" Set ISA to %d\n"), adv
);
9158 printf (_(" Unknown opcode %d with operands: "), op_code
);
9160 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
9162 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
9163 i
== 1 ? "" : ", ");
9177 display_debug_pubnames (Elf_Internal_Shdr
*section
,
9178 unsigned char *start
,
9179 FILE *file ATTRIBUTE_UNUSED
)
9181 DWARF2_Internal_PubNames pubnames
;
9184 end
= start
+ section
->sh_size
;
9186 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9190 unsigned char *data
;
9191 unsigned long offset
;
9192 int offset_size
, initial_length_size
;
9196 pubnames
.pn_length
= byte_get (data
, 4);
9198 if (pubnames
.pn_length
== 0xffffffff)
9200 pubnames
.pn_length
= byte_get (data
, 8);
9203 initial_length_size
= 12;
9208 initial_length_size
= 4;
9211 pubnames
.pn_version
= byte_get (data
, 2);
9213 pubnames
.pn_offset
= byte_get (data
, offset_size
);
9214 data
+= offset_size
;
9215 pubnames
.pn_size
= byte_get (data
, offset_size
);
9216 data
+= offset_size
;
9218 start
+= pubnames
.pn_length
+ initial_length_size
;
9220 if (pubnames
.pn_version
!= 2 && pubnames
.pn_version
!= 3)
9222 static int warned
= 0;
9226 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
9233 printf (_(" Length: %ld\n"),
9234 pubnames
.pn_length
);
9235 printf (_(" Version: %d\n"),
9236 pubnames
.pn_version
);
9237 printf (_(" Offset into .debug_info section: %ld\n"),
9238 pubnames
.pn_offset
);
9239 printf (_(" Size of area in .debug_info section: %ld\n"),
9242 printf (_("\n Offset\tName\n"));
9246 offset
= byte_get (data
, offset_size
);
9250 data
+= offset_size
;
9251 printf (" %-6ld\t\t%s\n", offset
, data
);
9252 data
+= strlen ((char *) data
) + 1;
9255 while (offset
!= 0);
9263 display_debug_macinfo (Elf_Internal_Shdr
*section
,
9264 unsigned char *start
,
9265 FILE *file ATTRIBUTE_UNUSED
)
9267 unsigned char *end
= start
+ section
->sh_size
;
9268 unsigned char *curr
= start
;
9269 unsigned int bytes_read
;
9270 enum dwarf_macinfo_record_type op
;
9272 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9276 unsigned int lineno
;
9284 case DW_MACINFO_start_file
:
9286 unsigned int filenum
;
9288 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9290 filenum
= read_leb128 (curr
, & bytes_read
, 0);
9293 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
9298 case DW_MACINFO_end_file
:
9299 printf (_(" DW_MACINFO_end_file\n"));
9302 case DW_MACINFO_define
:
9303 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9306 curr
+= strlen (string
) + 1;
9307 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
9311 case DW_MACINFO_undef
:
9312 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9315 curr
+= strlen (string
) + 1;
9316 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
9320 case DW_MACINFO_vendor_ext
:
9322 unsigned int constant
;
9324 constant
= read_leb128 (curr
, & bytes_read
, 0);
9327 curr
+= strlen (string
) + 1;
9328 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
9340 display_debug_abbrev (Elf_Internal_Shdr
*section
,
9341 unsigned char *start
,
9342 FILE *file ATTRIBUTE_UNUSED
)
9344 abbrev_entry
*entry
;
9345 unsigned char *end
= start
+ section
->sh_size
;
9347 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9351 start
= process_abbrev_section (start
, end
);
9353 if (first_abbrev
== NULL
)
9356 printf (_(" Number TAG\n"));
9358 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
9362 printf (_(" %ld %s [%s]\n"),
9364 get_TAG_name (entry
->tag
),
9365 entry
->children
? _("has children") : _("no children"));
9367 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
9368 printf (_(" %-18s %s\n"),
9369 get_AT_name (attr
->attribute
),
9370 get_FORM_name (attr
->form
));
9383 display_debug_loc (Elf_Internal_Shdr
*section
,
9384 unsigned char *start
, FILE *file
)
9386 unsigned char *section_end
;
9387 unsigned long bytes
;
9388 unsigned char *section_begin
= start
;
9390 unsigned int num_loc_list
= 0;
9391 unsigned long last_offset
= 0;
9392 unsigned int first
= 0;
9395 int seen_first_offset
= 0;
9396 int use_debug_info
= 1;
9397 unsigned char *next
;
9399 addr
= section
->sh_addr
;
9400 bytes
= section
->sh_size
;
9401 section_end
= start
+ bytes
;
9405 printf (_("\nThe .debug_loc section is empty.\n"));
9409 get_debug_info (file
);
9411 /* Check the order of location list in .debug_info section. If
9412 offsets of location lists are in the ascending order, we can
9413 use `debug_information' directly. */
9414 for (i
= 0; i
< num_debug_info_entries
; i
++)
9418 num
= debug_information
[i
].num_loc_offsets
;
9419 num_loc_list
+= num
;
9421 /* Check if we can use `debug_information' directly. */
9422 if (use_debug_info
&& num
!= 0)
9424 if (!seen_first_offset
)
9426 /* This is the first location list. */
9427 last_offset
= debug_information
[i
].loc_offsets
[0];
9429 seen_first_offset
= 1;
9435 for (; j
< num
; j
++)
9438 debug_information
[i
].loc_offsets
[j
])
9443 last_offset
= debug_information
[i
].loc_offsets
[j
];
9448 if (!use_debug_info
)
9449 /* FIXME: Should we handle this case? */
9450 error (_("Location lists in .debug_info section aren't in ascending order!\n"));
9452 if (!seen_first_offset
)
9453 error (_("No location lists in .debug_info section!\n"));
9455 if (debug_information
[first
].loc_offsets
[0] != 0)
9456 warn (_("Location lists in .debug_loc section start at 0x%lx\n"),
9457 debug_information
[first
].loc_offsets
[0]);
9459 printf (_("Contents of the .debug_loc section:\n\n"));
9460 printf (_(" Offset Begin End Expression\n"));
9462 seen_first_offset
= 0;
9463 for (i
= first
; i
< num_debug_info_entries
; i
++)
9465 unsigned long begin
;
9467 unsigned short length
;
9468 unsigned long offset
;
9469 unsigned int pointer_size
;
9470 unsigned long cu_offset
;
9472 pointer_size
= debug_information
[i
].pointer_size
;
9473 cu_offset
= debug_information
[i
].cu_offset
;
9475 for (j
= 0; j
< debug_information
[i
].num_loc_offsets
; j
++)
9477 offset
= debug_information
[i
].loc_offsets
[j
];
9478 next
= section_begin
+ offset
;
9480 if (!seen_first_offset
)
9481 seen_first_offset
= 1;
9485 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
9486 start
- section_begin
, next
- section_begin
);
9487 else if (start
> next
)
9488 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
9489 start
- section_begin
, next
- section_begin
);
9495 begin
= byte_get (start
, pointer_size
);
9496 start
+= pointer_size
;
9497 end
= byte_get (start
, pointer_size
);
9498 start
+= pointer_size
;
9500 if (begin
== 0 && end
== 0)
9503 /* For now, skip any base address specifiers. */
9504 if (begin
== 0xffffffff)
9510 length
= byte_get (start
, 2);
9513 printf (" %8.8lx %8.8lx %8.8lx (",
9514 offset
, begin
, end
);
9515 decode_location_expression (start
, pointer_size
, length
,
9520 warn ("Bad location list at %8.8lx from %8.8lx to %8.8lx\n",
9521 offset
, begin
, end
);
9526 if (j
< debug_information
[i
].num_loc_offsets
-1)
9527 printf (_(" <End of list>"));
9535 display_debug_str (Elf_Internal_Shdr
*section
,
9536 unsigned char *start
,
9537 FILE *file ATTRIBUTE_UNUSED
)
9539 unsigned long bytes
;
9542 addr
= section
->sh_addr
;
9543 bytes
= section
->sh_size
;
9547 printf (_("\nThe .debug_str section is empty.\n"));
9551 printf (_("Contents of the .debug_str section:\n\n"));
9559 lbytes
= (bytes
> 16 ? 16 : bytes
);
9561 printf (" 0x%8.8lx ", (unsigned long) addr
);
9563 for (j
= 0; j
< 16; j
++)
9566 printf ("%2.2x", start
[j
]);
9574 for (j
= 0; j
< lbytes
; j
++)
9577 if (k
>= ' ' && k
< 0x80)
9597 display_debug_info (Elf_Internal_Shdr
* section
,
9598 unsigned char * start
, FILE * file
)
9600 return process_debug_info (section
, start
, file
, 0);
9605 display_debug_aranges (Elf_Internal_Shdr
*section
,
9606 unsigned char *start
,
9607 FILE *file ATTRIBUTE_UNUSED
)
9609 unsigned char *end
= start
+ section
->sh_size
;
9611 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
9615 unsigned char *hdrptr
;
9616 DWARF2_Internal_ARange arange
;
9617 unsigned char *ranges
;
9618 unsigned long length
;
9619 unsigned long address
;
9622 int initial_length_size
;
9626 arange
.ar_length
= byte_get (hdrptr
, 4);
9629 if (arange
.ar_length
== 0xffffffff)
9631 arange
.ar_length
= byte_get (hdrptr
, 8);
9634 initial_length_size
= 12;
9639 initial_length_size
= 4;
9642 arange
.ar_version
= byte_get (hdrptr
, 2);
9645 arange
.ar_info_offset
= byte_get (hdrptr
, offset_size
);
9646 hdrptr
+= offset_size
;
9648 arange
.ar_pointer_size
= byte_get (hdrptr
, 1);
9651 arange
.ar_segment_size
= byte_get (hdrptr
, 1);
9654 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
9656 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
9660 printf (_(" Length: %ld\n"), arange
.ar_length
);
9661 printf (_(" Version: %d\n"), arange
.ar_version
);
9662 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
9663 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
9664 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
9666 printf (_("\n Address Length\n"));
9670 /* Must pad to an alignment boundary that is twice the pointer size. */
9671 excess
= (hdrptr
- start
) % (2 * arange
.ar_pointer_size
);
9673 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
9677 address
= byte_get (ranges
, arange
.ar_pointer_size
);
9679 ranges
+= arange
.ar_pointer_size
;
9681 length
= byte_get (ranges
, arange
.ar_pointer_size
);
9683 ranges
+= arange
.ar_pointer_size
;
9685 /* A pair of zeros marks the end of the list. */
9686 if (address
== 0 && length
== 0)
9689 printf (" %8.8lx %lu\n", address
, length
);
9692 start
+= arange
.ar_length
+ initial_length_size
;
9701 display_64bit_debug_ranges (unsigned char * start
, unsigned char * end
)
9703 bfd_vma base_address
= 0;
9709 a
= byte_get (start
, 8);
9710 b
= byte_get (start
+ 8, 8);
9712 if (a
== 0xffffffffffffffffLL
)
9714 printf (_(" set base address to "));
9715 print_vma (b
, PREFIX_HEX
);
9718 else if (a
== 0 && b
== 0)
9719 printf ( _("end of range"));
9721 printf (_(" <corrupt range entry, start is greater than end>"));
9722 else if (base_address
== 0)
9724 printf ("range from base address + ");
9725 print_vma (a
, PREFIX_HEX
);
9726 printf (" to base address + ");
9727 print_vma (b
, PREFIX_HEX
);
9731 printf ("range from ");
9732 print_vma (base_address
+ a
, PREFIX_HEX
);
9734 print_vma (base_address
+ b
, PREFIX_HEX
);
9745 display_debug_ranges (Elf_Internal_Shdr
*section
,
9746 unsigned char *start
,
9747 FILE *file ATTRIBUTE_UNUSED
)
9749 unsigned long base_address
= 0;
9750 unsigned char *end
= start
+ section
->sh_size
;
9752 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
9759 a
= byte_get (start
, 4);
9760 b
= byte_get (start
+ 4, 4);
9762 if (a
== 0xffffffff)
9764 /* Attempt to handle 64-bit DWARF3 format. This assumes
9765 that in a 32-bit DWARF3 file the base address will
9766 never be 0xffffffff, and that the .debug_ranges section
9767 will never contain a mixture of 32-bit and 64-bit entries. */
9768 if (b
== 0xffffffff)
9769 return display_64bit_debug_ranges (start
, end
);
9771 printf (_(" set base address to 0x%lx\n"), b
);
9774 else if (a
== 0 && b
== 0)
9775 printf (_(" end of range\n"));
9777 printf (_(" <corrupt range entry, start is greater than end>\n"));
9778 else if (base_address
== 0)
9779 printf (_(" range from base address + 0x%lx to base address + 0x%lx\n"), a
, b
);
9781 printf (_(" range from 0x%lx to 0x%lx\n"), base_address
+ a
, base_address
+ b
);
9789 typedef struct Frame_Chunk
9791 struct Frame_Chunk
*next
;
9792 unsigned char *chunk_start
;
9794 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
9795 short int *col_type
;
9798 unsigned int code_factor
;
9800 unsigned long pc_begin
;
9801 unsigned long pc_range
;
9805 unsigned char fde_encoding
;
9806 unsigned char cfa_exp
;
9810 /* A marker for a col_type that means this column was never referenced
9811 in the frame info. */
9812 #define DW_CFA_unreferenced (-1)
9815 frame_need_space (Frame_Chunk
*fc
, int reg
)
9817 int prev
= fc
->ncols
;
9819 if (reg
< fc
->ncols
)
9822 fc
->ncols
= reg
+ 1;
9823 fc
->col_type
= xrealloc (fc
->col_type
, fc
->ncols
* sizeof (short int));
9824 fc
->col_offset
= xrealloc (fc
->col_offset
, fc
->ncols
* sizeof (int));
9826 while (prev
< fc
->ncols
)
9828 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
9829 fc
->col_offset
[prev
] = 0;
9835 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, int *max_regs
)
9840 if (*max_regs
< fc
->ncols
)
9841 *max_regs
= fc
->ncols
;
9843 if (*need_col_headers
)
9845 *need_col_headers
= 0;
9847 printf (" LOC CFA ");
9849 for (r
= 0; r
< *max_regs
; r
++)
9850 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
9855 printf ("r%-4d", r
);
9861 printf ("%08lx ", fc
->pc_begin
);
9863 strcpy (tmp
, "exp");
9865 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
9866 printf ("%-8s ", tmp
);
9868 for (r
= 0; r
< fc
->ncols
; r
++)
9870 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
9872 switch (fc
->col_type
[r
])
9874 case DW_CFA_undefined
:
9877 case DW_CFA_same_value
:
9881 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
9883 case DW_CFA_register
:
9884 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
9886 case DW_CFA_expression
:
9887 strcpy (tmp
, "exp");
9890 strcpy (tmp
, "n/a");
9893 printf ("%-5s", tmp
);
9900 size_of_encoded_value (int encoding
)
9902 switch (encoding
& 0x7)
9905 case 0: return is_32bit_elf
? 4 : 8;
9913 get_encoded_value (unsigned char *data
, int encoding
)
9915 int size
= size_of_encoded_value (encoding
);
9916 if (encoding
& DW_EH_PE_signed
)
9917 return byte_get_signed (data
, size
);
9919 return byte_get (data
, size
);
9922 #define GET(N) byte_get (start, N); start += N
9923 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
9924 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
9927 display_debug_frames (Elf_Internal_Shdr
*section
,
9928 unsigned char *start
,
9929 FILE *file ATTRIBUTE_UNUSED
)
9931 unsigned char *end
= start
+ section
->sh_size
;
9932 unsigned char *section_start
= start
;
9933 Frame_Chunk
*chunks
= 0;
9934 Frame_Chunk
*remembered_state
= 0;
9936 int is_eh
= streq (SECTION_NAME (section
), ".eh_frame");
9939 int addr_size
= is_32bit_elf
? 4 : 8;
9941 printf (_("The section %s contains:\n"), SECTION_NAME (section
));
9945 unsigned char *saved_start
;
9946 unsigned char *block_end
;
9947 unsigned long length
;
9948 unsigned long cie_id
;
9951 int need_col_headers
= 1;
9952 unsigned char *augmentation_data
= NULL
;
9953 unsigned long augmentation_data_len
= 0;
9954 int encoded_ptr_size
= addr_size
;
9956 int initial_length_size
;
9958 saved_start
= start
;
9959 length
= byte_get (start
, 4); start
+= 4;
9963 printf ("\n%08lx ZERO terminator\n\n",
9964 (unsigned long)(saved_start
- section_start
));
9968 if (length
== 0xffffffff)
9970 length
= byte_get (start
, 8);
9973 initial_length_size
= 12;
9978 initial_length_size
= 4;
9981 block_end
= saved_start
+ length
+ initial_length_size
;
9982 cie_id
= byte_get (start
, offset_size
); start
+= offset_size
;
9984 if (elf_header
.e_type
== ET_REL
9985 && !debug_apply_rela_addends (file
, section
, offset_size
,
9986 section_start
, start
, block_end
))
9989 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
9993 fc
= xmalloc (sizeof (Frame_Chunk
));
9994 memset (fc
, 0, sizeof (Frame_Chunk
));
9998 fc
->chunk_start
= saved_start
;
10000 fc
->col_type
= xmalloc (sizeof (short int));
10001 fc
->col_offset
= xmalloc (sizeof (int));
10002 frame_need_space (fc
, max_regs
-1);
10004 version
= *start
++;
10006 fc
->augmentation
= start
;
10007 start
= strchr (start
, '\0') + 1;
10009 if (fc
->augmentation
[0] == 'z')
10011 fc
->code_factor
= LEB ();
10012 fc
->data_factor
= SLEB ();
10021 augmentation_data_len
= LEB ();
10022 augmentation_data
= start
;
10023 start
+= augmentation_data_len
;
10025 else if (streq (fc
->augmentation
, "eh"))
10027 start
+= addr_size
;
10028 fc
->code_factor
= LEB ();
10029 fc
->data_factor
= SLEB ();
10041 fc
->code_factor
= LEB ();
10042 fc
->data_factor
= SLEB ();
10054 if (do_debug_frames_interp
)
10055 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
10056 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
10057 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
10061 printf ("\n%08lx %08lx %08lx CIE\n",
10062 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
10063 printf (" Version: %d\n", version
);
10064 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
10065 printf (" Code alignment factor: %u\n", fc
->code_factor
);
10066 printf (" Data alignment factor: %d\n", fc
->data_factor
);
10067 printf (" Return address column: %d\n", fc
->ra
);
10069 if (augmentation_data_len
)
10072 printf (" Augmentation data: ");
10073 for (i
= 0; i
< augmentation_data_len
; ++i
)
10074 printf (" %02x", augmentation_data
[i
]);
10080 if (augmentation_data_len
)
10082 unsigned char *p
, *q
;
10083 p
= fc
->augmentation
+ 1;
10084 q
= augmentation_data
;
10090 else if (*p
== 'P')
10091 q
+= 1 + size_of_encoded_value (*q
);
10092 else if (*p
== 'R')
10093 fc
->fde_encoding
= *q
++;
10099 if (fc
->fde_encoding
)
10100 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
10103 frame_need_space (fc
, fc
->ra
);
10107 unsigned char *look_for
;
10108 static Frame_Chunk fde_fc
;
10111 memset (fc
, 0, sizeof (Frame_Chunk
));
10113 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
10115 for (cie
= chunks
; cie
; cie
= cie
->next
)
10116 if (cie
->chunk_start
== look_for
)
10121 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
10122 cie_id
, saved_start
);
10125 fc
->col_type
= xmalloc (sizeof (short int));
10126 fc
->col_offset
= xmalloc (sizeof (int));
10127 frame_need_space (fc
, max_regs
- 1);
10129 fc
->augmentation
= "";
10130 fc
->fde_encoding
= 0;
10134 fc
->ncols
= cie
->ncols
;
10135 fc
->col_type
= xmalloc (fc
->ncols
* sizeof (short int));
10136 fc
->col_offset
= xmalloc (fc
->ncols
* sizeof (int));
10137 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
10138 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
10139 fc
->augmentation
= cie
->augmentation
;
10140 fc
->code_factor
= cie
->code_factor
;
10141 fc
->data_factor
= cie
->data_factor
;
10142 fc
->cfa_reg
= cie
->cfa_reg
;
10143 fc
->cfa_offset
= cie
->cfa_offset
;
10145 frame_need_space (fc
, max_regs
-1);
10146 fc
->fde_encoding
= cie
->fde_encoding
;
10149 if (fc
->fde_encoding
)
10150 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
10152 fc
->pc_begin
= get_encoded_value (start
, fc
->fde_encoding
);
10153 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
10154 /* Don't adjust for ET_REL since there's invariably a pcrel
10155 reloc here, which we haven't applied. */
10156 && elf_header
.e_type
!= ET_REL
)
10157 fc
->pc_begin
+= section
->sh_addr
+ (start
- section_start
);
10158 start
+= encoded_ptr_size
;
10159 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
10160 start
+= encoded_ptr_size
;
10162 if (cie
->augmentation
[0] == 'z')
10164 augmentation_data_len
= LEB ();
10165 augmentation_data
= start
;
10166 start
+= augmentation_data_len
;
10169 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
10170 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
10171 (unsigned long)(cie
->chunk_start
- section_start
),
10172 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
10173 if (! do_debug_frames_interp
&& augmentation_data_len
)
10177 printf (" Augmentation data: ");
10178 for (i
= 0; i
< augmentation_data_len
; ++i
)
10179 printf (" %02x", augmentation_data
[i
]);
10185 /* At this point, fc is the current chunk, cie (if any) is set, and
10186 we're about to interpret instructions for the chunk. */
10187 /* ??? At present we need to do this always, since this sizes the
10188 fc->col_type and fc->col_offset arrays, which we write into always.
10189 We should probably split the interpreted and non-interpreted bits
10190 into two different routines, since there's so much that doesn't
10191 really overlap between them. */
10192 if (1 || do_debug_frames_interp
)
10194 /* Start by making a pass over the chunk, allocating storage
10195 and taking note of what registers are used. */
10196 unsigned char *tmp
= start
;
10198 while (start
< block_end
)
10201 unsigned long reg
, tmp
;
10208 /* Warning: if you add any more cases to this switch, be
10209 sure to add them to the corresponding switch below. */
10212 case DW_CFA_advance_loc
:
10214 case DW_CFA_offset
:
10216 frame_need_space (fc
, opa
);
10217 fc
->col_type
[opa
] = DW_CFA_undefined
;
10219 case DW_CFA_restore
:
10220 frame_need_space (fc
, opa
);
10221 fc
->col_type
[opa
] = DW_CFA_undefined
;
10223 case DW_CFA_set_loc
:
10224 start
+= encoded_ptr_size
;
10226 case DW_CFA_advance_loc1
:
10229 case DW_CFA_advance_loc2
:
10232 case DW_CFA_advance_loc4
:
10235 case DW_CFA_offset_extended
:
10236 reg
= LEB (); LEB ();
10237 frame_need_space (fc
, reg
);
10238 fc
->col_type
[reg
] = DW_CFA_undefined
;
10240 case DW_CFA_restore_extended
:
10242 frame_need_space (fc
, reg
);
10243 fc
->col_type
[reg
] = DW_CFA_undefined
;
10245 case DW_CFA_undefined
:
10247 frame_need_space (fc
, reg
);
10248 fc
->col_type
[reg
] = DW_CFA_undefined
;
10250 case DW_CFA_same_value
:
10252 frame_need_space (fc
, reg
);
10253 fc
->col_type
[reg
] = DW_CFA_undefined
;
10255 case DW_CFA_register
:
10256 reg
= LEB (); LEB ();
10257 frame_need_space (fc
, reg
);
10258 fc
->col_type
[reg
] = DW_CFA_undefined
;
10260 case DW_CFA_def_cfa
:
10263 case DW_CFA_def_cfa_register
:
10266 case DW_CFA_def_cfa_offset
:
10269 case DW_CFA_def_cfa_expression
:
10273 case DW_CFA_expression
:
10277 frame_need_space (fc
, reg
);
10278 fc
->col_type
[reg
] = DW_CFA_undefined
;
10280 case DW_CFA_offset_extended_sf
:
10281 reg
= LEB (); SLEB ();
10282 frame_need_space (fc
, reg
);
10283 fc
->col_type
[reg
] = DW_CFA_undefined
;
10285 case DW_CFA_def_cfa_sf
:
10288 case DW_CFA_def_cfa_offset_sf
:
10291 case DW_CFA_MIPS_advance_loc8
:
10294 case DW_CFA_GNU_args_size
:
10297 case DW_CFA_GNU_negative_offset_extended
:
10298 reg
= LEB (); LEB ();
10299 frame_need_space (fc
, reg
);
10300 fc
->col_type
[reg
] = DW_CFA_undefined
;
10309 /* Now we know what registers are used, make a second pass over
10310 the chunk, this time actually printing out the info. */
10312 while (start
< block_end
)
10315 unsigned long ul
, reg
, roffs
;
10324 /* Warning: if you add any more cases to this switch, be
10325 sure to add them to the corresponding switch above. */
10328 case DW_CFA_advance_loc
:
10329 if (do_debug_frames_interp
)
10330 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10332 printf (" DW_CFA_advance_loc: %d to %08lx\n",
10333 opa
* fc
->code_factor
,
10334 fc
->pc_begin
+ opa
* fc
->code_factor
);
10335 fc
->pc_begin
+= opa
* fc
->code_factor
;
10338 case DW_CFA_offset
:
10340 if (! do_debug_frames_interp
)
10341 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
10342 opa
, roffs
* fc
->data_factor
);
10343 fc
->col_type
[opa
] = DW_CFA_offset
;
10344 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
10347 case DW_CFA_restore
:
10348 if (! do_debug_frames_interp
)
10349 printf (" DW_CFA_restore: r%d\n", opa
);
10350 fc
->col_type
[opa
] = cie
->col_type
[opa
];
10351 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
10354 case DW_CFA_set_loc
:
10355 vma
= get_encoded_value (start
, fc
->fde_encoding
);
10356 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
10357 && elf_header
.e_type
!= ET_REL
)
10358 vma
+= section
->sh_addr
+ (start
- section_start
);
10359 start
+= encoded_ptr_size
;
10360 if (do_debug_frames_interp
)
10361 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10363 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
10364 fc
->pc_begin
= vma
;
10367 case DW_CFA_advance_loc1
:
10368 ofs
= byte_get (start
, 1); start
+= 1;
10369 if (do_debug_frames_interp
)
10370 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10372 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
10373 ofs
* fc
->code_factor
,
10374 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10375 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10378 case DW_CFA_advance_loc2
:
10379 ofs
= byte_get (start
, 2); start
+= 2;
10380 if (do_debug_frames_interp
)
10381 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10383 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
10384 ofs
* fc
->code_factor
,
10385 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10386 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10389 case DW_CFA_advance_loc4
:
10390 ofs
= byte_get (start
, 4); start
+= 4;
10391 if (do_debug_frames_interp
)
10392 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10394 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
10395 ofs
* fc
->code_factor
,
10396 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10397 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10400 case DW_CFA_offset_extended
:
10403 if (! do_debug_frames_interp
)
10404 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
10405 reg
, roffs
* fc
->data_factor
);
10406 fc
->col_type
[reg
] = DW_CFA_offset
;
10407 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
10410 case DW_CFA_restore_extended
:
10412 if (! do_debug_frames_interp
)
10413 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
10414 fc
->col_type
[reg
] = cie
->col_type
[reg
];
10415 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
10418 case DW_CFA_undefined
:
10420 if (! do_debug_frames_interp
)
10421 printf (" DW_CFA_undefined: r%ld\n", reg
);
10422 fc
->col_type
[reg
] = DW_CFA_undefined
;
10423 fc
->col_offset
[reg
] = 0;
10426 case DW_CFA_same_value
:
10428 if (! do_debug_frames_interp
)
10429 printf (" DW_CFA_same_value: r%ld\n", reg
);
10430 fc
->col_type
[reg
] = DW_CFA_same_value
;
10431 fc
->col_offset
[reg
] = 0;
10434 case DW_CFA_register
:
10437 if (! do_debug_frames_interp
)
10438 printf (" DW_CFA_register: r%ld in r%ld\n", reg
, roffs
);
10439 fc
->col_type
[reg
] = DW_CFA_register
;
10440 fc
->col_offset
[reg
] = roffs
;
10443 case DW_CFA_remember_state
:
10444 if (! do_debug_frames_interp
)
10445 printf (" DW_CFA_remember_state\n");
10446 rs
= xmalloc (sizeof (Frame_Chunk
));
10447 rs
->ncols
= fc
->ncols
;
10448 rs
->col_type
= xmalloc (rs
->ncols
* sizeof (short int));
10449 rs
->col_offset
= xmalloc (rs
->ncols
* sizeof (int));
10450 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
10451 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
10452 rs
->next
= remembered_state
;
10453 remembered_state
= rs
;
10456 case DW_CFA_restore_state
:
10457 if (! do_debug_frames_interp
)
10458 printf (" DW_CFA_restore_state\n");
10459 rs
= remembered_state
;
10462 remembered_state
= rs
->next
;
10463 frame_need_space (fc
, rs
->ncols
-1);
10464 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
10465 memcpy (fc
->col_offset
, rs
->col_offset
,
10466 rs
->ncols
* sizeof (int));
10467 free (rs
->col_type
);
10468 free (rs
->col_offset
);
10471 else if (do_debug_frames_interp
)
10472 printf ("Mismatched DW_CFA_restore_state\n");
10475 case DW_CFA_def_cfa
:
10476 fc
->cfa_reg
= LEB ();
10477 fc
->cfa_offset
= LEB ();
10479 if (! do_debug_frames_interp
)
10480 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
10481 fc
->cfa_reg
, fc
->cfa_offset
);
10484 case DW_CFA_def_cfa_register
:
10485 fc
->cfa_reg
= LEB ();
10487 if (! do_debug_frames_interp
)
10488 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
10491 case DW_CFA_def_cfa_offset
:
10492 fc
->cfa_offset
= LEB ();
10493 if (! do_debug_frames_interp
)
10494 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
10498 if (! do_debug_frames_interp
)
10499 printf (" DW_CFA_nop\n");
10502 case DW_CFA_def_cfa_expression
:
10504 if (! do_debug_frames_interp
)
10506 printf (" DW_CFA_def_cfa_expression (");
10507 decode_location_expression (start
, addr_size
, ul
, 0);
10514 case DW_CFA_expression
:
10517 if (! do_debug_frames_interp
)
10519 printf (" DW_CFA_expression: r%ld (", reg
);
10520 decode_location_expression (start
, addr_size
, ul
, 0);
10523 fc
->col_type
[reg
] = DW_CFA_expression
;
10527 case DW_CFA_offset_extended_sf
:
10530 frame_need_space (fc
, reg
);
10531 if (! do_debug_frames_interp
)
10532 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
10533 reg
, l
* fc
->data_factor
);
10534 fc
->col_type
[reg
] = DW_CFA_offset
;
10535 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
10538 case DW_CFA_def_cfa_sf
:
10539 fc
->cfa_reg
= LEB ();
10540 fc
->cfa_offset
= SLEB ();
10542 if (! do_debug_frames_interp
)
10543 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
10544 fc
->cfa_reg
, fc
->cfa_offset
);
10547 case DW_CFA_def_cfa_offset_sf
:
10548 fc
->cfa_offset
= SLEB ();
10549 if (! do_debug_frames_interp
)
10550 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
10553 case DW_CFA_MIPS_advance_loc8
:
10554 ofs
= byte_get (start
, 8); start
+= 8;
10555 if (do_debug_frames_interp
)
10556 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10558 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
10559 ofs
* fc
->code_factor
,
10560 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10561 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10564 case DW_CFA_GNU_window_save
:
10565 if (! do_debug_frames_interp
)
10566 printf (" DW_CFA_GNU_window_save\n");
10569 case DW_CFA_GNU_args_size
:
10571 if (! do_debug_frames_interp
)
10572 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
10575 case DW_CFA_GNU_negative_offset_extended
:
10578 frame_need_space (fc
, reg
);
10579 if (! do_debug_frames_interp
)
10580 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
10581 reg
, l
* fc
->data_factor
);
10582 fc
->col_type
[reg
] = DW_CFA_offset
;
10583 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
10587 warn (_("unsupported or unknown DW_CFA_%d\n"), op
);
10592 if (do_debug_frames_interp
)
10593 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10608 display_debug_not_supported (Elf_Internal_Shdr
*section
,
10609 unsigned char *start ATTRIBUTE_UNUSED
,
10610 FILE *file ATTRIBUTE_UNUSED
)
10612 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
10613 SECTION_NAME (section
));
10618 /* A structure containing the name of a debug section
10619 and a pointer to a function that can decode it. */
10622 const char *const name
;
10623 int (*display
) (Elf_Internal_Shdr
*, unsigned char *, FILE *);
10627 { ".debug_abbrev", display_debug_abbrev
},
10628 { ".debug_aranges", display_debug_aranges
},
10629 { ".debug_frame", display_debug_frames
},
10630 { ".debug_info", display_debug_info
},
10631 { ".debug_line", display_debug_lines
},
10632 { ".debug_pubnames", display_debug_pubnames
},
10633 { ".eh_frame", display_debug_frames
},
10634 { ".debug_macinfo", display_debug_macinfo
},
10635 { ".debug_str", display_debug_str
},
10636 { ".debug_loc", display_debug_loc
},
10637 { ".debug_pubtypes", display_debug_pubnames
},
10638 { ".debug_ranges", display_debug_ranges
},
10639 { ".debug_static_func", display_debug_not_supported
},
10640 { ".debug_static_vars", display_debug_not_supported
},
10641 { ".debug_types", display_debug_not_supported
},
10642 { ".debug_weaknames", display_debug_not_supported
}
10646 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
10648 char *name
= SECTION_NAME (section
);
10649 bfd_size_type length
;
10653 length
= section
->sh_size
;
10656 printf (_("\nSection '%s' has no debugging data.\n"), name
);
10660 if (strneq (name
, ".gnu.linkonce.wi.", 17))
10661 name
= ".debug_info";
10663 /* See if we know how to display the contents of this section. */
10664 for (i
= NUM_ELEM (debug_displays
); i
--;)
10665 if (streq (debug_displays
[i
].name
, name
))
10667 unsigned char *start
;
10669 start
= get_data (NULL
, file
, section
->sh_offset
, length
,
10670 _("debug section data"));
10677 result
&= debug_displays
[i
].display (section
, start
, file
);
10680 /* If we loaded in the abbrev section
10681 at some point, we must release it here. */
10689 printf (_("Unrecognized debug section: %s\n"), name
);
10697 process_section_contents (FILE *file
)
10699 Elf_Internal_Shdr
*section
;
10705 for (i
= 0, section
= section_headers
;
10706 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
10709 #ifdef SUPPORT_DISASSEMBLY
10710 if (dump_sects
[i
] & DISASS_DUMP
)
10711 disassemble_section (section
, file
);
10713 if (dump_sects
[i
] & HEX_DUMP
)
10714 dump_section (section
, file
);
10716 if (dump_sects
[i
] & DEBUG_DUMP
)
10717 display_debug_section (section
, file
);
10720 /* Check to see if the user requested a
10721 dump of a section that does not exist. */
10722 while (i
++ < num_dump_sects
)
10724 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
10728 process_mips_fpe_exception (int mask
)
10733 if (mask
& OEX_FPU_INEX
)
10734 fputs ("INEX", stdout
), first
= 0;
10735 if (mask
& OEX_FPU_UFLO
)
10736 printf ("%sUFLO", first
? "" : "|"), first
= 0;
10737 if (mask
& OEX_FPU_OFLO
)
10738 printf ("%sOFLO", first
? "" : "|"), first
= 0;
10739 if (mask
& OEX_FPU_DIV0
)
10740 printf ("%sDIV0", first
? "" : "|"), first
= 0;
10741 if (mask
& OEX_FPU_INVAL
)
10742 printf ("%sINVAL", first
? "" : "|");
10745 fputs ("0", stdout
);
10749 process_mips_specific (FILE *file
)
10751 Elf_Internal_Dyn
*entry
;
10752 size_t liblist_offset
= 0;
10753 size_t liblistno
= 0;
10754 size_t conflictsno
= 0;
10755 size_t options_offset
= 0;
10756 size_t conflicts_offset
= 0;
10758 /* We have a lot of special sections. Thanks SGI! */
10759 if (dynamic_section
== NULL
)
10760 /* No information available. */
10763 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
10764 switch (entry
->d_tag
)
10766 case DT_MIPS_LIBLIST
:
10768 = offset_from_vma (file
, entry
->d_un
.d_val
,
10769 liblistno
* sizeof (Elf32_External_Lib
));
10771 case DT_MIPS_LIBLISTNO
:
10772 liblistno
= entry
->d_un
.d_val
;
10774 case DT_MIPS_OPTIONS
:
10775 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
10777 case DT_MIPS_CONFLICT
:
10779 = offset_from_vma (file
, entry
->d_un
.d_val
,
10780 conflictsno
* sizeof (Elf32_External_Conflict
));
10782 case DT_MIPS_CONFLICTNO
:
10783 conflictsno
= entry
->d_un
.d_val
;
10789 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
10791 Elf32_External_Lib
*elib
;
10794 elib
= get_data (NULL
, file
, liblist_offset
,
10795 liblistno
* sizeof (Elf32_External_Lib
),
10799 printf ("\nSection '.liblist' contains %lu entries:\n",
10800 (unsigned long) liblistno
);
10801 fputs (" Library Time Stamp Checksum Version Flags\n",
10804 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
10811 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
10812 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
10813 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
10814 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
10815 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
10817 tmp
= gmtime (&time
);
10818 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
10819 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10820 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10822 printf ("%3lu: ", (unsigned long) cnt
);
10823 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
10824 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
10826 printf ("<corrupt: %9ld>", liblist
.l_name
);
10827 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
10828 liblist
.l_version
);
10830 if (liblist
.l_flags
== 0)
10834 static const struct
10841 { " EXACT_MATCH", LL_EXACT_MATCH
},
10842 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
10843 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
10844 { " EXPORTS", LL_EXPORTS
},
10845 { " DELAY_LOAD", LL_DELAY_LOAD
},
10846 { " DELTA", LL_DELTA
}
10848 int flags
= liblist
.l_flags
;
10852 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
10854 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
10856 fputs (l_flags_vals
[fcnt
].name
, stdout
);
10857 flags
^= l_flags_vals
[fcnt
].bit
;
10860 printf (" %#x", (unsigned int) flags
);
10870 if (options_offset
!= 0)
10872 Elf_External_Options
*eopt
;
10873 Elf_Internal_Shdr
*sect
= section_headers
;
10874 Elf_Internal_Options
*iopt
;
10875 Elf_Internal_Options
*option
;
10879 /* Find the section header so that we get the size. */
10880 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
10883 eopt
= get_data (NULL
, file
, options_offset
, sect
->sh_size
,
10887 iopt
= malloc ((sect
->sh_size
/ sizeof (eopt
)) * sizeof (*iopt
));
10890 error (_("Out of memory"));
10897 while (offset
< sect
->sh_size
)
10899 Elf_External_Options
*eoption
;
10901 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
10903 option
->kind
= BYTE_GET (eoption
->kind
);
10904 option
->size
= BYTE_GET (eoption
->size
);
10905 option
->section
= BYTE_GET (eoption
->section
);
10906 option
->info
= BYTE_GET (eoption
->info
);
10908 offset
+= option
->size
;
10914 printf (_("\nSection '%s' contains %d entries:\n"),
10915 SECTION_NAME (sect
), cnt
);
10923 switch (option
->kind
)
10926 /* This shouldn't happen. */
10927 printf (" NULL %d %lx", option
->section
, option
->info
);
10930 printf (" REGINFO ");
10931 if (elf_header
.e_machine
== EM_MIPS
)
10934 Elf32_External_RegInfo
*ereg
;
10935 Elf32_RegInfo reginfo
;
10937 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
10938 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
10939 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
10940 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
10941 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
10942 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
10943 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
10945 printf ("GPR %08lx GP 0x%lx\n",
10946 reginfo
.ri_gprmask
,
10947 (unsigned long) reginfo
.ri_gp_value
);
10948 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
10949 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
10950 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
10955 Elf64_External_RegInfo
*ereg
;
10956 Elf64_Internal_RegInfo reginfo
;
10958 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
10959 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
10960 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
10961 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
10962 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
10963 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
10964 reginfo
.ri_gp_value
= BYTE_GET8 (ereg
->ri_gp_value
);
10966 printf ("GPR %08lx GP 0x",
10967 reginfo
.ri_gprmask
);
10968 printf_vma (reginfo
.ri_gp_value
);
10971 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
10972 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
10973 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
10977 case ODK_EXCEPTIONS
:
10978 fputs (" EXCEPTIONS fpe_min(", stdout
);
10979 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
10980 fputs (") fpe_max(", stdout
);
10981 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
10982 fputs (")", stdout
);
10984 if (option
->info
& OEX_PAGE0
)
10985 fputs (" PAGE0", stdout
);
10986 if (option
->info
& OEX_SMM
)
10987 fputs (" SMM", stdout
);
10988 if (option
->info
& OEX_FPDBUG
)
10989 fputs (" FPDBUG", stdout
);
10990 if (option
->info
& OEX_DISMISS
)
10991 fputs (" DISMISS", stdout
);
10994 fputs (" PAD ", stdout
);
10995 if (option
->info
& OPAD_PREFIX
)
10996 fputs (" PREFIX", stdout
);
10997 if (option
->info
& OPAD_POSTFIX
)
10998 fputs (" POSTFIX", stdout
);
10999 if (option
->info
& OPAD_SYMBOL
)
11000 fputs (" SYMBOL", stdout
);
11003 fputs (" HWPATCH ", stdout
);
11004 if (option
->info
& OHW_R4KEOP
)
11005 fputs (" R4KEOP", stdout
);
11006 if (option
->info
& OHW_R8KPFETCH
)
11007 fputs (" R8KPFETCH", stdout
);
11008 if (option
->info
& OHW_R5KEOP
)
11009 fputs (" R5KEOP", stdout
);
11010 if (option
->info
& OHW_R5KCVTL
)
11011 fputs (" R5KCVTL", stdout
);
11014 fputs (" FILL ", stdout
);
11015 /* XXX Print content of info word? */
11018 fputs (" TAGS ", stdout
);
11019 /* XXX Print content of info word? */
11022 fputs (" HWAND ", stdout
);
11023 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11024 fputs (" R4KEOP_CHECKED", stdout
);
11025 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11026 fputs (" R4KEOP_CLEAN", stdout
);
11029 fputs (" HWOR ", 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 printf (" GP_GROUP %#06lx self-contained %#06lx",
11037 option
->info
& OGP_GROUP
,
11038 (option
->info
& OGP_SELF
) >> 16);
11041 printf (" IDENT %#06lx self-contained %#06lx",
11042 option
->info
& OGP_GROUP
,
11043 (option
->info
& OGP_SELF
) >> 16);
11046 /* This shouldn't happen. */
11047 printf (" %3d ??? %d %lx",
11048 option
->kind
, option
->section
, option
->info
);
11052 len
= sizeof (*eopt
);
11053 while (len
< option
->size
)
11054 if (((char *) option
)[len
] >= ' '
11055 && ((char *) option
)[len
] < 0x7f)
11056 printf ("%c", ((char *) option
)[len
++]);
11058 printf ("\\%03o", ((char *) option
)[len
++]);
11060 fputs ("\n", stdout
);
11068 if (conflicts_offset
!= 0 && conflictsno
!= 0)
11070 Elf32_Conflict
*iconf
;
11073 if (dynamic_symbols
== NULL
)
11075 error (_("conflict list found without a dynamic symbol table"));
11079 iconf
= malloc (conflictsno
* sizeof (*iconf
));
11082 error (_("Out of memory"));
11088 Elf32_External_Conflict
*econf32
;
11090 econf32
= get_data (NULL
, file
, conflicts_offset
,
11091 conflictsno
* sizeof (*econf32
), _("conflict"));
11095 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11096 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
11102 Elf64_External_Conflict
*econf64
;
11104 econf64
= get_data (NULL
, file
, conflicts_offset
,
11105 conflictsno
* sizeof (*econf64
), _("conflict"));
11109 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11110 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
11115 printf (_("\nSection '.conflict' contains %lu entries:\n"),
11116 (unsigned long) conflictsno
);
11117 puts (_(" Num: Index Value Name"));
11119 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11121 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
11123 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
11124 print_vma (psym
->st_value
, FULL_HEX
);
11126 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11127 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11129 printf ("<corrupt: %14ld>", psym
->st_name
);
11140 process_gnu_liblist (FILE *file
)
11142 Elf_Internal_Shdr
*section
, *string_sec
;
11143 Elf32_External_Lib
*elib
;
11151 for (i
= 0, section
= section_headers
;
11152 i
< elf_header
.e_shnum
;
11155 switch (section
->sh_type
)
11157 case SHT_GNU_LIBLIST
:
11158 elib
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
11163 string_sec
= SECTION_HEADER (section
->sh_link
);
11165 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
11166 string_sec
->sh_size
, _("liblist string table"));
11169 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
11175 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
11176 SECTION_NAME (section
),
11177 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
11179 puts (" Library Time Stamp Checksum Version Flags");
11181 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
11189 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
11190 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
11191 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
11192 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
11193 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
11195 tmp
= gmtime (&time
);
11196 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
11197 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11198 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11200 printf ("%3lu: ", (unsigned long) cnt
);
11202 printf ("%-20s", strtab
+ liblist
.l_name
);
11204 printf ("%-20.20s", strtab
+ liblist
.l_name
);
11205 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
11206 liblist
.l_version
, liblist
.l_flags
);
11216 static const char *
11217 get_note_type (unsigned e_type
)
11219 static char buff
[64];
11221 if (elf_header
.e_type
== ET_CORE
)
11225 return _("NT_AUXV (auxiliary vector)");
11227 return _("NT_PRSTATUS (prstatus structure)");
11229 return _("NT_FPREGSET (floating point registers)");
11231 return _("NT_PRPSINFO (prpsinfo structure)");
11232 case NT_TASKSTRUCT
:
11233 return _("NT_TASKSTRUCT (task structure)");
11235 return _("NT_PRXFPREG (user_xfpregs structure)");
11237 return _("NT_PSTATUS (pstatus structure)");
11239 return _("NT_FPREGS (floating point registers)");
11241 return _("NT_PSINFO (psinfo structure)");
11243 return _("NT_LWPSTATUS (lwpstatus_t structure)");
11245 return _("NT_LWPSINFO (lwpsinfo_t structure)");
11246 case NT_WIN32PSTATUS
:
11247 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
11255 return _("NT_VERSION (version)");
11257 return _("NT_ARCH (architecture)");
11262 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
11266 static const char *
11267 get_netbsd_elfcore_note_type (unsigned e_type
)
11269 static char buff
[64];
11271 if (e_type
== NT_NETBSDCORE_PROCINFO
)
11273 /* NetBSD core "procinfo" structure. */
11274 return _("NetBSD procinfo structure");
11277 /* As of Jan 2002 there are no other machine-independent notes
11278 defined for NetBSD core files. If the note type is less
11279 than the start of the machine-dependent note types, we don't
11282 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
11284 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
11288 switch (elf_header
.e_machine
)
11290 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
11291 and PT_GETFPREGS == mach+2. */
11296 case EM_SPARC32PLUS
:
11300 case NT_NETBSDCORE_FIRSTMACH
+0:
11301 return _("PT_GETREGS (reg structure)");
11302 case NT_NETBSDCORE_FIRSTMACH
+2:
11303 return _("PT_GETFPREGS (fpreg structure)");
11309 /* On all other arch's, PT_GETREGS == mach+1 and
11310 PT_GETFPREGS == mach+3. */
11314 case NT_NETBSDCORE_FIRSTMACH
+1:
11315 return _("PT_GETREGS (reg structure)");
11316 case NT_NETBSDCORE_FIRSTMACH
+3:
11317 return _("PT_GETFPREGS (fpreg structure)");
11323 sprintf (buff
, _("PT_FIRSTMACH+%d"), e_type
- NT_NETBSDCORE_FIRSTMACH
);
11327 /* Note that by the ELF standard, the name field is already null byte
11328 terminated, and namesz includes the terminating null byte.
11329 I.E. the value of namesz for the name "FSF" is 4.
11331 If the value of namesz is zero, there is no name present. */
11333 process_note (Elf_Internal_Note
*pnote
)
11337 if (pnote
->namesz
== 0)
11338 /* If there is no note name, then use the default set of
11339 note type strings. */
11340 nt
= get_note_type (pnote
->type
);
11342 else if (strneq (pnote
->namedata
, "NetBSD-CORE", 11))
11343 /* NetBSD-specific core file notes. */
11344 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
11347 /* Don't recognize this note name; just use the default set of
11348 note type strings. */
11349 nt
= get_note_type (pnote
->type
);
11351 printf (" %s\t\t0x%08lx\t%s\n",
11352 pnote
->namesz
? pnote
->namedata
: "(NONE)",
11353 pnote
->descsz
, nt
);
11359 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
11361 Elf_External_Note
*pnotes
;
11362 Elf_External_Note
*external
;
11368 pnotes
= get_data (NULL
, file
, offset
, length
, _("notes"));
11374 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
11375 (unsigned long) offset
, (unsigned long) length
);
11376 printf (_(" Owner\t\tData size\tDescription\n"));
11378 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
11380 Elf_External_Note
*next
;
11381 Elf_Internal_Note inote
;
11384 inote
.type
= BYTE_GET (external
->type
);
11385 inote
.namesz
= BYTE_GET (external
->namesz
);
11386 inote
.namedata
= external
->name
;
11387 inote
.descsz
= BYTE_GET (external
->descsz
);
11388 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
11389 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
11391 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
11393 if (((char *) next
) > (((char *) pnotes
) + length
))
11395 warn (_("corrupt note found at offset %x into core notes\n"),
11396 ((char *) external
) - ((char *) pnotes
));
11397 warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
11398 inote
.type
, inote
.namesz
, inote
.descsz
);
11404 /* Verify that name is null terminated. It appears that at least
11405 one version of Linux (RedHat 6.0) generates corefiles that don't
11406 comply with the ELF spec by failing to include the null byte in
11408 if (inote
.namedata
[inote
.namesz
] != '\0')
11410 temp
= malloc (inote
.namesz
+ 1);
11414 error (_("Out of memory\n"));
11419 strncpy (temp
, inote
.namedata
, inote
.namesz
);
11420 temp
[inote
.namesz
] = 0;
11422 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
11423 inote
.namedata
= temp
;
11426 res
&= process_note (& inote
);
11441 process_corefile_note_segments (FILE *file
)
11443 Elf_Internal_Phdr
*segment
;
11447 if (! get_program_headers (file
))
11450 for (i
= 0, segment
= program_headers
;
11451 i
< elf_header
.e_phnum
;
11454 if (segment
->p_type
== PT_NOTE
)
11455 res
&= process_corefile_note_segment (file
,
11456 (bfd_vma
) segment
->p_offset
,
11457 (bfd_vma
) segment
->p_filesz
);
11464 process_note_sections (FILE *file
)
11466 Elf_Internal_Shdr
*section
;
11470 for (i
= 0, section
= section_headers
;
11471 i
< elf_header
.e_shnum
;
11473 if (section
->sh_type
== SHT_NOTE
)
11474 res
&= process_corefile_note_segment (file
,
11475 (bfd_vma
) section
->sh_offset
,
11476 (bfd_vma
) section
->sh_size
);
11482 process_notes (FILE *file
)
11484 /* If we have not been asked to display the notes then do nothing. */
11488 if (elf_header
.e_type
!= ET_CORE
)
11489 return process_note_sections (file
);
11491 /* No program headers means no NOTE segment. */
11492 if (elf_header
.e_phnum
> 0)
11493 return process_corefile_note_segments (file
);
11495 printf (_("No note segments present in the core file.\n"));
11500 process_arch_specific (FILE *file
)
11505 switch (elf_header
.e_machine
)
11508 case EM_MIPS_RS3_LE
:
11509 return process_mips_specific (file
);
11518 get_file_header (FILE *file
)
11520 /* Read in the identity array. */
11521 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
11524 /* Determine how to read the rest of the header. */
11525 switch (elf_header
.e_ident
[EI_DATA
])
11527 default: /* fall through */
11528 case ELFDATANONE
: /* fall through */
11530 byte_get
= byte_get_little_endian
;
11531 byte_put
= byte_put_little_endian
;
11534 byte_get
= byte_get_big_endian
;
11535 byte_put
= byte_put_big_endian
;
11539 /* For now we only support 32 bit and 64 bit ELF files. */
11540 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
11542 /* Read in the rest of the header. */
11545 Elf32_External_Ehdr ehdr32
;
11547 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
11550 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
11551 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
11552 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
11553 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
11554 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
11555 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
11556 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
11557 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
11558 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
11559 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
11560 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
11561 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
11562 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
11566 Elf64_External_Ehdr ehdr64
;
11568 /* If we have been compiled with sizeof (bfd_vma) == 4, then
11569 we will not be able to cope with the 64bit data found in
11570 64 ELF files. Detect this now and abort before we start
11571 overwriting things. */
11572 if (sizeof (bfd_vma
) < 8)
11574 error (_("This instance of readelf has been built without support for a\n\
11575 64 bit data type and so it cannot read 64 bit ELF files.\n"));
11579 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
11582 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
11583 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
11584 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
11585 elf_header
.e_entry
= BYTE_GET8 (ehdr64
.e_entry
);
11586 elf_header
.e_phoff
= BYTE_GET8 (ehdr64
.e_phoff
);
11587 elf_header
.e_shoff
= BYTE_GET8 (ehdr64
.e_shoff
);
11588 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
11589 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
11590 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
11591 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
11592 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
11593 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
11594 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
11597 if (elf_header
.e_shoff
)
11599 /* There may be some extensions in the first section header. Don't
11600 bomb if we can't read it. */
11602 get_32bit_section_headers (file
, 1);
11604 get_64bit_section_headers (file
, 1);
11610 /* Process one ELF object file according to the command line options.
11611 This file may actually be stored in an archive. The file is
11612 positioned at the start of the ELF object. */
11615 process_object (char *file_name
, FILE *file
)
11619 if (! get_file_header (file
))
11621 error (_("%s: Failed to read file header\n"), file_name
);
11625 /* Initialise per file variables. */
11626 for (i
= NUM_ELEM (version_info
); i
--;)
11627 version_info
[i
] = 0;
11629 for (i
= NUM_ELEM (dynamic_info
); i
--;)
11630 dynamic_info
[i
] = 0;
11632 /* Process the file. */
11634 printf (_("\nFile: %s\n"), file_name
);
11636 /* Initialise the dump_sects array from the cmdline_dump_sects array.
11637 Note we do this even if cmdline_dump_sects is empty because we
11638 must make sure that the dump_sets array is zeroed out before each
11639 object file is processed. */
11640 if (num_dump_sects
> num_cmdline_dump_sects
)
11641 memset (dump_sects
, 0, num_dump_sects
);
11643 if (num_cmdline_dump_sects
> 0)
11645 if (num_dump_sects
== 0)
11646 /* A sneaky way of allocating the dump_sects array. */
11647 request_dump (num_cmdline_dump_sects
, 0);
11649 assert (num_dump_sects
>= num_cmdline_dump_sects
);
11650 memcpy (dump_sects
, cmdline_dump_sects
, num_cmdline_dump_sects
);
11653 if (! process_file_header ())
11656 if (! process_section_headers (file
)
11657 || ! process_section_groups (file
))
11659 /* Without loaded section headers and section groups we
11660 cannot process lots of things. */
11661 do_unwind
= do_version
= do_dump
= do_arch
= 0;
11663 if (! do_using_dynamic
)
11664 do_syms
= do_reloc
= 0;
11667 if (process_program_headers (file
))
11668 process_dynamic_section (file
);
11670 process_relocs (file
);
11672 process_unwind (file
);
11674 process_symbol_table (file
);
11676 process_syminfo (file
);
11678 process_version_sections (file
);
11680 process_section_contents (file
);
11682 process_notes (file
);
11684 process_gnu_liblist (file
);
11686 process_arch_specific (file
);
11688 if (program_headers
)
11690 free (program_headers
);
11691 program_headers
= NULL
;
11694 if (section_headers
)
11696 free (section_headers
);
11697 section_headers
= NULL
;
11702 free (string_table
);
11703 string_table
= NULL
;
11704 string_table_length
= 0;
11707 if (dynamic_strings
)
11709 free (dynamic_strings
);
11710 dynamic_strings
= NULL
;
11711 dynamic_strings_length
= 0;
11714 if (dynamic_symbols
)
11716 free (dynamic_symbols
);
11717 dynamic_symbols
= NULL
;
11718 num_dynamic_syms
= 0;
11721 if (dynamic_syminfo
)
11723 free (dynamic_syminfo
);
11724 dynamic_syminfo
= NULL
;
11727 if (section_headers_groups
)
11729 free (section_headers_groups
);
11730 section_headers_groups
= NULL
;
11733 if (section_groups
)
11735 struct group_list
*g
, *next
;
11737 for (i
= 0; i
< group_count
; i
++)
11739 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
11746 free (section_groups
);
11747 section_groups
= NULL
;
11750 if (debug_information
)
11752 for (i
= 0; i
< num_debug_info_entries
; i
++)
11753 if (debug_information
[i
].loc_offsets
!= NULL
)
11754 free (debug_information
[i
].loc_offsets
);
11755 free (debug_information
);
11756 debug_information
= NULL
;
11757 num_debug_info_entries
= 0;
11763 /* Process an ELF archive. The file is positioned just after the
11767 process_archive (char *file_name
, FILE *file
)
11769 struct ar_hdr arhdr
;
11771 unsigned long size
;
11772 char *longnames
= NULL
;
11773 unsigned long longnames_size
= 0;
11774 size_t file_name_size
;
11779 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
11780 if (got
!= sizeof arhdr
)
11785 error (_("%s: failed to read archive header\n"), file_name
);
11789 if (memcmp (arhdr
.ar_name
, "/ ", 16) == 0)
11791 /* This is the archive symbol table. Skip it.
11792 FIXME: We should have an option to dump it. */
11793 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
11794 if (fseek (file
, size
+ (size
& 1), SEEK_CUR
) != 0)
11796 error (_("%s: failed to skip archive symbol table\n"), file_name
);
11800 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
11801 if (got
!= sizeof arhdr
)
11806 error (_("%s: failed to read archive header\n"), file_name
);
11811 if (memcmp (arhdr
.ar_name
, "// ", 16) == 0)
11813 /* This is the archive string table holding long member
11816 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
11818 longnames
= malloc (longnames_size
);
11819 if (longnames
== NULL
)
11821 error (_("Out of memory\n"));
11825 if (fread (longnames
, longnames_size
, 1, file
) != 1)
11828 error (_("%s: failed to read string table\n"), file_name
);
11832 if ((longnames_size
& 1) != 0)
11835 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
11836 if (got
!= sizeof arhdr
)
11843 error (_("%s: failed to read archive header\n"), file_name
);
11848 file_name_size
= strlen (file_name
);
11857 if (arhdr
.ar_name
[0] == '/')
11861 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
11862 if (off
>= longnames_size
)
11864 error (_("%s: invalid archive string table offset %lu\n"), off
);
11869 name
= longnames
+ off
;
11870 nameend
= memchr (name
, '/', longnames_size
- off
);
11874 name
= arhdr
.ar_name
;
11875 nameend
= memchr (name
, '/', 16);
11878 if (nameend
== NULL
)
11880 error (_("%s: bad archive file name\n"));
11885 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
11886 if (namealc
== NULL
)
11888 error (_("Out of memory\n"));
11893 memcpy (namealc
, file_name
, file_name_size
);
11894 namealc
[file_name_size
] = '(';
11895 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
11896 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
11897 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
11899 archive_file_offset
= ftell (file
);
11900 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
11902 ret
|= process_object (namealc
, file
);
11907 (archive_file_offset
11908 + archive_file_size
11909 + (archive_file_size
& 1)),
11912 error (_("%s: failed to seek to next archive header\n"), file_name
);
11917 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
11918 if (got
!= sizeof arhdr
)
11923 error (_("%s: failed to read archive header\n"), file_name
);
11929 if (longnames
!= 0)
11936 process_file (char *file_name
)
11939 struct stat statbuf
;
11940 char armag
[SARMAG
];
11943 if (stat (file_name
, &statbuf
) < 0)
11945 if (errno
== ENOENT
)
11946 error (_("'%s': No such file\n"), file_name
);
11948 error (_("Could not locate '%s'. System error message: %s\n"),
11949 file_name
, strerror (errno
));
11953 if (! S_ISREG (statbuf
.st_mode
))
11955 error (_("'%s' is not an ordinary file\n"), file_name
);
11959 file
= fopen (file_name
, "rb");
11962 error (_("Input file '%s' is not readable.\n"), file_name
);
11966 if (fread (armag
, SARMAG
, 1, file
) != 1)
11968 error (_("%s: Failed to read file header\n"), file_name
);
11973 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
11974 ret
= process_archive (file_name
, file
);
11978 archive_file_size
= archive_file_offset
= 0;
11979 ret
= process_object (file_name
, file
);
11987 #ifdef SUPPORT_DISASSEMBLY
11988 /* Needed by the i386 disassembler. For extra credit, someone could
11989 fix this so that we insert symbolic addresses here, esp for GOT/PLT
11993 print_address (unsigned int addr
, FILE *outfile
)
11995 fprintf (outfile
,"0x%8.8x", addr
);
11998 /* Needed by the i386 disassembler. */
12000 db_task_printsym (unsigned int addr
)
12002 print_address (addr
, stderr
);
12007 main (int argc
, char **argv
)
12011 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
12012 setlocale (LC_MESSAGES
, "");
12014 #if defined (HAVE_SETLOCALE)
12015 setlocale (LC_CTYPE
, "");
12017 bindtextdomain (PACKAGE
, LOCALEDIR
);
12018 textdomain (PACKAGE
);
12020 parse_args (argc
, argv
);
12022 if (num_dump_sects
> 0)
12024 /* Make a copy of the dump_sects array. */
12025 cmdline_dump_sects
= malloc (num_dump_sects
);
12026 if (cmdline_dump_sects
== NULL
)
12027 error (_("Out of memory allocating dump request table."));
12030 memcpy (cmdline_dump_sects
, dump_sects
, num_dump_sects
);
12031 num_cmdline_dump_sects
= num_dump_sects
;
12035 if (optind
< (argc
- 1))
12039 while (optind
< argc
)
12040 err
|= process_file (argv
[optind
++]);
12042 if (dump_sects
!= NULL
)
12044 if (cmdline_dump_sects
!= NULL
)
12045 free (cmdline_dump_sects
);