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., 51 Franklin Street - Fifth Floor, 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"
98 #include "elf/msp430.h"
102 #include "elf/ppc64.h"
103 #include "elf/s390.h"
105 #include "elf/sparc.h"
106 #include "elf/v850.h"
108 #include "elf/x86-64.h"
109 #include "elf/xstormy16.h"
111 #include "elf/iq2000.h"
112 #include "elf/xtensa.h"
118 #include "libiberty.h"
120 char *program_name
= "readelf";
121 static long archive_file_offset
;
122 static unsigned long archive_file_size
;
123 static unsigned long dynamic_addr
;
124 static bfd_size_type dynamic_size
;
125 static unsigned int dynamic_nent
;
126 static char *dynamic_strings
;
127 static unsigned long dynamic_strings_length
;
128 static char *string_table
;
129 static unsigned long string_table_length
;
130 static unsigned long num_dynamic_syms
;
131 static Elf_Internal_Sym
*dynamic_symbols
;
132 static Elf_Internal_Syminfo
*dynamic_syminfo
;
133 static unsigned long dynamic_syminfo_offset
;
134 static unsigned int dynamic_syminfo_nent
;
135 static char program_interpreter
[64];
136 static bfd_vma dynamic_info
[DT_JMPREL
+ 1];
137 static bfd_vma version_info
[16];
138 static Elf_Internal_Ehdr elf_header
;
139 static Elf_Internal_Shdr
*section_headers
;
140 static Elf_Internal_Phdr
*program_headers
;
141 static Elf_Internal_Dyn
*dynamic_section
;
142 static Elf_Internal_Shdr
*symtab_shndx_hdr
;
143 static int show_name
;
144 static int do_dynamic
;
147 static int do_sections
;
148 static int do_section_groups
;
149 static int do_full_section_name
;
150 static int do_segments
;
151 static int do_unwind
;
152 static int do_using_dynamic
;
153 static int do_header
;
155 static int do_version
;
157 static int do_histogram
;
158 static int do_debugging
;
159 static int do_debug_info
;
160 static int do_debug_abbrevs
;
161 static int do_debug_lines
;
162 static int do_debug_pubnames
;
163 static int do_debug_aranges
;
164 static int do_debug_ranges
;
165 static int do_debug_frames
;
166 static int do_debug_frames_interp
;
167 static int do_debug_macinfo
;
168 static int do_debug_str
;
169 static int do_debug_loc
;
172 static int is_32bit_elf
;
173 static int have_frame_base
;
174 static int need_base_address
;
175 static bfd_vma eh_addr_size
;
179 struct group_list
*next
;
180 unsigned int section_index
;
185 struct group_list
*root
;
186 unsigned int group_index
;
189 static size_t group_count
;
190 static struct group
*section_groups
;
191 static struct group
**section_headers_groups
;
193 /* A dynamic array of flags indicating for which sections a hex dump
194 has been requested (via the -x switch) and/or a disassembly dump
195 (via the -i switch). */
196 char *cmdline_dump_sects
= NULL
;
197 unsigned num_cmdline_dump_sects
= 0;
199 /* A dynamic array of flags indicating for which sections a dump of
200 some kind has been requested. It is reset on a per-object file
201 basis and then initialised from the cmdline_dump_sects array and
202 the results of interpreting the -w switch. */
203 char *dump_sects
= NULL
;
204 unsigned int num_dump_sects
= 0;
206 #define HEX_DUMP (1 << 0)
207 #define DISASS_DUMP (1 << 1)
208 #define DEBUG_DUMP (1 << 2)
210 /* How to rpint a vma value. */
211 typedef enum print_mode
223 static bfd_vma (*byte_get
) (unsigned char *, int);
224 static void (*byte_put
) (unsigned char *, bfd_vma
, int);
228 #define SECTION_NAME(X) ((X) == NULL ? "<none>" : \
229 ((X)->sh_name >= string_table_length \
230 ? "<corrupt>" : string_table + (X)->sh_name))
232 /* Given st_shndx I, map to section_headers index. */
233 #define SECTION_HEADER_INDEX(I) \
234 ((I) < SHN_LORESERVE \
236 : ((I) <= SHN_HIRESERVE \
238 : (I) - (SHN_HIRESERVE + 1 - SHN_LORESERVE)))
240 /* Reverse of the above. */
241 #define SECTION_HEADER_NUM(N) \
242 ((N) < SHN_LORESERVE \
244 : (N) + (SHN_HIRESERVE + 1 - SHN_LORESERVE))
246 #define SECTION_HEADER(I) (section_headers + SECTION_HEADER_INDEX (I))
248 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
250 #define BYTE_GET(field) byte_get (field, sizeof (field))
252 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
254 #define GET_ELF_SYMBOLS(file, section) \
255 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
256 : get_64bit_elf_symbols (file, section))
258 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
259 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
260 already been called and verified that the string exists. */
261 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
263 /* This is just a bit of syntatic sugar. */
264 #define streq(a,b) (strcmp ((a), (b)) == 0)
265 #define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
268 error (const char *message
, ...)
272 va_start (args
, message
);
273 fprintf (stderr
, _("%s: Error: "), program_name
);
274 vfprintf (stderr
, message
, args
);
279 warn (const char *message
, ...)
283 va_start (args
, message
);
284 fprintf (stderr
, _("%s: Warning: "), program_name
);
285 vfprintf (stderr
, message
, args
);
290 get_data (void *var
, FILE *file
, long offset
, size_t size
, const char *reason
)
297 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
299 error (_("Unable to seek to 0x%x for %s\n"),
300 archive_file_offset
+ offset
, reason
);
307 mvar
= malloc (size
);
311 error (_("Out of memory allocating 0x%x bytes for %s\n"),
317 if (fread (mvar
, size
, 1, file
) != 1)
319 error (_("Unable to read in 0x%x bytes of %s\n"), size
, reason
);
329 byte_get_little_endian (unsigned char *field
, int size
)
337 return ((unsigned int) (field
[0]))
338 | (((unsigned int) (field
[1])) << 8);
342 /* We want to extract data from an 8 byte wide field and
343 place it into a 4 byte wide field. Since this is a little
344 endian source we can just use the 4 byte extraction code. */
348 return ((unsigned long) (field
[0]))
349 | (((unsigned long) (field
[1])) << 8)
350 | (((unsigned long) (field
[2])) << 16)
351 | (((unsigned long) (field
[3])) << 24);
355 return ((bfd_vma
) (field
[0]))
356 | (((bfd_vma
) (field
[1])) << 8)
357 | (((bfd_vma
) (field
[2])) << 16)
358 | (((bfd_vma
) (field
[3])) << 24)
359 | (((bfd_vma
) (field
[4])) << 32)
360 | (((bfd_vma
) (field
[5])) << 40)
361 | (((bfd_vma
) (field
[6])) << 48)
362 | (((bfd_vma
) (field
[7])) << 56);
365 error (_("Unhandled data length: %d\n"), size
);
371 byte_get_signed (unsigned char *field
, int size
)
373 bfd_vma x
= byte_get (field
, size
);
378 return (x
^ 0x80) - 0x80;
380 return (x
^ 0x8000) - 0x8000;
382 return (x
^ 0x80000000) - 0x80000000;
391 byte_put_little_endian (unsigned char *field
, bfd_vma value
, int size
)
396 field
[7] = (((value
>> 24) >> 24) >> 8) & 0xff;
397 field
[6] = ((value
>> 24) >> 24) & 0xff;
398 field
[5] = ((value
>> 24) >> 16) & 0xff;
399 field
[4] = ((value
>> 24) >> 8) & 0xff;
402 field
[3] = (value
>> 24) & 0xff;
403 field
[2] = (value
>> 16) & 0xff;
406 field
[1] = (value
>> 8) & 0xff;
409 field
[0] = value
& 0xff;
413 error (_("Unhandled data length: %d\n"), size
);
418 #if defined BFD64 && !BFD_HOST_64BIT_LONG
420 print_dec_vma (bfd_vma vma
, int is_signed
)
426 if (is_signed
&& (bfd_signed_vma
) vma
< 0)
435 *bufp
++ = '0' + vma
% 10;
447 print_hex_vma (bfd_vma vma
)
455 char digit
= '0' + (vma
& 0x0f);
457 digit
+= 'a' - '0' - 10;
470 /* Print a VMA value. */
472 print_vma (bfd_vma vma
, print_mode mode
)
481 return printf ("0x%8.8lx", (unsigned long) vma
);
484 return printf ("%8.8lx", (unsigned long) vma
);
488 return printf ("%5ld", (long) vma
);
492 return printf ("0x%lx", (unsigned long) vma
);
495 return printf ("%lx", (unsigned long) vma
);
498 return printf ("%ld", (unsigned long) vma
);
501 return printf ("%lu", (unsigned long) vma
);
524 #if BFD_HOST_64BIT_LONG
525 return nc
+ printf ("%lx", vma
);
527 return nc
+ print_hex_vma (vma
);
531 #if BFD_HOST_64BIT_LONG
532 return printf ("%ld", vma
);
534 return print_dec_vma (vma
, 1);
538 #if BFD_HOST_64BIT_LONG
540 return printf ("%5ld", vma
);
542 return printf ("%#lx", vma
);
545 return printf ("%5ld", _bfd_int64_low (vma
));
547 return print_hex_vma (vma
);
551 #if BFD_HOST_64BIT_LONG
552 return printf ("%lu", vma
);
554 return print_dec_vma (vma
, 0);
562 /* Display a symbol on stdout. If do_wide is not true then
563 format the symbol to be at most WIDTH characters,
564 truncating as necessary. If WIDTH is negative then
565 format the string to be exactly - WIDTH characters,
566 truncating or padding as necessary. */
569 print_symbol (int width
, const char *symbol
)
572 printf ("%s", symbol
);
574 printf ("%-*.*s", width
, width
, symbol
);
576 printf ("%-.*s", width
, symbol
);
580 byte_get_big_endian (unsigned char *field
, int size
)
588 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
592 /* Although we are extracing data from an 8 byte wide field,
593 we are returning only 4 bytes of data. */
598 return ((unsigned long) (field
[3]))
599 | (((unsigned long) (field
[2])) << 8)
600 | (((unsigned long) (field
[1])) << 16)
601 | (((unsigned long) (field
[0])) << 24);
605 return ((bfd_vma
) (field
[7]))
606 | (((bfd_vma
) (field
[6])) << 8)
607 | (((bfd_vma
) (field
[5])) << 16)
608 | (((bfd_vma
) (field
[4])) << 24)
609 | (((bfd_vma
) (field
[3])) << 32)
610 | (((bfd_vma
) (field
[2])) << 40)
611 | (((bfd_vma
) (field
[1])) << 48)
612 | (((bfd_vma
) (field
[0])) << 56);
616 error (_("Unhandled data length: %d\n"), size
);
622 byte_put_big_endian (unsigned char *field
, bfd_vma value
, int size
)
627 field
[7] = value
& 0xff;
628 field
[6] = (value
>> 8) & 0xff;
629 field
[5] = (value
>> 16) & 0xff;
630 field
[4] = (value
>> 24) & 0xff;
635 field
[3] = value
& 0xff;
636 field
[2] = (value
>> 8) & 0xff;
640 field
[1] = value
& 0xff;
644 field
[0] = value
& 0xff;
648 error (_("Unhandled data length: %d\n"), size
);
653 /* Return a pointer to section NAME, or NULL if no such section exists. */
655 static Elf_Internal_Shdr
*
656 find_section (const char *name
)
660 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
661 if (streq (SECTION_NAME (section_headers
+ i
), name
))
662 return section_headers
+ i
;
667 /* Guess the relocation size commonly used by the specific machines. */
670 guess_is_rela (unsigned long e_machine
)
674 /* Targets that use REL relocations. */
689 /* Targets that use RELA relocations. */
704 case EM_CYGNUS_MN10200
:
706 case EM_CYGNUS_MN10300
:
754 warn (_("Don't know about relocations on this machine architecture\n"));
760 slurp_rela_relocs (FILE *file
,
761 unsigned long rel_offset
,
762 unsigned long rel_size
,
763 Elf_Internal_Rela
**relasp
,
764 unsigned long *nrelasp
)
766 Elf_Internal_Rela
*relas
;
767 unsigned long nrelas
;
772 Elf32_External_Rela
*erelas
;
774 erelas
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
778 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
780 relas
= malloc (nrelas
* sizeof (Elf_Internal_Rela
));
784 error (_("out of memory parsing relocs"));
788 for (i
= 0; i
< nrelas
; i
++)
790 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
791 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
792 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
799 Elf64_External_Rela
*erelas
;
801 erelas
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
805 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
807 relas
= malloc (nrelas
* sizeof (Elf_Internal_Rela
));
811 error (_("out of memory parsing relocs"));
815 for (i
= 0; i
< nrelas
; i
++)
817 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
818 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
819 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
830 slurp_rel_relocs (FILE *file
,
831 unsigned long rel_offset
,
832 unsigned long rel_size
,
833 Elf_Internal_Rela
**relsp
,
834 unsigned long *nrelsp
)
836 Elf_Internal_Rela
*rels
;
842 Elf32_External_Rel
*erels
;
844 erels
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
848 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
850 rels
= malloc (nrels
* sizeof (Elf_Internal_Rela
));
854 error (_("out of memory parsing relocs"));
858 for (i
= 0; i
< nrels
; i
++)
860 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
861 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
862 rels
[i
].r_addend
= 0;
869 Elf64_External_Rel
*erels
;
871 erels
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
875 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
877 rels
= malloc (nrels
* sizeof (Elf_Internal_Rela
));
881 error (_("out of memory parsing relocs"));
885 for (i
= 0; i
< nrels
; i
++)
887 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
888 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
889 rels
[i
].r_addend
= 0;
899 /* Display the contents of the relocation data found at the specified
903 dump_relocations (FILE *file
,
904 unsigned long rel_offset
,
905 unsigned long rel_size
,
906 Elf_Internal_Sym
*symtab
,
909 unsigned long strtablen
,
913 Elf_Internal_Rela
*rels
;
916 if (is_rela
== UNKNOWN
)
917 is_rela
= guess_is_rela (elf_header
.e_machine
);
921 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
926 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
935 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
937 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
942 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
944 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
952 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
954 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
959 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
961 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
965 for (i
= 0; i
< rel_size
; i
++)
968 const char *rtype2
= NULL
;
969 const char *rtype3
= NULL
;
972 bfd_vma symtab_index
;
977 offset
= rels
[i
].r_offset
;
978 info
= rels
[i
].r_info
;
982 type
= ELF32_R_TYPE (info
);
983 symtab_index
= ELF32_R_SYM (info
);
987 /* The #ifdef BFD64 below is to prevent a compile time warning.
988 We know that if we do not have a 64 bit data type that we
989 will never execute this code anyway. */
991 if (elf_header
.e_machine
== EM_MIPS
)
993 /* In little-endian objects, r_info isn't really a 64-bit
994 little-endian value: it has a 32-bit little-endian
995 symbol index followed by four individual byte fields.
996 Reorder INFO accordingly. */
997 if (elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
998 info
= (((info
& 0xffffffff) << 32)
999 | ((info
>> 56) & 0xff)
1000 | ((info
>> 40) & 0xff00)
1001 | ((info
>> 24) & 0xff0000)
1002 | ((info
>> 8) & 0xff000000));
1003 type
= ELF64_MIPS_R_TYPE (info
);
1004 type2
= ELF64_MIPS_R_TYPE2 (info
);
1005 type3
= ELF64_MIPS_R_TYPE3 (info
);
1007 else if (elf_header
.e_machine
== EM_SPARCV9
)
1008 type
= ELF64_R_TYPE_ID (info
);
1010 type
= ELF64_R_TYPE (info
);
1012 symtab_index
= ELF64_R_SYM (info
);
1018 #ifdef _bfd_int64_low
1019 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset
), _bfd_int64_low (info
));
1021 printf ("%8.8lx %8.8lx ", offset
, info
);
1026 #ifdef _bfd_int64_low
1028 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1029 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1030 _bfd_int64_high (offset
),
1031 _bfd_int64_low (offset
),
1032 _bfd_int64_high (info
),
1033 _bfd_int64_low (info
));
1036 ? "%16.16lx %16.16lx "
1037 : "%12.12lx %12.12lx ",
1042 switch (elf_header
.e_machine
)
1049 case EM_CYGNUS_M32R
:
1050 rtype
= elf_m32r_reloc_type (type
);
1055 rtype
= elf_i386_reloc_type (type
);
1060 rtype
= elf_m68hc11_reloc_type (type
);
1064 rtype
= elf_m68k_reloc_type (type
);
1068 rtype
= elf_i960_reloc_type (type
);
1073 rtype
= elf_avr_reloc_type (type
);
1076 case EM_OLD_SPARCV9
:
1077 case EM_SPARC32PLUS
:
1080 rtype
= elf_sparc_reloc_type (type
);
1084 case EM_CYGNUS_V850
:
1085 rtype
= v850_reloc_type (type
);
1089 case EM_CYGNUS_D10V
:
1090 rtype
= elf_d10v_reloc_type (type
);
1094 case EM_CYGNUS_D30V
:
1095 rtype
= elf_d30v_reloc_type (type
);
1099 rtype
= elf_dlx_reloc_type (type
);
1103 rtype
= elf_sh_reloc_type (type
);
1107 case EM_CYGNUS_MN10300
:
1108 rtype
= elf_mn10300_reloc_type (type
);
1112 case EM_CYGNUS_MN10200
:
1113 rtype
= elf_mn10200_reloc_type (type
);
1117 case EM_CYGNUS_FR30
:
1118 rtype
= elf_fr30_reloc_type (type
);
1122 rtype
= elf_frv_reloc_type (type
);
1126 rtype
= elf_mcore_reloc_type (type
);
1130 rtype
= elf_mmix_reloc_type (type
);
1135 rtype
= elf_msp430_reloc_type (type
);
1139 rtype
= elf_ppc_reloc_type (type
);
1143 rtype
= elf_ppc64_reloc_type (type
);
1147 case EM_MIPS_RS3_LE
:
1148 rtype
= elf_mips_reloc_type (type
);
1151 rtype2
= elf_mips_reloc_type (type2
);
1152 rtype3
= elf_mips_reloc_type (type3
);
1157 rtype
= elf_alpha_reloc_type (type
);
1161 rtype
= elf_arm_reloc_type (type
);
1165 rtype
= elf_arc_reloc_type (type
);
1169 rtype
= elf_hppa_reloc_type (type
);
1175 rtype
= elf_h8_reloc_type (type
);
1180 rtype
= elf_or32_reloc_type (type
);
1185 rtype
= elf_pj_reloc_type (type
);
1188 rtype
= elf_ia64_reloc_type (type
);
1192 rtype
= elf_cris_reloc_type (type
);
1196 rtype
= elf_i860_reloc_type (type
);
1200 rtype
= elf_x86_64_reloc_type (type
);
1204 rtype
= i370_reloc_type (type
);
1209 rtype
= elf_s390_reloc_type (type
);
1213 rtype
= elf_xstormy16_reloc_type (type
);
1217 rtype
= elf_crx_reloc_type (type
);
1221 rtype
= elf_vax_reloc_type (type
);
1226 rtype
= elf_ip2k_reloc_type (type
);
1230 rtype
= elf_iq2000_reloc_type (type
);
1235 rtype
= elf_xtensa_reloc_type (type
);
1239 rtype
= elf_ms1_reloc_type (type
);
1244 #ifdef _bfd_int64_low
1245 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type
));
1247 printf (_("unrecognized: %-7lx"), type
);
1250 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1252 if (elf_header
.e_machine
== EM_ALPHA
1253 && streq (rtype
, "R_ALPHA_LITUSE")
1256 switch (rels
[i
].r_addend
)
1258 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1259 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1260 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1261 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1262 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1263 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1264 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1265 default: rtype
= NULL
;
1268 printf (" (%s)", rtype
);
1272 printf (_("<unknown addend: %lx>"),
1273 (unsigned long) rels
[i
].r_addend
);
1276 else if (symtab_index
)
1278 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1279 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1282 Elf_Internal_Sym
*psym
;
1284 psym
= symtab
+ symtab_index
;
1287 print_vma (psym
->st_value
, LONG_HEX
);
1288 printf (is_32bit_elf
? " " : " ");
1290 if (psym
->st_name
== 0)
1292 const char *sec_name
= "<null>";
1295 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1297 bfd_vma sec_index
= (bfd_vma
) -1;
1299 if (psym
->st_shndx
< SHN_LORESERVE
)
1300 sec_index
= psym
->st_shndx
;
1301 else if (psym
->st_shndx
> SHN_HIRESERVE
)
1302 sec_index
= psym
->st_shndx
- (SHN_HIRESERVE
+ 1
1305 if (sec_index
!= (bfd_vma
) -1)
1306 sec_name
= SECTION_NAME (section_headers
+ sec_index
);
1307 else if (psym
->st_shndx
== SHN_ABS
)
1309 else if (psym
->st_shndx
== SHN_COMMON
)
1310 sec_name
= "COMMON";
1311 else if (elf_header
.e_machine
== EM_IA_64
1312 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1313 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1314 sec_name
= "ANSI_COM";
1317 sprintf (name_buf
, "<section 0x%x>",
1318 (unsigned int) psym
->st_shndx
);
1319 sec_name
= name_buf
;
1322 print_symbol (22, sec_name
);
1324 else if (strtab
== NULL
)
1325 printf (_("<string table index: %3ld>"), psym
->st_name
);
1326 else if (psym
->st_name
> strtablen
)
1327 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1329 print_symbol (22, strtab
+ psym
->st_name
);
1332 printf (" + %lx", (unsigned long) rels
[i
].r_addend
);
1337 printf ("%*c", is_32bit_elf
?
1338 (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1339 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1342 if (elf_header
.e_machine
== EM_SPARCV9
&& streq (rtype
, "R_SPARC_OLO10"))
1343 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1347 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1349 printf (" Type2: ");
1352 #ifdef _bfd_int64_low
1353 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2
));
1355 printf (_("unrecognized: %-7lx"), type2
);
1358 printf ("%-17.17s", rtype2
);
1360 printf ("\n Type3: ");
1363 #ifdef _bfd_int64_low
1364 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3
));
1366 printf (_("unrecognized: %-7lx"), type3
);
1369 printf ("%-17.17s", rtype3
);
1381 get_mips_dynamic_type (unsigned long type
)
1385 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1386 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1387 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1388 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1389 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1390 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1391 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1392 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1393 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1394 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1395 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1396 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1397 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1398 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1399 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1400 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1401 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1402 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1403 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1404 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1405 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1406 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1407 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1408 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1409 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1410 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1411 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1412 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1413 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1414 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1415 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1416 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1417 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1418 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1419 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1420 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1421 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1422 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1423 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1424 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1425 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1426 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1427 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1434 get_sparc64_dynamic_type (unsigned long type
)
1438 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1445 get_ppc_dynamic_type (unsigned long type
)
1449 case DT_PPC_GOT
: return "PPC_GOT";
1456 get_ppc64_dynamic_type (unsigned long type
)
1460 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1461 case DT_PPC64_OPD
: return "PPC64_OPD";
1462 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1469 get_parisc_dynamic_type (unsigned long type
)
1473 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1474 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1475 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1476 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1477 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1478 case DT_HP_PREINIT
: return "HP_PREINIT";
1479 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1480 case DT_HP_NEEDED
: return "HP_NEEDED";
1481 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1482 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1483 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1484 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1485 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1492 get_ia64_dynamic_type (unsigned long type
)
1496 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1503 get_alpha_dynamic_type (unsigned long type
)
1507 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1514 get_dynamic_type (unsigned long type
)
1516 static char buff
[64];
1520 case DT_NULL
: return "NULL";
1521 case DT_NEEDED
: return "NEEDED";
1522 case DT_PLTRELSZ
: return "PLTRELSZ";
1523 case DT_PLTGOT
: return "PLTGOT";
1524 case DT_HASH
: return "HASH";
1525 case DT_STRTAB
: return "STRTAB";
1526 case DT_SYMTAB
: return "SYMTAB";
1527 case DT_RELA
: return "RELA";
1528 case DT_RELASZ
: return "RELASZ";
1529 case DT_RELAENT
: return "RELAENT";
1530 case DT_STRSZ
: return "STRSZ";
1531 case DT_SYMENT
: return "SYMENT";
1532 case DT_INIT
: return "INIT";
1533 case DT_FINI
: return "FINI";
1534 case DT_SONAME
: return "SONAME";
1535 case DT_RPATH
: return "RPATH";
1536 case DT_SYMBOLIC
: return "SYMBOLIC";
1537 case DT_REL
: return "REL";
1538 case DT_RELSZ
: return "RELSZ";
1539 case DT_RELENT
: return "RELENT";
1540 case DT_PLTREL
: return "PLTREL";
1541 case DT_DEBUG
: return "DEBUG";
1542 case DT_TEXTREL
: return "TEXTREL";
1543 case DT_JMPREL
: return "JMPREL";
1544 case DT_BIND_NOW
: return "BIND_NOW";
1545 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1546 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1547 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1548 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1549 case DT_RUNPATH
: return "RUNPATH";
1550 case DT_FLAGS
: return "FLAGS";
1552 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1553 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1555 case DT_CHECKSUM
: return "CHECKSUM";
1556 case DT_PLTPADSZ
: return "PLTPADSZ";
1557 case DT_MOVEENT
: return "MOVEENT";
1558 case DT_MOVESZ
: return "MOVESZ";
1559 case DT_FEATURE
: return "FEATURE";
1560 case DT_POSFLAG_1
: return "POSFLAG_1";
1561 case DT_SYMINSZ
: return "SYMINSZ";
1562 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1564 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1565 case DT_CONFIG
: return "CONFIG";
1566 case DT_DEPAUDIT
: return "DEPAUDIT";
1567 case DT_AUDIT
: return "AUDIT";
1568 case DT_PLTPAD
: return "PLTPAD";
1569 case DT_MOVETAB
: return "MOVETAB";
1570 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1572 case DT_VERSYM
: return "VERSYM";
1574 case DT_RELACOUNT
: return "RELACOUNT";
1575 case DT_RELCOUNT
: return "RELCOUNT";
1576 case DT_FLAGS_1
: return "FLAGS_1";
1577 case DT_VERDEF
: return "VERDEF";
1578 case DT_VERDEFNUM
: return "VERDEFNUM";
1579 case DT_VERNEED
: return "VERNEED";
1580 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1582 case DT_AUXILIARY
: return "AUXILIARY";
1583 case DT_USED
: return "USED";
1584 case DT_FILTER
: return "FILTER";
1586 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1587 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1588 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1589 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1590 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1593 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1597 switch (elf_header
.e_machine
)
1600 case EM_MIPS_RS3_LE
:
1601 result
= get_mips_dynamic_type (type
);
1604 result
= get_sparc64_dynamic_type (type
);
1607 result
= get_ppc_dynamic_type (type
);
1610 result
= get_ppc64_dynamic_type (type
);
1613 result
= get_ia64_dynamic_type (type
);
1616 result
= get_alpha_dynamic_type (type
);
1626 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1628 else if ((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1632 switch (elf_header
.e_machine
)
1635 result
= get_parisc_dynamic_type (type
);
1645 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1649 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1656 get_file_type (unsigned e_type
)
1658 static char buff
[32];
1662 case ET_NONE
: return _("NONE (None)");
1663 case ET_REL
: return _("REL (Relocatable file)");
1664 case ET_EXEC
: return _("EXEC (Executable file)");
1665 case ET_DYN
: return _("DYN (Shared object file)");
1666 case ET_CORE
: return _("CORE (Core file)");
1669 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1670 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1671 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1672 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1674 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1680 get_machine_name (unsigned e_machine
)
1682 static char buff
[64]; /* XXX */
1686 case EM_NONE
: return _("None");
1687 case EM_M32
: return "WE32100";
1688 case EM_SPARC
: return "Sparc";
1689 case EM_386
: return "Intel 80386";
1690 case EM_68K
: return "MC68000";
1691 case EM_88K
: return "MC88000";
1692 case EM_486
: return "Intel 80486";
1693 case EM_860
: return "Intel 80860";
1694 case EM_MIPS
: return "MIPS R3000";
1695 case EM_S370
: return "IBM System/370";
1696 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1697 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1698 case EM_PARISC
: return "HPPA";
1699 case EM_PPC_OLD
: return "Power PC (old)";
1700 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1701 case EM_960
: return "Intel 90860";
1702 case EM_PPC
: return "PowerPC";
1703 case EM_PPC64
: return "PowerPC64";
1704 case EM_V800
: return "NEC V800";
1705 case EM_FR20
: return "Fujitsu FR20";
1706 case EM_RH32
: return "TRW RH32";
1707 case EM_MCORE
: return "MCORE";
1708 case EM_ARM
: return "ARM";
1709 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1710 case EM_SH
: return "Renesas / SuperH SH";
1711 case EM_SPARCV9
: return "Sparc v9";
1712 case EM_TRICORE
: return "Siemens Tricore";
1713 case EM_ARC
: return "ARC";
1714 case EM_H8_300
: return "Renesas H8/300";
1715 case EM_H8_300H
: return "Renesas H8/300H";
1716 case EM_H8S
: return "Renesas H8S";
1717 case EM_H8_500
: return "Renesas H8/500";
1718 case EM_IA_64
: return "Intel IA-64";
1719 case EM_MIPS_X
: return "Stanford MIPS-X";
1720 case EM_COLDFIRE
: return "Motorola Coldfire";
1721 case EM_68HC12
: return "Motorola M68HC12";
1722 case EM_ALPHA
: return "Alpha";
1723 case EM_CYGNUS_D10V
:
1724 case EM_D10V
: return "d10v";
1725 case EM_CYGNUS_D30V
:
1726 case EM_D30V
: return "d30v";
1727 case EM_CYGNUS_M32R
:
1728 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1729 case EM_CYGNUS_V850
:
1730 case EM_V850
: return "NEC v850";
1731 case EM_CYGNUS_MN10300
:
1732 case EM_MN10300
: return "mn10300";
1733 case EM_CYGNUS_MN10200
:
1734 case EM_MN10200
: return "mn10200";
1735 case EM_CYGNUS_FR30
:
1736 case EM_FR30
: return "Fujitsu FR30";
1737 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1739 case EM_PJ
: return "picoJava";
1740 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1741 case EM_PCP
: return "Siemens PCP";
1742 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1743 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1744 case EM_STARCORE
: return "Motorola Star*Core processor";
1745 case EM_ME16
: return "Toyota ME16 processor";
1746 case EM_ST100
: return "STMicroelectronics ST100 processor";
1747 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1748 case EM_FX66
: return "Siemens FX66 microcontroller";
1749 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1750 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1751 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1752 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1753 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1754 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1755 case EM_SVX
: return "Silicon Graphics SVx";
1756 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1757 case EM_VAX
: return "Digital VAX";
1759 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1760 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1761 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1762 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1763 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1764 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1765 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1766 case EM_PRISM
: return "Vitesse Prism";
1767 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1769 case EM_S390
: return "IBM S/390";
1770 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1772 case EM_OR32
: return "OpenRISC";
1773 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1774 case EM_DLX
: return "OpenDLX";
1776 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1777 case EM_IQ2000
: return "Vitesse IQ2000";
1779 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1780 case EM_MS1
: return "Morpho Techologies MS1 processor";
1782 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_machine
);
1788 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
1793 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1794 e_flags
&= ~ EF_ARM_EABIMASK
;
1796 /* Handle "generic" ARM flags. */
1797 if (e_flags
& EF_ARM_RELEXEC
)
1799 strcat (buf
, ", relocatable executable");
1800 e_flags
&= ~ EF_ARM_RELEXEC
;
1803 if (e_flags
& EF_ARM_HASENTRY
)
1805 strcat (buf
, ", has entry point");
1806 e_flags
&= ~ EF_ARM_HASENTRY
;
1809 /* Now handle EABI specific flags. */
1813 strcat (buf
, ", <unrecognized EABI>");
1818 case EF_ARM_EABI_VER1
:
1819 strcat (buf
, ", Version1 EABI");
1824 /* Process flags one bit at a time. */
1825 flag
= e_flags
& - e_flags
;
1830 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1831 strcat (buf
, ", sorted symbol tables");
1841 case EF_ARM_EABI_VER2
:
1842 strcat (buf
, ", Version2 EABI");
1847 /* Process flags one bit at a time. */
1848 flag
= e_flags
& - e_flags
;
1853 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1854 strcat (buf
, ", sorted symbol tables");
1857 case EF_ARM_DYNSYMSUSESEGIDX
:
1858 strcat (buf
, ", dynamic symbols use segment index");
1861 case EF_ARM_MAPSYMSFIRST
:
1862 strcat (buf
, ", mapping symbols precede others");
1872 case EF_ARM_EABI_VER3
:
1873 strcat (buf
, ", Version3 EABI");
1876 case EF_ARM_EABI_VER4
:
1877 strcat (buf
, ", Version4 EABI");
1882 /* Process flags one bit at a time. */
1883 flag
= e_flags
& - e_flags
;
1889 strcat (buf
, ", BE8");
1893 strcat (buf
, ", LE8");
1903 case EF_ARM_EABI_UNKNOWN
:
1904 strcat (buf
, ", GNU EABI");
1909 /* Process flags one bit at a time. */
1910 flag
= e_flags
& - e_flags
;
1915 case EF_ARM_INTERWORK
:
1916 strcat (buf
, ", interworking enabled");
1919 case EF_ARM_APCS_26
:
1920 strcat (buf
, ", uses APCS/26");
1923 case EF_ARM_APCS_FLOAT
:
1924 strcat (buf
, ", uses APCS/float");
1928 strcat (buf
, ", position independent");
1932 strcat (buf
, ", 8 bit structure alignment");
1935 case EF_ARM_NEW_ABI
:
1936 strcat (buf
, ", uses new ABI");
1939 case EF_ARM_OLD_ABI
:
1940 strcat (buf
, ", uses old ABI");
1943 case EF_ARM_SOFT_FLOAT
:
1944 strcat (buf
, ", software FP");
1947 case EF_ARM_VFP_FLOAT
:
1948 strcat (buf
, ", VFP");
1951 case EF_ARM_MAVERICK_FLOAT
:
1952 strcat (buf
, ", Maverick FP");
1963 strcat (buf
,", <unknown>");
1967 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
1969 static char buf
[1024];
1981 decode_ARM_machine_flags (e_flags
, buf
);
1985 switch (e_flags
& EF_FRV_CPU_MASK
)
1987 case EF_FRV_CPU_GENERIC
:
1991 strcat (buf
, ", fr???");
1994 case EF_FRV_CPU_FR300
:
1995 strcat (buf
, ", fr300");
1998 case EF_FRV_CPU_FR400
:
1999 strcat (buf
, ", fr400");
2001 case EF_FRV_CPU_FR405
:
2002 strcat (buf
, ", fr405");
2005 case EF_FRV_CPU_FR450
:
2006 strcat (buf
, ", fr450");
2009 case EF_FRV_CPU_FR500
:
2010 strcat (buf
, ", fr500");
2012 case EF_FRV_CPU_FR550
:
2013 strcat (buf
, ", fr550");
2016 case EF_FRV_CPU_SIMPLE
:
2017 strcat (buf
, ", simple");
2019 case EF_FRV_CPU_TOMCAT
:
2020 strcat (buf
, ", tomcat");
2026 if (e_flags
& EF_CPU32
)
2027 strcat (buf
, ", cpu32");
2028 if (e_flags
& EF_M68000
)
2029 strcat (buf
, ", m68000");
2033 if (e_flags
& EF_PPC_EMB
)
2034 strcat (buf
, ", emb");
2036 if (e_flags
& EF_PPC_RELOCATABLE
)
2037 strcat (buf
, ", relocatable");
2039 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2040 strcat (buf
, ", relocatable-lib");
2044 case EM_CYGNUS_V850
:
2045 switch (e_flags
& EF_V850_ARCH
)
2048 strcat (buf
, ", v850e1");
2051 strcat (buf
, ", v850e");
2054 strcat (buf
, ", v850");
2057 strcat (buf
, ", unknown v850 architecture variant");
2063 case EM_CYGNUS_M32R
:
2064 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2065 strcat (buf
, ", m32r");
2070 case EM_MIPS_RS3_LE
:
2071 if (e_flags
& EF_MIPS_NOREORDER
)
2072 strcat (buf
, ", noreorder");
2074 if (e_flags
& EF_MIPS_PIC
)
2075 strcat (buf
, ", pic");
2077 if (e_flags
& EF_MIPS_CPIC
)
2078 strcat (buf
, ", cpic");
2080 if (e_flags
& EF_MIPS_UCODE
)
2081 strcat (buf
, ", ugen_reserved");
2083 if (e_flags
& EF_MIPS_ABI2
)
2084 strcat (buf
, ", abi2");
2086 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2087 strcat (buf
, ", odk first");
2089 if (e_flags
& EF_MIPS_32BITMODE
)
2090 strcat (buf
, ", 32bitmode");
2092 switch ((e_flags
& EF_MIPS_MACH
))
2094 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2095 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2096 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2097 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2098 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2099 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2100 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2101 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2102 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2103 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2105 /* We simply ignore the field in this case to avoid confusion:
2106 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2109 default: strcat (buf
, ", unknown CPU"); break;
2112 switch ((e_flags
& EF_MIPS_ABI
))
2114 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2115 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2116 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2117 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2119 /* We simply ignore the field in this case to avoid confusion:
2120 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2121 This means it is likely to be an o32 file, but not for
2124 default: strcat (buf
, ", unknown ABI"); break;
2127 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2128 strcat (buf
, ", mdmx");
2130 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2131 strcat (buf
, ", mips16");
2133 switch ((e_flags
& EF_MIPS_ARCH
))
2135 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2136 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2137 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2138 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2139 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2140 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2141 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2142 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2143 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2144 default: strcat (buf
, ", unknown ISA"); break;
2150 switch ((e_flags
& EF_SH_MACH_MASK
))
2152 case EF_SH1
: strcat (buf
, ", sh1"); break;
2153 case EF_SH2
: strcat (buf
, ", sh2"); break;
2154 case EF_SH3
: strcat (buf
, ", sh3"); break;
2155 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2156 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2157 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2158 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2159 case EF_SH4
: strcat (buf
, ", sh4"); break;
2160 case EF_SH5
: strcat (buf
, ", sh5"); break;
2161 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2162 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2163 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2164 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2165 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2166 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2167 default: strcat (buf
, ", unknown ISA"); break;
2173 if (e_flags
& EF_SPARC_32PLUS
)
2174 strcat (buf
, ", v8+");
2176 if (e_flags
& EF_SPARC_SUN_US1
)
2177 strcat (buf
, ", ultrasparcI");
2179 if (e_flags
& EF_SPARC_SUN_US3
)
2180 strcat (buf
, ", ultrasparcIII");
2182 if (e_flags
& EF_SPARC_HAL_R1
)
2183 strcat (buf
, ", halr1");
2185 if (e_flags
& EF_SPARC_LEDATA
)
2186 strcat (buf
, ", ledata");
2188 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2189 strcat (buf
, ", tso");
2191 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2192 strcat (buf
, ", pso");
2194 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2195 strcat (buf
, ", rmo");
2199 switch (e_flags
& EF_PARISC_ARCH
)
2201 case EFA_PARISC_1_0
:
2202 strcpy (buf
, ", PA-RISC 1.0");
2204 case EFA_PARISC_1_1
:
2205 strcpy (buf
, ", PA-RISC 1.1");
2207 case EFA_PARISC_2_0
:
2208 strcpy (buf
, ", PA-RISC 2.0");
2213 if (e_flags
& EF_PARISC_TRAPNIL
)
2214 strcat (buf
, ", trapnil");
2215 if (e_flags
& EF_PARISC_EXT
)
2216 strcat (buf
, ", ext");
2217 if (e_flags
& EF_PARISC_LSB
)
2218 strcat (buf
, ", lsb");
2219 if (e_flags
& EF_PARISC_WIDE
)
2220 strcat (buf
, ", wide");
2221 if (e_flags
& EF_PARISC_NO_KABP
)
2222 strcat (buf
, ", no kabp");
2223 if (e_flags
& EF_PARISC_LAZYSWAP
)
2224 strcat (buf
, ", lazyswap");
2229 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2230 strcat (buf
, ", new calling convention");
2232 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2233 strcat (buf
, ", gnu calling convention");
2237 if ((e_flags
& EF_IA_64_ABI64
))
2238 strcat (buf
, ", 64-bit");
2240 strcat (buf
, ", 32-bit");
2241 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2242 strcat (buf
, ", reduced fp model");
2243 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2244 strcat (buf
, ", no function descriptors, constant gp");
2245 else if ((e_flags
& EF_IA_64_CONS_GP
))
2246 strcat (buf
, ", constant gp");
2247 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2248 strcat (buf
, ", absolute");
2252 if ((e_flags
& EF_VAX_NONPIC
))
2253 strcat (buf
, ", non-PIC");
2254 if ((e_flags
& EF_VAX_DFLOAT
))
2255 strcat (buf
, ", D-Float");
2256 if ((e_flags
& EF_VAX_GFLOAT
))
2257 strcat (buf
, ", G-Float");
2266 get_osabi_name (unsigned int osabi
)
2268 static char buff
[32];
2272 case ELFOSABI_NONE
: return "UNIX - System V";
2273 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2274 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2275 case ELFOSABI_LINUX
: return "UNIX - Linux";
2276 case ELFOSABI_HURD
: return "GNU/Hurd";
2277 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2278 case ELFOSABI_AIX
: return "UNIX - AIX";
2279 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2280 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2281 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2282 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2283 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2284 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2285 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2286 case ELFOSABI_AROS
: return "Amiga Research OS";
2287 case ELFOSABI_STANDALONE
: return _("Standalone App");
2288 case ELFOSABI_ARM
: return "ARM";
2290 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2296 get_arm_segment_type (unsigned long type
)
2310 get_mips_segment_type (unsigned long type
)
2314 case PT_MIPS_REGINFO
:
2316 case PT_MIPS_RTPROC
:
2318 case PT_MIPS_OPTIONS
:
2328 get_parisc_segment_type (unsigned long type
)
2332 case PT_HP_TLS
: return "HP_TLS";
2333 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2334 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2335 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2336 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2337 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2338 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2339 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2340 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2341 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2342 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2343 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2344 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2345 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2354 get_ia64_segment_type (unsigned long type
)
2358 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2359 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2360 case PT_HP_TLS
: return "HP_TLS";
2361 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2362 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2363 case PT_IA_64_HP_STACK
: return "HP_STACK";
2372 get_segment_type (unsigned long p_type
)
2374 static char buff
[32];
2378 case PT_NULL
: return "NULL";
2379 case PT_LOAD
: return "LOAD";
2380 case PT_DYNAMIC
: return "DYNAMIC";
2381 case PT_INTERP
: return "INTERP";
2382 case PT_NOTE
: return "NOTE";
2383 case PT_SHLIB
: return "SHLIB";
2384 case PT_PHDR
: return "PHDR";
2385 case PT_TLS
: return "TLS";
2387 case PT_GNU_EH_FRAME
:
2388 return "GNU_EH_FRAME";
2389 case PT_GNU_STACK
: return "GNU_STACK";
2390 case PT_GNU_RELRO
: return "GNU_RELRO";
2393 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2397 switch (elf_header
.e_machine
)
2400 result
= get_arm_segment_type (p_type
);
2403 case EM_MIPS_RS3_LE
:
2404 result
= get_mips_segment_type (p_type
);
2407 result
= get_parisc_segment_type (p_type
);
2410 result
= get_ia64_segment_type (p_type
);
2420 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2422 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2426 switch (elf_header
.e_machine
)
2429 result
= get_parisc_segment_type (p_type
);
2432 result
= get_ia64_segment_type (p_type
);
2442 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2445 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2452 get_mips_section_type_name (unsigned int sh_type
)
2456 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2457 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2458 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2459 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2460 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2461 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2462 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2463 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2464 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2465 case SHT_MIPS_RELD
: return "MIPS_RELD";
2466 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2467 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2468 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2469 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2470 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2471 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2472 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2473 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2474 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2475 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2476 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2477 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2478 case SHT_MIPS_LINE
: return "MIPS_LINE";
2479 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2480 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2481 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2482 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2483 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2484 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2485 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2486 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2487 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2488 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2489 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2490 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2491 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2492 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2493 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2494 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2502 get_parisc_section_type_name (unsigned int sh_type
)
2506 case SHT_PARISC_EXT
: return "PARISC_EXT";
2507 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2508 case SHT_PARISC_DOC
: return "PARISC_DOC";
2516 get_ia64_section_type_name (unsigned int sh_type
)
2518 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2519 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2520 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2524 case SHT_IA_64_EXT
: return "IA_64_EXT";
2525 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2526 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2534 get_x86_64_section_type_name (unsigned int sh_type
)
2538 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2546 get_arm_section_type_name (unsigned int sh_type
)
2559 get_section_type_name (unsigned int sh_type
)
2561 static char buff
[32];
2565 case SHT_NULL
: return "NULL";
2566 case SHT_PROGBITS
: return "PROGBITS";
2567 case SHT_SYMTAB
: return "SYMTAB";
2568 case SHT_STRTAB
: return "STRTAB";
2569 case SHT_RELA
: return "RELA";
2570 case SHT_HASH
: return "HASH";
2571 case SHT_DYNAMIC
: return "DYNAMIC";
2572 case SHT_NOTE
: return "NOTE";
2573 case SHT_NOBITS
: return "NOBITS";
2574 case SHT_REL
: return "REL";
2575 case SHT_SHLIB
: return "SHLIB";
2576 case SHT_DYNSYM
: return "DYNSYM";
2577 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2578 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2579 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2580 case SHT_GROUP
: return "GROUP";
2581 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2582 case SHT_GNU_verdef
: return "VERDEF";
2583 case SHT_GNU_verneed
: return "VERNEED";
2584 case SHT_GNU_versym
: return "VERSYM";
2585 case 0x6ffffff0: return "VERSYM";
2586 case 0x6ffffffc: return "VERDEF";
2587 case 0x7ffffffd: return "AUXILIARY";
2588 case 0x7fffffff: return "FILTER";
2589 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2592 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2596 switch (elf_header
.e_machine
)
2599 case EM_MIPS_RS3_LE
:
2600 result
= get_mips_section_type_name (sh_type
);
2603 result
= get_parisc_section_type_name (sh_type
);
2606 result
= get_ia64_section_type_name (sh_type
);
2609 result
= get_x86_64_section_type_name (sh_type
);
2612 result
= get_arm_section_type_name (sh_type
);
2622 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2624 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2625 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2626 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2627 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2629 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
2635 #define OPTION_DEBUG_DUMP 512
2637 static struct option options
[] =
2639 {"all", no_argument
, 0, 'a'},
2640 {"file-header", no_argument
, 0, 'h'},
2641 {"program-headers", no_argument
, 0, 'l'},
2642 {"headers", no_argument
, 0, 'e'},
2643 {"histogram", no_argument
, 0, 'I'},
2644 {"segments", no_argument
, 0, 'l'},
2645 {"sections", no_argument
, 0, 'S'},
2646 {"section-headers", no_argument
, 0, 'S'},
2647 {"section-groups", no_argument
, 0, 'g'},
2648 {"full-section-name",no_argument
, 0, 'N'},
2649 {"symbols", no_argument
, 0, 's'},
2650 {"syms", no_argument
, 0, 's'},
2651 {"relocs", no_argument
, 0, 'r'},
2652 {"notes", no_argument
, 0, 'n'},
2653 {"dynamic", no_argument
, 0, 'd'},
2654 {"arch-specific", no_argument
, 0, 'A'},
2655 {"version-info", no_argument
, 0, 'V'},
2656 {"use-dynamic", no_argument
, 0, 'D'},
2657 {"hex-dump", required_argument
, 0, 'x'},
2658 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2659 {"unwind", no_argument
, 0, 'u'},
2660 #ifdef SUPPORT_DISASSEMBLY
2661 {"instruction-dump", required_argument
, 0, 'i'},
2664 {"version", no_argument
, 0, 'v'},
2665 {"wide", no_argument
, 0, 'W'},
2666 {"help", no_argument
, 0, 'H'},
2667 {0, no_argument
, 0, 0}
2673 fprintf (stdout
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2674 fprintf (stdout
, _(" Display information about the contents of ELF format files\n"));
2675 fprintf (stdout
, _(" Options are:\n\
2676 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2677 -h --file-header Display the ELF file header\n\
2678 -l --program-headers Display the program headers\n\
2679 --segments An alias for --program-headers\n\
2680 -S --section-headers Display the sections' header\n\
2681 --sections An alias for --section-headers\n\
2682 -g --section-groups Display the section groups\n\
2683 -N --full-section-name\n\
2684 Display the full section name\n\
2685 -e --headers Equivalent to: -h -l -S\n\
2686 -s --syms Display the symbol table\n\
2687 --symbols An alias for --syms\n\
2688 -n --notes Display the core notes (if present)\n\
2689 -r --relocs Display the relocations (if present)\n\
2690 -u --unwind Display the unwind info (if present)\n\
2691 -d --dynamic Display the dynamic section (if present)\n\
2692 -V --version-info Display the version sections (if present)\n\
2693 -A --arch-specific Display architecture specific information (if any).\n\
2694 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2695 -x --hex-dump=<number> Dump the contents of section <number>\n\
2696 -w[liaprmfFsoR] or\n\
2697 --debug-dump[=line,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
2698 Display the contents of DWARF2 debug sections\n"));
2699 #ifdef SUPPORT_DISASSEMBLY
2700 fprintf (stdout
, _("\
2701 -i --instruction-dump=<number>\n\
2702 Disassemble the contents of section <number>\n"));
2704 fprintf (stdout
, _("\
2705 -I --histogram Display histogram of bucket list lengths\n\
2706 -W --wide Allow output width to exceed 80 characters\n\
2707 -H --help Display this information\n\
2708 -v --version Display the version number of readelf\n"));
2709 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2714 /* Record the fact that the user wants the contents of section number
2715 SECTION to be displayed using the method(s) encoded as flags bits
2716 in TYPE. Note, TYPE can be zero if we are creating the array for
2720 request_dump (unsigned int section
, int type
)
2722 if (section
>= num_dump_sects
)
2724 char *new_dump_sects
;
2726 new_dump_sects
= calloc (section
+ 1, 1);
2728 if (new_dump_sects
== NULL
)
2729 error (_("Out of memory allocating dump request table."));
2732 /* Copy current flag settings. */
2733 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2737 dump_sects
= new_dump_sects
;
2738 num_dump_sects
= section
+ 1;
2743 dump_sects
[section
] |= type
;
2749 parse_args (int argc
, char **argv
)
2756 while ((c
= getopt_long
2757 (argc
, argv
, "ersuahnldSDAINgw::x:i:vVWH", options
, NULL
)) != EOF
)
2778 do_section_groups
++;
2786 do_section_groups
++;
2789 do_full_section_name
++;
2831 section
= strtoul (optarg
, & cp
, 0);
2832 if (! *cp
&& section
>= 0)
2834 request_dump (section
, HEX_DUMP
);
2844 unsigned int index
= 0;
2848 while (optarg
[index
])
2849 switch (optarg
[index
++])
2858 do_debug_abbrevs
= 1;
2868 do_debug_pubnames
= 1;
2872 do_debug_aranges
= 1;
2876 do_debug_ranges
= 1;
2880 do_debug_frames_interp
= 1;
2882 do_debug_frames
= 1;
2887 do_debug_macinfo
= 1;
2901 warn (_("Unrecognized debug option '%s'\n"), optarg
);
2906 case OPTION_DEBUG_DUMP
:
2914 const char * option
;
2917 debug_dump_long_opts
;
2919 debug_dump_long_opts opts_table
[] =
2921 /* Please keep this table alpha- sorted. */
2922 { "Ranges", & do_debug_ranges
},
2923 { "abbrev", & do_debug_abbrevs
},
2924 { "aranges", & do_debug_aranges
},
2925 { "frames", & do_debug_frames
},
2926 { "frames-interp", & do_debug_frames_interp
},
2927 { "info", & do_debug_info
},
2928 { "line", & do_debug_lines
},
2929 { "loc", & do_debug_loc
},
2930 { "macro", & do_debug_macinfo
},
2931 { "pubnames", & do_debug_pubnames
},
2932 /* This entry is for compatability
2933 with earlier versions of readelf. */
2934 { "ranges", & do_debug_aranges
},
2935 { "str", & do_debug_str
},
2946 debug_dump_long_opts
* entry
;
2948 for (entry
= opts_table
; entry
->option
; entry
++)
2950 size_t len
= strlen (entry
->option
);
2952 if (strneq (p
, entry
->option
, len
)
2953 && (p
[len
] == ',' || p
[len
] == '\0'))
2955 * entry
->variable
= 1;
2957 /* The --debug-dump=frames-interp option also
2958 enables the --debug-dump=frames option. */
2959 if (do_debug_frames_interp
)
2960 do_debug_frames
= 1;
2967 if (entry
->option
== NULL
)
2969 warn (_("Unrecognized debug option '%s'\n"), p
);
2970 p
= strchr (p
, ',');
2980 #ifdef SUPPORT_DISASSEMBLY
2983 section
= strtoul (optarg
, & cp
, 0);
2984 if (! *cp
&& section
>= 0)
2986 request_dump (section
, DISASS_DUMP
);
2992 print_version (program_name
);
3002 /* xgettext:c-format */
3003 error (_("Invalid option '-%c'\n"), c
);
3010 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3011 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3012 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3013 && !do_section_groups
)
3017 warn (_("Nothing to do.\n"));
3023 get_elf_class (unsigned int elf_class
)
3025 static char buff
[32];
3029 case ELFCLASSNONE
: return _("none");
3030 case ELFCLASS32
: return "ELF32";
3031 case ELFCLASS64
: return "ELF64";
3033 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3039 get_data_encoding (unsigned int encoding
)
3041 static char buff
[32];
3045 case ELFDATANONE
: return _("none");
3046 case ELFDATA2LSB
: return _("2's complement, little endian");
3047 case ELFDATA2MSB
: return _("2's complement, big endian");
3049 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3054 /* Decode the data held in 'elf_header'. */
3057 process_file_header (void)
3059 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3060 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3061 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3062 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3065 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3073 printf (_("ELF Header:\n"));
3074 printf (_(" Magic: "));
3075 for (i
= 0; i
< EI_NIDENT
; i
++)
3076 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3078 printf (_(" Class: %s\n"),
3079 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3080 printf (_(" Data: %s\n"),
3081 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3082 printf (_(" Version: %d %s\n"),
3083 elf_header
.e_ident
[EI_VERSION
],
3084 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3086 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3089 printf (_(" OS/ABI: %s\n"),
3090 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3091 printf (_(" ABI Version: %d\n"),
3092 elf_header
.e_ident
[EI_ABIVERSION
]);
3093 printf (_(" Type: %s\n"),
3094 get_file_type (elf_header
.e_type
));
3095 printf (_(" Machine: %s\n"),
3096 get_machine_name (elf_header
.e_machine
));
3097 printf (_(" Version: 0x%lx\n"),
3098 (unsigned long) elf_header
.e_version
);
3100 printf (_(" Entry point address: "));
3101 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3102 printf (_("\n Start of program headers: "));
3103 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3104 printf (_(" (bytes into file)\n Start of section headers: "));
3105 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3106 printf (_(" (bytes into file)\n"));
3108 printf (_(" Flags: 0x%lx%s\n"),
3109 (unsigned long) elf_header
.e_flags
,
3110 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3111 printf (_(" Size of this header: %ld (bytes)\n"),
3112 (long) elf_header
.e_ehsize
);
3113 printf (_(" Size of program headers: %ld (bytes)\n"),
3114 (long) elf_header
.e_phentsize
);
3115 printf (_(" Number of program headers: %ld\n"),
3116 (long) elf_header
.e_phnum
);
3117 printf (_(" Size of section headers: %ld (bytes)\n"),
3118 (long) elf_header
.e_shentsize
);
3119 printf (_(" Number of section headers: %ld"),
3120 (long) elf_header
.e_shnum
);
3121 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
3122 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3123 putc ('\n', stdout
);
3124 printf (_(" Section header string table index: %ld"),
3125 (long) elf_header
.e_shstrndx
);
3126 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
3127 printf (" (%ld)", (long) section_headers
[0].sh_link
);
3128 putc ('\n', stdout
);
3131 if (section_headers
!= NULL
)
3133 if (elf_header
.e_shnum
== 0)
3134 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3135 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
3136 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3137 free (section_headers
);
3138 section_headers
= NULL
;
3146 get_32bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3148 Elf32_External_Phdr
*phdrs
;
3149 Elf32_External_Phdr
*external
;
3150 Elf_Internal_Phdr
*internal
;
3153 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3154 elf_header
.e_phentsize
* elf_header
.e_phnum
,
3155 _("program headers"));
3159 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3160 i
< elf_header
.e_phnum
;
3161 i
++, internal
++, external
++)
3163 internal
->p_type
= BYTE_GET (external
->p_type
);
3164 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3165 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3166 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3167 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3168 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3169 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3170 internal
->p_align
= BYTE_GET (external
->p_align
);
3179 get_64bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3181 Elf64_External_Phdr
*phdrs
;
3182 Elf64_External_Phdr
*external
;
3183 Elf_Internal_Phdr
*internal
;
3186 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3187 elf_header
.e_phentsize
* elf_header
.e_phnum
,
3188 _("program headers"));
3192 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3193 i
< elf_header
.e_phnum
;
3194 i
++, internal
++, external
++)
3196 internal
->p_type
= BYTE_GET (external
->p_type
);
3197 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3198 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3199 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3200 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3201 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3202 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3203 internal
->p_align
= BYTE_GET (external
->p_align
);
3211 /* Returns 1 if the program headers were read into `program_headers'. */
3214 get_program_headers (FILE *file
)
3216 Elf_Internal_Phdr
*phdrs
;
3218 /* Check cache of prior read. */
3219 if (program_headers
!= NULL
)
3222 phdrs
= malloc (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
3226 error (_("Out of memory\n"));
3231 ? get_32bit_program_headers (file
, phdrs
)
3232 : get_64bit_program_headers (file
, phdrs
))
3234 program_headers
= phdrs
;
3242 /* Returns 1 if the program headers were loaded. */
3245 process_program_headers (FILE *file
)
3247 Elf_Internal_Phdr
*segment
;
3250 if (elf_header
.e_phnum
== 0)
3253 printf (_("\nThere are no program headers in this file.\n"));
3257 if (do_segments
&& !do_header
)
3259 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3260 printf (_("Entry point "));
3261 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3262 printf (_("\nThere are %d program headers, starting at offset "),
3263 elf_header
.e_phnum
);
3264 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3268 if (! get_program_headers (file
))
3273 if (elf_header
.e_phnum
> 1)
3274 printf (_("\nProgram Headers:\n"));
3276 printf (_("\nProgram Headers:\n"));
3280 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3283 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3287 (_(" Type Offset VirtAddr PhysAddr\n"));
3289 (_(" FileSiz MemSiz Flags Align\n"));
3296 for (i
= 0, segment
= program_headers
;
3297 i
< elf_header
.e_phnum
;
3302 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3306 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3307 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3308 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3309 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3310 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3312 (segment
->p_flags
& PF_R
? 'R' : ' '),
3313 (segment
->p_flags
& PF_W
? 'W' : ' '),
3314 (segment
->p_flags
& PF_X
? 'E' : ' '));
3315 printf ("%#lx", (unsigned long) segment
->p_align
);
3319 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3320 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3323 print_vma (segment
->p_offset
, FULL_HEX
);
3327 print_vma (segment
->p_vaddr
, FULL_HEX
);
3329 print_vma (segment
->p_paddr
, FULL_HEX
);
3332 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3333 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3336 print_vma (segment
->p_filesz
, FULL_HEX
);
3340 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3341 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3344 print_vma (segment
->p_offset
, FULL_HEX
);
3348 (segment
->p_flags
& PF_R
? 'R' : ' '),
3349 (segment
->p_flags
& PF_W
? 'W' : ' '),
3350 (segment
->p_flags
& PF_X
? 'E' : ' '));
3352 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3353 printf ("%#lx", (unsigned long) segment
->p_align
);
3356 print_vma (segment
->p_align
, PREFIX_HEX
);
3361 print_vma (segment
->p_offset
, FULL_HEX
);
3363 print_vma (segment
->p_vaddr
, FULL_HEX
);
3365 print_vma (segment
->p_paddr
, FULL_HEX
);
3367 print_vma (segment
->p_filesz
, FULL_HEX
);
3369 print_vma (segment
->p_memsz
, FULL_HEX
);
3371 (segment
->p_flags
& PF_R
? 'R' : ' '),
3372 (segment
->p_flags
& PF_W
? 'W' : ' '),
3373 (segment
->p_flags
& PF_X
? 'E' : ' '));
3374 print_vma (segment
->p_align
, HEX
);
3378 switch (segment
->p_type
)
3382 error (_("more than one dynamic segment\n"));
3384 /* Try to locate the .dynamic section. If there is
3385 a section header table, we can easily locate it. */
3386 if (section_headers
!= NULL
)
3388 Elf_Internal_Shdr
*sec
;
3390 sec
= find_section (".dynamic");
3391 if (sec
== NULL
|| sec
->sh_size
== 0)
3393 error (_("no .dynamic section in the dynamic segment"));
3397 dynamic_addr
= sec
->sh_offset
;
3398 dynamic_size
= sec
->sh_size
;
3400 if (dynamic_addr
< segment
->p_offset
3401 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3402 warn (_("the .dynamic section is not contained within the dynamic segment"));
3403 else if (dynamic_addr
> segment
->p_offset
)
3404 warn (_("the .dynamic section is not the first section in the dynamic segment."));
3408 /* Otherwise, we can only assume that the .dynamic
3409 section is the first section in the DYNAMIC segment. */
3410 dynamic_addr
= segment
->p_offset
;
3411 dynamic_size
= segment
->p_filesz
;
3416 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3418 error (_("Unable to find program interpreter name\n"));
3421 program_interpreter
[0] = 0;
3422 fscanf (file
, "%63s", program_interpreter
);
3425 printf (_("\n [Requesting program interpreter: %s]"),
3426 program_interpreter
);
3432 putc ('\n', stdout
);
3435 if (do_segments
&& section_headers
!= NULL
)
3437 printf (_("\n Section to Segment mapping:\n"));
3438 printf (_(" Segment Sections...\n"));
3440 assert (string_table
!= NULL
);
3442 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3445 Elf_Internal_Shdr
*section
;
3447 segment
= program_headers
+ i
;
3448 section
= section_headers
;
3450 printf (" %2.2d ", i
);
3452 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3454 if (section
->sh_size
> 0
3455 /* Compare allocated sections by VMA, unallocated
3456 sections by file offset. */
3457 && (section
->sh_flags
& SHF_ALLOC
3458 ? (section
->sh_addr
>= segment
->p_vaddr
3459 && section
->sh_addr
+ section
->sh_size
3460 <= segment
->p_vaddr
+ segment
->p_memsz
)
3461 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
3462 && (section
->sh_offset
+ section
->sh_size
3463 <= segment
->p_offset
+ segment
->p_filesz
)))
3464 /* .tbss is special. It doesn't contribute memory space
3465 to normal segments. */
3466 && (!((section
->sh_flags
& SHF_TLS
) != 0
3467 && section
->sh_type
== SHT_NOBITS
)
3468 || segment
->p_type
== PT_TLS
))
3469 printf ("%s ", SECTION_NAME (section
));
3480 /* Find the file offset corresponding to VMA by using the program headers. */
3483 offset_from_vma (FILE *file
, bfd_vma vma
, bfd_size_type size
)
3485 Elf_Internal_Phdr
*seg
;
3487 if (! get_program_headers (file
))
3489 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3493 for (seg
= program_headers
;
3494 seg
< program_headers
+ elf_header
.e_phnum
;
3497 if (seg
->p_type
!= PT_LOAD
)
3500 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3501 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3502 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3505 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3512 get_32bit_section_headers (FILE *file
, unsigned int num
)
3514 Elf32_External_Shdr
*shdrs
;
3515 Elf_Internal_Shdr
*internal
;
3518 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3519 elf_header
.e_shentsize
* num
, _("section headers"));
3523 section_headers
= malloc (num
* sizeof (Elf_Internal_Shdr
));
3525 if (section_headers
== NULL
)
3527 error (_("Out of memory\n"));
3531 for (i
= 0, internal
= section_headers
;
3535 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3536 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3537 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3538 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3539 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3540 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3541 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3542 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3543 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3544 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3553 get_64bit_section_headers (FILE *file
, unsigned int num
)
3555 Elf64_External_Shdr
*shdrs
;
3556 Elf_Internal_Shdr
*internal
;
3559 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3560 elf_header
.e_shentsize
* num
, _("section headers"));
3564 section_headers
= malloc (num
* sizeof (Elf_Internal_Shdr
));
3566 if (section_headers
== NULL
)
3568 error (_("Out of memory\n"));
3572 for (i
= 0, internal
= section_headers
;
3576 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3577 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3578 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3579 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3580 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3581 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3582 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3583 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3584 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3585 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3593 static Elf_Internal_Sym
*
3594 get_32bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3596 unsigned long number
;
3597 Elf32_External_Sym
*esyms
;
3598 Elf_External_Sym_Shndx
*shndx
;
3599 Elf_Internal_Sym
*isyms
;
3600 Elf_Internal_Sym
*psym
;
3603 esyms
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
3609 if (symtab_shndx_hdr
!= NULL
3610 && (symtab_shndx_hdr
->sh_link
3611 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3613 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3614 symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3622 number
= section
->sh_size
/ section
->sh_entsize
;
3623 isyms
= malloc (number
* sizeof (Elf_Internal_Sym
));
3627 error (_("Out of memory\n"));
3634 for (j
= 0, psym
= isyms
;
3638 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3639 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3640 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3641 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3642 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3644 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3645 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3646 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3656 static Elf_Internal_Sym
*
3657 get_64bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3659 unsigned long number
;
3660 Elf64_External_Sym
*esyms
;
3661 Elf_External_Sym_Shndx
*shndx
;
3662 Elf_Internal_Sym
*isyms
;
3663 Elf_Internal_Sym
*psym
;
3666 esyms
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
3672 if (symtab_shndx_hdr
!= NULL
3673 && (symtab_shndx_hdr
->sh_link
3674 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3676 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3677 symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3685 number
= section
->sh_size
/ section
->sh_entsize
;
3686 isyms
= malloc (number
* sizeof (Elf_Internal_Sym
));
3690 error (_("Out of memory\n"));
3697 for (j
= 0, psym
= isyms
;
3701 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3702 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3703 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3704 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3705 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3707 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3708 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3709 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3720 get_elf_section_flags (bfd_vma sh_flags
)
3722 static char buff
[33];
3729 flag
= sh_flags
& - sh_flags
;
3734 case SHF_WRITE
: *p
= 'W'; break;
3735 case SHF_ALLOC
: *p
= 'A'; break;
3736 case SHF_EXECINSTR
: *p
= 'X'; break;
3737 case SHF_MERGE
: *p
= 'M'; break;
3738 case SHF_STRINGS
: *p
= 'S'; break;
3739 case SHF_INFO_LINK
: *p
= 'I'; break;
3740 case SHF_LINK_ORDER
: *p
= 'L'; break;
3741 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
3742 case SHF_GROUP
: *p
= 'G'; break;
3743 case SHF_TLS
: *p
= 'T'; break;
3746 if (flag
& SHF_MASKOS
)
3749 sh_flags
&= ~ SHF_MASKOS
;
3751 else if (flag
& SHF_MASKPROC
)
3754 sh_flags
&= ~ SHF_MASKPROC
;
3768 process_section_headers (FILE *file
)
3770 Elf_Internal_Shdr
*section
;
3773 section_headers
= NULL
;
3775 if (elf_header
.e_shnum
== 0)
3778 printf (_("\nThere are no sections in this file.\n"));
3783 if (do_sections
&& !do_header
)
3784 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3785 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
3789 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
3792 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
3795 /* Read in the string table, so that we have names to display. */
3796 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
3798 if (section
->sh_size
!= 0)
3800 string_table
= get_data (NULL
, file
, section
->sh_offset
,
3801 section
->sh_size
, _("string table"));
3803 if (string_table
== NULL
)
3806 string_table_length
= section
->sh_size
;
3809 /* Scan the sections for the dynamic symbol table
3810 and dynamic string table and debug sections. */
3811 dynamic_symbols
= NULL
;
3812 dynamic_strings
= NULL
;
3813 dynamic_syminfo
= NULL
;
3814 symtab_shndx_hdr
= NULL
;
3816 eh_addr_size
= is_32bit_elf
? 4 : 8;
3817 switch (elf_header
.e_machine
)
3820 case EM_MIPS_RS3_LE
:
3821 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
3822 FDE addresses. However, the ABI also has a semi-official ILP32
3823 variant for which the normal FDE address size rules apply.
3825 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
3826 section, where XX is the size of longs in bits. Unfortunately,
3827 earlier compilers provided no way of distinguishing ILP32 objects
3828 from LP64 objects, so if there's any doubt, we should assume that
3829 the official LP64 form is being used. */
3830 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
3831 && find_section (".gcc_compiled_long32") == NULL
)
3836 for (i
= 0, section
= section_headers
;
3837 i
< elf_header
.e_shnum
;
3840 char *name
= SECTION_NAME (section
);
3842 if (section
->sh_type
== SHT_DYNSYM
)
3844 if (dynamic_symbols
!= NULL
)
3846 error (_("File contains multiple dynamic symbol tables\n"));
3850 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
3851 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
3853 else if (section
->sh_type
== SHT_STRTAB
3854 && streq (name
, ".dynstr"))
3856 if (dynamic_strings
!= NULL
)
3858 error (_("File contains multiple dynamic string tables\n"));
3862 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
3863 section
->sh_size
, _("dynamic strings"));
3864 dynamic_strings_length
= section
->sh_size
;
3866 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
3868 if (symtab_shndx_hdr
!= NULL
)
3870 error (_("File contains multiple symtab shndx tables\n"));
3873 symtab_shndx_hdr
= section
;
3875 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
3876 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
3877 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
3878 || do_debug_loc
|| do_debug_ranges
)
3879 && strneq (name
, ".debug_", 7))
3884 || (do_debug_info
&& streq (name
, "info"))
3885 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
3886 || (do_debug_lines
&& streq (name
, "line"))
3887 || (do_debug_pubnames
&& streq (name
, "pubnames"))
3888 || (do_debug_aranges
&& streq (name
, "aranges"))
3889 || (do_debug_ranges
&& streq (name
, "ranges"))
3890 || (do_debug_frames
&& streq (name
, "frame"))
3891 || (do_debug_macinfo
&& streq (name
, "macinfo"))
3892 || (do_debug_str
&& streq (name
, "str"))
3893 || (do_debug_loc
&& streq (name
, "loc"))
3895 request_dump (i
, DEBUG_DUMP
);
3897 /* linkonce section to be combined with .debug_info at link time. */
3898 else if ((do_debugging
|| do_debug_info
)
3899 && strneq (name
, ".gnu.linkonce.wi.", 17))
3900 request_dump (i
, DEBUG_DUMP
);
3901 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
3902 request_dump (i
, DEBUG_DUMP
);
3908 if (elf_header
.e_shnum
> 1)
3909 printf (_("\nSection Headers:\n"));
3911 printf (_("\nSection Header:\n"));
3915 if (do_full_section_name
)
3917 printf (_(" [Nr] Name\n"));
3918 printf (_(" Type Addr Off Size ES Flg Lk Inf Al\n"));
3922 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
3926 if (do_full_section_name
)
3928 printf (_(" [Nr] Name\n"));
3929 printf (_(" Type Address Off Size ES Flg Lk Inf Al\n"));
3933 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
3937 if (do_full_section_name
)
3939 printf (_(" [Nr] Name\n"));
3940 printf (_(" Flags Type Address Offset\n"));
3941 printf (_(" Size EntSize Link Info Align\n"));
3945 printf (_(" [Nr] Name Type Address Offset\n"));
3946 printf (_(" Size EntSize Flags Link Info Align\n"));
3950 for (i
= 0, section
= section_headers
;
3951 i
< elf_header
.e_shnum
;
3954 if (do_full_section_name
)
3956 printf (" [%2u] %s\n",
3957 SECTION_HEADER_NUM (i
),
3958 SECTION_NAME (section
));
3959 if (is_32bit_elf
|| do_wide
)
3960 printf (" %-15.15s ",
3961 get_section_type_name (section
->sh_type
));
3964 printf (" [%2u] %-17.17s %-15.15s ",
3965 SECTION_HEADER_NUM (i
),
3966 SECTION_NAME (section
),
3967 get_section_type_name (section
->sh_type
));
3971 print_vma (section
->sh_addr
, LONG_HEX
);
3973 printf ( " %6.6lx %6.6lx %2.2lx",
3974 (unsigned long) section
->sh_offset
,
3975 (unsigned long) section
->sh_size
,
3976 (unsigned long) section
->sh_entsize
);
3978 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3980 printf ("%2ld %3lu %2ld\n",
3981 (unsigned long) section
->sh_link
,
3982 (unsigned long) section
->sh_info
,
3983 (unsigned long) section
->sh_addralign
);
3987 print_vma (section
->sh_addr
, LONG_HEX
);
3989 if ((long) section
->sh_offset
== section
->sh_offset
)
3990 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
3994 print_vma (section
->sh_offset
, LONG_HEX
);
3997 if ((unsigned long) section
->sh_size
== section
->sh_size
)
3998 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4002 print_vma (section
->sh_size
, LONG_HEX
);
4005 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4006 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4010 print_vma (section
->sh_entsize
, LONG_HEX
);
4013 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4015 printf ("%2ld %3lu ",
4016 (unsigned long) section
->sh_link
,
4017 (unsigned long) section
->sh_info
);
4019 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4020 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
4023 print_vma (section
->sh_addralign
, DEC
);
4027 else if (do_full_section_name
)
4029 printf (" %-15.15s %-15.15s ",
4030 get_elf_section_flags (section
->sh_flags
),
4031 get_section_type_name (section
->sh_type
));
4033 print_vma (section
->sh_addr
, LONG_HEX
);
4034 if ((long) section
->sh_offset
== section
->sh_offset
)
4035 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4039 print_vma (section
->sh_offset
, LONG_HEX
);
4042 print_vma (section
->sh_size
, LONG_HEX
);
4044 print_vma (section
->sh_entsize
, LONG_HEX
);
4046 printf (" %2ld %3lu %ld\n",
4047 (unsigned long) section
->sh_link
,
4048 (unsigned long) section
->sh_info
,
4049 (unsigned long) section
->sh_addralign
);
4054 print_vma (section
->sh_addr
, LONG_HEX
);
4055 if ((long) section
->sh_offset
== section
->sh_offset
)
4056 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4060 print_vma (section
->sh_offset
, LONG_HEX
);
4063 print_vma (section
->sh_size
, LONG_HEX
);
4065 print_vma (section
->sh_entsize
, LONG_HEX
);
4067 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4069 printf (" %2ld %3lu %ld\n",
4070 (unsigned long) section
->sh_link
,
4071 (unsigned long) section
->sh_info
,
4072 (unsigned long) section
->sh_addralign
);
4076 printf (_("Key to Flags:\n\
4077 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4078 I (info), L (link order), G (group), x (unknown)\n\
4079 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4085 get_group_flags (unsigned int flags
)
4087 static char buff
[32];
4094 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x]"), flags
);
4101 process_section_groups (FILE *file
)
4103 Elf_Internal_Shdr
*section
;
4105 struct group
*group
;
4106 Elf_Internal_Shdr
*symtab_sec
, *strtab_sec
;
4107 Elf_Internal_Sym
*symtab
;
4110 /* Don't process section groups unless needed. */
4111 if (!do_unwind
&& !do_section_groups
)
4114 if (elf_header
.e_shnum
== 0)
4116 if (do_section_groups
)
4117 printf (_("\nThere are no sections in this file.\n"));
4122 if (section_headers
== NULL
)
4124 error (_("Section headers are not available!\n"));
4128 section_headers_groups
= calloc (elf_header
.e_shnum
,
4129 sizeof (struct group
*));
4131 if (section_headers_groups
== NULL
)
4133 error (_("Out of memory\n"));
4137 /* Scan the sections for the group section. */
4139 for (i
= 0, section
= section_headers
;
4140 i
< elf_header
.e_shnum
;
4142 if (section
->sh_type
== SHT_GROUP
)
4145 if (group_count
== 0)
4147 if (do_section_groups
)
4148 printf (_("\nThere are no section groups in this file.\n"));
4153 section_groups
= calloc (group_count
, sizeof (struct group
));
4155 if (section_groups
== NULL
)
4157 error (_("Out of memory\n"));
4165 for (i
= 0, section
= section_headers
, group
= section_groups
;
4166 i
< elf_header
.e_shnum
;
4169 if (section
->sh_type
== SHT_GROUP
)
4171 char *name
= SECTION_NAME (section
);
4173 unsigned char *start
, *indices
;
4174 unsigned int entry
, j
, size
;
4175 Elf_Internal_Shdr
*sec
;
4176 Elf_Internal_Sym
*sym
;
4178 /* Get the symbol table. */
4179 sec
= SECTION_HEADER (section
->sh_link
);
4180 if (sec
->sh_type
!= SHT_SYMTAB
)
4182 error (_("Bad sh_link in group section `%s'\n"), name
);
4186 if (symtab_sec
!= sec
)
4191 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4194 sym
= symtab
+ section
->sh_info
;
4196 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4198 bfd_vma sec_index
= SECTION_HEADER_INDEX (sym
->st_shndx
);
4201 error (_("Bad sh_info in group section `%s'\n"), name
);
4205 group_name
= SECTION_NAME (section_headers
+ sec_index
);
4210 /* Get the string table. */
4211 sec
= SECTION_HEADER (symtab_sec
->sh_link
);
4212 if (strtab_sec
!= sec
)
4217 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
4218 strtab_sec
->sh_size
,
4221 group_name
= strtab
+ sym
->st_name
;
4224 start
= get_data (NULL
, file
, section
->sh_offset
,
4225 section
->sh_size
, _("section data"));
4228 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4229 entry
= byte_get (indices
, 4);
4232 if (do_section_groups
)
4234 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4235 get_group_flags (entry
), i
, name
, group_name
, size
);
4237 printf (_(" [Index] Name\n"));
4240 group
->group_index
= i
;
4242 for (j
= 0; j
< size
; j
++)
4244 struct group_list
*g
;
4246 entry
= byte_get (indices
, 4);
4249 if (entry
>= elf_header
.e_shnum
)
4251 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4252 entry
, i
, elf_header
.e_shnum
- 1);
4255 else if (entry
>= SHN_LORESERVE
&& entry
<= SHN_HIRESERVE
)
4257 error (_("invalid section [%5u] in group section [%5u]\n"),
4262 if (section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4267 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4269 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4274 /* Intel C/C++ compiler may put section 0 in a
4275 section group. We just warn it the first time
4276 and ignore it afterwards. */
4277 static int warned
= 0;
4280 error (_("section 0 in group section [%5u]\n"),
4281 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4287 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4290 if (do_section_groups
)
4292 sec
= SECTION_HEADER (entry
);
4293 printf (" [%5u] %s\n",
4294 entry
, SECTION_NAME (sec
));
4297 g
= xmalloc (sizeof (struct group_list
));
4298 g
->section_index
= entry
;
4299 g
->next
= group
->root
;
4323 } dynamic_relocations
[] =
4325 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4326 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4327 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4330 /* Process the reloc section. */
4333 process_relocs (FILE *file
)
4335 unsigned long rel_size
;
4336 unsigned long rel_offset
;
4342 if (do_using_dynamic
)
4346 int has_dynamic_reloc
;
4349 has_dynamic_reloc
= 0;
4351 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4353 is_rela
= dynamic_relocations
[i
].rela
;
4354 name
= dynamic_relocations
[i
].name
;
4355 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4356 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4358 has_dynamic_reloc
|= rel_size
;
4360 if (is_rela
== UNKNOWN
)
4362 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4363 switch (dynamic_info
[DT_PLTREL
])
4377 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4378 name
, rel_offset
, rel_size
);
4380 dump_relocations (file
,
4381 offset_from_vma (file
, rel_offset
, rel_size
),
4383 dynamic_symbols
, num_dynamic_syms
,
4384 dynamic_strings
, dynamic_strings_length
, is_rela
);
4388 if (! has_dynamic_reloc
)
4389 printf (_("\nThere are no dynamic relocations in this file.\n"));
4393 Elf_Internal_Shdr
*section
;
4397 for (i
= 0, section
= section_headers
;
4398 i
< elf_header
.e_shnum
;
4401 if ( section
->sh_type
!= SHT_RELA
4402 && section
->sh_type
!= SHT_REL
)
4405 rel_offset
= section
->sh_offset
;
4406 rel_size
= section
->sh_size
;
4410 Elf_Internal_Shdr
*strsec
;
4413 printf (_("\nRelocation section "));
4415 if (string_table
== NULL
)
4416 printf ("%d", section
->sh_name
);
4418 printf (_("'%s'"), SECTION_NAME (section
));
4420 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4421 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4423 is_rela
= section
->sh_type
== SHT_RELA
;
4425 if (section
->sh_link
)
4427 Elf_Internal_Shdr
*symsec
;
4428 Elf_Internal_Sym
*symtab
;
4429 unsigned long nsyms
;
4430 unsigned long strtablen
;
4431 char *strtab
= NULL
;
4433 symsec
= SECTION_HEADER (section
->sh_link
);
4434 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4435 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4440 strsec
= SECTION_HEADER (symsec
->sh_link
);
4442 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4443 strsec
->sh_size
, _("string table"));
4444 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4446 dump_relocations (file
, rel_offset
, rel_size
,
4447 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4453 dump_relocations (file
, rel_offset
, rel_size
,
4454 NULL
, 0, NULL
, 0, is_rela
);
4461 printf (_("\nThere are no relocations in this file.\n"));
4467 /* Process the unwind section. */
4469 #include "unwind-ia64.h"
4471 /* An absolute address consists of a section and an offset. If the
4472 section is NULL, the offset itself is the address, otherwise, the
4473 address equals to LOAD_ADDRESS(section) + offset. */
4477 unsigned short section
;
4481 struct ia64_unw_aux_info
4483 struct ia64_unw_table_entry
4485 struct absaddr start
;
4487 struct absaddr info
;
4489 *table
; /* Unwind table. */
4490 unsigned long table_len
; /* Length of unwind table. */
4491 unsigned char *info
; /* Unwind info. */
4492 unsigned long info_size
; /* Size of unwind info. */
4493 bfd_vma info_addr
; /* starting address of unwind info. */
4494 bfd_vma seg_base
; /* Starting address of segment. */
4495 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4496 unsigned long nsyms
; /* Number of symbols. */
4497 char *strtab
; /* The string table. */
4498 unsigned long strtab_size
; /* Size of string table. */
4502 find_symbol_for_address (Elf_Internal_Sym
*symtab
,
4503 unsigned long nsyms
,
4505 unsigned long strtab_size
,
4506 struct absaddr addr
,
4507 const char **symname
,
4510 bfd_vma dist
= 0x100000;
4511 Elf_Internal_Sym
*sym
, *best
= NULL
;
4514 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
4516 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4517 && sym
->st_name
!= 0
4518 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4519 && addr
.offset
>= sym
->st_value
4520 && addr
.offset
- sym
->st_value
< dist
)
4523 dist
= addr
.offset
- sym
->st_value
;
4530 *symname
= (best
->st_name
>= strtab_size
4531 ? "<corrupt>" : strtab
+ best
->st_name
);
4536 *offset
= addr
.offset
;
4540 dump_ia64_unwind (struct ia64_unw_aux_info
*aux
)
4542 struct ia64_unw_table_entry
*tp
;
4545 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4549 const unsigned char *dp
;
4550 const unsigned char *head
;
4551 const char *procname
;
4553 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4554 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
4556 fputs ("\n<", stdout
);
4560 fputs (procname
, stdout
);
4563 printf ("+%lx", (unsigned long) offset
);
4566 fputs (">: [", stdout
);
4567 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4568 fputc ('-', stdout
);
4569 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4570 printf ("], info at +0x%lx\n",
4571 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4573 head
= aux
->info
+ (tp
->info
.offset
- aux
->info_addr
);
4574 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
4576 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4577 (unsigned) UNW_VER (stamp
),
4578 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4579 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4580 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4581 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
4583 if (UNW_VER (stamp
) != 1)
4585 printf ("\tUnknown version.\n");
4590 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
4591 dp
= unw_decode (dp
, in_body
, & in_body
);
4596 slurp_ia64_unwind_table (FILE *file
,
4597 struct ia64_unw_aux_info
*aux
,
4598 Elf_Internal_Shdr
*sec
)
4600 unsigned long size
, nrelas
, i
;
4601 Elf_Internal_Phdr
*seg
;
4602 struct ia64_unw_table_entry
*tep
;
4603 Elf_Internal_Shdr
*relsec
;
4604 Elf_Internal_Rela
*rela
, *rp
;
4605 unsigned char *table
, *tp
;
4606 Elf_Internal_Sym
*sym
;
4607 const char *relname
;
4609 /* First, find the starting address of the segment that includes
4612 if (elf_header
.e_phnum
)
4614 if (! get_program_headers (file
))
4617 for (seg
= program_headers
;
4618 seg
< program_headers
+ elf_header
.e_phnum
;
4621 if (seg
->p_type
!= PT_LOAD
)
4624 if (sec
->sh_addr
>= seg
->p_vaddr
4625 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4627 aux
->seg_base
= seg
->p_vaddr
;
4633 /* Second, build the unwind table from the contents of the unwind section: */
4634 size
= sec
->sh_size
;
4635 table
= get_data (NULL
, file
, sec
->sh_offset
, size
, _("unwind table"));
4639 aux
->table
= xmalloc (size
/ (3 * eh_addr_size
) * sizeof (aux
->table
[0]));
4641 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * eh_addr_size
, ++tep
)
4643 tep
->start
.section
= SHN_UNDEF
;
4644 tep
->end
.section
= SHN_UNDEF
;
4645 tep
->info
.section
= SHN_UNDEF
;
4648 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4649 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4650 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
4654 tep
->start
.offset
= BYTE_GET ((unsigned char *) tp
+ 0);
4655 tep
->end
.offset
= BYTE_GET ((unsigned char *) tp
+ 8);
4656 tep
->info
.offset
= BYTE_GET ((unsigned char *) tp
+ 16);
4658 tep
->start
.offset
+= aux
->seg_base
;
4659 tep
->end
.offset
+= aux
->seg_base
;
4660 tep
->info
.offset
+= aux
->seg_base
;
4664 /* Third, apply any relocations to the unwind table: */
4666 for (relsec
= section_headers
;
4667 relsec
< section_headers
+ elf_header
.e_shnum
;
4670 if (relsec
->sh_type
!= SHT_RELA
4671 || SECTION_HEADER (relsec
->sh_info
) != sec
)
4674 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
4678 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4682 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4683 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4687 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4688 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4691 if (! strneq (relname
, "R_IA64_SEGREL", 13))
4693 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4697 i
= rp
->r_offset
/ (3 * eh_addr_size
);
4699 switch (rp
->r_offset
/eh_addr_size
% 3)
4702 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4703 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
4706 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4707 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
4710 aux
->table
[i
].info
.section
= sym
->st_shndx
;
4711 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
4721 aux
->table_len
= size
/ (3 * eh_addr_size
);
4726 ia64_process_unwind (FILE *file
)
4728 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
4729 unsigned long i
, unwcount
= 0, unwstart
= 0;
4730 struct ia64_unw_aux_info aux
;
4732 memset (& aux
, 0, sizeof (aux
));
4734 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4736 if (sec
->sh_type
== SHT_SYMTAB
)
4738 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
4739 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
4741 strsec
= SECTION_HEADER (sec
->sh_link
);
4742 aux
.strtab_size
= strsec
->sh_size
;
4743 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4744 aux
.strtab_size
, _("string table"));
4746 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4751 printf (_("\nThere are no unwind sections in this file.\n"));
4753 while (unwcount
-- > 0)
4758 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
4759 i
< elf_header
.e_shnum
; ++i
, ++sec
)
4760 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4767 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
4769 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
4771 /* We need to find which section group it is in. */
4772 struct group_list
*g
= section_headers_groups
[i
]->root
;
4774 for (; g
!= NULL
; g
= g
->next
)
4776 sec
= SECTION_HEADER (g
->section_index
);
4778 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
4783 i
= elf_header
.e_shnum
;
4785 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
4787 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
4788 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
4789 suffix
= SECTION_NAME (unwsec
) + len
;
4790 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4792 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
4793 && streq (SECTION_NAME (sec
) + len2
, suffix
))
4798 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
4799 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
4800 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
4801 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
4803 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
4804 suffix
= SECTION_NAME (unwsec
) + len
;
4805 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4807 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
4808 && streq (SECTION_NAME (sec
) + len2
, suffix
))
4812 if (i
== elf_header
.e_shnum
)
4814 printf (_("\nCould not find unwind info section for "));
4816 if (string_table
== NULL
)
4817 printf ("%d", unwsec
->sh_name
);
4819 printf (_("'%s'"), SECTION_NAME (unwsec
));
4823 aux
.info_size
= sec
->sh_size
;
4824 aux
.info_addr
= sec
->sh_addr
;
4825 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, aux
.info_size
,
4828 printf (_("\nUnwind section "));
4830 if (string_table
== NULL
)
4831 printf ("%d", unwsec
->sh_name
);
4833 printf (_("'%s'"), SECTION_NAME (unwsec
));
4835 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4836 (unsigned long) unwsec
->sh_offset
,
4837 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
4839 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
4841 if (aux
.table_len
> 0)
4842 dump_ia64_unwind (& aux
);
4845 free ((char *) aux
.table
);
4847 free ((char *) aux
.info
);
4856 free ((char *) aux
.strtab
);
4861 struct hppa_unw_aux_info
4863 struct hppa_unw_table_entry
4865 struct absaddr start
;
4867 unsigned int Cannot_unwind
:1; /* 0 */
4868 unsigned int Millicode
:1; /* 1 */
4869 unsigned int Millicode_save_sr0
:1; /* 2 */
4870 unsigned int Region_description
:2; /* 3..4 */
4871 unsigned int reserved1
:1; /* 5 */
4872 unsigned int Entry_SR
:1; /* 6 */
4873 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
4874 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
4875 unsigned int Args_stored
:1; /* 16 */
4876 unsigned int Variable_Frame
:1; /* 17 */
4877 unsigned int Separate_Package_Body
:1; /* 18 */
4878 unsigned int Frame_Extension_Millicode
:1; /* 19 */
4879 unsigned int Stack_Overflow_Check
:1; /* 20 */
4880 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
4881 unsigned int Ada_Region
:1; /* 22 */
4882 unsigned int cxx_info
:1; /* 23 */
4883 unsigned int cxx_try_catch
:1; /* 24 */
4884 unsigned int sched_entry_seq
:1; /* 25 */
4885 unsigned int reserved2
:1; /* 26 */
4886 unsigned int Save_SP
:1; /* 27 */
4887 unsigned int Save_RP
:1; /* 28 */
4888 unsigned int Save_MRP_in_frame
:1; /* 29 */
4889 unsigned int extn_ptr_defined
:1; /* 30 */
4890 unsigned int Cleanup_defined
:1; /* 31 */
4892 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
4893 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
4894 unsigned int Large_frame
:1; /* 2 */
4895 unsigned int Pseudo_SP_Set
:1; /* 3 */
4896 unsigned int reserved4
:1; /* 4 */
4897 unsigned int Total_frame_size
:27; /* 5..31 */
4899 *table
; /* Unwind table. */
4900 unsigned long table_len
; /* Length of unwind table. */
4901 bfd_vma seg_base
; /* Starting address of segment. */
4902 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4903 unsigned long nsyms
; /* Number of symbols. */
4904 char *strtab
; /* The string table. */
4905 unsigned long strtab_size
; /* Size of string table. */
4909 dump_hppa_unwind (struct hppa_unw_aux_info
*aux
)
4911 struct hppa_unw_table_entry
*tp
;
4913 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4916 const char *procname
;
4918 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4919 aux
->strtab_size
, tp
->start
, &procname
,
4922 fputs ("\n<", stdout
);
4926 fputs (procname
, stdout
);
4929 printf ("+%lx", (unsigned long) offset
);
4932 fputs (">: [", stdout
);
4933 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4934 fputc ('-', stdout
);
4935 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4938 #define PF(_m) if (tp->_m) printf (#_m " ");
4939 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
4942 PF(Millicode_save_sr0
);
4943 /* PV(Region_description); */
4949 PF(Separate_Package_Body
);
4950 PF(Frame_Extension_Millicode
);
4951 PF(Stack_Overflow_Check
);
4952 PF(Two_Instruction_SP_Increment
);
4956 PF(sched_entry_seq
);
4959 PF(Save_MRP_in_frame
);
4960 PF(extn_ptr_defined
);
4961 PF(Cleanup_defined
);
4962 PF(MPE_XL_interrupt_marker
);
4963 PF(HP_UX_interrupt_marker
);
4966 PV(Total_frame_size
);
4975 slurp_hppa_unwind_table (FILE *file
,
4976 struct hppa_unw_aux_info
*aux
,
4977 Elf_Internal_Shdr
*sec
)
4979 unsigned long size
, unw_ent_size
, nrelas
, i
;
4980 Elf_Internal_Phdr
*seg
;
4981 struct hppa_unw_table_entry
*tep
;
4982 Elf_Internal_Shdr
*relsec
;
4983 Elf_Internal_Rela
*rela
, *rp
;
4984 unsigned char *table
, *tp
;
4985 Elf_Internal_Sym
*sym
;
4986 const char *relname
;
4988 /* First, find the starting address of the segment that includes
4991 if (elf_header
.e_phnum
)
4993 if (! get_program_headers (file
))
4996 for (seg
= program_headers
;
4997 seg
< program_headers
+ elf_header
.e_phnum
;
5000 if (seg
->p_type
!= PT_LOAD
)
5003 if (sec
->sh_addr
>= seg
->p_vaddr
5004 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5006 aux
->seg_base
= seg
->p_vaddr
;
5012 /* Second, build the unwind table from the contents of the unwind
5014 size
= sec
->sh_size
;
5015 table
= get_data (NULL
, file
, sec
->sh_offset
, size
, _("unwind table"));
5019 unw_ent_size
= 2 * eh_addr_size
+ 8;
5021 tep
= aux
->table
= xmalloc (size
/ unw_ent_size
* sizeof (aux
->table
[0]));
5023 for (tp
= table
; tp
< table
+ size
; tp
+= (2 * eh_addr_size
+ 8), ++tep
)
5025 unsigned int tmp1
, tmp2
;
5027 tep
->start
.section
= SHN_UNDEF
;
5028 tep
->end
.section
= SHN_UNDEF
;
5032 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5033 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5034 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
5035 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
5039 tep
->start
.offset
= BYTE_GET ((unsigned char *) tp
+ 0);
5040 tep
->end
.offset
= BYTE_GET ((unsigned char *) tp
+ 8);
5041 tmp1
= byte_get ((unsigned char *) tp
+ 16, 4);
5042 tmp2
= byte_get ((unsigned char *) tp
+ 20, 4);
5045 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
5046 tep
->Millicode
= (tmp1
>> 30) & 0x1;
5047 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
5048 tep
->Region_description
= (tmp1
>> 27) & 0x3;
5049 tep
->reserved1
= (tmp1
>> 26) & 0x1;
5050 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
5051 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
5052 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
5053 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
5054 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
5055 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
5056 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
5057 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
5058 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
5059 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
5060 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
5061 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
5062 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
5063 tep
->reserved2
= (tmp1
>> 5) & 0x1;
5064 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
5065 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
5066 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
5067 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
5068 tep
->Cleanup_defined
= tmp1
& 0x1;
5070 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5071 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5072 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5073 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5074 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5075 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5077 tep
->start
.offset
+= aux
->seg_base
;
5078 tep
->end
.offset
+= aux
->seg_base
;
5082 /* Third, apply any relocations to the unwind table. */
5084 for (relsec
= section_headers
;
5085 relsec
< section_headers
+ elf_header
.e_shnum
;
5088 if (relsec
->sh_type
!= SHT_RELA
5089 || SECTION_HEADER (relsec
->sh_info
) != sec
)
5092 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5096 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5100 relname
= elf_hppa_reloc_type (ELF32_R_TYPE (rp
->r_info
));
5101 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
5105 relname
= elf_hppa_reloc_type (ELF64_R_TYPE (rp
->r_info
));
5106 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
5109 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5110 if (strncmp (relname
, "R_PARISC_SEGREL", 15) != 0)
5112 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5116 i
= rp
->r_offset
/ unw_ent_size
;
5118 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5121 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5122 aux
->table
[i
].start
.offset
+= sym
->st_value
+ rp
->r_addend
;
5125 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5126 aux
->table
[i
].end
.offset
+= sym
->st_value
+ rp
->r_addend
;
5136 aux
->table_len
= size
/ unw_ent_size
;
5142 hppa_process_unwind (FILE *file
)
5144 struct hppa_unw_aux_info aux
;
5145 Elf_Internal_Shdr
*unwsec
= NULL
;
5146 Elf_Internal_Shdr
*strsec
;
5147 Elf_Internal_Shdr
*sec
;
5150 memset (& aux
, 0, sizeof (aux
));
5152 assert (string_table
!= NULL
);
5154 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5156 if (sec
->sh_type
== SHT_SYMTAB
)
5158 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5159 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5161 strsec
= SECTION_HEADER (sec
->sh_link
);
5162 aux
.strtab_size
= strsec
->sh_size
;
5163 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5164 aux
.strtab_size
, _("string table"));
5166 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5171 printf (_("\nThere are no unwind sections in this file.\n"));
5173 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5175 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5177 printf (_("\nUnwind section "));
5178 printf (_("'%s'"), SECTION_NAME (sec
));
5180 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5181 (unsigned long) sec
->sh_offset
,
5182 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5184 slurp_hppa_unwind_table (file
, &aux
, sec
);
5185 if (aux
.table_len
> 0)
5186 dump_hppa_unwind (&aux
);
5189 free ((char *) aux
.table
);
5197 free ((char *) aux
.strtab
);
5203 process_unwind (FILE *file
)
5205 struct unwind_handler
{
5207 int (*handler
)(FILE *file
);
5209 { EM_IA_64
, ia64_process_unwind
},
5210 { EM_PARISC
, hppa_process_unwind
},
5218 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5219 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5220 return handlers
[i
].handler (file
);
5222 printf (_("\nThere are no unwind sections in this file.\n"));
5227 dynamic_section_mips_val (Elf_Internal_Dyn
*entry
)
5229 switch (entry
->d_tag
)
5232 if (entry
->d_un
.d_val
== 0)
5236 static const char * opts
[] =
5238 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5239 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5240 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5241 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5246 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++cnt
)
5247 if (entry
->d_un
.d_val
& (1 << cnt
))
5249 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5256 case DT_MIPS_IVERSION
:
5257 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5258 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5260 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5263 case DT_MIPS_TIME_STAMP
:
5268 time_t time
= entry
->d_un
.d_val
;
5269 tmp
= gmtime (&time
);
5270 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5271 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5272 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5273 printf ("Time Stamp: %s\n", timebuf
);
5277 case DT_MIPS_RLD_VERSION
:
5278 case DT_MIPS_LOCAL_GOTNO
:
5279 case DT_MIPS_CONFLICTNO
:
5280 case DT_MIPS_LIBLISTNO
:
5281 case DT_MIPS_SYMTABNO
:
5282 case DT_MIPS_UNREFEXTNO
:
5283 case DT_MIPS_HIPAGENO
:
5284 case DT_MIPS_DELTA_CLASS_NO
:
5285 case DT_MIPS_DELTA_INSTANCE_NO
:
5286 case DT_MIPS_DELTA_RELOC_NO
:
5287 case DT_MIPS_DELTA_SYM_NO
:
5288 case DT_MIPS_DELTA_CLASSSYM_NO
:
5289 case DT_MIPS_COMPACT_SIZE
:
5290 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5294 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
5300 dynamic_section_parisc_val (Elf_Internal_Dyn
*entry
)
5302 switch (entry
->d_tag
)
5304 case DT_HP_DLD_FLAGS
:
5313 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5314 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5315 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5316 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5317 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5318 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5319 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5320 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5321 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5322 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5323 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
5327 bfd_vma val
= entry
->d_un
.d_val
;
5329 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
5330 if (val
& flags
[cnt
].bit
)
5334 fputs (flags
[cnt
].str
, stdout
);
5336 val
^= flags
[cnt
].bit
;
5339 if (val
!= 0 || first
)
5343 print_vma (val
, HEX
);
5349 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5356 dynamic_section_ia64_val (Elf_Internal_Dyn
*entry
)
5358 switch (entry
->d_tag
)
5360 case DT_IA_64_PLT_RESERVE
:
5361 /* First 3 slots reserved. */
5362 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5364 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5368 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5375 get_32bit_dynamic_section (FILE *file
)
5377 Elf32_External_Dyn
*edyn
, *ext
;
5378 Elf_Internal_Dyn
*entry
;
5380 edyn
= get_data (NULL
, file
, dynamic_addr
, dynamic_size
,
5381 _("dynamic section"));
5385 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5386 might not have the luxury of section headers. Look for the DT_NULL
5387 terminator to determine the number of entries. */
5388 for (ext
= edyn
, dynamic_nent
= 0;
5389 (char *) ext
< (char *) edyn
+ dynamic_size
;
5393 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5397 dynamic_section
= malloc (dynamic_nent
* sizeof (*entry
));
5398 if (dynamic_section
== NULL
)
5400 error (_("Out of memory\n"));
5405 for (ext
= edyn
, entry
= dynamic_section
;
5406 entry
< dynamic_section
+ dynamic_nent
;
5409 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5410 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5419 get_64bit_dynamic_section (FILE *file
)
5421 Elf64_External_Dyn
*edyn
, *ext
;
5422 Elf_Internal_Dyn
*entry
;
5424 edyn
= get_data (NULL
, file
, dynamic_addr
, dynamic_size
,
5425 _("dynamic section"));
5429 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5430 might not have the luxury of section headers. Look for the DT_NULL
5431 terminator to determine the number of entries. */
5432 for (ext
= edyn
, dynamic_nent
= 0;
5433 (char *) ext
< (char *) edyn
+ dynamic_size
;
5437 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5441 dynamic_section
= malloc (dynamic_nent
* sizeof (*entry
));
5442 if (dynamic_section
== NULL
)
5444 error (_("Out of memory\n"));
5449 for (ext
= edyn
, entry
= dynamic_section
;
5450 entry
< dynamic_section
+ dynamic_nent
;
5453 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5454 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5463 print_dynamic_flags (bfd_vma flags
)
5471 flag
= flags
& - flags
;
5481 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
5482 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
5483 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
5484 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
5485 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
5486 default: fputs ("unknown", stdout
); break;
5492 /* Parse and display the contents of the dynamic section. */
5495 process_dynamic_section (FILE *file
)
5497 Elf_Internal_Dyn
*entry
;
5499 if (dynamic_size
== 0)
5502 printf (_("\nThere is no dynamic section in this file.\n"));
5509 if (! get_32bit_dynamic_section (file
))
5512 else if (! get_64bit_dynamic_section (file
))
5515 /* Find the appropriate symbol table. */
5516 if (dynamic_symbols
== NULL
)
5518 for (entry
= dynamic_section
;
5519 entry
< dynamic_section
+ dynamic_nent
;
5522 Elf_Internal_Shdr section
;
5524 if (entry
->d_tag
!= DT_SYMTAB
)
5527 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
5529 /* Since we do not know how big the symbol table is,
5530 we default to reading in the entire file (!) and
5531 processing that. This is overkill, I know, but it
5533 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5535 if (archive_file_offset
!= 0)
5536 section
.sh_size
= archive_file_size
- section
.sh_offset
;
5539 if (fseek (file
, 0, SEEK_END
))
5540 error (_("Unable to seek to end of file!"));
5542 section
.sh_size
= ftell (file
) - section
.sh_offset
;
5546 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
5548 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
5550 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
5551 if (num_dynamic_syms
< 1)
5553 error (_("Unable to determine the number of symbols to load\n"));
5557 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
5561 /* Similarly find a string table. */
5562 if (dynamic_strings
== NULL
)
5564 for (entry
= dynamic_section
;
5565 entry
< dynamic_section
+ dynamic_nent
;
5568 unsigned long offset
;
5571 if (entry
->d_tag
!= DT_STRTAB
)
5574 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
5576 /* Since we do not know how big the string table is,
5577 we default to reading in the entire file (!) and
5578 processing that. This is overkill, I know, but it
5581 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5583 if (archive_file_offset
!= 0)
5584 str_tab_len
= archive_file_size
- offset
;
5587 if (fseek (file
, 0, SEEK_END
))
5588 error (_("Unable to seek to end of file\n"));
5589 str_tab_len
= ftell (file
) - offset
;
5592 if (str_tab_len
< 1)
5595 (_("Unable to determine the length of the dynamic string table\n"));
5599 dynamic_strings
= get_data (NULL
, file
, offset
, str_tab_len
,
5600 _("dynamic string table"));
5601 dynamic_strings_length
= str_tab_len
;
5606 /* And find the syminfo section if available. */
5607 if (dynamic_syminfo
== NULL
)
5609 unsigned long syminsz
= 0;
5611 for (entry
= dynamic_section
;
5612 entry
< dynamic_section
+ dynamic_nent
;
5615 if (entry
->d_tag
== DT_SYMINENT
)
5617 /* Note: these braces are necessary to avoid a syntax
5618 error from the SunOS4 C compiler. */
5619 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
5621 else if (entry
->d_tag
== DT_SYMINSZ
)
5622 syminsz
= entry
->d_un
.d_val
;
5623 else if (entry
->d_tag
== DT_SYMINFO
)
5624 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
5628 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
5630 Elf_External_Syminfo
*extsyminfo
, *extsym
;
5631 Elf_Internal_Syminfo
*syminfo
;
5633 /* There is a syminfo section. Read the data. */
5634 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, syminsz
,
5635 _("symbol information"));
5639 dynamic_syminfo
= malloc (syminsz
);
5640 if (dynamic_syminfo
== NULL
)
5642 error (_("Out of memory\n"));
5646 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
5647 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
5648 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
5649 ++syminfo
, ++extsym
)
5651 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
5652 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
5659 if (do_dynamic
&& dynamic_addr
)
5660 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
5661 dynamic_addr
, dynamic_nent
);
5663 printf (_(" Tag Type Name/Value\n"));
5665 for (entry
= dynamic_section
;
5666 entry
< dynamic_section
+ dynamic_nent
;
5674 print_vma (entry
->d_tag
, FULL_HEX
);
5675 dtype
= get_dynamic_type (entry
->d_tag
);
5676 printf (" (%s)%*s", dtype
,
5677 ((is_32bit_elf
? 27 : 19)
5678 - (int) strlen (dtype
)),
5682 switch (entry
->d_tag
)
5686 print_dynamic_flags (entry
->d_un
.d_val
);
5696 switch (entry
->d_tag
)
5699 printf (_("Auxiliary library"));
5703 printf (_("Filter library"));
5707 printf (_("Configuration file"));
5711 printf (_("Dependency audit library"));
5715 printf (_("Audit library"));
5719 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5720 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5724 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5733 printf (_("Flags:"));
5735 if (entry
->d_un
.d_val
== 0)
5736 printf (_(" None\n"));
5739 unsigned long int val
= entry
->d_un
.d_val
;
5741 if (val
& DTF_1_PARINIT
)
5743 printf (" PARINIT");
5744 val
^= DTF_1_PARINIT
;
5746 if (val
& DTF_1_CONFEXP
)
5748 printf (" CONFEXP");
5749 val
^= DTF_1_CONFEXP
;
5752 printf (" %lx", val
);
5761 printf (_("Flags:"));
5763 if (entry
->d_un
.d_val
== 0)
5764 printf (_(" None\n"));
5767 unsigned long int val
= entry
->d_un
.d_val
;
5769 if (val
& DF_P1_LAZYLOAD
)
5771 printf (" LAZYLOAD");
5772 val
^= DF_P1_LAZYLOAD
;
5774 if (val
& DF_P1_GROUPPERM
)
5776 printf (" GROUPPERM");
5777 val
^= DF_P1_GROUPPERM
;
5780 printf (" %lx", val
);
5789 printf (_("Flags:"));
5790 if (entry
->d_un
.d_val
== 0)
5791 printf (_(" None\n"));
5794 unsigned long int val
= entry
->d_un
.d_val
;
5801 if (val
& DF_1_GLOBAL
)
5806 if (val
& DF_1_GROUP
)
5811 if (val
& DF_1_NODELETE
)
5813 printf (" NODELETE");
5814 val
^= DF_1_NODELETE
;
5816 if (val
& DF_1_LOADFLTR
)
5818 printf (" LOADFLTR");
5819 val
^= DF_1_LOADFLTR
;
5821 if (val
& DF_1_INITFIRST
)
5823 printf (" INITFIRST");
5824 val
^= DF_1_INITFIRST
;
5826 if (val
& DF_1_NOOPEN
)
5831 if (val
& DF_1_ORIGIN
)
5836 if (val
& DF_1_DIRECT
)
5841 if (val
& DF_1_TRANS
)
5846 if (val
& DF_1_INTERPOSE
)
5848 printf (" INTERPOSE");
5849 val
^= DF_1_INTERPOSE
;
5851 if (val
& DF_1_NODEFLIB
)
5853 printf (" NODEFLIB");
5854 val
^= DF_1_NODEFLIB
;
5856 if (val
& DF_1_NODUMP
)
5861 if (val
& DF_1_CONLFAT
)
5863 printf (" CONLFAT");
5864 val
^= DF_1_CONLFAT
;
5867 printf (" %lx", val
);
5874 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5876 puts (get_dynamic_type (entry
->d_un
.d_val
));
5896 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5902 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5903 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
5909 switch (entry
->d_tag
)
5912 printf (_("Shared library: [%s]"), name
);
5914 if (streq (name
, program_interpreter
))
5915 printf (_(" program interpreter"));
5919 printf (_("Library soname: [%s]"), name
);
5923 printf (_("Library rpath: [%s]"), name
);
5927 printf (_("Library runpath: [%s]"), name
);
5931 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5936 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5949 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5953 case DT_INIT_ARRAYSZ
:
5954 case DT_FINI_ARRAYSZ
:
5955 case DT_GNU_CONFLICTSZ
:
5956 case DT_GNU_LIBLISTSZ
:
5959 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5960 printf (" (bytes)\n");
5970 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5983 if (entry
->d_tag
== DT_USED
5984 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5986 char *name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
5990 printf (_("Not needed object: [%s]\n"), name
);
5995 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6001 /* The value of this entry is ignored. */
6006 case DT_GNU_PRELINKED
:
6010 time_t time
= entry
->d_un
.d_val
;
6012 tmp
= gmtime (&time
);
6013 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6014 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6015 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6021 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
6022 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
6027 switch (elf_header
.e_machine
)
6030 case EM_MIPS_RS3_LE
:
6031 dynamic_section_mips_val (entry
);
6034 dynamic_section_parisc_val (entry
);
6037 dynamic_section_ia64_val (entry
);
6040 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6052 get_ver_flags (unsigned int flags
)
6054 static char buff
[32];
6061 if (flags
& VER_FLG_BASE
)
6062 strcat (buff
, "BASE ");
6064 if (flags
& VER_FLG_WEAK
)
6066 if (flags
& VER_FLG_BASE
)
6067 strcat (buff
, "| ");
6069 strcat (buff
, "WEAK ");
6072 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
6073 strcat (buff
, "| <unknown>");
6078 /* Display the contents of the version sections. */
6080 process_version_sections (FILE *file
)
6082 Elf_Internal_Shdr
*section
;
6089 for (i
= 0, section
= section_headers
;
6090 i
< elf_header
.e_shnum
;
6093 switch (section
->sh_type
)
6095 case SHT_GNU_verdef
:
6097 Elf_External_Verdef
*edefs
;
6104 (_("\nVersion definition section '%s' contains %ld entries:\n"),
6105 SECTION_NAME (section
), section
->sh_info
);
6107 printf (_(" Addr: 0x"));
6108 printf_vma (section
->sh_addr
);
6109 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6110 (unsigned long) section
->sh_offset
, section
->sh_link
,
6111 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
6113 edefs
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
6114 _("version definition section"));
6118 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6121 Elf_External_Verdef
*edef
;
6122 Elf_Internal_Verdef ent
;
6123 Elf_External_Verdaux
*eaux
;
6124 Elf_Internal_Verdaux aux
;
6128 vstart
= ((char *) edefs
) + idx
;
6130 edef
= (Elf_External_Verdef
*) vstart
;
6132 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
6133 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
6134 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
6135 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
6136 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
6137 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
6138 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
6140 printf (_(" %#06x: Rev: %d Flags: %s"),
6141 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
6143 printf (_(" Index: %d Cnt: %d "),
6144 ent
.vd_ndx
, ent
.vd_cnt
);
6146 vstart
+= ent
.vd_aux
;
6148 eaux
= (Elf_External_Verdaux
*) vstart
;
6150 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6151 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6153 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6154 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6156 printf (_("Name index: %ld\n"), aux
.vda_name
);
6158 isum
= idx
+ ent
.vd_aux
;
6160 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6162 isum
+= aux
.vda_next
;
6163 vstart
+= aux
.vda_next
;
6165 eaux
= (Elf_External_Verdaux
*) vstart
;
6167 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6168 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6170 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6171 printf (_(" %#06x: Parent %d: %s\n"),
6172 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6174 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6175 isum
, j
, aux
.vda_name
);
6185 case SHT_GNU_verneed
:
6187 Elf_External_Verneed
*eneed
;
6193 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
6194 SECTION_NAME (section
), section
->sh_info
);
6196 printf (_(" Addr: 0x"));
6197 printf_vma (section
->sh_addr
);
6198 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
6199 (unsigned long) section
->sh_offset
, section
->sh_link
,
6200 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
6202 eneed
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
6203 _("version need section"));
6207 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6209 Elf_External_Verneed
*entry
;
6210 Elf_Internal_Verneed ent
;
6215 vstart
= ((char *) eneed
) + idx
;
6217 entry
= (Elf_External_Verneed
*) vstart
;
6219 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6220 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6221 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6222 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6223 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6225 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6227 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6228 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6230 printf (_(" File: %lx"), ent
.vn_file
);
6232 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6234 vstart
+= ent
.vn_aux
;
6236 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6238 Elf_External_Vernaux
*eaux
;
6239 Elf_Internal_Vernaux aux
;
6241 eaux
= (Elf_External_Vernaux
*) vstart
;
6243 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6244 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6245 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6246 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6247 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6249 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6250 printf (_(" %#06x: Name: %s"),
6251 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6253 printf (_(" %#06x: Name index: %lx"),
6254 isum
, aux
.vna_name
);
6256 printf (_(" Flags: %s Version: %d\n"),
6257 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6259 isum
+= aux
.vna_next
;
6260 vstart
+= aux
.vna_next
;
6270 case SHT_GNU_versym
:
6272 Elf_Internal_Shdr
*link_section
;
6275 unsigned char *edata
;
6276 unsigned short *data
;
6278 Elf_Internal_Sym
*symbols
;
6279 Elf_Internal_Shdr
*string_sec
;
6282 link_section
= SECTION_HEADER (section
->sh_link
);
6283 total
= section
->sh_size
/ section
->sh_entsize
;
6287 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6289 string_sec
= SECTION_HEADER (link_section
->sh_link
);
6291 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
6292 string_sec
->sh_size
, _("version string table"));
6296 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6297 SECTION_NAME (section
), total
);
6299 printf (_(" Addr: "));
6300 printf_vma (section
->sh_addr
);
6301 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6302 (unsigned long) section
->sh_offset
, section
->sh_link
,
6303 SECTION_NAME (link_section
));
6305 off
= offset_from_vma (file
,
6306 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6307 total
* sizeof (short));
6308 edata
= get_data (NULL
, file
, off
, total
* sizeof (short),
6309 _("version symbol data"));
6316 data
= malloc (total
* sizeof (short));
6318 for (cnt
= total
; cnt
--;)
6319 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6324 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6327 int check_def
, check_need
;
6330 printf (" %03x:", cnt
);
6332 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6333 switch (data
[cnt
+ j
])
6336 fputs (_(" 0 (*local*) "), stdout
);
6340 fputs (_(" 1 (*global*) "), stdout
);
6344 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
6345 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
6349 if (SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
6352 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6359 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6361 Elf_Internal_Verneed ivn
;
6362 unsigned long offset
;
6364 offset
= offset_from_vma
6365 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6366 sizeof (Elf_External_Verneed
));
6370 Elf_Internal_Vernaux ivna
;
6371 Elf_External_Verneed evn
;
6372 Elf_External_Vernaux evna
;
6373 unsigned long a_off
;
6375 get_data (&evn
, file
, offset
, sizeof (evn
),
6378 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6379 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6381 a_off
= offset
+ ivn
.vn_aux
;
6385 get_data (&evna
, file
, a_off
, sizeof (evna
),
6386 _("version need aux (2)"));
6388 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6389 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6391 a_off
+= ivna
.vna_next
;
6393 while (ivna
.vna_other
!= data
[cnt
+ j
]
6394 && ivna
.vna_next
!= 0);
6396 if (ivna
.vna_other
== data
[cnt
+ j
])
6398 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6400 name
= strtab
+ ivna
.vna_name
;
6401 nn
+= printf ("(%s%-*s",
6403 12 - (int) strlen (name
),
6409 offset
+= ivn
.vn_next
;
6411 while (ivn
.vn_next
);
6414 if (check_def
&& data
[cnt
+ j
] != 0x8001
6415 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6417 Elf_Internal_Verdef ivd
;
6418 Elf_External_Verdef evd
;
6419 unsigned long offset
;
6421 offset
= offset_from_vma
6422 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6427 get_data (&evd
, file
, offset
, sizeof (evd
),
6430 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6431 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6433 offset
+= ivd
.vd_next
;
6435 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
6436 && ivd
.vd_next
!= 0);
6438 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
6440 Elf_External_Verdaux evda
;
6441 Elf_Internal_Verdaux ivda
;
6443 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6445 get_data (&evda
, file
,
6446 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
6447 sizeof (evda
), _("version def aux"));
6449 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6451 name
= strtab
+ ivda
.vda_name
;
6452 nn
+= printf ("(%s%-*s",
6454 12 - (int) strlen (name
),
6460 printf ("%*c", 18 - nn
, ' ');
6478 printf (_("\nNo version information found in this file.\n"));
6484 get_symbol_binding (unsigned int binding
)
6486 static char buff
[32];
6490 case STB_LOCAL
: return "LOCAL";
6491 case STB_GLOBAL
: return "GLOBAL";
6492 case STB_WEAK
: return "WEAK";
6494 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
6495 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
6497 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
6498 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
6500 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
6506 get_symbol_type (unsigned int type
)
6508 static char buff
[32];
6512 case STT_NOTYPE
: return "NOTYPE";
6513 case STT_OBJECT
: return "OBJECT";
6514 case STT_FUNC
: return "FUNC";
6515 case STT_SECTION
: return "SECTION";
6516 case STT_FILE
: return "FILE";
6517 case STT_COMMON
: return "COMMON";
6518 case STT_TLS
: return "TLS";
6520 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
6522 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
6523 return "THUMB_FUNC";
6525 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
6528 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
6529 return "PARISC_MILLI";
6531 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
6533 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
6535 if (elf_header
.e_machine
== EM_PARISC
)
6537 if (type
== STT_HP_OPAQUE
)
6539 if (type
== STT_HP_STUB
)
6543 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
6546 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
6552 get_symbol_visibility (unsigned int visibility
)
6556 case STV_DEFAULT
: return "DEFAULT";
6557 case STV_INTERNAL
: return "INTERNAL";
6558 case STV_HIDDEN
: return "HIDDEN";
6559 case STV_PROTECTED
: return "PROTECTED";
6565 get_symbol_index_type (unsigned int type
)
6567 static char buff
[32];
6571 case SHN_UNDEF
: return "UND";
6572 case SHN_ABS
: return "ABS";
6573 case SHN_COMMON
: return "COM";
6575 if (type
== SHN_IA_64_ANSI_COMMON
6576 && elf_header
.e_machine
== EM_IA_64
6577 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
6579 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
6580 sprintf (buff
, "PRC[0x%04x]", type
);
6581 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
6582 sprintf (buff
, "OS [0x%04x]", type
);
6583 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
6584 sprintf (buff
, "RSV[0x%04x]", type
);
6586 sprintf (buff
, "%3d", type
);
6594 get_dynamic_data (FILE *file
, unsigned int number
, unsigned int ent_size
)
6596 unsigned char *e_data
;
6599 e_data
= malloc (number
* ent_size
);
6603 error (_("Out of memory\n"));
6607 if (fread (e_data
, ent_size
, number
, file
) != number
)
6609 error (_("Unable to read in dynamic data\n"));
6613 i_data
= malloc (number
* sizeof (*i_data
));
6617 error (_("Out of memory\n"));
6623 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
6630 /* Dump the symbol table. */
6632 process_symbol_table (FILE *file
)
6634 Elf_Internal_Shdr
*section
;
6635 bfd_vma nbuckets
= 0;
6636 bfd_vma nchains
= 0;
6637 bfd_vma
*buckets
= NULL
;
6638 bfd_vma
*chains
= NULL
;
6640 if (! do_syms
&& !do_histogram
)
6643 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
6646 unsigned char nb
[8];
6647 unsigned char nc
[8];
6648 int hash_ent_size
= 4;
6650 if ((elf_header
.e_machine
== EM_ALPHA
6651 || elf_header
.e_machine
== EM_S390
6652 || elf_header
.e_machine
== EM_S390_OLD
)
6653 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
6657 (archive_file_offset
6658 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
6659 sizeof nb
+ sizeof nc
)),
6662 error (_("Unable to seek to start of dynamic information"));
6666 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
6668 error (_("Failed to read in number of buckets\n"));
6672 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
6674 error (_("Failed to read in number of chains\n"));
6678 nbuckets
= byte_get (nb
, hash_ent_size
);
6679 nchains
= byte_get (nc
, hash_ent_size
);
6681 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
6682 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
6684 if (buckets
== NULL
|| chains
== NULL
)
6689 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
6694 printf (_("\nSymbol table for image:\n"));
6696 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6698 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6700 for (hn
= 0; hn
< nbuckets
; hn
++)
6705 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
6707 Elf_Internal_Sym
*psym
;
6710 psym
= dynamic_symbols
+ si
;
6712 n
= print_vma (si
, DEC_5
);
6714 fputs (" " + n
, stdout
);
6715 printf (" %3lu: ", hn
);
6716 print_vma (psym
->st_value
, LONG_HEX
);
6718 print_vma (psym
->st_size
, DEC_5
);
6720 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6721 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6722 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6723 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
6724 if (VALID_DYNAMIC_NAME (psym
->st_name
))
6725 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
6727 printf (" <corrupt: %14ld>", psym
->st_name
);
6732 else if (do_syms
&& !do_using_dynamic
)
6736 for (i
= 0, section
= section_headers
;
6737 i
< elf_header
.e_shnum
;
6742 Elf_Internal_Sym
*symtab
;
6743 Elf_Internal_Sym
*psym
;
6746 if ( section
->sh_type
!= SHT_SYMTAB
6747 && section
->sh_type
!= SHT_DYNSYM
)
6750 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
6751 SECTION_NAME (section
),
6752 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
6754 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6756 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6758 symtab
= GET_ELF_SYMBOLS (file
, section
);
6762 if (section
->sh_link
== elf_header
.e_shstrndx
)
6763 strtab
= string_table
;
6766 Elf_Internal_Shdr
*string_sec
;
6768 string_sec
= SECTION_HEADER (section
->sh_link
);
6770 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
6771 string_sec
->sh_size
, _("string table"));
6774 for (si
= 0, psym
= symtab
;
6775 si
< section
->sh_size
/ section
->sh_entsize
;
6778 printf ("%6d: ", si
);
6779 print_vma (psym
->st_value
, LONG_HEX
);
6781 print_vma (psym
->st_size
, DEC_5
);
6782 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6783 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6784 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6785 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
6786 print_symbol (25, strtab
+ psym
->st_name
);
6788 if (section
->sh_type
== SHT_DYNSYM
&&
6789 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
6791 unsigned char data
[2];
6792 unsigned short vers_data
;
6793 unsigned long offset
;
6797 offset
= offset_from_vma
6798 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6799 sizeof data
+ si
* sizeof (vers_data
));
6801 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
6802 sizeof (data
), _("version data"));
6804 vers_data
= byte_get (data
, 2);
6806 is_nobits
= (SECTION_HEADER (psym
->st_shndx
)->sh_type
6809 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
6811 if ((vers_data
& 0x8000) || vers_data
> 1)
6813 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
6814 && (is_nobits
|| ! check_def
))
6816 Elf_External_Verneed evn
;
6817 Elf_Internal_Verneed ivn
;
6818 Elf_Internal_Vernaux ivna
;
6820 /* We must test both. */
6821 offset
= offset_from_vma
6822 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6827 unsigned long vna_off
;
6829 get_data (&evn
, file
, offset
, sizeof (evn
),
6832 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6833 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6835 vna_off
= offset
+ ivn
.vn_aux
;
6839 Elf_External_Vernaux evna
;
6841 get_data (&evna
, file
, vna_off
,
6843 _("version need aux (3)"));
6845 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6846 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6847 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6849 vna_off
+= ivna
.vna_next
;
6851 while (ivna
.vna_other
!= vers_data
6852 && ivna
.vna_next
!= 0);
6854 if (ivna
.vna_other
== vers_data
)
6857 offset
+= ivn
.vn_next
;
6859 while (ivn
.vn_next
!= 0);
6861 if (ivna
.vna_other
== vers_data
)
6864 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
6867 else if (! is_nobits
)
6868 error (_("bad dynamic symbol"));
6875 if (vers_data
!= 0x8001
6876 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6878 Elf_Internal_Verdef ivd
;
6879 Elf_Internal_Verdaux ivda
;
6880 Elf_External_Verdaux evda
;
6881 unsigned long offset
;
6883 offset
= offset_from_vma
6885 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6886 sizeof (Elf_External_Verdef
));
6890 Elf_External_Verdef evd
;
6892 get_data (&evd
, file
, offset
, sizeof (evd
),
6895 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6896 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6897 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6899 offset
+= ivd
.vd_next
;
6901 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
6902 && ivd
.vd_next
!= 0);
6904 offset
-= ivd
.vd_next
;
6905 offset
+= ivd
.vd_aux
;
6907 get_data (&evda
, file
, offset
, sizeof (evda
),
6908 _("version def aux"));
6910 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6912 if (psym
->st_name
!= ivda
.vda_name
)
6913 printf ((vers_data
& 0x8000)
6915 strtab
+ ivda
.vda_name
);
6925 if (strtab
!= string_table
)
6931 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
6933 if (do_histogram
&& buckets
!= NULL
)
6935 unsigned long *lengths
;
6936 unsigned long *counts
;
6939 unsigned long maxlength
= 0;
6940 unsigned long nzero_counts
= 0;
6941 unsigned long nsyms
= 0;
6943 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
6944 (unsigned long) nbuckets
);
6945 printf (_(" Length Number %% of total Coverage\n"));
6947 lengths
= calloc (nbuckets
, sizeof (*lengths
));
6948 if (lengths
== NULL
)
6950 error (_("Out of memory"));
6953 for (hn
= 0; hn
< nbuckets
; ++hn
)
6955 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
6958 if (maxlength
< ++lengths
[hn
])
6963 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
6966 error (_("Out of memory"));
6970 for (hn
= 0; hn
< nbuckets
; ++hn
)
6971 ++counts
[lengths
[hn
]];
6976 printf (" 0 %-10lu (%5.1f%%)\n",
6977 counts
[0], (counts
[0] * 100.0) / nbuckets
);
6978 for (i
= 1; i
<= maxlength
; ++i
)
6980 nzero_counts
+= counts
[i
] * i
;
6981 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
6982 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
6983 (nzero_counts
* 100.0) / nsyms
);
6991 if (buckets
!= NULL
)
7001 process_syminfo (FILE *file ATTRIBUTE_UNUSED
)
7005 if (dynamic_syminfo
== NULL
7007 /* No syminfo, this is ok. */
7010 /* There better should be a dynamic symbol section. */
7011 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
7015 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7016 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
7018 printf (_(" Num: Name BoundTo Flags\n"));
7019 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
7021 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
7023 printf ("%4d: ", i
);
7024 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
7025 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
7027 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
7030 switch (dynamic_syminfo
[i
].si_boundto
)
7032 case SYMINFO_BT_SELF
:
7033 fputs ("SELF ", stdout
);
7035 case SYMINFO_BT_PARENT
:
7036 fputs ("PARENT ", stdout
);
7039 if (dynamic_syminfo
[i
].si_boundto
> 0
7040 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
7041 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
7043 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
7047 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
7051 if (flags
& SYMINFO_FLG_DIRECT
)
7053 if (flags
& SYMINFO_FLG_PASSTHRU
)
7054 printf (" PASSTHRU");
7055 if (flags
& SYMINFO_FLG_COPY
)
7057 if (flags
& SYMINFO_FLG_LAZYLOAD
)
7058 printf (" LAZYLOAD");
7066 #ifdef SUPPORT_DISASSEMBLY
7068 disassemble_section (Elf_Internal_Shdr
*section
, FILE *file
)
7070 printf (_("\nAssembly dump of section %s\n"),
7071 SECTION_NAME (section
));
7073 /* XXX -- to be done --- XXX */
7080 dump_section (Elf_Internal_Shdr
*section
, FILE *file
)
7082 bfd_size_type bytes
;
7084 unsigned char *data
;
7085 unsigned char *start
;
7087 bytes
= section
->sh_size
;
7089 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
7091 printf (_("\nSection '%s' has no data to dump.\n"),
7092 SECTION_NAME (section
));
7096 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
7098 addr
= section
->sh_addr
;
7100 start
= get_data (NULL
, file
, section
->sh_offset
, bytes
, _("section data"));
7112 lbytes
= (bytes
> 16 ? 16 : bytes
);
7114 printf (" 0x%8.8lx ", (unsigned long) addr
);
7116 switch (elf_header
.e_ident
[EI_DATA
])
7120 for (j
= 15; j
>= 0; j
--)
7123 printf ("%2.2x", data
[j
]);
7133 for (j
= 0; j
< 16; j
++)
7136 printf ("%2.2x", data
[j
]);
7146 for (j
= 0; j
< lbytes
; j
++)
7149 if (k
>= ' ' && k
< 0x7f)
7168 static unsigned long int
7169 read_leb128 (unsigned char *data
, unsigned int *length_return
, int sign
)
7171 unsigned long int result
= 0;
7172 unsigned int num_read
= 0;
7173 unsigned int shift
= 0;
7181 result
|= ((unsigned long int) (byte
& 0x7f)) << shift
;
7186 while (byte
& 0x80);
7188 if (length_return
!= NULL
)
7189 *length_return
= num_read
;
7191 if (sign
&& (shift
< 8 * sizeof (result
)) && (byte
& 0x40))
7192 result
|= -1L << shift
;
7197 typedef struct State_Machine_Registers
7199 unsigned long address
;
7202 unsigned int column
;
7206 /* This variable hold the number of the last entry seen
7207 in the File Table. */
7208 unsigned int last_file_entry
;
7211 static SMR state_machine_regs
;
7214 reset_state_machine (int is_stmt
)
7216 state_machine_regs
.address
= 0;
7217 state_machine_regs
.file
= 1;
7218 state_machine_regs
.line
= 1;
7219 state_machine_regs
.column
= 0;
7220 state_machine_regs
.is_stmt
= is_stmt
;
7221 state_machine_regs
.basic_block
= 0;
7222 state_machine_regs
.end_sequence
= 0;
7223 state_machine_regs
.last_file_entry
= 0;
7226 /* Handled an extend line op.
7227 Returns the number of bytes read. */
7230 process_extended_line_op (unsigned char *data
, int is_stmt
, int pointer_size
)
7232 unsigned char op_code
;
7233 unsigned int bytes_read
;
7235 unsigned char *name
;
7238 len
= read_leb128 (data
, & bytes_read
, 0);
7243 warn (_("badly formed extended line op encountered!\n"));
7250 printf (_(" Extended opcode %d: "), op_code
);
7254 case DW_LNE_end_sequence
:
7255 printf (_("End of Sequence\n\n"));
7256 reset_state_machine (is_stmt
);
7259 case DW_LNE_set_address
:
7260 adr
= byte_get (data
, pointer_size
);
7261 printf (_("set Address to 0x%lx\n"), adr
);
7262 state_machine_regs
.address
= adr
;
7265 case DW_LNE_define_file
:
7266 printf (_(" define new File Table entry\n"));
7267 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
7269 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
7271 data
+= strlen ((char *) data
) + 1;
7272 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7274 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7276 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7277 printf (_("%s\n\n"), name
);
7281 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
7288 static const char *debug_str_contents
;
7289 static bfd_vma debug_str_size
;
7292 load_debug_str (FILE *file
)
7294 Elf_Internal_Shdr
*sec
;
7296 /* If it is already loaded, do nothing. */
7297 if (debug_str_contents
!= NULL
)
7300 /* Locate the .debug_str section. */
7301 sec
= find_section (".debug_str");
7305 debug_str_size
= sec
->sh_size
;
7307 debug_str_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7308 _("debug_str section data"));
7312 free_debug_str (void)
7314 if (debug_str_contents
== NULL
)
7317 free ((char *) debug_str_contents
);
7318 debug_str_contents
= NULL
;
7323 fetch_indirect_string (unsigned long offset
)
7325 if (debug_str_contents
== NULL
)
7326 return _("<no .debug_str section>");
7328 if (offset
> debug_str_size
)
7330 warn (_("DW_FORM_strp offset too big: %x\n"), offset
);
7331 return _("<offset is too big>");
7334 return debug_str_contents
+ offset
;
7337 static const char *debug_loc_contents
;
7338 static bfd_vma debug_loc_size
;
7341 load_debug_loc (FILE *file
)
7343 Elf_Internal_Shdr
*sec
;
7345 /* If it is already loaded, do nothing. */
7346 if (debug_loc_contents
!= NULL
)
7349 /* Locate the .debug_loc section. */
7350 sec
= find_section (".debug_loc");
7354 debug_loc_size
= sec
->sh_size
;
7356 debug_loc_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7357 _("debug_loc section data"));
7361 free_debug_loc (void)
7363 if (debug_loc_contents
== NULL
)
7366 free ((char *) debug_loc_contents
);
7367 debug_loc_contents
= NULL
;
7371 static const char * debug_range_contents
;
7372 static unsigned long debug_range_size
;
7375 load_debug_range (FILE *file
)
7377 Elf_Internal_Shdr
*sec
;
7379 /* If it is already loaded, do nothing. */
7380 if (debug_range_contents
!= NULL
)
7383 /* Locate the .debug_ranges section. */
7384 sec
= find_section (".debug_ranges");
7388 debug_range_size
= sec
->sh_size
;
7390 debug_range_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7391 _("debug_range section data"));
7395 free_debug_range (void)
7397 if (debug_range_contents
== NULL
)
7400 free ((char *) debug_range_contents
);
7401 debug_range_contents
= NULL
;
7402 debug_range_size
= 0;
7405 /* Apply addends of RELA relocations. */
7408 debug_apply_rela_addends (FILE *file
,
7409 Elf_Internal_Shdr
*section
,
7411 unsigned char *sec_data
,
7412 unsigned char *start
,
7415 Elf_Internal_Shdr
*relsec
;
7417 if (end
- start
< reloc_size
)
7420 for (relsec
= section_headers
;
7421 relsec
< section_headers
+ elf_header
.e_shnum
;
7424 unsigned long nrelas
;
7425 Elf_Internal_Rela
*rela
, *rp
;
7426 Elf_Internal_Shdr
*symsec
;
7427 Elf_Internal_Sym
*symtab
;
7428 Elf_Internal_Sym
*sym
;
7430 if (relsec
->sh_type
!= SHT_RELA
7431 || SECTION_HEADER (relsec
->sh_info
) != section
7432 || relsec
->sh_size
== 0)
7435 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7439 symsec
= SECTION_HEADER (relsec
->sh_link
);
7440 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
7442 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7446 if (rp
->r_offset
>= (bfd_vma
) (start
- sec_data
)
7447 && rp
->r_offset
< (bfd_vma
) (end
- sec_data
) - reloc_size
)
7448 loc
= sec_data
+ rp
->r_offset
;
7454 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
7456 if (ELF32_R_SYM (rp
->r_info
) != 0
7457 && ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
7458 /* Relocations against object symbols can happen,
7459 eg when referencing a global array. For an
7460 example of this see the _clz.o binary in libgcc.a. */
7461 && ELF32_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7463 warn (_("skipping unexpected symbol type %s in relocation in section .rela%s\n"),
7464 get_symbol_type (ELF32_ST_TYPE (sym
->st_info
)),
7465 SECTION_NAME (section
));
7471 /* In MIPS little-endian objects, r_info isn't really a
7472 64-bit little-endian value: it has a 32-bit little-endian
7473 symbol index followed by four individual byte fields.
7474 Reorder INFO accordingly. */
7475 if (elf_header
.e_machine
== EM_MIPS
7476 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
7477 rp
->r_info
= (((rp
->r_info
& 0xffffffff) << 32)
7478 | ((rp
->r_info
>> 56) & 0xff)
7479 | ((rp
->r_info
>> 40) & 0xff00)
7480 | ((rp
->r_info
>> 24) & 0xff0000)
7481 | ((rp
->r_info
>> 8) & 0xff000000));
7483 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
7485 if (ELF64_R_SYM (rp
->r_info
) != 0
7486 && ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
7487 && ELF64_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7489 warn (_("skipping unexpected symbol type %s in relocation in section .rela.%s\n"),
7490 get_symbol_type (ELF64_ST_TYPE (sym
->st_info
)),
7491 SECTION_NAME (section
));
7496 byte_put (loc
, rp
->r_addend
, reloc_size
);
7506 /* FIXME: There are better and more efficient ways to handle
7507 these structures. For now though, I just want something that
7508 is simple to implement. */
7509 typedef struct abbrev_attr
7511 unsigned long attribute
;
7513 struct abbrev_attr
*next
;
7517 typedef struct abbrev_entry
7519 unsigned long entry
;
7522 struct abbrev_attr
*first_attr
;
7523 struct abbrev_attr
*last_attr
;
7524 struct abbrev_entry
*next
;
7528 static abbrev_entry
*first_abbrev
= NULL
;
7529 static abbrev_entry
*last_abbrev
= NULL
;
7534 abbrev_entry
*abbrev
;
7536 for (abbrev
= first_abbrev
; abbrev
;)
7538 abbrev_entry
*next
= abbrev
->next
;
7541 for (attr
= abbrev
->first_attr
; attr
;)
7543 abbrev_attr
*next
= attr
->next
;
7553 last_abbrev
= first_abbrev
= NULL
;
7557 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
7559 abbrev_entry
*entry
;
7561 entry
= malloc (sizeof (*entry
));
7567 entry
->entry
= number
;
7569 entry
->children
= children
;
7570 entry
->first_attr
= NULL
;
7571 entry
->last_attr
= NULL
;
7574 if (first_abbrev
== NULL
)
7575 first_abbrev
= entry
;
7577 last_abbrev
->next
= entry
;
7579 last_abbrev
= entry
;
7583 add_abbrev_attr (unsigned long attribute
, unsigned long form
)
7587 attr
= malloc (sizeof (*attr
));
7593 attr
->attribute
= attribute
;
7597 if (last_abbrev
->first_attr
== NULL
)
7598 last_abbrev
->first_attr
= attr
;
7600 last_abbrev
->last_attr
->next
= attr
;
7602 last_abbrev
->last_attr
= attr
;
7605 /* Processes the (partial) contents of a .debug_abbrev section.
7606 Returns NULL if the end of the section was encountered.
7607 Returns the address after the last byte read if the end of
7608 an abbreviation set was found. */
7610 static unsigned char *
7611 process_abbrev_section (unsigned char *start
, unsigned char *end
)
7613 if (first_abbrev
!= NULL
)
7618 unsigned int bytes_read
;
7619 unsigned long entry
;
7621 unsigned long attribute
;
7624 entry
= read_leb128 (start
, & bytes_read
, 0);
7625 start
+= bytes_read
;
7627 /* A single zero is supposed to end the section according
7628 to the standard. If there's more, then signal that to
7631 return start
== end
? NULL
: start
;
7633 tag
= read_leb128 (start
, & bytes_read
, 0);
7634 start
+= bytes_read
;
7636 children
= *start
++;
7638 add_abbrev (entry
, tag
, children
);
7644 attribute
= read_leb128 (start
, & bytes_read
, 0);
7645 start
+= bytes_read
;
7647 form
= read_leb128 (start
, & bytes_read
, 0);
7648 start
+= bytes_read
;
7651 add_abbrev_attr (attribute
, form
);
7653 while (attribute
!= 0);
7660 get_TAG_name (unsigned long tag
)
7664 case DW_TAG_padding
: return "DW_TAG_padding";
7665 case DW_TAG_array_type
: return "DW_TAG_array_type";
7666 case DW_TAG_class_type
: return "DW_TAG_class_type";
7667 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
7668 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
7669 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
7670 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
7671 case DW_TAG_label
: return "DW_TAG_label";
7672 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
7673 case DW_TAG_member
: return "DW_TAG_member";
7674 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
7675 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
7676 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
7677 case DW_TAG_string_type
: return "DW_TAG_string_type";
7678 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
7679 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
7680 case DW_TAG_typedef
: return "DW_TAG_typedef";
7681 case DW_TAG_union_type
: return "DW_TAG_union_type";
7682 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
7683 case DW_TAG_variant
: return "DW_TAG_variant";
7684 case DW_TAG_common_block
: return "DW_TAG_common_block";
7685 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
7686 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
7687 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
7688 case DW_TAG_module
: return "DW_TAG_module";
7689 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
7690 case DW_TAG_set_type
: return "DW_TAG_set_type";
7691 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
7692 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
7693 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
7694 case DW_TAG_base_type
: return "DW_TAG_base_type";
7695 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
7696 case DW_TAG_const_type
: return "DW_TAG_const_type";
7697 case DW_TAG_constant
: return "DW_TAG_constant";
7698 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
7699 case DW_TAG_file_type
: return "DW_TAG_file_type";
7700 case DW_TAG_friend
: return "DW_TAG_friend";
7701 case DW_TAG_namelist
: return "DW_TAG_namelist";
7702 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
7703 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
7704 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
7705 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
7706 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
7707 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
7708 case DW_TAG_try_block
: return "DW_TAG_try_block";
7709 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
7710 case DW_TAG_variable
: return "DW_TAG_variable";
7711 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
7712 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
7713 case DW_TAG_format_label
: return "DW_TAG_format_label";
7714 case DW_TAG_function_template
: return "DW_TAG_function_template";
7715 case DW_TAG_class_template
: return "DW_TAG_class_template";
7716 /* DWARF 2.1 values. */
7717 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
7718 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
7719 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
7720 case DW_TAG_namespace
: return "DW_TAG_namespace";
7721 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
7722 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
7723 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
7724 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
7726 case DW_TAG_upc_shared_type
: return "DW_TAG_upc_shared_type";
7727 case DW_TAG_upc_strict_type
: return "DW_TAG_upc_strict_type";
7728 case DW_TAG_upc_relaxed_type
: return "DW_TAG_upc_relaxed_type";
7731 static char buffer
[100];
7733 snprintf (buffer
, sizeof (buffer
), _("Unknown TAG value: %lx"), tag
);
7740 get_FORM_name (unsigned long form
)
7744 case DW_FORM_addr
: return "DW_FORM_addr";
7745 case DW_FORM_block2
: return "DW_FORM_block2";
7746 case DW_FORM_block4
: return "DW_FORM_block4";
7747 case DW_FORM_data2
: return "DW_FORM_data2";
7748 case DW_FORM_data4
: return "DW_FORM_data4";
7749 case DW_FORM_data8
: return "DW_FORM_data8";
7750 case DW_FORM_string
: return "DW_FORM_string";
7751 case DW_FORM_block
: return "DW_FORM_block";
7752 case DW_FORM_block1
: return "DW_FORM_block1";
7753 case DW_FORM_data1
: return "DW_FORM_data1";
7754 case DW_FORM_flag
: return "DW_FORM_flag";
7755 case DW_FORM_sdata
: return "DW_FORM_sdata";
7756 case DW_FORM_strp
: return "DW_FORM_strp";
7757 case DW_FORM_udata
: return "DW_FORM_udata";
7758 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
7759 case DW_FORM_ref1
: return "DW_FORM_ref1";
7760 case DW_FORM_ref2
: return "DW_FORM_ref2";
7761 case DW_FORM_ref4
: return "DW_FORM_ref4";
7762 case DW_FORM_ref8
: return "DW_FORM_ref8";
7763 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
7764 case DW_FORM_indirect
: return "DW_FORM_indirect";
7767 static char buffer
[100];
7769 snprintf (buffer
, sizeof (buffer
), _("Unknown FORM value: %lx"), form
);
7775 static unsigned char *
7776 display_block (unsigned char *data
, unsigned long length
)
7778 printf (_(" %lu byte block: "), length
);
7781 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
7787 decode_location_expression (unsigned char * data
,
7788 unsigned int pointer_size
,
7789 unsigned long length
,
7790 unsigned long cu_offset
)
7793 unsigned int bytes_read
;
7794 unsigned long uvalue
;
7795 unsigned char *end
= data
+ length
;
7796 int need_frame_base
= 0;
7805 printf ("DW_OP_addr: %lx",
7806 (unsigned long) byte_get (data
, pointer_size
));
7807 data
+= pointer_size
;
7810 printf ("DW_OP_deref");
7813 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
7816 printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data
++, 1));
7819 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
7823 printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data
, 2));
7827 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
7831 printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data
, 4));
7835 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
7836 (unsigned long) byte_get (data
+ 4, 4));
7840 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
7841 (long) byte_get (data
+ 4, 4));
7845 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
7849 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
7853 printf ("DW_OP_dup");
7856 printf ("DW_OP_drop");
7859 printf ("DW_OP_over");
7862 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
7865 printf ("DW_OP_swap");
7868 printf ("DW_OP_rot");
7871 printf ("DW_OP_xderef");
7874 printf ("DW_OP_abs");
7877 printf ("DW_OP_and");
7880 printf ("DW_OP_div");
7883 printf ("DW_OP_minus");
7886 printf ("DW_OP_mod");
7889 printf ("DW_OP_mul");
7892 printf ("DW_OP_neg");
7895 printf ("DW_OP_not");
7898 printf ("DW_OP_or");
7901 printf ("DW_OP_plus");
7903 case DW_OP_plus_uconst
:
7904 printf ("DW_OP_plus_uconst: %lu",
7905 read_leb128 (data
, &bytes_read
, 0));
7909 printf ("DW_OP_shl");
7912 printf ("DW_OP_shr");
7915 printf ("DW_OP_shra");
7918 printf ("DW_OP_xor");
7921 printf ("DW_OP_bra: %ld", (long) byte_get_signed (data
, 2));
7925 printf ("DW_OP_eq");
7928 printf ("DW_OP_ge");
7931 printf ("DW_OP_gt");
7934 printf ("DW_OP_le");
7937 printf ("DW_OP_lt");
7940 printf ("DW_OP_ne");
7943 printf ("DW_OP_skip: %ld", (long) byte_get_signed (data
, 2));
7979 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
8014 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
8049 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
8050 read_leb128 (data
, &bytes_read
, 1));
8055 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
8059 need_frame_base
= 1;
8060 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
8064 uvalue
= read_leb128 (data
, &bytes_read
, 0);
8066 printf ("DW_OP_bregx: %lu %ld", uvalue
,
8067 read_leb128 (data
, &bytes_read
, 1));
8071 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
8074 case DW_OP_deref_size
:
8075 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
8077 case DW_OP_xderef_size
:
8078 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
8081 printf ("DW_OP_nop");
8084 /* DWARF 3 extensions. */
8085 case DW_OP_push_object_address
:
8086 printf ("DW_OP_push_object_address");
8089 /* XXX: Strictly speaking for 64-bit DWARF3 files
8090 this ought to be an 8-byte wide computation. */
8091 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2) + cu_offset
);
8095 /* XXX: Strictly speaking for 64-bit DWARF3 files
8096 this ought to be an 8-byte wide computation. */
8097 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4) + cu_offset
);
8100 case DW_OP_call_ref
:
8101 printf ("DW_OP_call_ref");
8104 /* GNU extensions. */
8105 case DW_OP_GNU_push_tls_address
:
8106 printf ("DW_OP_GNU_push_tls_address");
8110 if (op
>= DW_OP_lo_user
8111 && op
<= DW_OP_hi_user
)
8112 printf (_("(User defined location op)"));
8114 printf (_("(Unknown location op)"));
8115 /* No way to tell where the next op is, so just bail. */
8116 return need_frame_base
;
8119 /* Separate the ops. */
8124 return need_frame_base
;
8127 /* This structure records the information that
8128 we extract from the.debug_info section. */
8131 unsigned int pointer_size
;
8132 unsigned long cu_offset
;
8133 unsigned long base_address
;
8134 /* This is an array of offsets to the location list table. */
8135 unsigned long *loc_offsets
;
8136 int *have_frame_base
;
8137 unsigned int num_loc_offsets
;
8138 unsigned int max_loc_offsets
;
8139 unsigned long *range_lists
;
8140 unsigned int num_range_lists
;
8141 unsigned int max_range_lists
;
8145 static debug_info
* debug_information
= NULL
;
8146 static unsigned int num_debug_info_entries
= 0;
8147 static unsigned int last_pointer_size
= 0;
8148 static int warned_about_missing_comp_units
= FALSE
;
8150 static unsigned char *
8151 read_and_display_attr_value (unsigned long attribute
,
8153 unsigned char *data
,
8154 unsigned long cu_offset
,
8155 unsigned long pointer_size
,
8156 unsigned long offset_size
,
8158 debug_info
*debug_info_p
,
8161 unsigned long uvalue
= 0;
8162 unsigned char *block_start
= NULL
;
8163 unsigned int bytes_read
;
8170 case DW_FORM_ref_addr
:
8171 if (dwarf_version
== 2)
8173 uvalue
= byte_get (data
, pointer_size
);
8174 data
+= pointer_size
;
8176 else if (dwarf_version
== 3)
8178 uvalue
= byte_get (data
, offset_size
);
8179 data
+= offset_size
;
8183 error (_("Internal error: DWARF version is not 2 or 3.\n"));
8188 uvalue
= byte_get (data
, pointer_size
);
8189 data
+= pointer_size
;
8193 uvalue
= byte_get (data
, offset_size
);
8194 data
+= offset_size
;
8200 uvalue
= byte_get (data
++, 1);
8205 uvalue
= byte_get (data
, 2);
8211 uvalue
= byte_get (data
, 4);
8216 uvalue
= read_leb128 (data
, & bytes_read
, 1);
8220 case DW_FORM_ref_udata
:
8222 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8226 case DW_FORM_indirect
:
8227 form
= read_leb128 (data
, & bytes_read
, 0);
8230 printf (" %s", get_FORM_name (form
));
8231 return read_and_display_attr_value (attribute
, form
, data
,
8232 cu_offset
, pointer_size
,
8233 offset_size
, dwarf_version
,
8234 debug_info_p
, do_loc
);
8239 case DW_FORM_ref_addr
:
8241 printf (" <#%lx>", uvalue
);
8247 case DW_FORM_ref_udata
:
8249 printf (" <%lx>", uvalue
+ cu_offset
);
8255 printf (" %#lx", uvalue
);
8264 printf (" %ld", uvalue
);
8271 uvalue
= byte_get (data
, 4);
8272 printf (" %lx", uvalue
);
8273 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
8275 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8276 && num_debug_info_entries
== 0)
8278 if (sizeof (uvalue
) == 8)
8279 uvalue
= byte_get (data
, 8);
8281 error (_("DW_FORM_data8 is unsupported when sizeof (unsigned long) != 8\n"));
8286 case DW_FORM_string
:
8288 printf (" %s", data
);
8289 data
+= strlen ((char *) data
) + 1;
8293 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8294 block_start
= data
+ bytes_read
;
8296 data
= block_start
+ uvalue
;
8298 data
= display_block (block_start
, uvalue
);
8301 case DW_FORM_block1
:
8302 uvalue
= byte_get (data
, 1);
8303 block_start
= data
+ 1;
8305 data
= block_start
+ uvalue
;
8307 data
= display_block (block_start
, uvalue
);
8310 case DW_FORM_block2
:
8311 uvalue
= byte_get (data
, 2);
8312 block_start
= data
+ 2;
8314 data
= block_start
+ uvalue
;
8316 data
= display_block (block_start
, uvalue
);
8319 case DW_FORM_block4
:
8320 uvalue
= byte_get (data
, 4);
8321 block_start
= data
+ 4;
8323 data
= block_start
+ uvalue
;
8325 data
= display_block (block_start
, uvalue
);
8330 printf (_(" (indirect string, offset: 0x%lx): %s"),
8331 uvalue
, fetch_indirect_string (uvalue
));
8334 case DW_FORM_indirect
:
8335 /* Handled above. */
8339 warn (_("Unrecognized form: %d\n"), form
);
8343 /* For some attributes we can display further information. */
8344 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8345 && num_debug_info_entries
== 0)
8349 case DW_AT_frame_base
:
8350 have_frame_base
= 1;
8351 case DW_AT_location
:
8352 case DW_AT_data_member_location
:
8353 case DW_AT_vtable_elem_location
:
8354 case DW_AT_allocated
:
8355 case DW_AT_associated
:
8356 case DW_AT_data_location
:
8358 case DW_AT_upper_bound
:
8359 case DW_AT_lower_bound
:
8360 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8362 /* Process location list. */
8363 unsigned int max
= debug_info_p
->max_loc_offsets
;
8364 unsigned int num
= debug_info_p
->num_loc_offsets
;
8366 if (max
== 0 || num
>= max
)
8369 debug_info_p
->loc_offsets
8370 = xrealloc (debug_info_p
->loc_offsets
,
8371 max
* sizeof (*debug_info_p
->loc_offsets
));
8372 debug_info_p
->have_frame_base
8373 = xrealloc (debug_info_p
->have_frame_base
,
8374 max
* sizeof (*debug_info_p
->have_frame_base
));
8375 debug_info_p
->max_loc_offsets
= max
;
8377 debug_info_p
->loc_offsets
[num
] = uvalue
;
8378 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
8379 debug_info_p
->num_loc_offsets
++;
8384 if (need_base_address
)
8385 debug_info_p
->base_address
= uvalue
;
8389 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8391 /* Process range list. */
8392 unsigned int max
= debug_info_p
->max_range_lists
;
8393 unsigned int num
= debug_info_p
->num_range_lists
;
8395 if (max
== 0 || num
>= max
)
8398 debug_info_p
->range_lists
8399 = xrealloc (debug_info_p
->range_lists
,
8400 max
* sizeof (*debug_info_p
->range_lists
));
8401 debug_info_p
->max_range_lists
= max
;
8403 debug_info_p
->range_lists
[num
] = uvalue
;
8404 debug_info_p
->num_range_lists
++;
8423 case DW_INL_not_inlined
:
8424 printf (_("(not inlined)"));
8426 case DW_INL_inlined
:
8427 printf (_("(inlined)"));
8429 case DW_INL_declared_not_inlined
:
8430 printf (_("(declared as inline but ignored)"));
8432 case DW_INL_declared_inlined
:
8433 printf (_("(declared as inline and inlined)"));
8436 printf (_(" (Unknown inline attribute value: %lx)"), uvalue
);
8441 case DW_AT_language
:
8444 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
8445 case DW_LANG_C89
: printf ("(ANSI C)"); break;
8446 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
8447 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
8448 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
8449 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
8450 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
8451 case DW_LANG_Ada83
: printf ("(Ada)"); break;
8452 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
8453 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
8454 /* DWARF 2.1 values. */
8455 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
8456 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
8457 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
8458 /* MIPS extension. */
8459 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
8460 /* UPC extension. */
8461 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
8463 printf ("(Unknown: %lx)", uvalue
);
8468 case DW_AT_encoding
:
8471 case DW_ATE_void
: printf ("(void)"); break;
8472 case DW_ATE_address
: printf ("(machine address)"); break;
8473 case DW_ATE_boolean
: printf ("(boolean)"); break;
8474 case DW_ATE_complex_float
: printf ("(complex float)"); break;
8475 case DW_ATE_float
: printf ("(float)"); break;
8476 case DW_ATE_signed
: printf ("(signed)"); break;
8477 case DW_ATE_signed_char
: printf ("(signed char)"); break;
8478 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
8479 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
8480 /* DWARF 2.1 value. */
8481 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
8482 /* GNU extension. */
8483 case DW_ATE_GNU_decimal_float
: printf ("(decimal float)"); break;
8485 if (uvalue
>= DW_ATE_lo_user
8486 && uvalue
<= DW_ATE_hi_user
)
8487 printf ("(user defined type)");
8489 printf ("(unknown type)");
8494 case DW_AT_accessibility
:
8497 case DW_ACCESS_public
: printf ("(public)"); break;
8498 case DW_ACCESS_protected
: printf ("(protected)"); break;
8499 case DW_ACCESS_private
: printf ("(private)"); break;
8501 printf ("(unknown accessibility)");
8506 case DW_AT_visibility
:
8509 case DW_VIS_local
: printf ("(local)"); break;
8510 case DW_VIS_exported
: printf ("(exported)"); break;
8511 case DW_VIS_qualified
: printf ("(qualified)"); break;
8512 default: printf ("(unknown visibility)"); break;
8516 case DW_AT_virtuality
:
8519 case DW_VIRTUALITY_none
: printf ("(none)"); break;
8520 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
8521 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
8522 default: printf ("(unknown virtuality)"); break;
8526 case DW_AT_identifier_case
:
8529 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
8530 case DW_ID_up_case
: printf ("(up_case)"); break;
8531 case DW_ID_down_case
: printf ("(down_case)"); break;
8532 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
8533 default: printf ("(unknown case)"); break;
8537 case DW_AT_calling_convention
:
8540 case DW_CC_normal
: printf ("(normal)"); break;
8541 case DW_CC_program
: printf ("(program)"); break;
8542 case DW_CC_nocall
: printf ("(nocall)"); break;
8544 if (uvalue
>= DW_CC_lo_user
8545 && uvalue
<= DW_CC_hi_user
)
8546 printf ("(user defined)");
8548 printf ("(unknown convention)");
8552 case DW_AT_ordering
:
8555 case -1: printf ("(undefined)"); break;
8556 case 0: printf ("(row major)"); break;
8557 case 1: printf ("(column major)"); break;
8561 case DW_AT_frame_base
:
8562 have_frame_base
= 1;
8563 case DW_AT_location
:
8564 case DW_AT_data_member_location
:
8565 case DW_AT_vtable_elem_location
:
8566 case DW_AT_allocated
:
8567 case DW_AT_associated
:
8568 case DW_AT_data_location
:
8570 case DW_AT_upper_bound
:
8571 case DW_AT_lower_bound
:
8574 int need_frame_base
;
8577 need_frame_base
= decode_location_expression (block_start
,
8582 if (need_frame_base
&& !have_frame_base
)
8583 printf (_(" [without DW_AT_frame_base]"));
8585 else if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8586 printf (_("(location list)"));
8598 get_AT_name (unsigned long attribute
)
8602 case DW_AT_sibling
: return "DW_AT_sibling";
8603 case DW_AT_location
: return "DW_AT_location";
8604 case DW_AT_name
: return "DW_AT_name";
8605 case DW_AT_ordering
: return "DW_AT_ordering";
8606 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
8607 case DW_AT_byte_size
: return "DW_AT_byte_size";
8608 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
8609 case DW_AT_bit_size
: return "DW_AT_bit_size";
8610 case DW_AT_element_list
: return "DW_AT_element_list";
8611 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
8612 case DW_AT_low_pc
: return "DW_AT_low_pc";
8613 case DW_AT_high_pc
: return "DW_AT_high_pc";
8614 case DW_AT_language
: return "DW_AT_language";
8615 case DW_AT_member
: return "DW_AT_member";
8616 case DW_AT_discr
: return "DW_AT_discr";
8617 case DW_AT_discr_value
: return "DW_AT_discr_value";
8618 case DW_AT_visibility
: return "DW_AT_visibility";
8619 case DW_AT_import
: return "DW_AT_import";
8620 case DW_AT_string_length
: return "DW_AT_string_length";
8621 case DW_AT_common_reference
: return "DW_AT_common_reference";
8622 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
8623 case DW_AT_const_value
: return "DW_AT_const_value";
8624 case DW_AT_containing_type
: return "DW_AT_containing_type";
8625 case DW_AT_default_value
: return "DW_AT_default_value";
8626 case DW_AT_inline
: return "DW_AT_inline";
8627 case DW_AT_is_optional
: return "DW_AT_is_optional";
8628 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
8629 case DW_AT_producer
: return "DW_AT_producer";
8630 case DW_AT_prototyped
: return "DW_AT_prototyped";
8631 case DW_AT_return_addr
: return "DW_AT_return_addr";
8632 case DW_AT_start_scope
: return "DW_AT_start_scope";
8633 case DW_AT_stride_size
: return "DW_AT_stride_size";
8634 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
8635 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
8636 case DW_AT_accessibility
: return "DW_AT_accessibility";
8637 case DW_AT_address_class
: return "DW_AT_address_class";
8638 case DW_AT_artificial
: return "DW_AT_artificial";
8639 case DW_AT_base_types
: return "DW_AT_base_types";
8640 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
8641 case DW_AT_count
: return "DW_AT_count";
8642 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
8643 case DW_AT_decl_column
: return "DW_AT_decl_column";
8644 case DW_AT_decl_file
: return "DW_AT_decl_file";
8645 case DW_AT_decl_line
: return "DW_AT_decl_line";
8646 case DW_AT_declaration
: return "DW_AT_declaration";
8647 case DW_AT_discr_list
: return "DW_AT_discr_list";
8648 case DW_AT_encoding
: return "DW_AT_encoding";
8649 case DW_AT_external
: return "DW_AT_external";
8650 case DW_AT_frame_base
: return "DW_AT_frame_base";
8651 case DW_AT_friend
: return "DW_AT_friend";
8652 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
8653 case DW_AT_macro_info
: return "DW_AT_macro_info";
8654 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
8655 case DW_AT_priority
: return "DW_AT_priority";
8656 case DW_AT_segment
: return "DW_AT_segment";
8657 case DW_AT_specification
: return "DW_AT_specification";
8658 case DW_AT_static_link
: return "DW_AT_static_link";
8659 case DW_AT_type
: return "DW_AT_type";
8660 case DW_AT_use_location
: return "DW_AT_use_location";
8661 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
8662 case DW_AT_virtuality
: return "DW_AT_virtuality";
8663 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
8664 /* DWARF 2.1 values. */
8665 case DW_AT_allocated
: return "DW_AT_allocated";
8666 case DW_AT_associated
: return "DW_AT_associated";
8667 case DW_AT_data_location
: return "DW_AT_data_location";
8668 case DW_AT_stride
: return "DW_AT_stride";
8669 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
8670 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
8671 case DW_AT_extension
: return "DW_AT_extension";
8672 case DW_AT_ranges
: return "DW_AT_ranges";
8673 case DW_AT_trampoline
: return "DW_AT_trampoline";
8674 case DW_AT_call_column
: return "DW_AT_call_column";
8675 case DW_AT_call_file
: return "DW_AT_call_file";
8676 case DW_AT_call_line
: return "DW_AT_call_line";
8677 /* SGI/MIPS extensions. */
8678 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
8679 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
8680 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
8681 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
8682 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
8683 case DW_AT_MIPS_software_pipeline_depth
:
8684 return "DW_AT_MIPS_software_pipeline_depth";
8685 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
8686 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
8687 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
8688 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
8689 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
8690 /* GNU extensions. */
8691 case DW_AT_sf_names
: return "DW_AT_sf_names";
8692 case DW_AT_src_info
: return "DW_AT_src_info";
8693 case DW_AT_mac_info
: return "DW_AT_mac_info";
8694 case DW_AT_src_coords
: return "DW_AT_src_coords";
8695 case DW_AT_body_begin
: return "DW_AT_body_begin";
8696 case DW_AT_body_end
: return "DW_AT_body_end";
8697 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
8698 /* UPC extension. */
8699 case DW_AT_upc_threads_scaled
: return "DW_AT_upc_threads_scaled";
8702 static char buffer
[100];
8704 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
8711 static unsigned char *
8712 read_and_display_attr (unsigned long attribute
,
8714 unsigned char *data
,
8715 unsigned long cu_offset
,
8716 unsigned long pointer_size
,
8717 unsigned long offset_size
,
8719 debug_info
*debug_info_p
,
8723 printf (" %-18s:", get_AT_name (attribute
));
8724 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
8725 pointer_size
, offset_size
,
8726 dwarf_version
, debug_info_p
,
8734 /* Process the contents of a .debug_info section. If do_loc is non-zero
8735 then we are scanning for location lists and we do not want to display
8736 anything to the user. */
8739 process_debug_info (Elf_Internal_Shdr
*section
, unsigned char *start
,
8740 FILE *file
, int do_loc
)
8742 unsigned char *end
= start
+ section
->sh_size
;
8743 unsigned char *section_begin
;
8745 unsigned int num_units
= 0;
8747 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8748 && num_debug_info_entries
== 0)
8750 unsigned long length
;
8752 /* First scan the section to get the number of comp units. */
8753 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
8756 /* Read the first 4 bytes. For a 32-bit DWARF section, this
8757 will be the length. For a 64-bit DWARF section, it'll be
8758 the escape code 0xffffffff followed by an 8 byte length. */
8759 length
= byte_get (section_begin
, 4);
8761 if (length
== 0xffffffff)
8763 length
= byte_get (section_begin
+ 4, 8);
8764 section_begin
+= length
+ 12;
8767 section_begin
+= length
+ 4;
8772 error (_("No comp units in .debug_info section ?"));
8776 /* Then allocate an array to hold the information. */
8777 debug_information
= malloc (num_units
*
8778 sizeof (* debug_information
));
8779 if (debug_information
== NULL
)
8781 error (_("Not enough memory for a debug info array of %u entries"),
8789 printf (_("The section %s contains:\n\n"),
8790 SECTION_NAME (section
));
8792 load_debug_str (file
);
8793 load_debug_loc (file
);
8794 load_debug_range (file
);
8797 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
8799 DWARF2_Internal_CompUnit compunit
;
8800 unsigned char *hdrptr
;
8801 unsigned char *cu_abbrev_offset_ptr
;
8802 unsigned char *tags
;
8804 unsigned long cu_offset
;
8806 int initial_length_size
;
8810 compunit
.cu_length
= byte_get (hdrptr
, 4);
8813 if (compunit
.cu_length
== 0xffffffff)
8815 compunit
.cu_length
= byte_get (hdrptr
, 8);
8818 initial_length_size
= 12;
8823 initial_length_size
= 4;
8826 compunit
.cu_version
= byte_get (hdrptr
, 2);
8829 cu_offset
= start
- section_begin
;
8830 start
+= compunit
.cu_length
+ initial_length_size
;
8832 if (elf_header
.e_type
== ET_REL
8833 && !debug_apply_rela_addends (file
, section
, offset_size
,
8834 section_begin
, hdrptr
, start
))
8837 cu_abbrev_offset_ptr
= hdrptr
;
8838 compunit
.cu_abbrev_offset
= byte_get (hdrptr
, offset_size
);
8839 hdrptr
+= offset_size
;
8841 compunit
.cu_pointer_size
= byte_get (hdrptr
, 1);
8843 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8844 && num_debug_info_entries
== 0)
8846 debug_information
[unit
].cu_offset
= cu_offset
;
8847 debug_information
[unit
].pointer_size
8848 = compunit
.cu_pointer_size
;
8849 debug_information
[unit
].base_address
= 0;
8850 debug_information
[unit
].loc_offsets
= NULL
;
8851 debug_information
[unit
].have_frame_base
= NULL
;
8852 debug_information
[unit
].max_loc_offsets
= 0;
8853 debug_information
[unit
].num_loc_offsets
= 0;
8854 debug_information
[unit
].range_lists
= NULL
;
8855 debug_information
[unit
].max_range_lists
= 0;
8856 debug_information
[unit
].num_range_lists
= 0;
8863 printf (_(" Compilation Unit @ offset 0x%lx:\n"), cu_offset
);
8864 printf (_(" Length: %ld\n"), compunit
.cu_length
);
8865 printf (_(" Version: %d\n"), compunit
.cu_version
);
8866 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
8867 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
8870 if (compunit
.cu_version
!= 2 && compunit
.cu_version
!= 3)
8872 warn (_("Only version 2 and 3 DWARF debug information is currently supported.\n"));
8878 /* Read in the abbrevs used by this compilation unit. */
8880 Elf_Internal_Shdr
*sec
;
8881 unsigned char *begin
;
8883 /* Locate the .debug_abbrev section and process it. */
8884 sec
= find_section (".debug_abbrev");
8887 warn (_("Unable to locate .debug_abbrev section!\n"));
8891 begin
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
8892 _("debug_abbrev section data"));
8896 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
8897 begin
+ sec
->sh_size
);
8903 while (tags
< start
)
8905 unsigned int bytes_read
;
8906 unsigned long abbrev_number
;
8907 abbrev_entry
*entry
;
8910 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
8913 /* A null DIE marks the end of a list of children. */
8914 if (abbrev_number
== 0)
8920 /* Scan through the abbreviation list until we reach the
8922 for (entry
= first_abbrev
;
8923 entry
&& entry
->entry
!= abbrev_number
;
8924 entry
= entry
->next
)
8929 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
8935 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
8937 (unsigned long) (tags
- section_begin
8940 get_TAG_name (entry
->tag
));
8945 need_base_address
= 0;
8947 case DW_TAG_compile_unit
:
8948 need_base_address
= 1;
8950 case DW_TAG_entry_point
:
8951 case DW_TAG_inlined_subroutine
:
8952 case DW_TAG_subprogram
:
8953 need_base_address
= 0;
8954 /* Assuming that there is no DW_AT_frame_base. */
8955 have_frame_base
= 0;
8959 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
8960 tags
= read_and_display_attr (attr
->attribute
,
8963 compunit
.cu_pointer_size
,
8965 compunit
.cu_version
,
8966 &debug_information
[unit
],
8969 if (entry
->children
)
8974 /* Set num_debug_info_entries here so that it can be used to check if
8975 we need to process .debug_loc and .debug_ranges sections. */
8976 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8977 && num_debug_info_entries
== 0)
8978 num_debug_info_entries
= num_units
;
8982 free_debug_range ();
8992 /* Retrieve the pointer size associated with the given compilation unit.
8993 Optionally the offset of this unit into the .debug_info section is
8994 also retutned. If there is no .debug_info section then an error
8995 message is issued and 0 is returned. If the requested comp unit has
8996 not been defined in the .debug_info section then a warning message
8997 is issued and the last know pointer size is returned. This message
8998 is only issued once per section dumped per file dumped. */
9001 get_pointer_size_and_offset_of_comp_unit (unsigned int comp_unit
,
9002 const char * section_name
,
9003 unsigned long * offset_return
)
9005 unsigned long offset
= 0;
9007 if (num_debug_info_entries
== 0)
9008 error (_("%s section needs a populated .debug_info section\n"),
9011 else if (comp_unit
>= num_debug_info_entries
)
9013 if (!warned_about_missing_comp_units
)
9015 warn (_("%s section has more comp units than .debug_info section\n"),
9017 warn (_("assuming that the pointer size is %d, from the last comp unit in .debug_info\n\n"),
9019 warned_about_missing_comp_units
= TRUE
;
9024 last_pointer_size
= debug_information
[comp_unit
].pointer_size
;
9025 offset
= debug_information
[comp_unit
].cu_offset
;
9028 if (offset_return
!= NULL
)
9029 * offset_return
= offset
;
9031 return last_pointer_size
;
9034 /* Locate and scan the .debug_info section in the file and record the pointer
9035 sizes and offsets for the compilation units in it. Usually an executable
9036 will have just one pointer size, but this is not guaranteed, and so we try
9037 not to make any assumptions. Returns zero upon failure, or the number of
9038 compilation units upon success. */
9041 get_debug_info (FILE * file
)
9043 Elf_Internal_Shdr
* section
;
9044 unsigned char * start
;
9047 /* Reset the last pointer size so that we can issue correct error
9048 messages if we are displaying the contents of more than one section. */
9049 last_pointer_size
= 0;
9050 warned_about_missing_comp_units
= FALSE
;
9052 /* If we already have the information there is nothing else to do. */
9053 if (num_debug_info_entries
> 0)
9054 return num_debug_info_entries
;
9056 section
= find_section (".debug_info");
9057 if (section
== NULL
)
9060 start
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
9061 _("extracting information from .debug_info section"));
9065 ret
= process_debug_info (section
, start
, file
, 1);
9068 return ret
? num_debug_info_entries
: 0;
9072 display_debug_lines (Elf_Internal_Shdr
*section
,
9073 unsigned char *start
, FILE *file
)
9075 unsigned char *data
= start
;
9076 unsigned char *end
= start
+ section
->sh_size
;
9077 unsigned int comp_unit
= 0;
9079 printf (_("\nDump of debug contents of section %s:\n\n"),
9080 SECTION_NAME (section
));
9082 get_debug_info (file
);
9086 DWARF2_Internal_LineInfo info
;
9087 unsigned char *standard_opcodes
;
9088 unsigned char *end_of_sequence
;
9089 unsigned char *hdrptr
;
9090 unsigned int pointer_size
;
9091 int initial_length_size
;
9097 /* Check the length of the block. */
9098 info
.li_length
= byte_get (hdrptr
, 4);
9101 if (info
.li_length
== 0xffffffff)
9103 /* This section is 64-bit DWARF 3. */
9104 info
.li_length
= byte_get (hdrptr
, 8);
9107 initial_length_size
= 12;
9112 initial_length_size
= 4;
9115 if (info
.li_length
+ initial_length_size
> section
->sh_size
)
9118 (_("The line info appears to be corrupt - the section is too small\n"));
9122 /* Check its version number. */
9123 info
.li_version
= byte_get (hdrptr
, 2);
9125 if (info
.li_version
!= 2 && info
.li_version
!= 3)
9127 warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
9131 info
.li_prologue_length
= byte_get (hdrptr
, offset_size
);
9132 hdrptr
+= offset_size
;
9133 info
.li_min_insn_length
= byte_get (hdrptr
, 1);
9135 info
.li_default_is_stmt
= byte_get (hdrptr
, 1);
9137 info
.li_line_base
= byte_get (hdrptr
, 1);
9139 info
.li_line_range
= byte_get (hdrptr
, 1);
9141 info
.li_opcode_base
= byte_get (hdrptr
, 1);
9144 /* Sign extend the line base field. */
9145 info
.li_line_base
<<= 24;
9146 info
.li_line_base
>>= 24;
9148 /* Get the pointer size from the comp unit associated
9149 with this block of line number information. */
9150 pointer_size
= get_pointer_size_and_offset_of_comp_unit
9151 (comp_unit
, ".debug_line", NULL
);
9154 printf (_(" Length: %ld\n"), info
.li_length
);
9155 printf (_(" DWARF Version: %d\n"), info
.li_version
);
9156 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
9157 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
9158 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
9159 printf (_(" Line Base: %d\n"), info
.li_line_base
);
9160 printf (_(" Line Range: %d\n"), info
.li_line_range
);
9161 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
9162 printf (_(" (Pointer size: %u)%s\n"),
9164 warned_about_missing_comp_units
? " [assumed]" : "" );
9166 end_of_sequence
= data
+ info
.li_length
+ initial_length_size
;
9168 reset_state_machine (info
.li_default_is_stmt
);
9170 /* Display the contents of the Opcodes table. */
9171 standard_opcodes
= hdrptr
;
9173 printf (_("\n Opcodes:\n"));
9175 for (i
= 1; i
< info
.li_opcode_base
; i
++)
9176 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
9178 /* Display the contents of the Directory table. */
9179 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
9182 printf (_("\n The Directory Table is empty.\n"));
9185 printf (_("\n The Directory Table:\n"));
9189 printf (_(" %s\n"), data
);
9191 data
+= strlen ((char *) data
) + 1;
9195 /* Skip the NUL at the end of the table. */
9198 /* Display the contents of the File Name table. */
9200 printf (_("\n The File Name Table is empty.\n"));
9203 printf (_("\n The File Name Table:\n"));
9204 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
9208 unsigned char *name
;
9209 unsigned int bytes_read
;
9211 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
9214 data
+= strlen ((char *) data
) + 1;
9216 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9218 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9220 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9222 printf (_("%s\n"), name
);
9226 /* Skip the NUL at the end of the table. */
9229 /* Now display the statements. */
9230 printf (_("\n Line Number Statements:\n"));
9232 while (data
< end_of_sequence
)
9234 unsigned char op_code
;
9236 unsigned int bytes_read
;
9240 if (op_code
>= info
.li_opcode_base
)
9242 op_code
-= info
.li_opcode_base
;
9243 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
9244 state_machine_regs
.address
+= adv
;
9245 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
9246 op_code
, adv
, state_machine_regs
.address
);
9247 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
9248 state_machine_regs
.line
+= adv
;
9249 printf (_(" and Line by %d to %d\n"),
9250 adv
, state_machine_regs
.line
);
9252 else switch (op_code
)
9254 case DW_LNS_extended_op
:
9255 if (pointer_size
== 0)
9257 warn (_("Extend line ops need a valid pointer size, guessing at 4\n"));
9261 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
9266 printf (_(" Copy\n"));
9269 case DW_LNS_advance_pc
:
9270 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
9272 state_machine_regs
.address
+= adv
;
9273 printf (_(" Advance PC by %d to %lx\n"), adv
,
9274 state_machine_regs
.address
);
9277 case DW_LNS_advance_line
:
9278 adv
= read_leb128 (data
, & bytes_read
, 1);
9280 state_machine_regs
.line
+= adv
;
9281 printf (_(" Advance Line by %d to %d\n"), adv
,
9282 state_machine_regs
.line
);
9285 case DW_LNS_set_file
:
9286 adv
= read_leb128 (data
, & bytes_read
, 0);
9288 printf (_(" Set File Name to entry %d in the File Name Table\n"),
9290 state_machine_regs
.file
= adv
;
9293 case DW_LNS_set_column
:
9294 adv
= read_leb128 (data
, & bytes_read
, 0);
9296 printf (_(" Set column to %d\n"), adv
);
9297 state_machine_regs
.column
= adv
;
9300 case DW_LNS_negate_stmt
:
9301 adv
= state_machine_regs
.is_stmt
;
9303 printf (_(" Set is_stmt to %d\n"), adv
);
9304 state_machine_regs
.is_stmt
= adv
;
9307 case DW_LNS_set_basic_block
:
9308 printf (_(" Set basic block\n"));
9309 state_machine_regs
.basic_block
= 1;
9312 case DW_LNS_const_add_pc
:
9313 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
9314 * info
.li_min_insn_length
);
9315 state_machine_regs
.address
+= adv
;
9316 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
9317 state_machine_regs
.address
);
9320 case DW_LNS_fixed_advance_pc
:
9321 adv
= byte_get (data
, 2);
9323 state_machine_regs
.address
+= adv
;
9324 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
9325 adv
, state_machine_regs
.address
);
9328 case DW_LNS_set_prologue_end
:
9329 printf (_(" Set prologue_end to true\n"));
9332 case DW_LNS_set_epilogue_begin
:
9333 printf (_(" Set epilogue_begin to true\n"));
9336 case DW_LNS_set_isa
:
9337 adv
= read_leb128 (data
, & bytes_read
, 0);
9339 printf (_(" Set ISA to %d\n"), adv
);
9343 printf (_(" Unknown opcode %d with operands: "), op_code
);
9345 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
9347 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
9348 i
== 1 ? "" : ", ");
9362 display_debug_pubnames (Elf_Internal_Shdr
*section
,
9363 unsigned char *start
,
9364 FILE *file ATTRIBUTE_UNUSED
)
9366 DWARF2_Internal_PubNames pubnames
;
9369 end
= start
+ section
->sh_size
;
9371 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9375 unsigned char *data
;
9376 unsigned long offset
;
9377 int offset_size
, initial_length_size
;
9381 pubnames
.pn_length
= byte_get (data
, 4);
9383 if (pubnames
.pn_length
== 0xffffffff)
9385 pubnames
.pn_length
= byte_get (data
, 8);
9388 initial_length_size
= 12;
9393 initial_length_size
= 4;
9396 pubnames
.pn_version
= byte_get (data
, 2);
9398 pubnames
.pn_offset
= byte_get (data
, offset_size
);
9399 data
+= offset_size
;
9400 pubnames
.pn_size
= byte_get (data
, offset_size
);
9401 data
+= offset_size
;
9403 start
+= pubnames
.pn_length
+ initial_length_size
;
9405 if (pubnames
.pn_version
!= 2 && pubnames
.pn_version
!= 3)
9407 static int warned
= 0;
9411 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
9418 printf (_(" Length: %ld\n"),
9419 pubnames
.pn_length
);
9420 printf (_(" Version: %d\n"),
9421 pubnames
.pn_version
);
9422 printf (_(" Offset into .debug_info section: %ld\n"),
9423 pubnames
.pn_offset
);
9424 printf (_(" Size of area in .debug_info section: %ld\n"),
9427 printf (_("\n Offset\tName\n"));
9431 offset
= byte_get (data
, offset_size
);
9435 data
+= offset_size
;
9436 printf (" %-6ld\t\t%s\n", offset
, data
);
9437 data
+= strlen ((char *) data
) + 1;
9440 while (offset
!= 0);
9448 display_debug_macinfo (Elf_Internal_Shdr
*section
,
9449 unsigned char *start
,
9450 FILE *file ATTRIBUTE_UNUSED
)
9452 unsigned char *end
= start
+ section
->sh_size
;
9453 unsigned char *curr
= start
;
9454 unsigned int bytes_read
;
9455 enum dwarf_macinfo_record_type op
;
9457 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9461 unsigned int lineno
;
9469 case DW_MACINFO_start_file
:
9471 unsigned int filenum
;
9473 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9475 filenum
= read_leb128 (curr
, & bytes_read
, 0);
9478 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
9483 case DW_MACINFO_end_file
:
9484 printf (_(" DW_MACINFO_end_file\n"));
9487 case DW_MACINFO_define
:
9488 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9490 string
= (char *) curr
;
9491 curr
+= strlen (string
) + 1;
9492 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
9496 case DW_MACINFO_undef
:
9497 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9499 string
= (char *) curr
;
9500 curr
+= strlen (string
) + 1;
9501 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
9505 case DW_MACINFO_vendor_ext
:
9507 unsigned int constant
;
9509 constant
= read_leb128 (curr
, & bytes_read
, 0);
9511 string
= (char *) curr
;
9512 curr
+= strlen (string
) + 1;
9513 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
9525 display_debug_abbrev (Elf_Internal_Shdr
*section
,
9526 unsigned char *start
,
9527 FILE *file ATTRIBUTE_UNUSED
)
9529 abbrev_entry
*entry
;
9530 unsigned char *end
= start
+ section
->sh_size
;
9532 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9536 start
= process_abbrev_section (start
, end
);
9538 if (first_abbrev
== NULL
)
9541 printf (_(" Number TAG\n"));
9543 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
9547 printf (_(" %ld %s [%s]\n"),
9549 get_TAG_name (entry
->tag
),
9550 entry
->children
? _("has children") : _("no children"));
9552 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
9553 printf (_(" %-18s %s\n"),
9554 get_AT_name (attr
->attribute
),
9555 get_FORM_name (attr
->form
));
9568 display_debug_loc (Elf_Internal_Shdr
*section
,
9569 unsigned char *start
, FILE *file
)
9571 unsigned char *section_end
;
9572 unsigned long bytes
;
9573 unsigned char *section_begin
= start
;
9574 unsigned int num_loc_list
= 0;
9575 unsigned long last_offset
= 0;
9576 unsigned int first
= 0;
9579 int seen_first_offset
= 0;
9580 int use_debug_info
= 1;
9581 unsigned char *next
;
9583 bytes
= section
->sh_size
;
9584 section_end
= start
+ bytes
;
9588 printf (_("\nThe .debug_loc section is empty.\n"));
9592 get_debug_info (file
);
9594 /* Check the order of location list in .debug_info section. If
9595 offsets of location lists are in the ascending order, we can
9596 use `debug_information' directly. */
9597 for (i
= 0; i
< num_debug_info_entries
; i
++)
9601 num
= debug_information
[i
].num_loc_offsets
;
9602 num_loc_list
+= num
;
9604 /* Check if we can use `debug_information' directly. */
9605 if (use_debug_info
&& num
!= 0)
9607 if (!seen_first_offset
)
9609 /* This is the first location list. */
9610 last_offset
= debug_information
[i
].loc_offsets
[0];
9612 seen_first_offset
= 1;
9618 for (; j
< num
; j
++)
9621 debug_information
[i
].loc_offsets
[j
])
9626 last_offset
= debug_information
[i
].loc_offsets
[j
];
9631 if (!use_debug_info
)
9632 /* FIXME: Should we handle this case? */
9633 error (_("Location lists in .debug_info section aren't in ascending order!\n"));
9635 if (!seen_first_offset
)
9636 error (_("No location lists in .debug_info section!\n"));
9638 if (debug_information
[first
].loc_offsets
[0] != 0)
9639 warn (_("Location lists in .debug_loc section start at 0x%lx\n"),
9640 debug_information
[first
].loc_offsets
[0]);
9642 printf (_("Contents of the .debug_loc section:\n\n"));
9643 printf (_(" Offset Begin End Expression\n"));
9645 seen_first_offset
= 0;
9646 for (i
= first
; i
< num_debug_info_entries
; i
++)
9648 unsigned long begin
;
9650 unsigned short length
;
9651 unsigned long offset
;
9652 unsigned int pointer_size
;
9653 unsigned long cu_offset
;
9654 unsigned long base_address
;
9655 int need_frame_base
;
9658 pointer_size
= debug_information
[i
].pointer_size
;
9659 cu_offset
= debug_information
[i
].cu_offset
;
9661 for (j
= 0; j
< debug_information
[i
].num_loc_offsets
; j
++)
9663 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
9664 offset
= debug_information
[i
].loc_offsets
[j
];
9665 next
= section_begin
+ offset
;
9666 base_address
= debug_information
[i
].base_address
;
9668 if (!seen_first_offset
)
9669 seen_first_offset
= 1;
9673 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
9674 start
- section_begin
, next
- section_begin
);
9675 else if (start
> next
)
9676 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
9677 start
- section_begin
, next
- section_begin
);
9683 begin
= byte_get (start
, pointer_size
);
9684 start
+= pointer_size
;
9685 end
= byte_get (start
, pointer_size
);
9686 start
+= pointer_size
;
9688 if (begin
== 0 && end
== 0)
9690 printf (_(" %8.8lx <End of list>\n"), offset
);
9694 /* Check base address specifiers. */
9695 if (begin
== -1UL && end
!= -1UL)
9698 printf (" %8.8lx %8.8lx %8.8lx (base address)\n",
9699 offset
, begin
, end
);
9703 length
= byte_get (start
, 2);
9706 printf (" %8.8lx %8.8lx %8.8lx (",
9707 offset
, begin
+ base_address
, end
+ base_address
);
9708 need_frame_base
= decode_location_expression (start
,
9714 if (need_frame_base
&& !has_frame_base
)
9715 printf (_(" [without DW_AT_frame_base]"));
9718 fputs (_(" (start == end)"), stdout
);
9719 else if (begin
> end
)
9720 fputs (_(" (start > end)"), stdout
);
9732 display_debug_str (Elf_Internal_Shdr
*section
,
9733 unsigned char *start
,
9734 FILE *file ATTRIBUTE_UNUSED
)
9736 unsigned long bytes
;
9739 addr
= section
->sh_addr
;
9740 bytes
= section
->sh_size
;
9744 printf (_("\nThe .debug_str section is empty.\n"));
9748 printf (_("Contents of the .debug_str section:\n\n"));
9756 lbytes
= (bytes
> 16 ? 16 : bytes
);
9758 printf (" 0x%8.8lx ", (unsigned long) addr
);
9760 for (j
= 0; j
< 16; j
++)
9763 printf ("%2.2x", start
[j
]);
9771 for (j
= 0; j
< lbytes
; j
++)
9774 if (k
>= ' ' && k
< 0x80)
9794 display_debug_info (Elf_Internal_Shdr
* section
,
9795 unsigned char * start
, FILE * file
)
9797 return process_debug_info (section
, start
, file
, 0);
9802 display_debug_aranges (Elf_Internal_Shdr
*section
,
9803 unsigned char *start
,
9804 FILE *file ATTRIBUTE_UNUSED
)
9806 unsigned char *end
= start
+ section
->sh_size
;
9808 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
9812 unsigned char *hdrptr
;
9813 DWARF2_Internal_ARange arange
;
9814 unsigned char *ranges
;
9815 unsigned long length
;
9816 unsigned long address
;
9819 int initial_length_size
;
9823 arange
.ar_length
= byte_get (hdrptr
, 4);
9826 if (arange
.ar_length
== 0xffffffff)
9828 arange
.ar_length
= byte_get (hdrptr
, 8);
9831 initial_length_size
= 12;
9836 initial_length_size
= 4;
9839 arange
.ar_version
= byte_get (hdrptr
, 2);
9842 arange
.ar_info_offset
= byte_get (hdrptr
, offset_size
);
9843 hdrptr
+= offset_size
;
9845 arange
.ar_pointer_size
= byte_get (hdrptr
, 1);
9848 arange
.ar_segment_size
= byte_get (hdrptr
, 1);
9851 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
9853 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
9857 printf (_(" Length: %ld\n"), arange
.ar_length
);
9858 printf (_(" Version: %d\n"), arange
.ar_version
);
9859 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
9860 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
9861 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
9863 printf (_("\n Address Length\n"));
9867 /* Must pad to an alignment boundary that is twice the pointer size. */
9868 excess
= (hdrptr
- start
) % (2 * arange
.ar_pointer_size
);
9870 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
9874 address
= byte_get (ranges
, arange
.ar_pointer_size
);
9876 ranges
+= arange
.ar_pointer_size
;
9878 length
= byte_get (ranges
, arange
.ar_pointer_size
);
9880 ranges
+= arange
.ar_pointer_size
;
9882 /* A pair of zeros marks the end of the list. */
9883 if (address
== 0 && length
== 0)
9886 printf (" %8.8lx %lu\n", address
, length
);
9889 start
+= arange
.ar_length
+ initial_length_size
;
9898 display_debug_ranges (Elf_Internal_Shdr
*section
,
9899 unsigned char *start
,
9900 FILE *file ATTRIBUTE_UNUSED
)
9902 unsigned char *section_end
;
9903 unsigned long bytes
;
9904 unsigned char *section_begin
= start
;
9905 unsigned int num_range_list
= 0;
9906 unsigned long last_offset
= 0;
9907 unsigned int first
= 0;
9910 int seen_first_offset
= 0;
9911 int use_debug_info
= 1;
9912 unsigned char *next
;
9914 bytes
= section
->sh_size
;
9915 section_end
= start
+ bytes
;
9919 printf (_("\nThe .debug_ranges section is empty.\n"));
9923 get_debug_info (file
);
9925 /* Check the order of range list in .debug_info section. If
9926 offsets of range lists are in the ascending order, we can
9927 use `debug_information' directly. */
9928 for (i
= 0; i
< num_debug_info_entries
; i
++)
9932 num
= debug_information
[i
].num_range_lists
;
9933 num_range_list
+= num
;
9935 /* Check if we can use `debug_information' directly. */
9936 if (use_debug_info
&& num
!= 0)
9938 if (!seen_first_offset
)
9940 /* This is the first range list. */
9941 last_offset
= debug_information
[i
].range_lists
[0];
9943 seen_first_offset
= 1;
9949 for (; j
< num
; j
++)
9952 debug_information
[i
].range_lists
[j
])
9957 last_offset
= debug_information
[i
].range_lists
[j
];
9962 if (!use_debug_info
)
9963 /* FIXME: Should we handle this case? */
9964 error (_("Range lists in .debug_info section aren't in ascending order!\n"));
9966 if (!seen_first_offset
)
9967 error (_("No range lists in .debug_info section!\n"));
9969 if (debug_information
[first
].range_lists
[0] != 0)
9970 warn (_("Range lists in .debug_ranges section start at 0x%lx\n"),
9971 debug_information
[first
].range_lists
[0]);
9973 printf (_("Contents of the .debug_ranges section:\n\n"));
9974 printf (_(" Offset Begin End\n"));
9976 seen_first_offset
= 0;
9977 for (i
= first
; i
< num_debug_info_entries
; i
++)
9979 unsigned long begin
;
9981 unsigned long offset
;
9982 unsigned int pointer_size
;
9983 unsigned long base_address
;
9985 pointer_size
= debug_information
[i
].pointer_size
;
9987 for (j
= 0; j
< debug_information
[i
].num_range_lists
; j
++)
9989 offset
= debug_information
[i
].range_lists
[j
];
9990 next
= section_begin
+ offset
;
9991 base_address
= debug_information
[i
].base_address
;
9993 if (!seen_first_offset
)
9994 seen_first_offset
= 1;
9998 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_ranges section.\n"),
9999 start
- section_begin
, next
- section_begin
);
10000 else if (start
> next
)
10001 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_ranges section.\n"),
10002 start
- section_begin
, next
- section_begin
);
10008 begin
= byte_get (start
, pointer_size
);
10009 start
+= pointer_size
;
10010 end
= byte_get (start
, pointer_size
);
10011 start
+= pointer_size
;
10013 if (begin
== 0 && end
== 0)
10015 printf (_(" %8.8lx <End of list>\n"), offset
);
10019 /* Check base address specifiers. */
10020 if (begin
== -1UL && end
!= -1UL)
10022 base_address
= end
;
10023 printf (" %8.8lx %8.8lx %8.8lx (base address)\n",
10024 offset
, begin
, end
);
10028 printf (" %8.8lx %8.8lx %8.8lx",
10029 offset
, begin
+ base_address
, end
+ base_address
);
10032 fputs (_(" (start == end)"), stdout
);
10033 else if (begin
> end
)
10034 fputs (_(" (start > end)"), stdout
);
10044 typedef struct Frame_Chunk
10046 struct Frame_Chunk
*next
;
10047 unsigned char *chunk_start
;
10049 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
10050 short int *col_type
;
10052 char *augmentation
;
10053 unsigned int code_factor
;
10055 unsigned long pc_begin
;
10056 unsigned long pc_range
;
10060 unsigned char fde_encoding
;
10061 unsigned char cfa_exp
;
10065 /* A marker for a col_type that means this column was never referenced
10066 in the frame info. */
10067 #define DW_CFA_unreferenced (-1)
10070 frame_need_space (Frame_Chunk
*fc
, int reg
)
10072 int prev
= fc
->ncols
;
10074 if (reg
< fc
->ncols
)
10077 fc
->ncols
= reg
+ 1;
10078 fc
->col_type
= xrealloc (fc
->col_type
, fc
->ncols
* sizeof (short int));
10079 fc
->col_offset
= xrealloc (fc
->col_offset
, fc
->ncols
* sizeof (int));
10081 while (prev
< fc
->ncols
)
10083 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
10084 fc
->col_offset
[prev
] = 0;
10090 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, int *max_regs
)
10095 if (*max_regs
< fc
->ncols
)
10096 *max_regs
= fc
->ncols
;
10098 if (*need_col_headers
)
10100 *need_col_headers
= 0;
10102 printf (" LOC CFA ");
10104 for (r
= 0; r
< *max_regs
; r
++)
10105 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
10110 printf ("r%-4d", r
);
10116 printf ("%08lx ", fc
->pc_begin
);
10118 strcpy (tmp
, "exp");
10120 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
10121 printf ("%-8s ", tmp
);
10123 for (r
= 0; r
< fc
->ncols
; r
++)
10125 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
10127 switch (fc
->col_type
[r
])
10129 case DW_CFA_undefined
:
10132 case DW_CFA_same_value
:
10135 case DW_CFA_offset
:
10136 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
10138 case DW_CFA_register
:
10139 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
10141 case DW_CFA_expression
:
10142 strcpy (tmp
, "exp");
10145 strcpy (tmp
, "n/a");
10148 printf ("%-5s", tmp
);
10155 size_of_encoded_value (int encoding
)
10157 switch (encoding
& 0x7)
10160 case 0: return eh_addr_size
;
10168 get_encoded_value (unsigned char *data
, int encoding
)
10170 int size
= size_of_encoded_value (encoding
);
10171 if (encoding
& DW_EH_PE_signed
)
10172 return byte_get_signed (data
, size
);
10174 return byte_get (data
, size
);
10177 #define GET(N) byte_get (start, N); start += N
10178 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
10179 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
10182 display_debug_frames (Elf_Internal_Shdr
*section
,
10183 unsigned char *start
,
10184 FILE *file ATTRIBUTE_UNUSED
)
10186 unsigned char *end
= start
+ section
->sh_size
;
10187 unsigned char *section_start
= start
;
10188 Frame_Chunk
*chunks
= 0;
10189 Frame_Chunk
*remembered_state
= 0;
10191 int is_eh
= streq (SECTION_NAME (section
), ".eh_frame");
10192 unsigned int length_return
;
10195 printf (_("The section %s contains:\n"), SECTION_NAME (section
));
10197 while (start
< end
)
10199 unsigned char *saved_start
;
10200 unsigned char *block_end
;
10201 unsigned long length
;
10202 unsigned long cie_id
;
10205 int need_col_headers
= 1;
10206 unsigned char *augmentation_data
= NULL
;
10207 unsigned long augmentation_data_len
= 0;
10208 int encoded_ptr_size
= eh_addr_size
;
10210 int initial_length_size
;
10212 saved_start
= start
;
10213 length
= byte_get (start
, 4); start
+= 4;
10217 printf ("\n%08lx ZERO terminator\n\n",
10218 (unsigned long)(saved_start
- section_start
));
10222 if (length
== 0xffffffff)
10224 length
= byte_get (start
, 8);
10227 initial_length_size
= 12;
10232 initial_length_size
= 4;
10235 block_end
= saved_start
+ length
+ initial_length_size
;
10236 cie_id
= byte_get (start
, offset_size
); start
+= offset_size
;
10238 if (elf_header
.e_type
== ET_REL
10239 && !debug_apply_rela_addends (file
, section
, offset_size
,
10240 section_start
, start
, block_end
))
10243 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
10247 fc
= xmalloc (sizeof (Frame_Chunk
));
10248 memset (fc
, 0, sizeof (Frame_Chunk
));
10252 fc
->chunk_start
= saved_start
;
10254 fc
->col_type
= xmalloc (sizeof (short int));
10255 fc
->col_offset
= xmalloc (sizeof (int));
10256 frame_need_space (fc
, max_regs
-1);
10258 version
= *start
++;
10260 fc
->augmentation
= (char *) start
;
10261 start
= (unsigned char *) strchr ((char *) start
, '\0') + 1;
10263 if (fc
->augmentation
[0] == 'z')
10265 fc
->code_factor
= LEB ();
10266 fc
->data_factor
= SLEB ();
10275 augmentation_data_len
= LEB ();
10276 augmentation_data
= start
;
10277 start
+= augmentation_data_len
;
10279 else if (streq (fc
->augmentation
, "eh"))
10281 start
+= eh_addr_size
;
10282 fc
->code_factor
= LEB ();
10283 fc
->data_factor
= SLEB ();
10295 fc
->code_factor
= LEB ();
10296 fc
->data_factor
= SLEB ();
10308 if (do_debug_frames_interp
)
10309 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
10310 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
10311 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
10315 printf ("\n%08lx %08lx %08lx CIE\n",
10316 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
10317 printf (" Version: %d\n", version
);
10318 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
10319 printf (" Code alignment factor: %u\n", fc
->code_factor
);
10320 printf (" Data alignment factor: %d\n", fc
->data_factor
);
10321 printf (" Return address column: %d\n", fc
->ra
);
10323 if (augmentation_data_len
)
10326 printf (" Augmentation data: ");
10327 for (i
= 0; i
< augmentation_data_len
; ++i
)
10328 printf (" %02x", augmentation_data
[i
]);
10334 if (augmentation_data_len
)
10336 unsigned char *p
, *q
;
10337 p
= (unsigned char *) fc
->augmentation
+ 1;
10338 q
= augmentation_data
;
10344 else if (*p
== 'P')
10345 q
+= 1 + size_of_encoded_value (*q
);
10346 else if (*p
== 'R')
10347 fc
->fde_encoding
= *q
++;
10353 if (fc
->fde_encoding
)
10354 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
10357 frame_need_space (fc
, fc
->ra
);
10361 unsigned char *look_for
;
10362 static Frame_Chunk fde_fc
;
10365 memset (fc
, 0, sizeof (Frame_Chunk
));
10367 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
10369 for (cie
= chunks
; cie
; cie
= cie
->next
)
10370 if (cie
->chunk_start
== look_for
)
10375 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
10376 cie_id
, saved_start
);
10379 fc
->col_type
= xmalloc (sizeof (short int));
10380 fc
->col_offset
= xmalloc (sizeof (int));
10381 frame_need_space (fc
, max_regs
- 1);
10383 fc
->augmentation
= "";
10384 fc
->fde_encoding
= 0;
10388 fc
->ncols
= cie
->ncols
;
10389 fc
->col_type
= xmalloc (fc
->ncols
* sizeof (short int));
10390 fc
->col_offset
= xmalloc (fc
->ncols
* sizeof (int));
10391 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
10392 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
10393 fc
->augmentation
= cie
->augmentation
;
10394 fc
->code_factor
= cie
->code_factor
;
10395 fc
->data_factor
= cie
->data_factor
;
10396 fc
->cfa_reg
= cie
->cfa_reg
;
10397 fc
->cfa_offset
= cie
->cfa_offset
;
10399 frame_need_space (fc
, max_regs
-1);
10400 fc
->fde_encoding
= cie
->fde_encoding
;
10403 if (fc
->fde_encoding
)
10404 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
10406 fc
->pc_begin
= get_encoded_value (start
, fc
->fde_encoding
);
10407 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
10408 /* Don't adjust for ET_REL since there's invariably a pcrel
10409 reloc here, which we haven't applied. */
10410 && elf_header
.e_type
!= ET_REL
)
10411 fc
->pc_begin
+= section
->sh_addr
+ (start
- section_start
);
10412 start
+= encoded_ptr_size
;
10413 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
10414 start
+= encoded_ptr_size
;
10416 if (cie
->augmentation
[0] == 'z')
10418 augmentation_data_len
= LEB ();
10419 augmentation_data
= start
;
10420 start
+= augmentation_data_len
;
10423 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
10424 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
10425 (unsigned long)(cie
->chunk_start
- section_start
),
10426 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
10427 if (! do_debug_frames_interp
&& augmentation_data_len
)
10431 printf (" Augmentation data: ");
10432 for (i
= 0; i
< augmentation_data_len
; ++i
)
10433 printf (" %02x", augmentation_data
[i
]);
10439 /* At this point, fc is the current chunk, cie (if any) is set, and
10440 we're about to interpret instructions for the chunk. */
10441 /* ??? At present we need to do this always, since this sizes the
10442 fc->col_type and fc->col_offset arrays, which we write into always.
10443 We should probably split the interpreted and non-interpreted bits
10444 into two different routines, since there's so much that doesn't
10445 really overlap between them. */
10446 if (1 || do_debug_frames_interp
)
10448 /* Start by making a pass over the chunk, allocating storage
10449 and taking note of what registers are used. */
10450 unsigned char *tmp
= start
;
10452 while (start
< block_end
)
10455 unsigned long reg
, tmp
;
10462 /* Warning: if you add any more cases to this switch, be
10463 sure to add them to the corresponding switch below. */
10466 case DW_CFA_advance_loc
:
10468 case DW_CFA_offset
:
10470 frame_need_space (fc
, opa
);
10471 fc
->col_type
[opa
] = DW_CFA_undefined
;
10473 case DW_CFA_restore
:
10474 frame_need_space (fc
, opa
);
10475 fc
->col_type
[opa
] = DW_CFA_undefined
;
10477 case DW_CFA_set_loc
:
10478 start
+= encoded_ptr_size
;
10480 case DW_CFA_advance_loc1
:
10483 case DW_CFA_advance_loc2
:
10486 case DW_CFA_advance_loc4
:
10489 case DW_CFA_offset_extended
:
10490 reg
= LEB (); LEB ();
10491 frame_need_space (fc
, reg
);
10492 fc
->col_type
[reg
] = DW_CFA_undefined
;
10494 case DW_CFA_restore_extended
:
10496 frame_need_space (fc
, reg
);
10497 fc
->col_type
[reg
] = DW_CFA_undefined
;
10499 case DW_CFA_undefined
:
10501 frame_need_space (fc
, reg
);
10502 fc
->col_type
[reg
] = DW_CFA_undefined
;
10504 case DW_CFA_same_value
:
10506 frame_need_space (fc
, reg
);
10507 fc
->col_type
[reg
] = DW_CFA_undefined
;
10509 case DW_CFA_register
:
10510 reg
= LEB (); LEB ();
10511 frame_need_space (fc
, reg
);
10512 fc
->col_type
[reg
] = DW_CFA_undefined
;
10514 case DW_CFA_def_cfa
:
10517 case DW_CFA_def_cfa_register
:
10520 case DW_CFA_def_cfa_offset
:
10523 case DW_CFA_def_cfa_expression
:
10527 case DW_CFA_expression
:
10531 frame_need_space (fc
, reg
);
10532 fc
->col_type
[reg
] = DW_CFA_undefined
;
10534 case DW_CFA_offset_extended_sf
:
10535 reg
= LEB (); SLEB ();
10536 frame_need_space (fc
, reg
);
10537 fc
->col_type
[reg
] = DW_CFA_undefined
;
10539 case DW_CFA_def_cfa_sf
:
10542 case DW_CFA_def_cfa_offset_sf
:
10545 case DW_CFA_MIPS_advance_loc8
:
10548 case DW_CFA_GNU_args_size
:
10551 case DW_CFA_GNU_negative_offset_extended
:
10552 reg
= LEB (); LEB ();
10553 frame_need_space (fc
, reg
);
10554 fc
->col_type
[reg
] = DW_CFA_undefined
;
10563 /* Now we know what registers are used, make a second pass over
10564 the chunk, this time actually printing out the info. */
10566 while (start
< block_end
)
10569 unsigned long ul
, reg
, roffs
;
10578 /* Warning: if you add any more cases to this switch, be
10579 sure to add them to the corresponding switch above. */
10582 case DW_CFA_advance_loc
:
10583 if (do_debug_frames_interp
)
10584 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10586 printf (" DW_CFA_advance_loc: %d to %08lx\n",
10587 opa
* fc
->code_factor
,
10588 fc
->pc_begin
+ opa
* fc
->code_factor
);
10589 fc
->pc_begin
+= opa
* fc
->code_factor
;
10592 case DW_CFA_offset
:
10594 if (! do_debug_frames_interp
)
10595 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
10596 opa
, roffs
* fc
->data_factor
);
10597 fc
->col_type
[opa
] = DW_CFA_offset
;
10598 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
10601 case DW_CFA_restore
:
10602 if (! do_debug_frames_interp
)
10603 printf (" DW_CFA_restore: r%d\n", opa
);
10604 fc
->col_type
[opa
] = cie
->col_type
[opa
];
10605 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
10608 case DW_CFA_set_loc
:
10609 vma
= get_encoded_value (start
, fc
->fde_encoding
);
10610 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
10611 && elf_header
.e_type
!= ET_REL
)
10612 vma
+= section
->sh_addr
+ (start
- section_start
);
10613 start
+= encoded_ptr_size
;
10614 if (do_debug_frames_interp
)
10615 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10617 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
10618 fc
->pc_begin
= vma
;
10621 case DW_CFA_advance_loc1
:
10622 ofs
= byte_get (start
, 1); start
+= 1;
10623 if (do_debug_frames_interp
)
10624 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10626 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
10627 ofs
* fc
->code_factor
,
10628 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10629 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10632 case DW_CFA_advance_loc2
:
10633 ofs
= byte_get (start
, 2); start
+= 2;
10634 if (do_debug_frames_interp
)
10635 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10637 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
10638 ofs
* fc
->code_factor
,
10639 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10640 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10643 case DW_CFA_advance_loc4
:
10644 ofs
= byte_get (start
, 4); start
+= 4;
10645 if (do_debug_frames_interp
)
10646 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10648 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
10649 ofs
* fc
->code_factor
,
10650 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10651 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10654 case DW_CFA_offset_extended
:
10657 if (! do_debug_frames_interp
)
10658 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
10659 reg
, roffs
* fc
->data_factor
);
10660 fc
->col_type
[reg
] = DW_CFA_offset
;
10661 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
10664 case DW_CFA_restore_extended
:
10666 if (! do_debug_frames_interp
)
10667 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
10668 fc
->col_type
[reg
] = cie
->col_type
[reg
];
10669 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
10672 case DW_CFA_undefined
:
10674 if (! do_debug_frames_interp
)
10675 printf (" DW_CFA_undefined: r%ld\n", reg
);
10676 fc
->col_type
[reg
] = DW_CFA_undefined
;
10677 fc
->col_offset
[reg
] = 0;
10680 case DW_CFA_same_value
:
10682 if (! do_debug_frames_interp
)
10683 printf (" DW_CFA_same_value: r%ld\n", reg
);
10684 fc
->col_type
[reg
] = DW_CFA_same_value
;
10685 fc
->col_offset
[reg
] = 0;
10688 case DW_CFA_register
:
10691 if (! do_debug_frames_interp
)
10692 printf (" DW_CFA_register: r%ld in r%ld\n", reg
, roffs
);
10693 fc
->col_type
[reg
] = DW_CFA_register
;
10694 fc
->col_offset
[reg
] = roffs
;
10697 case DW_CFA_remember_state
:
10698 if (! do_debug_frames_interp
)
10699 printf (" DW_CFA_remember_state\n");
10700 rs
= xmalloc (sizeof (Frame_Chunk
));
10701 rs
->ncols
= fc
->ncols
;
10702 rs
->col_type
= xmalloc (rs
->ncols
* sizeof (short int));
10703 rs
->col_offset
= xmalloc (rs
->ncols
* sizeof (int));
10704 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
10705 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
10706 rs
->next
= remembered_state
;
10707 remembered_state
= rs
;
10710 case DW_CFA_restore_state
:
10711 if (! do_debug_frames_interp
)
10712 printf (" DW_CFA_restore_state\n");
10713 rs
= remembered_state
;
10716 remembered_state
= rs
->next
;
10717 frame_need_space (fc
, rs
->ncols
-1);
10718 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
10719 memcpy (fc
->col_offset
, rs
->col_offset
,
10720 rs
->ncols
* sizeof (int));
10721 free (rs
->col_type
);
10722 free (rs
->col_offset
);
10725 else if (do_debug_frames_interp
)
10726 printf ("Mismatched DW_CFA_restore_state\n");
10729 case DW_CFA_def_cfa
:
10730 fc
->cfa_reg
= LEB ();
10731 fc
->cfa_offset
= LEB ();
10733 if (! do_debug_frames_interp
)
10734 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
10735 fc
->cfa_reg
, fc
->cfa_offset
);
10738 case DW_CFA_def_cfa_register
:
10739 fc
->cfa_reg
= LEB ();
10741 if (! do_debug_frames_interp
)
10742 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
10745 case DW_CFA_def_cfa_offset
:
10746 fc
->cfa_offset
= LEB ();
10747 if (! do_debug_frames_interp
)
10748 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
10752 if (! do_debug_frames_interp
)
10753 printf (" DW_CFA_nop\n");
10756 case DW_CFA_def_cfa_expression
:
10758 if (! do_debug_frames_interp
)
10760 printf (" DW_CFA_def_cfa_expression (");
10761 decode_location_expression (start
, eh_addr_size
, ul
, 0);
10768 case DW_CFA_expression
:
10771 if (! do_debug_frames_interp
)
10773 printf (" DW_CFA_expression: r%ld (", reg
);
10774 decode_location_expression (start
, eh_addr_size
, ul
, 0);
10777 fc
->col_type
[reg
] = DW_CFA_expression
;
10781 case DW_CFA_offset_extended_sf
:
10784 frame_need_space (fc
, reg
);
10785 if (! do_debug_frames_interp
)
10786 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
10787 reg
, l
* fc
->data_factor
);
10788 fc
->col_type
[reg
] = DW_CFA_offset
;
10789 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
10792 case DW_CFA_def_cfa_sf
:
10793 fc
->cfa_reg
= LEB ();
10794 fc
->cfa_offset
= SLEB ();
10795 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
10797 if (! do_debug_frames_interp
)
10798 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
10799 fc
->cfa_reg
, fc
->cfa_offset
);
10802 case DW_CFA_def_cfa_offset_sf
:
10803 fc
->cfa_offset
= SLEB ();
10804 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
10805 if (! do_debug_frames_interp
)
10806 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
10809 case DW_CFA_MIPS_advance_loc8
:
10810 ofs
= byte_get (start
, 8); start
+= 8;
10811 if (do_debug_frames_interp
)
10812 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10814 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
10815 ofs
* fc
->code_factor
,
10816 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10817 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10820 case DW_CFA_GNU_window_save
:
10821 if (! do_debug_frames_interp
)
10822 printf (" DW_CFA_GNU_window_save\n");
10825 case DW_CFA_GNU_args_size
:
10827 if (! do_debug_frames_interp
)
10828 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
10831 case DW_CFA_GNU_negative_offset_extended
:
10834 frame_need_space (fc
, reg
);
10835 if (! do_debug_frames_interp
)
10836 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
10837 reg
, l
* fc
->data_factor
);
10838 fc
->col_type
[reg
] = DW_CFA_offset
;
10839 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
10843 warn (_("unsupported or unknown DW_CFA_%d\n"), op
);
10848 if (do_debug_frames_interp
)
10849 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10864 display_debug_not_supported (Elf_Internal_Shdr
*section
,
10865 unsigned char *start ATTRIBUTE_UNUSED
,
10866 FILE *file ATTRIBUTE_UNUSED
)
10868 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
10869 SECTION_NAME (section
));
10874 /* A structure containing the name of a debug section
10875 and a pointer to a function that can decode it. */
10878 const char *const name
;
10879 int (*display
) (Elf_Internal_Shdr
*, unsigned char *, FILE *);
10883 { ".debug_abbrev", display_debug_abbrev
},
10884 { ".debug_aranges", display_debug_aranges
},
10885 { ".debug_frame", display_debug_frames
},
10886 { ".debug_info", display_debug_info
},
10887 { ".debug_line", display_debug_lines
},
10888 { ".debug_pubnames", display_debug_pubnames
},
10889 { ".eh_frame", display_debug_frames
},
10890 { ".debug_macinfo", display_debug_macinfo
},
10891 { ".debug_str", display_debug_str
},
10892 { ".debug_loc", display_debug_loc
},
10893 { ".debug_pubtypes", display_debug_pubnames
},
10894 { ".debug_ranges", display_debug_ranges
},
10895 { ".debug_static_func", display_debug_not_supported
},
10896 { ".debug_static_vars", display_debug_not_supported
},
10897 { ".debug_types", display_debug_not_supported
},
10898 { ".debug_weaknames", display_debug_not_supported
}
10902 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
10904 char *name
= SECTION_NAME (section
);
10905 bfd_size_type length
;
10909 length
= section
->sh_size
;
10912 printf (_("\nSection '%s' has no debugging data.\n"), name
);
10916 if (strneq (name
, ".gnu.linkonce.wi.", 17))
10917 name
= ".debug_info";
10919 /* See if we know how to display the contents of this section. */
10920 for (i
= NUM_ELEM (debug_displays
); i
--;)
10921 if (streq (debug_displays
[i
].name
, name
))
10923 unsigned char *start
;
10925 start
= get_data (NULL
, file
, section
->sh_offset
, length
,
10926 _("debug section data"));
10933 result
&= debug_displays
[i
].display (section
, start
, file
);
10936 /* If we loaded in the abbrev section
10937 at some point, we must release it here. */
10945 printf (_("Unrecognized debug section: %s\n"), name
);
10953 process_section_contents (FILE *file
)
10955 Elf_Internal_Shdr
*section
;
10961 for (i
= 0, section
= section_headers
;
10962 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
10965 #ifdef SUPPORT_DISASSEMBLY
10966 if (dump_sects
[i
] & DISASS_DUMP
)
10967 disassemble_section (section
, file
);
10969 if (dump_sects
[i
] & HEX_DUMP
)
10970 dump_section (section
, file
);
10972 if (dump_sects
[i
] & DEBUG_DUMP
)
10973 display_debug_section (section
, file
);
10976 /* Check to see if the user requested a
10977 dump of a section that does not exist. */
10978 while (i
++ < num_dump_sects
)
10980 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
10984 process_mips_fpe_exception (int mask
)
10989 if (mask
& OEX_FPU_INEX
)
10990 fputs ("INEX", stdout
), first
= 0;
10991 if (mask
& OEX_FPU_UFLO
)
10992 printf ("%sUFLO", first
? "" : "|"), first
= 0;
10993 if (mask
& OEX_FPU_OFLO
)
10994 printf ("%sOFLO", first
? "" : "|"), first
= 0;
10995 if (mask
& OEX_FPU_DIV0
)
10996 printf ("%sDIV0", first
? "" : "|"), first
= 0;
10997 if (mask
& OEX_FPU_INVAL
)
10998 printf ("%sINVAL", first
? "" : "|");
11001 fputs ("0", stdout
);
11005 process_mips_specific (FILE *file
)
11007 Elf_Internal_Dyn
*entry
;
11008 size_t liblist_offset
= 0;
11009 size_t liblistno
= 0;
11010 size_t conflictsno
= 0;
11011 size_t options_offset
= 0;
11012 size_t conflicts_offset
= 0;
11014 /* We have a lot of special sections. Thanks SGI! */
11015 if (dynamic_section
== NULL
)
11016 /* No information available. */
11019 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
11020 switch (entry
->d_tag
)
11022 case DT_MIPS_LIBLIST
:
11024 = offset_from_vma (file
, entry
->d_un
.d_val
,
11025 liblistno
* sizeof (Elf32_External_Lib
));
11027 case DT_MIPS_LIBLISTNO
:
11028 liblistno
= entry
->d_un
.d_val
;
11030 case DT_MIPS_OPTIONS
:
11031 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
11033 case DT_MIPS_CONFLICT
:
11035 = offset_from_vma (file
, entry
->d_un
.d_val
,
11036 conflictsno
* sizeof (Elf32_External_Conflict
));
11038 case DT_MIPS_CONFLICTNO
:
11039 conflictsno
= entry
->d_un
.d_val
;
11045 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
11047 Elf32_External_Lib
*elib
;
11050 elib
= get_data (NULL
, file
, liblist_offset
,
11051 liblistno
* sizeof (Elf32_External_Lib
),
11055 printf ("\nSection '.liblist' contains %lu entries:\n",
11056 (unsigned long) liblistno
);
11057 fputs (" Library Time Stamp Checksum Version Flags\n",
11060 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
11067 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
11068 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
11069 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
11070 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
11071 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
11073 tmp
= gmtime (&time
);
11074 snprintf (timebuf
, sizeof (timebuf
),
11075 "%04u-%02u-%02uT%02u:%02u:%02u",
11076 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11077 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11079 printf ("%3lu: ", (unsigned long) cnt
);
11080 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
11081 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
11083 printf ("<corrupt: %9ld>", liblist
.l_name
);
11084 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
11085 liblist
.l_version
);
11087 if (liblist
.l_flags
== 0)
11091 static const struct
11098 { " EXACT_MATCH", LL_EXACT_MATCH
},
11099 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
11100 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
11101 { " EXPORTS", LL_EXPORTS
},
11102 { " DELAY_LOAD", LL_DELAY_LOAD
},
11103 { " DELTA", LL_DELTA
}
11105 int flags
= liblist
.l_flags
;
11109 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
11111 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
11113 fputs (l_flags_vals
[fcnt
].name
, stdout
);
11114 flags
^= l_flags_vals
[fcnt
].bit
;
11117 printf (" %#x", (unsigned int) flags
);
11127 if (options_offset
!= 0)
11129 Elf_External_Options
*eopt
;
11130 Elf_Internal_Shdr
*sect
= section_headers
;
11131 Elf_Internal_Options
*iopt
;
11132 Elf_Internal_Options
*option
;
11136 /* Find the section header so that we get the size. */
11137 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
11140 eopt
= get_data (NULL
, file
, options_offset
, sect
->sh_size
,
11144 iopt
= malloc ((sect
->sh_size
/ sizeof (eopt
)) * sizeof (*iopt
));
11147 error (_("Out of memory"));
11154 while (offset
< sect
->sh_size
)
11156 Elf_External_Options
*eoption
;
11158 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
11160 option
->kind
= BYTE_GET (eoption
->kind
);
11161 option
->size
= BYTE_GET (eoption
->size
);
11162 option
->section
= BYTE_GET (eoption
->section
);
11163 option
->info
= BYTE_GET (eoption
->info
);
11165 offset
+= option
->size
;
11171 printf (_("\nSection '%s' contains %d entries:\n"),
11172 SECTION_NAME (sect
), cnt
);
11180 switch (option
->kind
)
11183 /* This shouldn't happen. */
11184 printf (" NULL %d %lx", option
->section
, option
->info
);
11187 printf (" REGINFO ");
11188 if (elf_header
.e_machine
== EM_MIPS
)
11191 Elf32_External_RegInfo
*ereg
;
11192 Elf32_RegInfo reginfo
;
11194 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
11195 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
11196 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
11197 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
11198 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
11199 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
11200 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
11202 printf ("GPR %08lx GP 0x%lx\n",
11203 reginfo
.ri_gprmask
,
11204 (unsigned long) reginfo
.ri_gp_value
);
11205 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11206 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11207 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11212 Elf64_External_RegInfo
*ereg
;
11213 Elf64_Internal_RegInfo reginfo
;
11215 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
11216 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
11217 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
11218 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
11219 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
11220 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
11221 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
11223 printf ("GPR %08lx GP 0x",
11224 reginfo
.ri_gprmask
);
11225 printf_vma (reginfo
.ri_gp_value
);
11228 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11229 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11230 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11234 case ODK_EXCEPTIONS
:
11235 fputs (" EXCEPTIONS fpe_min(", stdout
);
11236 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
11237 fputs (") fpe_max(", stdout
);
11238 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
11239 fputs (")", stdout
);
11241 if (option
->info
& OEX_PAGE0
)
11242 fputs (" PAGE0", stdout
);
11243 if (option
->info
& OEX_SMM
)
11244 fputs (" SMM", stdout
);
11245 if (option
->info
& OEX_FPDBUG
)
11246 fputs (" FPDBUG", stdout
);
11247 if (option
->info
& OEX_DISMISS
)
11248 fputs (" DISMISS", stdout
);
11251 fputs (" PAD ", stdout
);
11252 if (option
->info
& OPAD_PREFIX
)
11253 fputs (" PREFIX", stdout
);
11254 if (option
->info
& OPAD_POSTFIX
)
11255 fputs (" POSTFIX", stdout
);
11256 if (option
->info
& OPAD_SYMBOL
)
11257 fputs (" SYMBOL", stdout
);
11260 fputs (" HWPATCH ", stdout
);
11261 if (option
->info
& OHW_R4KEOP
)
11262 fputs (" R4KEOP", stdout
);
11263 if (option
->info
& OHW_R8KPFETCH
)
11264 fputs (" R8KPFETCH", stdout
);
11265 if (option
->info
& OHW_R5KEOP
)
11266 fputs (" R5KEOP", stdout
);
11267 if (option
->info
& OHW_R5KCVTL
)
11268 fputs (" R5KCVTL", stdout
);
11271 fputs (" FILL ", stdout
);
11272 /* XXX Print content of info word? */
11275 fputs (" TAGS ", stdout
);
11276 /* XXX Print content of info word? */
11279 fputs (" HWAND ", stdout
);
11280 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11281 fputs (" R4KEOP_CHECKED", stdout
);
11282 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11283 fputs (" R4KEOP_CLEAN", stdout
);
11286 fputs (" HWOR ", stdout
);
11287 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11288 fputs (" R4KEOP_CHECKED", stdout
);
11289 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11290 fputs (" R4KEOP_CLEAN", stdout
);
11293 printf (" GP_GROUP %#06lx self-contained %#06lx",
11294 option
->info
& OGP_GROUP
,
11295 (option
->info
& OGP_SELF
) >> 16);
11298 printf (" IDENT %#06lx self-contained %#06lx",
11299 option
->info
& OGP_GROUP
,
11300 (option
->info
& OGP_SELF
) >> 16);
11303 /* This shouldn't happen. */
11304 printf (" %3d ??? %d %lx",
11305 option
->kind
, option
->section
, option
->info
);
11309 len
= sizeof (*eopt
);
11310 while (len
< option
->size
)
11311 if (((char *) option
)[len
] >= ' '
11312 && ((char *) option
)[len
] < 0x7f)
11313 printf ("%c", ((char *) option
)[len
++]);
11315 printf ("\\%03o", ((char *) option
)[len
++]);
11317 fputs ("\n", stdout
);
11325 if (conflicts_offset
!= 0 && conflictsno
!= 0)
11327 Elf32_Conflict
*iconf
;
11330 if (dynamic_symbols
== NULL
)
11332 error (_("conflict list found without a dynamic symbol table"));
11336 iconf
= malloc (conflictsno
* sizeof (*iconf
));
11339 error (_("Out of memory"));
11345 Elf32_External_Conflict
*econf32
;
11347 econf32
= get_data (NULL
, file
, conflicts_offset
,
11348 conflictsno
* sizeof (*econf32
), _("conflict"));
11352 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11353 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
11359 Elf64_External_Conflict
*econf64
;
11361 econf64
= get_data (NULL
, file
, conflicts_offset
,
11362 conflictsno
* sizeof (*econf64
), _("conflict"));
11366 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11367 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
11372 printf (_("\nSection '.conflict' contains %lu entries:\n"),
11373 (unsigned long) conflictsno
);
11374 puts (_(" Num: Index Value Name"));
11376 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11378 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
11380 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
11381 print_vma (psym
->st_value
, FULL_HEX
);
11383 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11384 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11386 printf ("<corrupt: %14ld>", psym
->st_name
);
11397 process_gnu_liblist (FILE *file
)
11399 Elf_Internal_Shdr
*section
, *string_sec
;
11400 Elf32_External_Lib
*elib
;
11408 for (i
= 0, section
= section_headers
;
11409 i
< elf_header
.e_shnum
;
11412 switch (section
->sh_type
)
11414 case SHT_GNU_LIBLIST
:
11415 elib
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
11420 string_sec
= SECTION_HEADER (section
->sh_link
);
11422 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
11423 string_sec
->sh_size
, _("liblist string table"));
11426 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
11432 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
11433 SECTION_NAME (section
),
11434 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
11436 puts (" Library Time Stamp Checksum Version Flags");
11438 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
11446 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
11447 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
11448 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
11449 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
11450 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
11452 tmp
= gmtime (&time
);
11453 snprintf (timebuf
, sizeof (timebuf
),
11454 "%04u-%02u-%02uT%02u:%02u:%02u",
11455 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11456 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11458 printf ("%3lu: ", (unsigned long) cnt
);
11460 printf ("%-20s", strtab
+ liblist
.l_name
);
11462 printf ("%-20.20s", strtab
+ liblist
.l_name
);
11463 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
11464 liblist
.l_version
, liblist
.l_flags
);
11474 static const char *
11475 get_note_type (unsigned e_type
)
11477 static char buff
[64];
11479 if (elf_header
.e_type
== ET_CORE
)
11483 return _("NT_AUXV (auxiliary vector)");
11485 return _("NT_PRSTATUS (prstatus structure)");
11487 return _("NT_FPREGSET (floating point registers)");
11489 return _("NT_PRPSINFO (prpsinfo structure)");
11490 case NT_TASKSTRUCT
:
11491 return _("NT_TASKSTRUCT (task structure)");
11493 return _("NT_PRXFPREG (user_xfpregs structure)");
11495 return _("NT_PSTATUS (pstatus structure)");
11497 return _("NT_FPREGS (floating point registers)");
11499 return _("NT_PSINFO (psinfo structure)");
11501 return _("NT_LWPSTATUS (lwpstatus_t structure)");
11503 return _("NT_LWPSINFO (lwpsinfo_t structure)");
11504 case NT_WIN32PSTATUS
:
11505 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
11513 return _("NT_VERSION (version)");
11515 return _("NT_ARCH (architecture)");
11520 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11524 static const char *
11525 get_netbsd_elfcore_note_type (unsigned e_type
)
11527 static char buff
[64];
11529 if (e_type
== NT_NETBSDCORE_PROCINFO
)
11531 /* NetBSD core "procinfo" structure. */
11532 return _("NetBSD procinfo structure");
11535 /* As of Jan 2002 there are no other machine-independent notes
11536 defined for NetBSD core files. If the note type is less
11537 than the start of the machine-dependent note types, we don't
11540 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
11542 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11546 switch (elf_header
.e_machine
)
11548 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
11549 and PT_GETFPREGS == mach+2. */
11554 case EM_SPARC32PLUS
:
11558 case NT_NETBSDCORE_FIRSTMACH
+0:
11559 return _("PT_GETREGS (reg structure)");
11560 case NT_NETBSDCORE_FIRSTMACH
+2:
11561 return _("PT_GETFPREGS (fpreg structure)");
11567 /* On all other arch's, PT_GETREGS == mach+1 and
11568 PT_GETFPREGS == mach+3. */
11572 case NT_NETBSDCORE_FIRSTMACH
+1:
11573 return _("PT_GETREGS (reg structure)");
11574 case NT_NETBSDCORE_FIRSTMACH
+3:
11575 return _("PT_GETFPREGS (fpreg structure)");
11581 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
11582 e_type
- NT_NETBSDCORE_FIRSTMACH
);
11586 /* Note that by the ELF standard, the name field is already null byte
11587 terminated, and namesz includes the terminating null byte.
11588 I.E. the value of namesz for the name "FSF" is 4.
11590 If the value of namesz is zero, there is no name present. */
11592 process_note (Elf_Internal_Note
*pnote
)
11596 if (pnote
->namesz
== 0)
11597 /* If there is no note name, then use the default set of
11598 note type strings. */
11599 nt
= get_note_type (pnote
->type
);
11601 else if (strneq (pnote
->namedata
, "NetBSD-CORE", 11))
11602 /* NetBSD-specific core file notes. */
11603 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
11606 /* Don't recognize this note name; just use the default set of
11607 note type strings. */
11608 nt
= get_note_type (pnote
->type
);
11610 printf (" %s\t\t0x%08lx\t%s\n",
11611 pnote
->namesz
? pnote
->namedata
: "(NONE)",
11612 pnote
->descsz
, nt
);
11618 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
11620 Elf_External_Note
*pnotes
;
11621 Elf_External_Note
*external
;
11627 pnotes
= get_data (NULL
, file
, offset
, length
, _("notes"));
11633 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
11634 (unsigned long) offset
, (unsigned long) length
);
11635 printf (_(" Owner\t\tData size\tDescription\n"));
11637 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
11639 Elf_External_Note
*next
;
11640 Elf_Internal_Note inote
;
11643 inote
.type
= BYTE_GET (external
->type
);
11644 inote
.namesz
= BYTE_GET (external
->namesz
);
11645 inote
.namedata
= external
->name
;
11646 inote
.descsz
= BYTE_GET (external
->descsz
);
11647 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
11648 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
11650 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
11652 if (((char *) next
) > (((char *) pnotes
) + length
))
11654 warn (_("corrupt note found at offset %x into core notes\n"),
11655 ((char *) external
) - ((char *) pnotes
));
11656 warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
11657 inote
.type
, inote
.namesz
, inote
.descsz
);
11663 /* Verify that name is null terminated. It appears that at least
11664 one version of Linux (RedHat 6.0) generates corefiles that don't
11665 comply with the ELF spec by failing to include the null byte in
11667 if (inote
.namedata
[inote
.namesz
] != '\0')
11669 temp
= malloc (inote
.namesz
+ 1);
11673 error (_("Out of memory\n"));
11678 strncpy (temp
, inote
.namedata
, inote
.namesz
);
11679 temp
[inote
.namesz
] = 0;
11681 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
11682 inote
.namedata
= temp
;
11685 res
&= process_note (& inote
);
11700 process_corefile_note_segments (FILE *file
)
11702 Elf_Internal_Phdr
*segment
;
11706 if (! get_program_headers (file
))
11709 for (i
= 0, segment
= program_headers
;
11710 i
< elf_header
.e_phnum
;
11713 if (segment
->p_type
== PT_NOTE
)
11714 res
&= process_corefile_note_segment (file
,
11715 (bfd_vma
) segment
->p_offset
,
11716 (bfd_vma
) segment
->p_filesz
);
11723 process_note_sections (FILE *file
)
11725 Elf_Internal_Shdr
*section
;
11729 for (i
= 0, section
= section_headers
;
11730 i
< elf_header
.e_shnum
;
11732 if (section
->sh_type
== SHT_NOTE
)
11733 res
&= process_corefile_note_segment (file
,
11734 (bfd_vma
) section
->sh_offset
,
11735 (bfd_vma
) section
->sh_size
);
11741 process_notes (FILE *file
)
11743 /* If we have not been asked to display the notes then do nothing. */
11747 if (elf_header
.e_type
!= ET_CORE
)
11748 return process_note_sections (file
);
11750 /* No program headers means no NOTE segment. */
11751 if (elf_header
.e_phnum
> 0)
11752 return process_corefile_note_segments (file
);
11754 printf (_("No note segments present in the core file.\n"));
11759 process_arch_specific (FILE *file
)
11764 switch (elf_header
.e_machine
)
11767 case EM_MIPS_RS3_LE
:
11768 return process_mips_specific (file
);
11777 get_file_header (FILE *file
)
11779 /* Read in the identity array. */
11780 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
11783 /* Determine how to read the rest of the header. */
11784 switch (elf_header
.e_ident
[EI_DATA
])
11786 default: /* fall through */
11787 case ELFDATANONE
: /* fall through */
11789 byte_get
= byte_get_little_endian
;
11790 byte_put
= byte_put_little_endian
;
11793 byte_get
= byte_get_big_endian
;
11794 byte_put
= byte_put_big_endian
;
11798 /* For now we only support 32 bit and 64 bit ELF files. */
11799 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
11801 /* Read in the rest of the header. */
11804 Elf32_External_Ehdr ehdr32
;
11806 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
11809 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
11810 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
11811 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
11812 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
11813 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
11814 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
11815 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
11816 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
11817 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
11818 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
11819 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
11820 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
11821 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
11825 Elf64_External_Ehdr ehdr64
;
11827 /* If we have been compiled with sizeof (bfd_vma) == 4, then
11828 we will not be able to cope with the 64bit data found in
11829 64 ELF files. Detect this now and abort before we start
11830 overwriting things. */
11831 if (sizeof (bfd_vma
) < 8)
11833 error (_("This instance of readelf has been built without support for a\n\
11834 64 bit data type and so it cannot read 64 bit ELF files.\n"));
11838 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
11841 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
11842 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
11843 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
11844 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
11845 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
11846 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
11847 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
11848 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
11849 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
11850 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
11851 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
11852 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
11853 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
11856 if (elf_header
.e_shoff
)
11858 /* There may be some extensions in the first section header. Don't
11859 bomb if we can't read it. */
11861 get_32bit_section_headers (file
, 1);
11863 get_64bit_section_headers (file
, 1);
11869 /* Process one ELF object file according to the command line options.
11870 This file may actually be stored in an archive. The file is
11871 positioned at the start of the ELF object. */
11874 process_object (char *file_name
, FILE *file
)
11878 if (! get_file_header (file
))
11880 error (_("%s: Failed to read file header\n"), file_name
);
11884 /* Initialise per file variables. */
11885 for (i
= NUM_ELEM (version_info
); i
--;)
11886 version_info
[i
] = 0;
11888 for (i
= NUM_ELEM (dynamic_info
); i
--;)
11889 dynamic_info
[i
] = 0;
11891 /* Process the file. */
11893 printf (_("\nFile: %s\n"), file_name
);
11895 /* Initialise the dump_sects array from the cmdline_dump_sects array.
11896 Note we do this even if cmdline_dump_sects is empty because we
11897 must make sure that the dump_sets array is zeroed out before each
11898 object file is processed. */
11899 if (num_dump_sects
> num_cmdline_dump_sects
)
11900 memset (dump_sects
, 0, num_dump_sects
);
11902 if (num_cmdline_dump_sects
> 0)
11904 if (num_dump_sects
== 0)
11905 /* A sneaky way of allocating the dump_sects array. */
11906 request_dump (num_cmdline_dump_sects
, 0);
11908 assert (num_dump_sects
>= num_cmdline_dump_sects
);
11909 memcpy (dump_sects
, cmdline_dump_sects
, num_cmdline_dump_sects
);
11912 if (! process_file_header ())
11915 if (! process_section_headers (file
))
11917 /* Without loaded section headers we cannot process lots of
11919 do_unwind
= do_version
= do_dump
= do_arch
= 0;
11921 if (! do_using_dynamic
)
11922 do_syms
= do_reloc
= 0;
11925 if (! process_section_groups (file
))
11927 /* Without loaded section groups we cannot process unwind. */
11931 if (process_program_headers (file
))
11932 process_dynamic_section (file
);
11934 process_relocs (file
);
11936 process_unwind (file
);
11938 process_symbol_table (file
);
11940 process_syminfo (file
);
11942 process_version_sections (file
);
11944 process_section_contents (file
);
11946 process_notes (file
);
11948 process_gnu_liblist (file
);
11950 process_arch_specific (file
);
11952 if (program_headers
)
11954 free (program_headers
);
11955 program_headers
= NULL
;
11958 if (section_headers
)
11960 free (section_headers
);
11961 section_headers
= NULL
;
11966 free (string_table
);
11967 string_table
= NULL
;
11968 string_table_length
= 0;
11971 if (dynamic_strings
)
11973 free (dynamic_strings
);
11974 dynamic_strings
= NULL
;
11975 dynamic_strings_length
= 0;
11978 if (dynamic_symbols
)
11980 free (dynamic_symbols
);
11981 dynamic_symbols
= NULL
;
11982 num_dynamic_syms
= 0;
11985 if (dynamic_syminfo
)
11987 free (dynamic_syminfo
);
11988 dynamic_syminfo
= NULL
;
11991 if (section_headers_groups
)
11993 free (section_headers_groups
);
11994 section_headers_groups
= NULL
;
11997 if (section_groups
)
11999 struct group_list
*g
, *next
;
12001 for (i
= 0; i
< group_count
; i
++)
12003 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
12010 free (section_groups
);
12011 section_groups
= NULL
;
12014 if (debug_information
)
12016 for (i
= 0; i
< num_debug_info_entries
; i
++)
12018 if (!debug_information
[i
].max_loc_offsets
)
12020 free (debug_information
[i
].loc_offsets
);
12021 free (debug_information
[i
].have_frame_base
);
12023 if (!debug_information
[i
].max_range_lists
)
12024 free (debug_information
[i
].range_lists
);
12026 free (debug_information
);
12027 debug_information
= NULL
;
12028 num_debug_info_entries
= 0;
12034 /* Process an ELF archive. The file is positioned just after the
12038 process_archive (char *file_name
, FILE *file
)
12040 struct ar_hdr arhdr
;
12042 unsigned long size
;
12043 char *longnames
= NULL
;
12044 unsigned long longnames_size
= 0;
12045 size_t file_name_size
;
12050 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12051 if (got
!= sizeof arhdr
)
12056 error (_("%s: failed to read archive header\n"), file_name
);
12060 if (memcmp (arhdr
.ar_name
, "/ ", 16) == 0)
12062 /* This is the archive symbol table. Skip it.
12063 FIXME: We should have an option to dump it. */
12064 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
12065 if (fseek (file
, size
+ (size
& 1), SEEK_CUR
) != 0)
12067 error (_("%s: failed to skip archive symbol table\n"), file_name
);
12071 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12072 if (got
!= sizeof arhdr
)
12077 error (_("%s: failed to read archive header\n"), file_name
);
12082 if (memcmp (arhdr
.ar_name
, "// ", 16) == 0)
12084 /* This is the archive string table holding long member
12087 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
12089 longnames
= malloc (longnames_size
);
12090 if (longnames
== NULL
)
12092 error (_("Out of memory\n"));
12096 if (fread (longnames
, longnames_size
, 1, file
) != 1)
12099 error (_("%s: failed to read string table\n"), file_name
);
12103 if ((longnames_size
& 1) != 0)
12106 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12107 if (got
!= sizeof arhdr
)
12114 error (_("%s: failed to read archive header\n"), file_name
);
12119 file_name_size
= strlen (file_name
);
12128 if (arhdr
.ar_name
[0] == '/')
12132 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
12133 if (off
>= longnames_size
)
12135 error (_("%s: invalid archive string table offset %lu\n"), off
);
12140 name
= longnames
+ off
;
12141 nameend
= memchr (name
, '/', longnames_size
- off
);
12145 name
= arhdr
.ar_name
;
12146 nameend
= memchr (name
, '/', 16);
12149 if (nameend
== NULL
)
12151 error (_("%s: bad archive file name\n"));
12156 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
12157 if (namealc
== NULL
)
12159 error (_("Out of memory\n"));
12164 memcpy (namealc
, file_name
, file_name_size
);
12165 namealc
[file_name_size
] = '(';
12166 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
12167 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
12168 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
12170 archive_file_offset
= ftell (file
);
12171 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
12173 ret
|= process_object (namealc
, file
);
12178 (archive_file_offset
12179 + archive_file_size
12180 + (archive_file_size
& 1)),
12183 error (_("%s: failed to seek to next archive header\n"), file_name
);
12188 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12189 if (got
!= sizeof arhdr
)
12194 error (_("%s: failed to read archive header\n"), file_name
);
12200 if (longnames
!= 0)
12207 process_file (char *file_name
)
12210 struct stat statbuf
;
12211 char armag
[SARMAG
];
12214 if (stat (file_name
, &statbuf
) < 0)
12216 if (errno
== ENOENT
)
12217 error (_("'%s': No such file\n"), file_name
);
12219 error (_("Could not locate '%s'. System error message: %s\n"),
12220 file_name
, strerror (errno
));
12224 if (! S_ISREG (statbuf
.st_mode
))
12226 error (_("'%s' is not an ordinary file\n"), file_name
);
12230 file
= fopen (file_name
, "rb");
12233 error (_("Input file '%s' is not readable.\n"), file_name
);
12237 if (fread (armag
, SARMAG
, 1, file
) != 1)
12239 error (_("%s: Failed to read file header\n"), file_name
);
12244 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
12245 ret
= process_archive (file_name
, file
);
12249 archive_file_size
= archive_file_offset
= 0;
12250 ret
= process_object (file_name
, file
);
12258 #ifdef SUPPORT_DISASSEMBLY
12259 /* Needed by the i386 disassembler. For extra credit, someone could
12260 fix this so that we insert symbolic addresses here, esp for GOT/PLT
12264 print_address (unsigned int addr
, FILE *outfile
)
12266 fprintf (outfile
,"0x%8.8x", addr
);
12269 /* Needed by the i386 disassembler. */
12271 db_task_printsym (unsigned int addr
)
12273 print_address (addr
, stderr
);
12278 main (int argc
, char **argv
)
12282 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
12283 setlocale (LC_MESSAGES
, "");
12285 #if defined (HAVE_SETLOCALE)
12286 setlocale (LC_CTYPE
, "");
12288 bindtextdomain (PACKAGE
, LOCALEDIR
);
12289 textdomain (PACKAGE
);
12291 parse_args (argc
, argv
);
12293 if (num_dump_sects
> 0)
12295 /* Make a copy of the dump_sects array. */
12296 cmdline_dump_sects
= malloc (num_dump_sects
);
12297 if (cmdline_dump_sects
== NULL
)
12298 error (_("Out of memory allocating dump request table."));
12301 memcpy (cmdline_dump_sects
, dump_sects
, num_dump_sects
);
12302 num_cmdline_dump_sects
= num_dump_sects
;
12306 if (optind
< (argc
- 1))
12310 while (optind
< argc
)
12311 err
|= process_file (argv
[optind
++]);
12313 if (dump_sects
!= NULL
)
12315 if (cmdline_dump_sects
!= NULL
)
12316 free (cmdline_dump_sects
);