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"
92 #include "elf/m68hc11.h"
93 #include "elf/mcore.h"
96 #include "elf/mn10200.h"
97 #include "elf/mn10300.h"
99 #include "elf/msp430.h"
100 #include "elf/or32.h"
103 #include "elf/ppc64.h"
104 #include "elf/s390.h"
106 #include "elf/sparc.h"
107 #include "elf/v850.h"
109 #include "elf/x86-64.h"
110 #include "elf/xstormy16.h"
112 #include "elf/iq2000.h"
113 #include "elf/xtensa.h"
119 #include "libiberty.h"
121 char *program_name
= "readelf";
122 static long archive_file_offset
;
123 static unsigned long archive_file_size
;
124 static unsigned long dynamic_addr
;
125 static bfd_size_type dynamic_size
;
126 static unsigned int dynamic_nent
;
127 static char *dynamic_strings
;
128 static unsigned long dynamic_strings_length
;
129 static char *string_table
;
130 static unsigned long string_table_length
;
131 static unsigned long num_dynamic_syms
;
132 static Elf_Internal_Sym
*dynamic_symbols
;
133 static Elf_Internal_Syminfo
*dynamic_syminfo
;
134 static unsigned long dynamic_syminfo_offset
;
135 static unsigned int dynamic_syminfo_nent
;
136 static char program_interpreter
[64];
137 static bfd_vma dynamic_info
[DT_JMPREL
+ 1];
138 static bfd_vma version_info
[16];
139 static Elf_Internal_Ehdr elf_header
;
140 static Elf_Internal_Shdr
*section_headers
;
141 static Elf_Internal_Phdr
*program_headers
;
142 static Elf_Internal_Dyn
*dynamic_section
;
143 static Elf_Internal_Shdr
*symtab_shndx_hdr
;
144 static int show_name
;
145 static int do_dynamic
;
148 static int do_sections
;
149 static int do_section_groups
;
150 static int do_section_details
;
151 static int do_segments
;
152 static int do_unwind
;
153 static int do_using_dynamic
;
154 static int do_header
;
156 static int do_version
;
158 static int do_histogram
;
159 static int do_debugging
;
160 static int do_debug_info
;
161 static int do_debug_abbrevs
;
162 static int do_debug_lines
;
163 static int do_debug_pubnames
;
164 static int do_debug_aranges
;
165 static int do_debug_ranges
;
166 static int do_debug_frames
;
167 static int do_debug_frames_interp
;
168 static int do_debug_macinfo
;
169 static int do_debug_str
;
170 static int do_debug_loc
;
173 static int is_32bit_elf
;
174 static int have_frame_base
;
175 static int need_base_address
;
176 static bfd_vma eh_addr_size
;
180 struct group_list
*next
;
181 unsigned int section_index
;
186 struct group_list
*root
;
187 unsigned int group_index
;
190 static size_t group_count
;
191 static struct group
*section_groups
;
192 static struct group
**section_headers_groups
;
194 /* A dynamic array of flags indicating for which sections a hex dump
195 has been requested (via the -x switch) and/or a disassembly dump
196 (via the -i switch). */
197 char *cmdline_dump_sects
= NULL
;
198 unsigned num_cmdline_dump_sects
= 0;
200 /* A dynamic array of flags indicating for which sections a dump of
201 some kind has been requested. It is reset on a per-object file
202 basis and then initialised from the cmdline_dump_sects array and
203 the results of interpreting the -w switch. */
204 char *dump_sects
= NULL
;
205 unsigned int num_dump_sects
= 0;
207 #define HEX_DUMP (1 << 0)
208 #define DISASS_DUMP (1 << 1)
209 #define DEBUG_DUMP (1 << 2)
211 /* How to print a vma value. */
212 typedef enum print_mode
224 static bfd_vma (*byte_get
) (unsigned char *, int);
225 static void (*byte_put
) (unsigned char *, bfd_vma
, int);
229 #define SECTION_NAME(X) ((X) == NULL ? "<none>" : \
230 ((X)->sh_name >= string_table_length \
231 ? "<corrupt>" : string_table + (X)->sh_name))
233 /* Given st_shndx I, map to section_headers index. */
234 #define SECTION_HEADER_INDEX(I) \
235 ((I) < SHN_LORESERVE \
237 : ((I) <= SHN_HIRESERVE \
239 : (I) - (SHN_HIRESERVE + 1 - SHN_LORESERVE)))
241 /* Reverse of the above. */
242 #define SECTION_HEADER_NUM(N) \
243 ((N) < SHN_LORESERVE \
245 : (N) + (SHN_HIRESERVE + 1 - SHN_LORESERVE))
247 #define SECTION_HEADER(I) (section_headers + SECTION_HEADER_INDEX (I))
249 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
251 #define BYTE_GET(field) byte_get (field, sizeof (field))
253 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
255 #define GET_ELF_SYMBOLS(file, section) \
256 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
257 : get_64bit_elf_symbols (file, section))
259 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
260 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
261 already been called and verified that the string exists. */
262 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
264 /* This is just a bit of syntatic sugar. */
265 #define streq(a,b) (strcmp ((a), (b)) == 0)
266 #define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
268 static void ATTRIBUTE_PRINTF_1
269 error (const char *message
, ...)
273 va_start (args
, message
);
274 fprintf (stderr
, _("%s: Error: "), program_name
);
275 vfprintf (stderr
, message
, args
);
279 static void ATTRIBUTE_PRINTF_1
280 warn (const char *message
, ...)
284 va_start (args
, message
);
285 fprintf (stderr
, _("%s: Warning: "), program_name
);
286 vfprintf (stderr
, message
, args
);
291 cmalloc (size_t nmemb
, size_t size
)
293 /* Check for overflow. */
294 if (nmemb
>= ~(size_t) 0 / size
)
297 return malloc (nmemb
* size
);
301 xcmalloc (size_t nmemb
, size_t size
)
303 /* Check for overflow. */
304 if (nmemb
>= ~(size_t) 0 / size
)
307 return xmalloc (nmemb
* size
);
311 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
313 /* Check for overflow. */
314 if (nmemb
>= ~(size_t) 0 / size
)
317 return xrealloc (ptr
, nmemb
* size
);
321 get_data (void *var
, FILE *file
, long offset
, size_t size
, size_t nmemb
,
326 if (size
== 0 || nmemb
== 0)
329 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
331 error (_("Unable to seek to 0x%lx for %s\n"),
332 archive_file_offset
+ offset
, reason
);
339 /* Check for overflow. */
340 if (nmemb
< (~(size_t) 0 - 1) / size
)
341 /* + 1 so that we can '\0' terminate invalid string table sections. */
342 mvar
= malloc (size
* nmemb
+ 1);
346 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
347 (unsigned long)(size
* nmemb
), reason
);
351 ((char *) mvar
)[size
* nmemb
] = '\0';
354 if (fread (mvar
, size
, nmemb
, file
) != nmemb
)
356 error (_("Unable to read in 0x%lx bytes of %s\n"),
357 (unsigned long)(size
* nmemb
), reason
);
367 byte_get_little_endian (unsigned char *field
, int size
)
375 return ((unsigned int) (field
[0]))
376 | (((unsigned int) (field
[1])) << 8);
380 /* We want to extract data from an 8 byte wide field and
381 place it into a 4 byte wide field. Since this is a little
382 endian source we can just use the 4 byte extraction code. */
386 return ((unsigned long) (field
[0]))
387 | (((unsigned long) (field
[1])) << 8)
388 | (((unsigned long) (field
[2])) << 16)
389 | (((unsigned long) (field
[3])) << 24);
393 return ((bfd_vma
) (field
[0]))
394 | (((bfd_vma
) (field
[1])) << 8)
395 | (((bfd_vma
) (field
[2])) << 16)
396 | (((bfd_vma
) (field
[3])) << 24)
397 | (((bfd_vma
) (field
[4])) << 32)
398 | (((bfd_vma
) (field
[5])) << 40)
399 | (((bfd_vma
) (field
[6])) << 48)
400 | (((bfd_vma
) (field
[7])) << 56);
403 error (_("Unhandled data length: %d\n"), size
);
409 byte_get_signed (unsigned char *field
, int size
)
411 bfd_vma x
= byte_get (field
, size
);
416 return (x
^ 0x80) - 0x80;
418 return (x
^ 0x8000) - 0x8000;
420 return (x
^ 0x80000000) - 0x80000000;
429 byte_put_little_endian (unsigned char *field
, bfd_vma value
, int size
)
434 field
[7] = (((value
>> 24) >> 24) >> 8) & 0xff;
435 field
[6] = ((value
>> 24) >> 24) & 0xff;
436 field
[5] = ((value
>> 24) >> 16) & 0xff;
437 field
[4] = ((value
>> 24) >> 8) & 0xff;
440 field
[3] = (value
>> 24) & 0xff;
441 field
[2] = (value
>> 16) & 0xff;
444 field
[1] = (value
>> 8) & 0xff;
447 field
[0] = value
& 0xff;
451 error (_("Unhandled data length: %d\n"), size
);
456 #if defined BFD64 && !BFD_HOST_64BIT_LONG
458 print_dec_vma (bfd_vma vma
, int is_signed
)
464 if (is_signed
&& (bfd_signed_vma
) vma
< 0)
473 *bufp
++ = '0' + vma
% 10;
485 print_hex_vma (bfd_vma vma
)
493 char digit
= '0' + (vma
& 0x0f);
495 digit
+= 'a' - '0' - 10;
508 /* Print a VMA value. */
510 print_vma (bfd_vma vma
, print_mode mode
)
519 return printf ("0x%8.8lx", (unsigned long) vma
);
522 return printf ("%8.8lx", (unsigned long) vma
);
526 return printf ("%5ld", (long) vma
);
530 return printf ("0x%lx", (unsigned long) vma
);
533 return printf ("%lx", (unsigned long) vma
);
536 return printf ("%ld", (unsigned long) vma
);
539 return printf ("%lu", (unsigned long) vma
);
562 #if BFD_HOST_64BIT_LONG
563 return nc
+ printf ("%lx", vma
);
565 return nc
+ print_hex_vma (vma
);
569 #if BFD_HOST_64BIT_LONG
570 return printf ("%ld", vma
);
572 return print_dec_vma (vma
, 1);
576 #if BFD_HOST_64BIT_LONG
578 return printf ("%5ld", vma
);
580 return printf ("%#lx", vma
);
583 return printf ("%5ld", _bfd_int64_low (vma
));
585 return print_hex_vma (vma
);
589 #if BFD_HOST_64BIT_LONG
590 return printf ("%lu", vma
);
592 return print_dec_vma (vma
, 0);
600 /* Display a symbol on stdout. If do_wide is not true then
601 format the symbol to be at most WIDTH characters,
602 truncating as necessary. If WIDTH is negative then
603 format the string to be exactly - WIDTH characters,
604 truncating or padding as necessary. */
607 print_symbol (int width
, const char *symbol
)
610 printf ("%s", symbol
);
612 printf ("%-*.*s", width
, width
, symbol
);
614 printf ("%-.*s", width
, symbol
);
618 byte_get_big_endian (unsigned char *field
, int size
)
626 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
630 /* Although we are extracing data from an 8 byte wide field,
631 we are returning only 4 bytes of data. */
636 return ((unsigned long) (field
[3]))
637 | (((unsigned long) (field
[2])) << 8)
638 | (((unsigned long) (field
[1])) << 16)
639 | (((unsigned long) (field
[0])) << 24);
643 return ((bfd_vma
) (field
[7]))
644 | (((bfd_vma
) (field
[6])) << 8)
645 | (((bfd_vma
) (field
[5])) << 16)
646 | (((bfd_vma
) (field
[4])) << 24)
647 | (((bfd_vma
) (field
[3])) << 32)
648 | (((bfd_vma
) (field
[2])) << 40)
649 | (((bfd_vma
) (field
[1])) << 48)
650 | (((bfd_vma
) (field
[0])) << 56);
654 error (_("Unhandled data length: %d\n"), size
);
660 byte_put_big_endian (unsigned char *field
, bfd_vma value
, int size
)
665 field
[7] = value
& 0xff;
666 field
[6] = (value
>> 8) & 0xff;
667 field
[5] = (value
>> 16) & 0xff;
668 field
[4] = (value
>> 24) & 0xff;
673 field
[3] = value
& 0xff;
674 field
[2] = (value
>> 8) & 0xff;
678 field
[1] = value
& 0xff;
682 field
[0] = value
& 0xff;
686 error (_("Unhandled data length: %d\n"), size
);
691 /* Return a pointer to section NAME, or NULL if no such section exists. */
693 static Elf_Internal_Shdr
*
694 find_section (const char *name
)
698 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
699 if (streq (SECTION_NAME (section_headers
+ i
), name
))
700 return section_headers
+ i
;
705 /* Guess the relocation size commonly used by the specific machines. */
708 guess_is_rela (unsigned long e_machine
)
712 /* Targets that use REL relocations. */
727 /* Targets that use RELA relocations. */
742 case EM_CYGNUS_MN10200
:
744 case EM_CYGNUS_MN10300
:
793 warn (_("Don't know about relocations on this machine architecture\n"));
799 slurp_rela_relocs (FILE *file
,
800 unsigned long rel_offset
,
801 unsigned long rel_size
,
802 Elf_Internal_Rela
**relasp
,
803 unsigned long *nrelasp
)
805 Elf_Internal_Rela
*relas
;
806 unsigned long nrelas
;
811 Elf32_External_Rela
*erelas
;
813 erelas
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
817 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
819 relas
= cmalloc (nrelas
, sizeof (Elf_Internal_Rela
));
824 error (_("out of memory parsing relocs"));
828 for (i
= 0; i
< nrelas
; i
++)
830 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
831 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
832 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
839 Elf64_External_Rela
*erelas
;
841 erelas
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
845 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
847 relas
= cmalloc (nrelas
, sizeof (Elf_Internal_Rela
));
852 error (_("out of memory parsing relocs"));
856 for (i
= 0; i
< nrelas
; i
++)
858 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
859 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
860 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
871 slurp_rel_relocs (FILE *file
,
872 unsigned long rel_offset
,
873 unsigned long rel_size
,
874 Elf_Internal_Rela
**relsp
,
875 unsigned long *nrelsp
)
877 Elf_Internal_Rela
*rels
;
883 Elf32_External_Rel
*erels
;
885 erels
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
889 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
891 rels
= cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
896 error (_("out of memory parsing relocs"));
900 for (i
= 0; i
< nrels
; i
++)
902 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
903 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
904 rels
[i
].r_addend
= 0;
911 Elf64_External_Rel
*erels
;
913 erels
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
917 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
919 rels
= cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
924 error (_("out of memory parsing relocs"));
928 for (i
= 0; i
< nrels
; i
++)
930 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
931 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
932 rels
[i
].r_addend
= 0;
942 /* Display the contents of the relocation data found at the specified
946 dump_relocations (FILE *file
,
947 unsigned long rel_offset
,
948 unsigned long rel_size
,
949 Elf_Internal_Sym
*symtab
,
952 unsigned long strtablen
,
956 Elf_Internal_Rela
*rels
;
959 if (is_rela
== UNKNOWN
)
960 is_rela
= guess_is_rela (elf_header
.e_machine
);
964 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
969 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
978 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
980 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
985 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
987 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
995 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
997 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1002 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1004 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1008 for (i
= 0; i
< rel_size
; i
++)
1011 const char *rtype2
= NULL
;
1012 const char *rtype3
= NULL
;
1015 bfd_vma symtab_index
;
1020 offset
= rels
[i
].r_offset
;
1021 info
= rels
[i
].r_info
;
1025 type
= ELF32_R_TYPE (info
);
1026 symtab_index
= ELF32_R_SYM (info
);
1030 /* The #ifdef BFD64 below is to prevent a compile time warning.
1031 We know that if we do not have a 64 bit data type that we
1032 will never execute this code anyway. */
1034 if (elf_header
.e_machine
== EM_MIPS
)
1036 /* In little-endian objects, r_info isn't really a 64-bit
1037 little-endian value: it has a 32-bit little-endian
1038 symbol index followed by four individual byte fields.
1039 Reorder INFO accordingly. */
1040 if (elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1041 info
= (((info
& 0xffffffff) << 32)
1042 | ((info
>> 56) & 0xff)
1043 | ((info
>> 40) & 0xff00)
1044 | ((info
>> 24) & 0xff0000)
1045 | ((info
>> 8) & 0xff000000));
1046 type
= ELF64_MIPS_R_TYPE (info
);
1047 type2
= ELF64_MIPS_R_TYPE2 (info
);
1048 type3
= ELF64_MIPS_R_TYPE3 (info
);
1050 else if (elf_header
.e_machine
== EM_SPARCV9
)
1051 type
= ELF64_R_TYPE_ID (info
);
1053 type
= ELF64_R_TYPE (info
);
1055 symtab_index
= ELF64_R_SYM (info
);
1061 #ifdef _bfd_int64_low
1062 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset
), _bfd_int64_low (info
));
1064 printf ("%8.8lx %8.8lx ", offset
, info
);
1069 #ifdef _bfd_int64_low
1071 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1072 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1073 _bfd_int64_high (offset
),
1074 _bfd_int64_low (offset
),
1075 _bfd_int64_high (info
),
1076 _bfd_int64_low (info
));
1079 ? "%16.16lx %16.16lx "
1080 : "%12.12lx %12.12lx ",
1085 switch (elf_header
.e_machine
)
1092 case EM_CYGNUS_M32R
:
1093 rtype
= elf_m32r_reloc_type (type
);
1098 rtype
= elf_i386_reloc_type (type
);
1103 rtype
= elf_m68hc11_reloc_type (type
);
1107 rtype
= elf_m68k_reloc_type (type
);
1111 rtype
= elf_i960_reloc_type (type
);
1116 rtype
= elf_avr_reloc_type (type
);
1119 case EM_OLD_SPARCV9
:
1120 case EM_SPARC32PLUS
:
1123 rtype
= elf_sparc_reloc_type (type
);
1127 case EM_CYGNUS_V850
:
1128 rtype
= v850_reloc_type (type
);
1132 case EM_CYGNUS_D10V
:
1133 rtype
= elf_d10v_reloc_type (type
);
1137 case EM_CYGNUS_D30V
:
1138 rtype
= elf_d30v_reloc_type (type
);
1142 rtype
= elf_dlx_reloc_type (type
);
1146 rtype
= elf_sh_reloc_type (type
);
1150 case EM_CYGNUS_MN10300
:
1151 rtype
= elf_mn10300_reloc_type (type
);
1155 case EM_CYGNUS_MN10200
:
1156 rtype
= elf_mn10200_reloc_type (type
);
1160 case EM_CYGNUS_FR30
:
1161 rtype
= elf_fr30_reloc_type (type
);
1165 rtype
= elf_frv_reloc_type (type
);
1169 rtype
= elf_mcore_reloc_type (type
);
1173 rtype
= elf_mmix_reloc_type (type
);
1178 rtype
= elf_msp430_reloc_type (type
);
1182 rtype
= elf_ppc_reloc_type (type
);
1186 rtype
= elf_ppc64_reloc_type (type
);
1190 case EM_MIPS_RS3_LE
:
1191 rtype
= elf_mips_reloc_type (type
);
1194 rtype2
= elf_mips_reloc_type (type2
);
1195 rtype3
= elf_mips_reloc_type (type3
);
1200 rtype
= elf_alpha_reloc_type (type
);
1204 rtype
= elf_arm_reloc_type (type
);
1208 rtype
= elf_arc_reloc_type (type
);
1212 rtype
= elf_hppa_reloc_type (type
);
1218 rtype
= elf_h8_reloc_type (type
);
1223 rtype
= elf_or32_reloc_type (type
);
1228 rtype
= elf_pj_reloc_type (type
);
1231 rtype
= elf_ia64_reloc_type (type
);
1235 rtype
= elf_cris_reloc_type (type
);
1239 rtype
= elf_i860_reloc_type (type
);
1243 rtype
= elf_x86_64_reloc_type (type
);
1247 rtype
= i370_reloc_type (type
);
1252 rtype
= elf_s390_reloc_type (type
);
1256 rtype
= elf_xstormy16_reloc_type (type
);
1260 rtype
= elf_crx_reloc_type (type
);
1264 rtype
= elf_vax_reloc_type (type
);
1269 rtype
= elf_ip2k_reloc_type (type
);
1273 rtype
= elf_iq2000_reloc_type (type
);
1278 rtype
= elf_xtensa_reloc_type (type
);
1282 rtype
= elf_m32c_reloc_type (type
);
1286 rtype
= elf_ms1_reloc_type (type
);
1291 #ifdef _bfd_int64_low
1292 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type
));
1294 printf (_("unrecognized: %-7lx"), type
);
1297 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1299 if (elf_header
.e_machine
== EM_ALPHA
1300 && streq (rtype
, "R_ALPHA_LITUSE")
1303 switch (rels
[i
].r_addend
)
1305 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1306 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1307 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1308 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1309 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1310 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1311 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1312 default: rtype
= NULL
;
1315 printf (" (%s)", rtype
);
1319 printf (_("<unknown addend: %lx>"),
1320 (unsigned long) rels
[i
].r_addend
);
1323 else if (symtab_index
)
1325 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1326 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1329 Elf_Internal_Sym
*psym
;
1331 psym
= symtab
+ symtab_index
;
1334 print_vma (psym
->st_value
, LONG_HEX
);
1335 printf (is_32bit_elf
? " " : " ");
1337 if (psym
->st_name
== 0)
1339 const char *sec_name
= "<null>";
1342 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1344 bfd_vma sec_index
= (bfd_vma
) -1;
1346 if (psym
->st_shndx
< SHN_LORESERVE
)
1347 sec_index
= psym
->st_shndx
;
1348 else if (psym
->st_shndx
> SHN_HIRESERVE
)
1349 sec_index
= psym
->st_shndx
- (SHN_HIRESERVE
+ 1
1352 if (sec_index
!= (bfd_vma
) -1)
1353 sec_name
= SECTION_NAME (section_headers
+ sec_index
);
1354 else if (psym
->st_shndx
== SHN_ABS
)
1356 else if (psym
->st_shndx
== SHN_COMMON
)
1357 sec_name
= "COMMON";
1358 else if (elf_header
.e_machine
== EM_X86_64
1359 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1360 sec_name
= "LARGE_COMMON";
1361 else if (elf_header
.e_machine
== EM_IA_64
1362 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1363 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1364 sec_name
= "ANSI_COM";
1367 sprintf (name_buf
, "<section 0x%x>",
1368 (unsigned int) psym
->st_shndx
);
1369 sec_name
= name_buf
;
1372 print_symbol (22, sec_name
);
1374 else if (strtab
== NULL
)
1375 printf (_("<string table index: %3ld>"), psym
->st_name
);
1376 else if (psym
->st_name
>= strtablen
)
1377 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1379 print_symbol (22, strtab
+ psym
->st_name
);
1382 printf (" + %lx", (unsigned long) rels
[i
].r_addend
);
1387 printf ("%*c", is_32bit_elf
?
1388 (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1389 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1392 if (elf_header
.e_machine
== EM_SPARCV9
&& streq (rtype
, "R_SPARC_OLO10"))
1393 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1397 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1399 printf (" Type2: ");
1402 #ifdef _bfd_int64_low
1403 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2
));
1405 printf (_("unrecognized: %-7lx"), type2
);
1408 printf ("%-17.17s", rtype2
);
1410 printf ("\n Type3: ");
1413 #ifdef _bfd_int64_low
1414 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3
));
1416 printf (_("unrecognized: %-7lx"), type3
);
1419 printf ("%-17.17s", rtype3
);
1431 get_mips_dynamic_type (unsigned long type
)
1435 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1436 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1437 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1438 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1439 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1440 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1441 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1442 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1443 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1444 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1445 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1446 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1447 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1448 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1449 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1450 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1451 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1452 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1453 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1454 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1455 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1456 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1457 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1458 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1459 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1460 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1461 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1462 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1463 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1464 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1465 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1466 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1467 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1468 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1469 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1470 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1471 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1472 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1473 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1474 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1475 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1476 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1477 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1484 get_sparc64_dynamic_type (unsigned long type
)
1488 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1495 get_ppc_dynamic_type (unsigned long type
)
1499 case DT_PPC_GOT
: return "PPC_GOT";
1506 get_ppc64_dynamic_type (unsigned long type
)
1510 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1511 case DT_PPC64_OPD
: return "PPC64_OPD";
1512 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1519 get_parisc_dynamic_type (unsigned long type
)
1523 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1524 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1525 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1526 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1527 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1528 case DT_HP_PREINIT
: return "HP_PREINIT";
1529 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1530 case DT_HP_NEEDED
: return "HP_NEEDED";
1531 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1532 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1533 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1534 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1535 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1536 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1537 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1538 case DT_HP_FILTERED
: return "HP_FILTERED";
1539 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1540 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1541 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1542 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1543 case DT_PLT
: return "PLT";
1544 case DT_PLT_SIZE
: return "PLT_SIZE";
1545 case DT_DLT
: return "DLT";
1546 case DT_DLT_SIZE
: return "DLT_SIZE";
1553 get_ia64_dynamic_type (unsigned long type
)
1557 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1564 get_alpha_dynamic_type (unsigned long type
)
1568 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1575 get_dynamic_type (unsigned long type
)
1577 static char buff
[64];
1581 case DT_NULL
: return "NULL";
1582 case DT_NEEDED
: return "NEEDED";
1583 case DT_PLTRELSZ
: return "PLTRELSZ";
1584 case DT_PLTGOT
: return "PLTGOT";
1585 case DT_HASH
: return "HASH";
1586 case DT_STRTAB
: return "STRTAB";
1587 case DT_SYMTAB
: return "SYMTAB";
1588 case DT_RELA
: return "RELA";
1589 case DT_RELASZ
: return "RELASZ";
1590 case DT_RELAENT
: return "RELAENT";
1591 case DT_STRSZ
: return "STRSZ";
1592 case DT_SYMENT
: return "SYMENT";
1593 case DT_INIT
: return "INIT";
1594 case DT_FINI
: return "FINI";
1595 case DT_SONAME
: return "SONAME";
1596 case DT_RPATH
: return "RPATH";
1597 case DT_SYMBOLIC
: return "SYMBOLIC";
1598 case DT_REL
: return "REL";
1599 case DT_RELSZ
: return "RELSZ";
1600 case DT_RELENT
: return "RELENT";
1601 case DT_PLTREL
: return "PLTREL";
1602 case DT_DEBUG
: return "DEBUG";
1603 case DT_TEXTREL
: return "TEXTREL";
1604 case DT_JMPREL
: return "JMPREL";
1605 case DT_BIND_NOW
: return "BIND_NOW";
1606 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1607 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1608 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1609 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1610 case DT_RUNPATH
: return "RUNPATH";
1611 case DT_FLAGS
: return "FLAGS";
1613 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1614 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1616 case DT_CHECKSUM
: return "CHECKSUM";
1617 case DT_PLTPADSZ
: return "PLTPADSZ";
1618 case DT_MOVEENT
: return "MOVEENT";
1619 case DT_MOVESZ
: return "MOVESZ";
1620 case DT_FEATURE
: return "FEATURE";
1621 case DT_POSFLAG_1
: return "POSFLAG_1";
1622 case DT_SYMINSZ
: return "SYMINSZ";
1623 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1625 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1626 case DT_CONFIG
: return "CONFIG";
1627 case DT_DEPAUDIT
: return "DEPAUDIT";
1628 case DT_AUDIT
: return "AUDIT";
1629 case DT_PLTPAD
: return "PLTPAD";
1630 case DT_MOVETAB
: return "MOVETAB";
1631 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1633 case DT_VERSYM
: return "VERSYM";
1635 case DT_RELACOUNT
: return "RELACOUNT";
1636 case DT_RELCOUNT
: return "RELCOUNT";
1637 case DT_FLAGS_1
: return "FLAGS_1";
1638 case DT_VERDEF
: return "VERDEF";
1639 case DT_VERDEFNUM
: return "VERDEFNUM";
1640 case DT_VERNEED
: return "VERNEED";
1641 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1643 case DT_AUXILIARY
: return "AUXILIARY";
1644 case DT_USED
: return "USED";
1645 case DT_FILTER
: return "FILTER";
1647 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1648 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1649 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1650 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1651 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1654 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1658 switch (elf_header
.e_machine
)
1661 case EM_MIPS_RS3_LE
:
1662 result
= get_mips_dynamic_type (type
);
1665 result
= get_sparc64_dynamic_type (type
);
1668 result
= get_ppc_dynamic_type (type
);
1671 result
= get_ppc64_dynamic_type (type
);
1674 result
= get_ia64_dynamic_type (type
);
1677 result
= get_alpha_dynamic_type (type
);
1687 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1689 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1690 || (elf_header
.e_machine
== EM_PARISC
1691 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1695 switch (elf_header
.e_machine
)
1698 result
= get_parisc_dynamic_type (type
);
1708 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1712 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1719 get_file_type (unsigned e_type
)
1721 static char buff
[32];
1725 case ET_NONE
: return _("NONE (None)");
1726 case ET_REL
: return _("REL (Relocatable file)");
1727 case ET_EXEC
: return _("EXEC (Executable file)");
1728 case ET_DYN
: return _("DYN (Shared object file)");
1729 case ET_CORE
: return _("CORE (Core file)");
1732 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1733 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1734 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1735 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1737 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1743 get_machine_name (unsigned e_machine
)
1745 static char buff
[64]; /* XXX */
1749 case EM_NONE
: return _("None");
1750 case EM_M32
: return "WE32100";
1751 case EM_SPARC
: return "Sparc";
1752 case EM_386
: return "Intel 80386";
1753 case EM_68K
: return "MC68000";
1754 case EM_88K
: return "MC88000";
1755 case EM_486
: return "Intel 80486";
1756 case EM_860
: return "Intel 80860";
1757 case EM_MIPS
: return "MIPS R3000";
1758 case EM_S370
: return "IBM System/370";
1759 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1760 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1761 case EM_PARISC
: return "HPPA";
1762 case EM_PPC_OLD
: return "Power PC (old)";
1763 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1764 case EM_960
: return "Intel 90860";
1765 case EM_PPC
: return "PowerPC";
1766 case EM_PPC64
: return "PowerPC64";
1767 case EM_V800
: return "NEC V800";
1768 case EM_FR20
: return "Fujitsu FR20";
1769 case EM_RH32
: return "TRW RH32";
1770 case EM_MCORE
: return "MCORE";
1771 case EM_ARM
: return "ARM";
1772 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1773 case EM_SH
: return "Renesas / SuperH SH";
1774 case EM_SPARCV9
: return "Sparc v9";
1775 case EM_TRICORE
: return "Siemens Tricore";
1776 case EM_ARC
: return "ARC";
1777 case EM_H8_300
: return "Renesas H8/300";
1778 case EM_H8_300H
: return "Renesas H8/300H";
1779 case EM_H8S
: return "Renesas H8S";
1780 case EM_H8_500
: return "Renesas H8/500";
1781 case EM_IA_64
: return "Intel IA-64";
1782 case EM_MIPS_X
: return "Stanford MIPS-X";
1783 case EM_COLDFIRE
: return "Motorola Coldfire";
1784 case EM_68HC12
: return "Motorola M68HC12";
1785 case EM_ALPHA
: return "Alpha";
1786 case EM_CYGNUS_D10V
:
1787 case EM_D10V
: return "d10v";
1788 case EM_CYGNUS_D30V
:
1789 case EM_D30V
: return "d30v";
1790 case EM_CYGNUS_M32R
:
1791 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1792 case EM_CYGNUS_V850
:
1793 case EM_V850
: return "NEC v850";
1794 case EM_CYGNUS_MN10300
:
1795 case EM_MN10300
: return "mn10300";
1796 case EM_CYGNUS_MN10200
:
1797 case EM_MN10200
: return "mn10200";
1798 case EM_CYGNUS_FR30
:
1799 case EM_FR30
: return "Fujitsu FR30";
1800 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1802 case EM_PJ
: return "picoJava";
1803 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1804 case EM_PCP
: return "Siemens PCP";
1805 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1806 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1807 case EM_STARCORE
: return "Motorola Star*Core processor";
1808 case EM_ME16
: return "Toyota ME16 processor";
1809 case EM_ST100
: return "STMicroelectronics ST100 processor";
1810 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1811 case EM_FX66
: return "Siemens FX66 microcontroller";
1812 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1813 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1814 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1815 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1816 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1817 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1818 case EM_SVX
: return "Silicon Graphics SVx";
1819 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1820 case EM_VAX
: return "Digital VAX";
1822 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1823 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1824 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1825 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1826 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1827 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1828 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1829 case EM_PRISM
: return "Vitesse Prism";
1830 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1832 case EM_S390
: return "IBM S/390";
1833 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1835 case EM_OR32
: return "OpenRISC";
1836 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1837 case EM_DLX
: return "OpenDLX";
1839 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1840 case EM_IQ2000
: return "Vitesse IQ2000";
1842 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1843 case EM_M32C
: return "Renesas M32c";
1844 case EM_MS1
: return "Morpho Techologies MS1 processor";
1846 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_machine
);
1852 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
1857 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1858 e_flags
&= ~ EF_ARM_EABIMASK
;
1860 /* Handle "generic" ARM flags. */
1861 if (e_flags
& EF_ARM_RELEXEC
)
1863 strcat (buf
, ", relocatable executable");
1864 e_flags
&= ~ EF_ARM_RELEXEC
;
1867 if (e_flags
& EF_ARM_HASENTRY
)
1869 strcat (buf
, ", has entry point");
1870 e_flags
&= ~ EF_ARM_HASENTRY
;
1873 /* Now handle EABI specific flags. */
1877 strcat (buf
, ", <unrecognized EABI>");
1882 case EF_ARM_EABI_VER1
:
1883 strcat (buf
, ", Version1 EABI");
1888 /* Process flags one bit at a time. */
1889 flag
= e_flags
& - e_flags
;
1894 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1895 strcat (buf
, ", sorted symbol tables");
1905 case EF_ARM_EABI_VER2
:
1906 strcat (buf
, ", Version2 EABI");
1911 /* Process flags one bit at a time. */
1912 flag
= e_flags
& - e_flags
;
1917 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1918 strcat (buf
, ", sorted symbol tables");
1921 case EF_ARM_DYNSYMSUSESEGIDX
:
1922 strcat (buf
, ", dynamic symbols use segment index");
1925 case EF_ARM_MAPSYMSFIRST
:
1926 strcat (buf
, ", mapping symbols precede others");
1936 case EF_ARM_EABI_VER3
:
1937 strcat (buf
, ", Version3 EABI");
1940 case EF_ARM_EABI_VER4
:
1941 strcat (buf
, ", Version4 EABI");
1946 /* Process flags one bit at a time. */
1947 flag
= e_flags
& - e_flags
;
1953 strcat (buf
, ", BE8");
1957 strcat (buf
, ", LE8");
1967 case EF_ARM_EABI_UNKNOWN
:
1968 strcat (buf
, ", GNU EABI");
1973 /* Process flags one bit at a time. */
1974 flag
= e_flags
& - e_flags
;
1979 case EF_ARM_INTERWORK
:
1980 strcat (buf
, ", interworking enabled");
1983 case EF_ARM_APCS_26
:
1984 strcat (buf
, ", uses APCS/26");
1987 case EF_ARM_APCS_FLOAT
:
1988 strcat (buf
, ", uses APCS/float");
1992 strcat (buf
, ", position independent");
1996 strcat (buf
, ", 8 bit structure alignment");
1999 case EF_ARM_NEW_ABI
:
2000 strcat (buf
, ", uses new ABI");
2003 case EF_ARM_OLD_ABI
:
2004 strcat (buf
, ", uses old ABI");
2007 case EF_ARM_SOFT_FLOAT
:
2008 strcat (buf
, ", software FP");
2011 case EF_ARM_VFP_FLOAT
:
2012 strcat (buf
, ", VFP");
2015 case EF_ARM_MAVERICK_FLOAT
:
2016 strcat (buf
, ", Maverick FP");
2027 strcat (buf
,", <unknown>");
2031 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2033 static char buf
[1024];
2045 decode_ARM_machine_flags (e_flags
, buf
);
2049 switch (e_flags
& EF_FRV_CPU_MASK
)
2051 case EF_FRV_CPU_GENERIC
:
2055 strcat (buf
, ", fr???");
2058 case EF_FRV_CPU_FR300
:
2059 strcat (buf
, ", fr300");
2062 case EF_FRV_CPU_FR400
:
2063 strcat (buf
, ", fr400");
2065 case EF_FRV_CPU_FR405
:
2066 strcat (buf
, ", fr405");
2069 case EF_FRV_CPU_FR450
:
2070 strcat (buf
, ", fr450");
2073 case EF_FRV_CPU_FR500
:
2074 strcat (buf
, ", fr500");
2076 case EF_FRV_CPU_FR550
:
2077 strcat (buf
, ", fr550");
2080 case EF_FRV_CPU_SIMPLE
:
2081 strcat (buf
, ", simple");
2083 case EF_FRV_CPU_TOMCAT
:
2084 strcat (buf
, ", tomcat");
2090 if (e_flags
& EF_CPU32
)
2091 strcat (buf
, ", cpu32");
2092 if (e_flags
& EF_M68000
)
2093 strcat (buf
, ", m68000");
2097 if (e_flags
& EF_PPC_EMB
)
2098 strcat (buf
, ", emb");
2100 if (e_flags
& EF_PPC_RELOCATABLE
)
2101 strcat (buf
, ", relocatable");
2103 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2104 strcat (buf
, ", relocatable-lib");
2108 case EM_CYGNUS_V850
:
2109 switch (e_flags
& EF_V850_ARCH
)
2112 strcat (buf
, ", v850e1");
2115 strcat (buf
, ", v850e");
2118 strcat (buf
, ", v850");
2121 strcat (buf
, ", unknown v850 architecture variant");
2127 case EM_CYGNUS_M32R
:
2128 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2129 strcat (buf
, ", m32r");
2134 case EM_MIPS_RS3_LE
:
2135 if (e_flags
& EF_MIPS_NOREORDER
)
2136 strcat (buf
, ", noreorder");
2138 if (e_flags
& EF_MIPS_PIC
)
2139 strcat (buf
, ", pic");
2141 if (e_flags
& EF_MIPS_CPIC
)
2142 strcat (buf
, ", cpic");
2144 if (e_flags
& EF_MIPS_UCODE
)
2145 strcat (buf
, ", ugen_reserved");
2147 if (e_flags
& EF_MIPS_ABI2
)
2148 strcat (buf
, ", abi2");
2150 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2151 strcat (buf
, ", odk first");
2153 if (e_flags
& EF_MIPS_32BITMODE
)
2154 strcat (buf
, ", 32bitmode");
2156 switch ((e_flags
& EF_MIPS_MACH
))
2158 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2159 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2160 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2161 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2162 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2163 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2164 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2165 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2166 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2167 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2169 /* We simply ignore the field in this case to avoid confusion:
2170 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2173 default: strcat (buf
, ", unknown CPU"); break;
2176 switch ((e_flags
& EF_MIPS_ABI
))
2178 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2179 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2180 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2181 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2183 /* We simply ignore the field in this case to avoid confusion:
2184 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2185 This means it is likely to be an o32 file, but not for
2188 default: strcat (buf
, ", unknown ABI"); break;
2191 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2192 strcat (buf
, ", mdmx");
2194 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2195 strcat (buf
, ", mips16");
2197 switch ((e_flags
& EF_MIPS_ARCH
))
2199 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2200 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2201 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2202 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2203 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2204 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2205 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2206 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2207 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2208 default: strcat (buf
, ", unknown ISA"); break;
2214 switch ((e_flags
& EF_SH_MACH_MASK
))
2216 case EF_SH1
: strcat (buf
, ", sh1"); break;
2217 case EF_SH2
: strcat (buf
, ", sh2"); break;
2218 case EF_SH3
: strcat (buf
, ", sh3"); break;
2219 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2220 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2221 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2222 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2223 case EF_SH4
: strcat (buf
, ", sh4"); break;
2224 case EF_SH5
: strcat (buf
, ", sh5"); break;
2225 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2226 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2227 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2228 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2229 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2230 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2231 default: strcat (buf
, ", unknown ISA"); break;
2237 if (e_flags
& EF_SPARC_32PLUS
)
2238 strcat (buf
, ", v8+");
2240 if (e_flags
& EF_SPARC_SUN_US1
)
2241 strcat (buf
, ", ultrasparcI");
2243 if (e_flags
& EF_SPARC_SUN_US3
)
2244 strcat (buf
, ", ultrasparcIII");
2246 if (e_flags
& EF_SPARC_HAL_R1
)
2247 strcat (buf
, ", halr1");
2249 if (e_flags
& EF_SPARC_LEDATA
)
2250 strcat (buf
, ", ledata");
2252 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2253 strcat (buf
, ", tso");
2255 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2256 strcat (buf
, ", pso");
2258 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2259 strcat (buf
, ", rmo");
2263 switch (e_flags
& EF_PARISC_ARCH
)
2265 case EFA_PARISC_1_0
:
2266 strcpy (buf
, ", PA-RISC 1.0");
2268 case EFA_PARISC_1_1
:
2269 strcpy (buf
, ", PA-RISC 1.1");
2271 case EFA_PARISC_2_0
:
2272 strcpy (buf
, ", PA-RISC 2.0");
2277 if (e_flags
& EF_PARISC_TRAPNIL
)
2278 strcat (buf
, ", trapnil");
2279 if (e_flags
& EF_PARISC_EXT
)
2280 strcat (buf
, ", ext");
2281 if (e_flags
& EF_PARISC_LSB
)
2282 strcat (buf
, ", lsb");
2283 if (e_flags
& EF_PARISC_WIDE
)
2284 strcat (buf
, ", wide");
2285 if (e_flags
& EF_PARISC_NO_KABP
)
2286 strcat (buf
, ", no kabp");
2287 if (e_flags
& EF_PARISC_LAZYSWAP
)
2288 strcat (buf
, ", lazyswap");
2293 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2294 strcat (buf
, ", new calling convention");
2296 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2297 strcat (buf
, ", gnu calling convention");
2301 if ((e_flags
& EF_IA_64_ABI64
))
2302 strcat (buf
, ", 64-bit");
2304 strcat (buf
, ", 32-bit");
2305 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2306 strcat (buf
, ", reduced fp model");
2307 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2308 strcat (buf
, ", no function descriptors, constant gp");
2309 else if ((e_flags
& EF_IA_64_CONS_GP
))
2310 strcat (buf
, ", constant gp");
2311 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2312 strcat (buf
, ", absolute");
2316 if ((e_flags
& EF_VAX_NONPIC
))
2317 strcat (buf
, ", non-PIC");
2318 if ((e_flags
& EF_VAX_DFLOAT
))
2319 strcat (buf
, ", D-Float");
2320 if ((e_flags
& EF_VAX_GFLOAT
))
2321 strcat (buf
, ", G-Float");
2330 get_osabi_name (unsigned int osabi
)
2332 static char buff
[32];
2336 case ELFOSABI_NONE
: return "UNIX - System V";
2337 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2338 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2339 case ELFOSABI_LINUX
: return "UNIX - Linux";
2340 case ELFOSABI_HURD
: return "GNU/Hurd";
2341 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2342 case ELFOSABI_AIX
: return "UNIX - AIX";
2343 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2344 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2345 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2346 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2347 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2348 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2349 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2350 case ELFOSABI_AROS
: return "Amiga Research OS";
2351 case ELFOSABI_STANDALONE
: return _("Standalone App");
2352 case ELFOSABI_ARM
: return "ARM";
2354 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2360 get_arm_segment_type (unsigned long type
)
2374 get_mips_segment_type (unsigned long type
)
2378 case PT_MIPS_REGINFO
:
2380 case PT_MIPS_RTPROC
:
2382 case PT_MIPS_OPTIONS
:
2392 get_parisc_segment_type (unsigned long type
)
2396 case PT_HP_TLS
: return "HP_TLS";
2397 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2398 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2399 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2400 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2401 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2402 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2403 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2404 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2405 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2406 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2407 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2408 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2409 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2410 case PT_HP_STACK
: return "HP_STACK";
2411 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2412 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2413 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2414 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2423 get_ia64_segment_type (unsigned long type
)
2427 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2428 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2429 case PT_HP_TLS
: return "HP_TLS";
2430 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2431 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2432 case PT_IA_64_HP_STACK
: return "HP_STACK";
2441 get_segment_type (unsigned long p_type
)
2443 static char buff
[32];
2447 case PT_NULL
: return "NULL";
2448 case PT_LOAD
: return "LOAD";
2449 case PT_DYNAMIC
: return "DYNAMIC";
2450 case PT_INTERP
: return "INTERP";
2451 case PT_NOTE
: return "NOTE";
2452 case PT_SHLIB
: return "SHLIB";
2453 case PT_PHDR
: return "PHDR";
2454 case PT_TLS
: return "TLS";
2456 case PT_GNU_EH_FRAME
:
2457 return "GNU_EH_FRAME";
2458 case PT_GNU_STACK
: return "GNU_STACK";
2459 case PT_GNU_RELRO
: return "GNU_RELRO";
2462 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2466 switch (elf_header
.e_machine
)
2469 result
= get_arm_segment_type (p_type
);
2472 case EM_MIPS_RS3_LE
:
2473 result
= get_mips_segment_type (p_type
);
2476 result
= get_parisc_segment_type (p_type
);
2479 result
= get_ia64_segment_type (p_type
);
2489 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2491 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2495 switch (elf_header
.e_machine
)
2498 result
= get_parisc_segment_type (p_type
);
2501 result
= get_ia64_segment_type (p_type
);
2511 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2514 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2521 get_mips_section_type_name (unsigned int sh_type
)
2525 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2526 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2527 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2528 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2529 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2530 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2531 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2532 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2533 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2534 case SHT_MIPS_RELD
: return "MIPS_RELD";
2535 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2536 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2537 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2538 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2539 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2540 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2541 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2542 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2543 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2544 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2545 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2546 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2547 case SHT_MIPS_LINE
: return "MIPS_LINE";
2548 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2549 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2550 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2551 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2552 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2553 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2554 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2555 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2556 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2557 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2558 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2559 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2560 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2561 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2562 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2563 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2571 get_parisc_section_type_name (unsigned int sh_type
)
2575 case SHT_PARISC_EXT
: return "PARISC_EXT";
2576 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2577 case SHT_PARISC_DOC
: return "PARISC_DOC";
2578 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
2579 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
2580 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
2581 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
2589 get_ia64_section_type_name (unsigned int sh_type
)
2591 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2592 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2593 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2597 case SHT_IA_64_EXT
: return "IA_64_EXT";
2598 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2599 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2607 get_x86_64_section_type_name (unsigned int sh_type
)
2611 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2619 get_arm_section_type_name (unsigned int sh_type
)
2632 get_section_type_name (unsigned int sh_type
)
2634 static char buff
[32];
2638 case SHT_NULL
: return "NULL";
2639 case SHT_PROGBITS
: return "PROGBITS";
2640 case SHT_SYMTAB
: return "SYMTAB";
2641 case SHT_STRTAB
: return "STRTAB";
2642 case SHT_RELA
: return "RELA";
2643 case SHT_HASH
: return "HASH";
2644 case SHT_DYNAMIC
: return "DYNAMIC";
2645 case SHT_NOTE
: return "NOTE";
2646 case SHT_NOBITS
: return "NOBITS";
2647 case SHT_REL
: return "REL";
2648 case SHT_SHLIB
: return "SHLIB";
2649 case SHT_DYNSYM
: return "DYNSYM";
2650 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2651 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2652 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2653 case SHT_GROUP
: return "GROUP";
2654 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2655 case SHT_GNU_verdef
: return "VERDEF";
2656 case SHT_GNU_verneed
: return "VERNEED";
2657 case SHT_GNU_versym
: return "VERSYM";
2658 case 0x6ffffff0: return "VERSYM";
2659 case 0x6ffffffc: return "VERDEF";
2660 case 0x7ffffffd: return "AUXILIARY";
2661 case 0x7fffffff: return "FILTER";
2662 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2665 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2669 switch (elf_header
.e_machine
)
2672 case EM_MIPS_RS3_LE
:
2673 result
= get_mips_section_type_name (sh_type
);
2676 result
= get_parisc_section_type_name (sh_type
);
2679 result
= get_ia64_section_type_name (sh_type
);
2682 result
= get_x86_64_section_type_name (sh_type
);
2685 result
= get_arm_section_type_name (sh_type
);
2695 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2697 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2698 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2699 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2700 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2702 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
2708 #define OPTION_DEBUG_DUMP 512
2710 static struct option options
[] =
2712 {"all", no_argument
, 0, 'a'},
2713 {"file-header", no_argument
, 0, 'h'},
2714 {"program-headers", no_argument
, 0, 'l'},
2715 {"headers", no_argument
, 0, 'e'},
2716 {"histogram", no_argument
, 0, 'I'},
2717 {"segments", no_argument
, 0, 'l'},
2718 {"sections", no_argument
, 0, 'S'},
2719 {"section-headers", no_argument
, 0, 'S'},
2720 {"section-groups", no_argument
, 0, 'g'},
2721 {"section-details", no_argument
, 0, 't'},
2722 {"full-section-name",no_argument
, 0, 'N'},
2723 {"symbols", no_argument
, 0, 's'},
2724 {"syms", no_argument
, 0, 's'},
2725 {"relocs", no_argument
, 0, 'r'},
2726 {"notes", no_argument
, 0, 'n'},
2727 {"dynamic", no_argument
, 0, 'd'},
2728 {"arch-specific", no_argument
, 0, 'A'},
2729 {"version-info", no_argument
, 0, 'V'},
2730 {"use-dynamic", no_argument
, 0, 'D'},
2731 {"hex-dump", required_argument
, 0, 'x'},
2732 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2733 {"unwind", no_argument
, 0, 'u'},
2734 #ifdef SUPPORT_DISASSEMBLY
2735 {"instruction-dump", required_argument
, 0, 'i'},
2738 {"version", no_argument
, 0, 'v'},
2739 {"wide", no_argument
, 0, 'W'},
2740 {"help", no_argument
, 0, 'H'},
2741 {0, no_argument
, 0, 0}
2747 fprintf (stdout
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2748 fprintf (stdout
, _(" Display information about the contents of ELF format files\n"));
2749 fprintf (stdout
, _(" Options are:\n\
2750 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2751 -h --file-header Display the ELF file header\n\
2752 -l --program-headers Display the program headers\n\
2753 --segments An alias for --program-headers\n\
2754 -S --section-headers Display the sections' header\n\
2755 --sections An alias for --section-headers\n\
2756 -g --section-groups Display the section groups\n\
2757 -t --section-details Display the section details\n\
2758 -e --headers Equivalent to: -h -l -S\n\
2759 -s --syms Display the symbol table\n\
2760 --symbols An alias for --syms\n\
2761 -n --notes Display the core notes (if present)\n\
2762 -r --relocs Display the relocations (if present)\n\
2763 -u --unwind Display the unwind info (if present)\n\
2764 -d --dynamic Display the dynamic section (if present)\n\
2765 -V --version-info Display the version sections (if present)\n\
2766 -A --arch-specific Display architecture specific information (if any).\n\
2767 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2768 -x --hex-dump=<number> Dump the contents of section <number>\n\
2769 -w[liaprmfFsoR] or\n\
2770 --debug-dump[=line,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
2771 Display the contents of DWARF2 debug sections\n"));
2772 #ifdef SUPPORT_DISASSEMBLY
2773 fprintf (stdout
, _("\
2774 -i --instruction-dump=<number>\n\
2775 Disassemble the contents of section <number>\n"));
2777 fprintf (stdout
, _("\
2778 -I --histogram Display histogram of bucket list lengths\n\
2779 -W --wide Allow output width to exceed 80 characters\n\
2780 -H --help Display this information\n\
2781 -v --version Display the version number of readelf\n"));
2782 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2787 /* Record the fact that the user wants the contents of section number
2788 SECTION to be displayed using the method(s) encoded as flags bits
2789 in TYPE. Note, TYPE can be zero if we are creating the array for
2793 request_dump (unsigned int section
, int type
)
2795 if (section
>= num_dump_sects
)
2797 char *new_dump_sects
;
2799 new_dump_sects
= calloc (section
+ 1, 1);
2801 if (new_dump_sects
== NULL
)
2802 error (_("Out of memory allocating dump request table."));
2805 /* Copy current flag settings. */
2806 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2810 dump_sects
= new_dump_sects
;
2811 num_dump_sects
= section
+ 1;
2816 dump_sects
[section
] |= type
;
2822 parse_args (int argc
, char **argv
)
2829 while ((c
= getopt_long
2830 (argc
, argv
, "ersuahnldSDAINtgw::x:i:vVWH", options
, NULL
)) != EOF
)
2851 do_section_groups
++;
2859 do_section_groups
++;
2864 do_section_details
++;
2906 section
= strtoul (optarg
, & cp
, 0);
2907 if (! *cp
&& section
>= 0)
2909 request_dump (section
, HEX_DUMP
);
2919 unsigned int index
= 0;
2923 while (optarg
[index
])
2924 switch (optarg
[index
++])
2933 do_debug_abbrevs
= 1;
2943 do_debug_pubnames
= 1;
2947 do_debug_aranges
= 1;
2951 do_debug_ranges
= 1;
2955 do_debug_frames_interp
= 1;
2957 do_debug_frames
= 1;
2962 do_debug_macinfo
= 1;
2976 warn (_("Unrecognized debug option '%s'\n"), optarg
);
2981 case OPTION_DEBUG_DUMP
:
2989 const char * option
;
2992 debug_dump_long_opts
;
2994 debug_dump_long_opts opts_table
[] =
2996 /* Please keep this table alpha- sorted. */
2997 { "Ranges", & do_debug_ranges
},
2998 { "abbrev", & do_debug_abbrevs
},
2999 { "aranges", & do_debug_aranges
},
3000 { "frames", & do_debug_frames
},
3001 { "frames-interp", & do_debug_frames_interp
},
3002 { "info", & do_debug_info
},
3003 { "line", & do_debug_lines
},
3004 { "loc", & do_debug_loc
},
3005 { "macro", & do_debug_macinfo
},
3006 { "pubnames", & do_debug_pubnames
},
3007 /* This entry is for compatability
3008 with earlier versions of readelf. */
3009 { "ranges", & do_debug_aranges
},
3010 { "str", & do_debug_str
},
3021 debug_dump_long_opts
* entry
;
3023 for (entry
= opts_table
; entry
->option
; entry
++)
3025 size_t len
= strlen (entry
->option
);
3027 if (strneq (p
, entry
->option
, len
)
3028 && (p
[len
] == ',' || p
[len
] == '\0'))
3030 * entry
->variable
= 1;
3032 /* The --debug-dump=frames-interp option also
3033 enables the --debug-dump=frames option. */
3034 if (do_debug_frames_interp
)
3035 do_debug_frames
= 1;
3042 if (entry
->option
== NULL
)
3044 warn (_("Unrecognized debug option '%s'\n"), p
);
3045 p
= strchr (p
, ',');
3055 #ifdef SUPPORT_DISASSEMBLY
3058 section
= strtoul (optarg
, & cp
, 0);
3059 if (! *cp
&& section
>= 0)
3061 request_dump (section
, DISASS_DUMP
);
3067 print_version (program_name
);
3077 /* xgettext:c-format */
3078 error (_("Invalid option '-%c'\n"), c
);
3085 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3086 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3087 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3088 && !do_section_groups
)
3092 warn (_("Nothing to do.\n"));
3098 get_elf_class (unsigned int elf_class
)
3100 static char buff
[32];
3104 case ELFCLASSNONE
: return _("none");
3105 case ELFCLASS32
: return "ELF32";
3106 case ELFCLASS64
: return "ELF64";
3108 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3114 get_data_encoding (unsigned int encoding
)
3116 static char buff
[32];
3120 case ELFDATANONE
: return _("none");
3121 case ELFDATA2LSB
: return _("2's complement, little endian");
3122 case ELFDATA2MSB
: return _("2's complement, big endian");
3124 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3129 /* Decode the data held in 'elf_header'. */
3132 process_file_header (void)
3134 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3135 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3136 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3137 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3140 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3148 printf (_("ELF Header:\n"));
3149 printf (_(" Magic: "));
3150 for (i
= 0; i
< EI_NIDENT
; i
++)
3151 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3153 printf (_(" Class: %s\n"),
3154 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3155 printf (_(" Data: %s\n"),
3156 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3157 printf (_(" Version: %d %s\n"),
3158 elf_header
.e_ident
[EI_VERSION
],
3159 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3161 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3164 printf (_(" OS/ABI: %s\n"),
3165 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3166 printf (_(" ABI Version: %d\n"),
3167 elf_header
.e_ident
[EI_ABIVERSION
]);
3168 printf (_(" Type: %s\n"),
3169 get_file_type (elf_header
.e_type
));
3170 printf (_(" Machine: %s\n"),
3171 get_machine_name (elf_header
.e_machine
));
3172 printf (_(" Version: 0x%lx\n"),
3173 (unsigned long) elf_header
.e_version
);
3175 printf (_(" Entry point address: "));
3176 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3177 printf (_("\n Start of program headers: "));
3178 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3179 printf (_(" (bytes into file)\n Start of section headers: "));
3180 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3181 printf (_(" (bytes into file)\n"));
3183 printf (_(" Flags: 0x%lx%s\n"),
3184 (unsigned long) elf_header
.e_flags
,
3185 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3186 printf (_(" Size of this header: %ld (bytes)\n"),
3187 (long) elf_header
.e_ehsize
);
3188 printf (_(" Size of program headers: %ld (bytes)\n"),
3189 (long) elf_header
.e_phentsize
);
3190 printf (_(" Number of program headers: %ld\n"),
3191 (long) elf_header
.e_phnum
);
3192 printf (_(" Size of section headers: %ld (bytes)\n"),
3193 (long) elf_header
.e_shentsize
);
3194 printf (_(" Number of section headers: %ld"),
3195 (long) elf_header
.e_shnum
);
3196 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
3197 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3198 putc ('\n', stdout
);
3199 printf (_(" Section header string table index: %ld"),
3200 (long) elf_header
.e_shstrndx
);
3201 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
3202 printf (" (%ld)", (long) section_headers
[0].sh_link
);
3203 putc ('\n', stdout
);
3206 if (section_headers
!= NULL
)
3208 if (elf_header
.e_shnum
== 0)
3209 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3210 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
3211 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3212 free (section_headers
);
3213 section_headers
= NULL
;
3221 get_32bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3223 Elf32_External_Phdr
*phdrs
;
3224 Elf32_External_Phdr
*external
;
3225 Elf_Internal_Phdr
*internal
;
3228 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3229 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3230 _("program headers"));
3234 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3235 i
< elf_header
.e_phnum
;
3236 i
++, internal
++, external
++)
3238 internal
->p_type
= BYTE_GET (external
->p_type
);
3239 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3240 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3241 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3242 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3243 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3244 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3245 internal
->p_align
= BYTE_GET (external
->p_align
);
3254 get_64bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3256 Elf64_External_Phdr
*phdrs
;
3257 Elf64_External_Phdr
*external
;
3258 Elf_Internal_Phdr
*internal
;
3261 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3262 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3263 _("program headers"));
3267 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3268 i
< elf_header
.e_phnum
;
3269 i
++, internal
++, external
++)
3271 internal
->p_type
= BYTE_GET (external
->p_type
);
3272 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3273 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3274 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3275 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3276 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3277 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3278 internal
->p_align
= BYTE_GET (external
->p_align
);
3286 /* Returns 1 if the program headers were read into `program_headers'. */
3289 get_program_headers (FILE *file
)
3291 Elf_Internal_Phdr
*phdrs
;
3293 /* Check cache of prior read. */
3294 if (program_headers
!= NULL
)
3297 phdrs
= cmalloc (elf_header
.e_phnum
, sizeof (Elf_Internal_Phdr
));
3301 error (_("Out of memory\n"));
3306 ? get_32bit_program_headers (file
, phdrs
)
3307 : get_64bit_program_headers (file
, phdrs
))
3309 program_headers
= phdrs
;
3317 /* Returns 1 if the program headers were loaded. */
3320 process_program_headers (FILE *file
)
3322 Elf_Internal_Phdr
*segment
;
3325 if (elf_header
.e_phnum
== 0)
3328 printf (_("\nThere are no program headers in this file.\n"));
3332 if (do_segments
&& !do_header
)
3334 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3335 printf (_("Entry point "));
3336 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3337 printf (_("\nThere are %d program headers, starting at offset "),
3338 elf_header
.e_phnum
);
3339 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3343 if (! get_program_headers (file
))
3348 if (elf_header
.e_phnum
> 1)
3349 printf (_("\nProgram Headers:\n"));
3351 printf (_("\nProgram Headers:\n"));
3355 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3358 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3362 (_(" Type Offset VirtAddr PhysAddr\n"));
3364 (_(" FileSiz MemSiz Flags Align\n"));
3371 for (i
= 0, segment
= program_headers
;
3372 i
< elf_header
.e_phnum
;
3377 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3381 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3382 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3383 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3384 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3385 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3387 (segment
->p_flags
& PF_R
? 'R' : ' '),
3388 (segment
->p_flags
& PF_W
? 'W' : ' '),
3389 (segment
->p_flags
& PF_X
? 'E' : ' '));
3390 printf ("%#lx", (unsigned long) segment
->p_align
);
3394 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3395 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3398 print_vma (segment
->p_offset
, FULL_HEX
);
3402 print_vma (segment
->p_vaddr
, FULL_HEX
);
3404 print_vma (segment
->p_paddr
, FULL_HEX
);
3407 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3408 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3411 print_vma (segment
->p_filesz
, FULL_HEX
);
3415 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3416 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3419 print_vma (segment
->p_offset
, FULL_HEX
);
3423 (segment
->p_flags
& PF_R
? 'R' : ' '),
3424 (segment
->p_flags
& PF_W
? 'W' : ' '),
3425 (segment
->p_flags
& PF_X
? 'E' : ' '));
3427 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3428 printf ("%#lx", (unsigned long) segment
->p_align
);
3431 print_vma (segment
->p_align
, PREFIX_HEX
);
3436 print_vma (segment
->p_offset
, FULL_HEX
);
3438 print_vma (segment
->p_vaddr
, FULL_HEX
);
3440 print_vma (segment
->p_paddr
, FULL_HEX
);
3442 print_vma (segment
->p_filesz
, FULL_HEX
);
3444 print_vma (segment
->p_memsz
, FULL_HEX
);
3446 (segment
->p_flags
& PF_R
? 'R' : ' '),
3447 (segment
->p_flags
& PF_W
? 'W' : ' '),
3448 (segment
->p_flags
& PF_X
? 'E' : ' '));
3449 print_vma (segment
->p_align
, HEX
);
3453 switch (segment
->p_type
)
3457 error (_("more than one dynamic segment\n"));
3459 /* Try to locate the .dynamic section. If there is
3460 a section header table, we can easily locate it. */
3461 if (section_headers
!= NULL
)
3463 Elf_Internal_Shdr
*sec
;
3465 sec
= find_section (".dynamic");
3466 if (sec
== NULL
|| sec
->sh_size
== 0)
3468 error (_("no .dynamic section in the dynamic segment"));
3472 dynamic_addr
= sec
->sh_offset
;
3473 dynamic_size
= sec
->sh_size
;
3475 if (dynamic_addr
< segment
->p_offset
3476 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3477 warn (_("the .dynamic section is not contained within the dynamic segment"));
3478 else if (dynamic_addr
> segment
->p_offset
)
3479 warn (_("the .dynamic section is not the first section in the dynamic segment."));
3483 /* Otherwise, we can only assume that the .dynamic
3484 section is the first section in the DYNAMIC segment. */
3485 dynamic_addr
= segment
->p_offset
;
3486 dynamic_size
= segment
->p_filesz
;
3491 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3493 error (_("Unable to find program interpreter name\n"));
3496 program_interpreter
[0] = 0;
3497 fscanf (file
, "%63s", program_interpreter
);
3500 printf (_("\n [Requesting program interpreter: %s]"),
3501 program_interpreter
);
3507 putc ('\n', stdout
);
3510 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3512 printf (_("\n Section to Segment mapping:\n"));
3513 printf (_(" Segment Sections...\n"));
3515 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3518 Elf_Internal_Shdr
*section
;
3520 segment
= program_headers
+ i
;
3521 section
= section_headers
;
3523 printf (" %2.2d ", i
);
3525 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3527 if (section
->sh_size
> 0
3528 /* Compare allocated sections by VMA, unallocated
3529 sections by file offset. */
3530 && (section
->sh_flags
& SHF_ALLOC
3531 ? (section
->sh_addr
>= segment
->p_vaddr
3532 && section
->sh_addr
+ section
->sh_size
3533 <= segment
->p_vaddr
+ segment
->p_memsz
)
3534 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
3535 && (section
->sh_offset
+ section
->sh_size
3536 <= segment
->p_offset
+ segment
->p_filesz
)))
3537 /* .tbss is special. It doesn't contribute memory space
3538 to normal segments. */
3539 && (!((section
->sh_flags
& SHF_TLS
) != 0
3540 && section
->sh_type
== SHT_NOBITS
)
3541 || segment
->p_type
== PT_TLS
))
3542 printf ("%s ", SECTION_NAME (section
));
3553 /* Find the file offset corresponding to VMA by using the program headers. */
3556 offset_from_vma (FILE *file
, bfd_vma vma
, bfd_size_type size
)
3558 Elf_Internal_Phdr
*seg
;
3560 if (! get_program_headers (file
))
3562 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3566 for (seg
= program_headers
;
3567 seg
< program_headers
+ elf_header
.e_phnum
;
3570 if (seg
->p_type
!= PT_LOAD
)
3573 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3574 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3575 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3578 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3585 get_32bit_section_headers (FILE *file
, unsigned int num
)
3587 Elf32_External_Shdr
*shdrs
;
3588 Elf_Internal_Shdr
*internal
;
3591 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3592 elf_header
.e_shentsize
, num
, _("section headers"));
3596 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3598 if (section_headers
== NULL
)
3600 error (_("Out of memory\n"));
3604 for (i
= 0, internal
= section_headers
;
3608 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3609 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3610 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3611 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3612 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3613 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3614 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3615 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3616 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3617 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3626 get_64bit_section_headers (FILE *file
, unsigned int num
)
3628 Elf64_External_Shdr
*shdrs
;
3629 Elf_Internal_Shdr
*internal
;
3632 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3633 elf_header
.e_shentsize
, num
, _("section headers"));
3637 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3639 if (section_headers
== NULL
)
3641 error (_("Out of memory\n"));
3645 for (i
= 0, internal
= section_headers
;
3649 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3650 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3651 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3652 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3653 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3654 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3655 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3656 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3657 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3658 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3666 static Elf_Internal_Sym
*
3667 get_32bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3669 unsigned long number
;
3670 Elf32_External_Sym
*esyms
;
3671 Elf_External_Sym_Shndx
*shndx
;
3672 Elf_Internal_Sym
*isyms
;
3673 Elf_Internal_Sym
*psym
;
3676 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3682 if (symtab_shndx_hdr
!= NULL
3683 && (symtab_shndx_hdr
->sh_link
3684 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3686 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3687 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3695 number
= section
->sh_size
/ section
->sh_entsize
;
3696 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3700 error (_("Out of memory\n"));
3707 for (j
= 0, psym
= isyms
;
3711 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3712 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3713 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3714 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3715 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3717 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3718 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3719 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3729 static Elf_Internal_Sym
*
3730 get_64bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3732 unsigned long number
;
3733 Elf64_External_Sym
*esyms
;
3734 Elf_External_Sym_Shndx
*shndx
;
3735 Elf_Internal_Sym
*isyms
;
3736 Elf_Internal_Sym
*psym
;
3739 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3745 if (symtab_shndx_hdr
!= NULL
3746 && (symtab_shndx_hdr
->sh_link
3747 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3749 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3750 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3758 number
= section
->sh_size
/ section
->sh_entsize
;
3759 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3763 error (_("Out of memory\n"));
3770 for (j
= 0, psym
= isyms
;
3774 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3775 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3776 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3777 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3778 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3780 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3781 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3782 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3793 get_elf_section_flags (bfd_vma sh_flags
)
3795 static char buff
[1024];
3797 int field_size
= is_32bit_elf
? 8 : 16;
3798 int index
, size
= sizeof (buff
) - (field_size
+ 4 + 1);
3799 bfd_vma os_flags
= 0;
3800 bfd_vma proc_flags
= 0;
3801 bfd_vma unknown_flags
= 0;
3815 { "LINK ORDER", 10 },
3816 { "OS NONCONF", 10 },
3821 if (do_section_details
)
3823 sprintf (buff
, "[%*.*lx]: ",
3824 field_size
, field_size
, (unsigned long) sh_flags
);
3825 p
+= field_size
+ 4;
3832 flag
= sh_flags
& - sh_flags
;
3835 if (do_section_details
)
3839 case SHF_WRITE
: index
= 0; break;
3840 case SHF_ALLOC
: index
= 1; break;
3841 case SHF_EXECINSTR
: index
= 2; break;
3842 case SHF_MERGE
: index
= 3; break;
3843 case SHF_STRINGS
: index
= 4; break;
3844 case SHF_INFO_LINK
: index
= 5; break;
3845 case SHF_LINK_ORDER
: index
= 6; break;
3846 case SHF_OS_NONCONFORMING
: index
= 7; break;
3847 case SHF_GROUP
: index
= 8; break;
3848 case SHF_TLS
: index
= 9; break;
3857 if (p
!= buff
+ field_size
+ 4)
3859 if (size
< (10 + 2))
3866 size
-= flags
[index
].len
;
3867 p
= stpcpy (p
, flags
[index
].str
);
3869 else if (flag
& SHF_MASKOS
)
3871 else if (flag
& SHF_MASKPROC
)
3874 unknown_flags
|= flag
;
3880 case SHF_WRITE
: *p
= 'W'; break;
3881 case SHF_ALLOC
: *p
= 'A'; break;
3882 case SHF_EXECINSTR
: *p
= 'X'; break;
3883 case SHF_MERGE
: *p
= 'M'; break;
3884 case SHF_STRINGS
: *p
= 'S'; break;
3885 case SHF_INFO_LINK
: *p
= 'I'; break;
3886 case SHF_LINK_ORDER
: *p
= 'L'; break;
3887 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
3888 case SHF_GROUP
: *p
= 'G'; break;
3889 case SHF_TLS
: *p
= 'T'; break;
3892 if (elf_header
.e_machine
== EM_X86_64
3893 && flag
== SHF_X86_64_LARGE
)
3895 else if (flag
& SHF_MASKOS
)
3898 sh_flags
&= ~ SHF_MASKOS
;
3900 else if (flag
& SHF_MASKPROC
)
3903 sh_flags
&= ~ SHF_MASKPROC
;
3913 if (do_section_details
)
3917 size
-= 5 + field_size
;
3918 if (p
!= buff
+ field_size
+ 4)
3926 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
3927 (unsigned long) os_flags
);
3928 p
+= 5 + field_size
;
3932 size
-= 7 + field_size
;
3933 if (p
!= buff
+ field_size
+ 4)
3941 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
3942 (unsigned long) proc_flags
);
3943 p
+= 7 + field_size
;
3947 size
-= 10 + field_size
;
3948 if (p
!= buff
+ field_size
+ 4)
3956 sprintf (p
, "UNKNOWN (%*.*lx)", field_size
, field_size
,
3957 (unsigned long) unknown_flags
);
3958 p
+= 10 + field_size
;
3967 process_section_headers (FILE *file
)
3969 Elf_Internal_Shdr
*section
;
3972 section_headers
= NULL
;
3974 if (elf_header
.e_shnum
== 0)
3977 printf (_("\nThere are no sections in this file.\n"));
3982 if (do_sections
&& !do_header
)
3983 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3984 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
3988 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
3991 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
3994 /* Read in the string table, so that we have names to display. */
3995 if (SECTION_HEADER_INDEX (elf_header
.e_shstrndx
) < elf_header
.e_shnum
)
3997 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
3999 if (section
->sh_size
!= 0)
4001 string_table
= get_data (NULL
, file
, section
->sh_offset
,
4002 1, section
->sh_size
, _("string table"));
4004 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4008 /* Scan the sections for the dynamic symbol table
4009 and dynamic string table and debug sections. */
4010 dynamic_symbols
= NULL
;
4011 dynamic_strings
= NULL
;
4012 dynamic_syminfo
= NULL
;
4013 symtab_shndx_hdr
= NULL
;
4015 eh_addr_size
= is_32bit_elf
? 4 : 8;
4016 switch (elf_header
.e_machine
)
4019 case EM_MIPS_RS3_LE
:
4020 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4021 FDE addresses. However, the ABI also has a semi-official ILP32
4022 variant for which the normal FDE address size rules apply.
4024 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4025 section, where XX is the size of longs in bits. Unfortunately,
4026 earlier compilers provided no way of distinguishing ILP32 objects
4027 from LP64 objects, so if there's any doubt, we should assume that
4028 the official LP64 form is being used. */
4029 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
4030 && find_section (".gcc_compiled_long32") == NULL
)
4035 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4038 size_t expected_entsize \
4039 = is_32bit_elf ? size32 : size64; \
4040 if (section->sh_entsize != expected_entsize) \
4041 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4042 i, (unsigned long int) section->sh_entsize, \
4043 (unsigned long int) expected_entsize); \
4044 section->sh_entsize = expected_entsize; \
4047 #define CHECK_ENTSIZE(section, i, type) \
4048 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4049 sizeof (Elf64_External_##type))
4051 for (i
= 0, section
= section_headers
;
4052 i
< elf_header
.e_shnum
;
4055 char *name
= SECTION_NAME (section
);
4057 if (section
->sh_type
== SHT_DYNSYM
)
4059 if (dynamic_symbols
!= NULL
)
4061 error (_("File contains multiple dynamic symbol tables\n"));
4065 CHECK_ENTSIZE (section
, i
, Sym
);
4066 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
4067 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
4069 else if (section
->sh_type
== SHT_STRTAB
4070 && streq (name
, ".dynstr"))
4072 if (dynamic_strings
!= NULL
)
4074 error (_("File contains multiple dynamic string tables\n"));
4078 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
4079 1, section
->sh_size
, _("dynamic strings"));
4080 dynamic_strings_length
= section
->sh_size
;
4082 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4084 if (symtab_shndx_hdr
!= NULL
)
4086 error (_("File contains multiple symtab shndx tables\n"));
4089 symtab_shndx_hdr
= section
;
4091 else if (section
->sh_type
== SHT_SYMTAB
)
4092 CHECK_ENTSIZE (section
, i
, Sym
);
4093 else if (section
->sh_type
== SHT_GROUP
)
4094 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4095 else if (section
->sh_type
== SHT_REL
)
4096 CHECK_ENTSIZE (section
, i
, Rel
);
4097 else if (section
->sh_type
== SHT_RELA
)
4098 CHECK_ENTSIZE (section
, i
, Rela
);
4099 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4100 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
4101 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
4102 || do_debug_loc
|| do_debug_ranges
)
4103 && strneq (name
, ".debug_", 7))
4108 || (do_debug_info
&& streq (name
, "info"))
4109 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
4110 || (do_debug_lines
&& streq (name
, "line"))
4111 || (do_debug_pubnames
&& streq (name
, "pubnames"))
4112 || (do_debug_aranges
&& streq (name
, "aranges"))
4113 || (do_debug_ranges
&& streq (name
, "ranges"))
4114 || (do_debug_frames
&& streq (name
, "frame"))
4115 || (do_debug_macinfo
&& streq (name
, "macinfo"))
4116 || (do_debug_str
&& streq (name
, "str"))
4117 || (do_debug_loc
&& streq (name
, "loc"))
4119 request_dump (i
, DEBUG_DUMP
);
4121 /* linkonce section to be combined with .debug_info at link time. */
4122 else if ((do_debugging
|| do_debug_info
)
4123 && strneq (name
, ".gnu.linkonce.wi.", 17))
4124 request_dump (i
, DEBUG_DUMP
);
4125 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4126 request_dump (i
, DEBUG_DUMP
);
4132 if (elf_header
.e_shnum
> 1)
4133 printf (_("\nSection Headers:\n"));
4135 printf (_("\nSection Header:\n"));
4139 if (do_section_details
)
4141 printf (_(" [Nr] Name\n"));
4142 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4146 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4150 if (do_section_details
)
4152 printf (_(" [Nr] Name\n"));
4153 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4157 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4161 if (do_section_details
)
4163 printf (_(" [Nr] Name\n"));
4164 printf (_(" Type Address Offset Link\n"));
4165 printf (_(" Size EntSize Info Align\n"));
4169 printf (_(" [Nr] Name Type Address Offset\n"));
4170 printf (_(" Size EntSize Flags Link Info Align\n"));
4174 if (do_section_details
)
4175 printf (_(" Flags\n"));
4177 for (i
= 0, section
= section_headers
;
4178 i
< elf_header
.e_shnum
;
4181 if (do_section_details
)
4183 printf (" [%2u] %s\n",
4184 SECTION_HEADER_NUM (i
),
4185 SECTION_NAME (section
));
4186 if (is_32bit_elf
|| do_wide
)
4187 printf (" %-15.15s ",
4188 get_section_type_name (section
->sh_type
));
4191 printf (" [%2u] %-17.17s %-15.15s ",
4192 SECTION_HEADER_NUM (i
),
4193 SECTION_NAME (section
),
4194 get_section_type_name (section
->sh_type
));
4198 print_vma (section
->sh_addr
, LONG_HEX
);
4200 printf ( " %6.6lx %6.6lx %2.2lx",
4201 (unsigned long) section
->sh_offset
,
4202 (unsigned long) section
->sh_size
,
4203 (unsigned long) section
->sh_entsize
);
4205 if (do_section_details
)
4206 fputs (" ", stdout
);
4208 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4210 printf ("%2ld %3lu %2ld\n",
4211 (unsigned long) section
->sh_link
,
4212 (unsigned long) section
->sh_info
,
4213 (unsigned long) section
->sh_addralign
);
4217 print_vma (section
->sh_addr
, LONG_HEX
);
4219 if ((long) section
->sh_offset
== section
->sh_offset
)
4220 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4224 print_vma (section
->sh_offset
, LONG_HEX
);
4227 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4228 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4232 print_vma (section
->sh_size
, LONG_HEX
);
4235 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4236 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4240 print_vma (section
->sh_entsize
, LONG_HEX
);
4243 if (do_section_details
)
4244 fputs (" ", stdout
);
4246 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4248 printf ("%2ld %3lu ",
4249 (unsigned long) section
->sh_link
,
4250 (unsigned long) section
->sh_info
);
4252 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4253 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
4256 print_vma (section
->sh_addralign
, DEC
);
4260 else if (do_section_details
)
4262 printf (" %-15.15s ",
4263 get_section_type_name (section
->sh_type
));
4264 print_vma (section
->sh_addr
, LONG_HEX
);
4265 if ((long) section
->sh_offset
== section
->sh_offset
)
4266 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4270 print_vma (section
->sh_offset
, LONG_HEX
);
4272 printf (" %ld\n ", (unsigned long) section
->sh_link
);
4273 print_vma (section
->sh_size
, LONG_HEX
);
4275 print_vma (section
->sh_entsize
, LONG_HEX
);
4277 printf (" %-16lu %ld\n",
4278 (unsigned long) section
->sh_info
,
4279 (unsigned long) section
->sh_addralign
);
4284 print_vma (section
->sh_addr
, LONG_HEX
);
4285 if ((long) section
->sh_offset
== section
->sh_offset
)
4286 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4290 print_vma (section
->sh_offset
, LONG_HEX
);
4293 print_vma (section
->sh_size
, LONG_HEX
);
4295 print_vma (section
->sh_entsize
, LONG_HEX
);
4297 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4299 printf (" %2ld %3lu %ld\n",
4300 (unsigned long) section
->sh_link
,
4301 (unsigned long) section
->sh_info
,
4302 (unsigned long) section
->sh_addralign
);
4305 if (do_section_details
)
4306 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
4309 if (!do_section_details
)
4310 printf (_("Key to Flags:\n\
4311 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4312 I (info), L (link order), G (group), x (unknown)\n\
4313 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4319 get_group_flags (unsigned int flags
)
4321 static char buff
[32];
4328 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x]"), flags
);
4335 process_section_groups (FILE *file
)
4337 Elf_Internal_Shdr
*section
;
4339 struct group
*group
;
4340 Elf_Internal_Shdr
*symtab_sec
, *strtab_sec
;
4341 Elf_Internal_Sym
*symtab
;
4345 /* Don't process section groups unless needed. */
4346 if (!do_unwind
&& !do_section_groups
)
4349 if (elf_header
.e_shnum
== 0)
4351 if (do_section_groups
)
4352 printf (_("\nThere are no sections in this file.\n"));
4357 if (section_headers
== NULL
)
4359 error (_("Section headers are not available!\n"));
4363 section_headers_groups
= calloc (elf_header
.e_shnum
,
4364 sizeof (struct group
*));
4366 if (section_headers_groups
== NULL
)
4368 error (_("Out of memory\n"));
4372 /* Scan the sections for the group section. */
4374 for (i
= 0, section
= section_headers
;
4375 i
< elf_header
.e_shnum
;
4377 if (section
->sh_type
== SHT_GROUP
)
4380 if (group_count
== 0)
4382 if (do_section_groups
)
4383 printf (_("\nThere are no section groups in this file.\n"));
4388 section_groups
= calloc (group_count
, sizeof (struct group
));
4390 if (section_groups
== NULL
)
4392 error (_("Out of memory\n"));
4401 for (i
= 0, section
= section_headers
, group
= section_groups
;
4402 i
< elf_header
.e_shnum
;
4405 if (section
->sh_type
== SHT_GROUP
)
4407 char *name
= SECTION_NAME (section
);
4409 unsigned char *start
, *indices
;
4410 unsigned int entry
, j
, size
;
4411 Elf_Internal_Shdr
*sec
;
4412 Elf_Internal_Sym
*sym
;
4414 /* Get the symbol table. */
4415 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
4416 || ((sec
= SECTION_HEADER (section
->sh_link
))->sh_type
4419 error (_("Bad sh_link in group section `%s'\n"), name
);
4423 if (symtab_sec
!= sec
)
4428 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4431 sym
= symtab
+ section
->sh_info
;
4433 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4435 bfd_vma sec_index
= SECTION_HEADER_INDEX (sym
->st_shndx
);
4438 error (_("Bad sh_info in group section `%s'\n"), name
);
4442 group_name
= SECTION_NAME (section_headers
+ sec_index
);
4451 /* Get the string table. */
4452 if (SECTION_HEADER_INDEX (symtab_sec
->sh_link
)
4453 >= elf_header
.e_shnum
)
4462 != (sec
= SECTION_HEADER (symtab_sec
->sh_link
)))
4467 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
4468 1, strtab_sec
->sh_size
,
4470 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
4472 group_name
= sym
->st_name
< strtab_size
4473 ? strtab
+ sym
->st_name
: "<corrupt>";
4476 start
= get_data (NULL
, file
, section
->sh_offset
,
4477 1, section
->sh_size
, _("section data"));
4480 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4481 entry
= byte_get (indices
, 4);
4484 if (do_section_groups
)
4486 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4487 get_group_flags (entry
), i
, name
, group_name
, size
);
4489 printf (_(" [Index] Name\n"));
4492 group
->group_index
= i
;
4494 for (j
= 0; j
< size
; j
++)
4496 struct group_list
*g
;
4498 entry
= byte_get (indices
, 4);
4501 if (SECTION_HEADER_INDEX (entry
) >= elf_header
.e_shnum
)
4503 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4504 entry
, i
, elf_header
.e_shnum
- 1);
4507 else if (entry
>= SHN_LORESERVE
&& entry
<= SHN_HIRESERVE
)
4509 error (_("invalid section [%5u] in group section [%5u]\n"),
4514 if (section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4519 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4521 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4526 /* Intel C/C++ compiler may put section 0 in a
4527 section group. We just warn it the first time
4528 and ignore it afterwards. */
4529 static int warned
= 0;
4532 error (_("section 0 in group section [%5u]\n"),
4533 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4539 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4542 if (do_section_groups
)
4544 sec
= SECTION_HEADER (entry
);
4545 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
4548 g
= xmalloc (sizeof (struct group_list
));
4549 g
->section_index
= entry
;
4550 g
->next
= group
->root
;
4574 } dynamic_relocations
[] =
4576 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4577 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4578 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4581 /* Process the reloc section. */
4584 process_relocs (FILE *file
)
4586 unsigned long rel_size
;
4587 unsigned long rel_offset
;
4593 if (do_using_dynamic
)
4597 int has_dynamic_reloc
;
4600 has_dynamic_reloc
= 0;
4602 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4604 is_rela
= dynamic_relocations
[i
].rela
;
4605 name
= dynamic_relocations
[i
].name
;
4606 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4607 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4609 has_dynamic_reloc
|= rel_size
;
4611 if (is_rela
== UNKNOWN
)
4613 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4614 switch (dynamic_info
[DT_PLTREL
])
4628 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4629 name
, rel_offset
, rel_size
);
4631 dump_relocations (file
,
4632 offset_from_vma (file
, rel_offset
, rel_size
),
4634 dynamic_symbols
, num_dynamic_syms
,
4635 dynamic_strings
, dynamic_strings_length
, is_rela
);
4639 if (! has_dynamic_reloc
)
4640 printf (_("\nThere are no dynamic relocations in this file.\n"));
4644 Elf_Internal_Shdr
*section
;
4648 for (i
= 0, section
= section_headers
;
4649 i
< elf_header
.e_shnum
;
4652 if ( section
->sh_type
!= SHT_RELA
4653 && section
->sh_type
!= SHT_REL
)
4656 rel_offset
= section
->sh_offset
;
4657 rel_size
= section
->sh_size
;
4661 Elf_Internal_Shdr
*strsec
;
4664 printf (_("\nRelocation section "));
4666 if (string_table
== NULL
)
4667 printf ("%d", section
->sh_name
);
4669 printf (_("'%s'"), SECTION_NAME (section
));
4671 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4672 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4674 is_rela
= section
->sh_type
== SHT_RELA
;
4676 if (section
->sh_link
4677 && SECTION_HEADER_INDEX (section
->sh_link
)
4678 < elf_header
.e_shnum
)
4680 Elf_Internal_Shdr
*symsec
;
4681 Elf_Internal_Sym
*symtab
;
4682 unsigned long nsyms
;
4683 unsigned long strtablen
= 0;
4684 char *strtab
= NULL
;
4686 symsec
= SECTION_HEADER (section
->sh_link
);
4687 if (symsec
->sh_type
!= SHT_SYMTAB
4688 && symsec
->sh_type
!= SHT_DYNSYM
)
4691 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4692 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4697 if (SECTION_HEADER_INDEX (symsec
->sh_link
)
4698 < elf_header
.e_shnum
)
4700 strsec
= SECTION_HEADER (symsec
->sh_link
);
4702 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4705 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4708 dump_relocations (file
, rel_offset
, rel_size
,
4709 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4715 dump_relocations (file
, rel_offset
, rel_size
,
4716 NULL
, 0, NULL
, 0, is_rela
);
4723 printf (_("\nThere are no relocations in this file.\n"));
4729 /* Process the unwind section. */
4731 #include "unwind-ia64.h"
4733 /* An absolute address consists of a section and an offset. If the
4734 section is NULL, the offset itself is the address, otherwise, the
4735 address equals to LOAD_ADDRESS(section) + offset. */
4739 unsigned short section
;
4743 struct ia64_unw_aux_info
4745 struct ia64_unw_table_entry
4747 struct absaddr start
;
4749 struct absaddr info
;
4751 *table
; /* Unwind table. */
4752 unsigned long table_len
; /* Length of unwind table. */
4753 unsigned char *info
; /* Unwind info. */
4754 unsigned long info_size
; /* Size of unwind info. */
4755 bfd_vma info_addr
; /* starting address of unwind info. */
4756 bfd_vma seg_base
; /* Starting address of segment. */
4757 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4758 unsigned long nsyms
; /* Number of symbols. */
4759 char *strtab
; /* The string table. */
4760 unsigned long strtab_size
; /* Size of string table. */
4764 find_symbol_for_address (Elf_Internal_Sym
*symtab
,
4765 unsigned long nsyms
,
4767 unsigned long strtab_size
,
4768 struct absaddr addr
,
4769 const char **symname
,
4772 bfd_vma dist
= 0x100000;
4773 Elf_Internal_Sym
*sym
, *best
= NULL
;
4776 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
4778 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4779 && sym
->st_name
!= 0
4780 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4781 && addr
.offset
>= sym
->st_value
4782 && addr
.offset
- sym
->st_value
< dist
)
4785 dist
= addr
.offset
- sym
->st_value
;
4792 *symname
= (best
->st_name
>= strtab_size
4793 ? "<corrupt>" : strtab
+ best
->st_name
);
4798 *offset
= addr
.offset
;
4802 dump_ia64_unwind (struct ia64_unw_aux_info
*aux
)
4804 struct ia64_unw_table_entry
*tp
;
4807 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4811 const unsigned char *dp
;
4812 const unsigned char *head
;
4813 const char *procname
;
4815 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4816 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
4818 fputs ("\n<", stdout
);
4822 fputs (procname
, stdout
);
4825 printf ("+%lx", (unsigned long) offset
);
4828 fputs (">: [", stdout
);
4829 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4830 fputc ('-', stdout
);
4831 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4832 printf ("], info at +0x%lx\n",
4833 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4835 head
= aux
->info
+ (tp
->info
.offset
- aux
->info_addr
);
4836 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
4838 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4839 (unsigned) UNW_VER (stamp
),
4840 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4841 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4842 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4843 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
4845 if (UNW_VER (stamp
) != 1)
4847 printf ("\tUnknown version.\n");
4852 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
4853 dp
= unw_decode (dp
, in_body
, & in_body
);
4858 slurp_ia64_unwind_table (FILE *file
,
4859 struct ia64_unw_aux_info
*aux
,
4860 Elf_Internal_Shdr
*sec
)
4862 unsigned long size
, nrelas
, i
;
4863 Elf_Internal_Phdr
*seg
;
4864 struct ia64_unw_table_entry
*tep
;
4865 Elf_Internal_Shdr
*relsec
;
4866 Elf_Internal_Rela
*rela
, *rp
;
4867 unsigned char *table
, *tp
;
4868 Elf_Internal_Sym
*sym
;
4869 const char *relname
;
4871 /* First, find the starting address of the segment that includes
4874 if (elf_header
.e_phnum
)
4876 if (! get_program_headers (file
))
4879 for (seg
= program_headers
;
4880 seg
< program_headers
+ elf_header
.e_phnum
;
4883 if (seg
->p_type
!= PT_LOAD
)
4886 if (sec
->sh_addr
>= seg
->p_vaddr
4887 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4889 aux
->seg_base
= seg
->p_vaddr
;
4895 /* Second, build the unwind table from the contents of the unwind section: */
4896 size
= sec
->sh_size
;
4897 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
4901 aux
->table
= xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
4903 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * eh_addr_size
, ++tep
)
4905 tep
->start
.section
= SHN_UNDEF
;
4906 tep
->end
.section
= SHN_UNDEF
;
4907 tep
->info
.section
= SHN_UNDEF
;
4910 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4911 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4912 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
4916 tep
->start
.offset
= BYTE_GET ((unsigned char *) tp
+ 0);
4917 tep
->end
.offset
= BYTE_GET ((unsigned char *) tp
+ 8);
4918 tep
->info
.offset
= BYTE_GET ((unsigned char *) tp
+ 16);
4920 tep
->start
.offset
+= aux
->seg_base
;
4921 tep
->end
.offset
+= aux
->seg_base
;
4922 tep
->info
.offset
+= aux
->seg_base
;
4926 /* Third, apply any relocations to the unwind table: */
4928 for (relsec
= section_headers
;
4929 relsec
< section_headers
+ elf_header
.e_shnum
;
4932 if (relsec
->sh_type
!= SHT_RELA
4933 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
4934 || SECTION_HEADER (relsec
->sh_info
) != sec
)
4937 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
4941 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4945 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4946 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4950 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4951 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4954 if (! strneq (relname
, "R_IA64_SEGREL", 13))
4956 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4960 i
= rp
->r_offset
/ (3 * eh_addr_size
);
4962 switch (rp
->r_offset
/eh_addr_size
% 3)
4965 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4966 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
4969 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4970 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
4973 aux
->table
[i
].info
.section
= sym
->st_shndx
;
4974 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
4984 aux
->table_len
= size
/ (3 * eh_addr_size
);
4989 ia64_process_unwind (FILE *file
)
4991 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
4992 unsigned long i
, unwcount
= 0, unwstart
= 0;
4993 struct ia64_unw_aux_info aux
;
4995 memset (& aux
, 0, sizeof (aux
));
4997 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4999 if (sec
->sh_type
== SHT_SYMTAB
5000 && SECTION_HEADER_INDEX (sec
->sh_link
) < elf_header
.e_shnum
)
5002 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5003 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5005 strsec
= SECTION_HEADER (sec
->sh_link
);
5006 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5007 1, strsec
->sh_size
, _("string table"));
5008 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5010 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5015 printf (_("\nThere are no unwind sections in this file.\n"));
5017 while (unwcount
-- > 0)
5022 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
5023 i
< elf_header
.e_shnum
; ++i
, ++sec
)
5024 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5031 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
5033 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
5035 /* We need to find which section group it is in. */
5036 struct group_list
*g
= section_headers_groups
[i
]->root
;
5038 for (; g
!= NULL
; g
= g
->next
)
5040 sec
= SECTION_HEADER (g
->section_index
);
5042 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
5047 i
= elf_header
.e_shnum
;
5049 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
5051 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5052 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
5053 suffix
= SECTION_NAME (unwsec
) + len
;
5054 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5056 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
5057 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5062 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5063 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5064 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
5065 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
5067 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
5068 suffix
= SECTION_NAME (unwsec
) + len
;
5069 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5071 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
5072 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5076 if (i
== elf_header
.e_shnum
)
5078 printf (_("\nCould not find unwind info section for "));
5080 if (string_table
== NULL
)
5081 printf ("%d", unwsec
->sh_name
);
5083 printf (_("'%s'"), SECTION_NAME (unwsec
));
5087 aux
.info_size
= sec
->sh_size
;
5088 aux
.info_addr
= sec
->sh_addr
;
5089 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, 1, aux
.info_size
,
5092 printf (_("\nUnwind section "));
5094 if (string_table
== NULL
)
5095 printf ("%d", unwsec
->sh_name
);
5097 printf (_("'%s'"), SECTION_NAME (unwsec
));
5099 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5100 (unsigned long) unwsec
->sh_offset
,
5101 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
5103 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
5105 if (aux
.table_len
> 0)
5106 dump_ia64_unwind (& aux
);
5109 free ((char *) aux
.table
);
5111 free ((char *) aux
.info
);
5120 free ((char *) aux
.strtab
);
5125 struct hppa_unw_aux_info
5127 struct hppa_unw_table_entry
5129 struct absaddr start
;
5131 unsigned int Cannot_unwind
:1; /* 0 */
5132 unsigned int Millicode
:1; /* 1 */
5133 unsigned int Millicode_save_sr0
:1; /* 2 */
5134 unsigned int Region_description
:2; /* 3..4 */
5135 unsigned int reserved1
:1; /* 5 */
5136 unsigned int Entry_SR
:1; /* 6 */
5137 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
5138 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
5139 unsigned int Args_stored
:1; /* 16 */
5140 unsigned int Variable_Frame
:1; /* 17 */
5141 unsigned int Separate_Package_Body
:1; /* 18 */
5142 unsigned int Frame_Extension_Millicode
:1; /* 19 */
5143 unsigned int Stack_Overflow_Check
:1; /* 20 */
5144 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
5145 unsigned int Ada_Region
:1; /* 22 */
5146 unsigned int cxx_info
:1; /* 23 */
5147 unsigned int cxx_try_catch
:1; /* 24 */
5148 unsigned int sched_entry_seq
:1; /* 25 */
5149 unsigned int reserved2
:1; /* 26 */
5150 unsigned int Save_SP
:1; /* 27 */
5151 unsigned int Save_RP
:1; /* 28 */
5152 unsigned int Save_MRP_in_frame
:1; /* 29 */
5153 unsigned int extn_ptr_defined
:1; /* 30 */
5154 unsigned int Cleanup_defined
:1; /* 31 */
5156 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
5157 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
5158 unsigned int Large_frame
:1; /* 2 */
5159 unsigned int Pseudo_SP_Set
:1; /* 3 */
5160 unsigned int reserved4
:1; /* 4 */
5161 unsigned int Total_frame_size
:27; /* 5..31 */
5163 *table
; /* Unwind table. */
5164 unsigned long table_len
; /* Length of unwind table. */
5165 bfd_vma seg_base
; /* Starting address of segment. */
5166 Elf_Internal_Sym
*symtab
; /* The symbol table. */
5167 unsigned long nsyms
; /* Number of symbols. */
5168 char *strtab
; /* The string table. */
5169 unsigned long strtab_size
; /* Size of string table. */
5173 dump_hppa_unwind (struct hppa_unw_aux_info
*aux
)
5175 struct hppa_unw_table_entry
*tp
;
5177 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5180 const char *procname
;
5182 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5183 aux
->strtab_size
, tp
->start
, &procname
,
5186 fputs ("\n<", stdout
);
5190 fputs (procname
, stdout
);
5193 printf ("+%lx", (unsigned long) offset
);
5196 fputs (">: [", stdout
);
5197 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5198 fputc ('-', stdout
);
5199 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5202 #define PF(_m) if (tp->_m) printf (#_m " ");
5203 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5206 PF(Millicode_save_sr0
);
5207 /* PV(Region_description); */
5213 PF(Separate_Package_Body
);
5214 PF(Frame_Extension_Millicode
);
5215 PF(Stack_Overflow_Check
);
5216 PF(Two_Instruction_SP_Increment
);
5220 PF(sched_entry_seq
);
5223 PF(Save_MRP_in_frame
);
5224 PF(extn_ptr_defined
);
5225 PF(Cleanup_defined
);
5226 PF(MPE_XL_interrupt_marker
);
5227 PF(HP_UX_interrupt_marker
);
5230 PV(Total_frame_size
);
5239 slurp_hppa_unwind_table (FILE *file
,
5240 struct hppa_unw_aux_info
*aux
,
5241 Elf_Internal_Shdr
*sec
)
5243 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
5244 Elf_Internal_Phdr
*seg
;
5245 struct hppa_unw_table_entry
*tep
;
5246 Elf_Internal_Shdr
*relsec
;
5247 Elf_Internal_Rela
*rela
, *rp
;
5248 unsigned char *table
, *tp
;
5249 Elf_Internal_Sym
*sym
;
5250 const char *relname
;
5252 /* First, find the starting address of the segment that includes
5255 if (elf_header
.e_phnum
)
5257 if (! get_program_headers (file
))
5260 for (seg
= program_headers
;
5261 seg
< program_headers
+ elf_header
.e_phnum
;
5264 if (seg
->p_type
!= PT_LOAD
)
5267 if (sec
->sh_addr
>= seg
->p_vaddr
5268 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5270 aux
->seg_base
= seg
->p_vaddr
;
5276 /* Second, build the unwind table from the contents of the unwind
5278 size
= sec
->sh_size
;
5279 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
5284 nentries
= size
/ unw_ent_size
;
5285 size
= unw_ent_size
* nentries
;
5287 tep
= aux
->table
= xcmalloc (nentries
, sizeof (aux
->table
[0]));
5289 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
5291 unsigned int tmp1
, tmp2
;
5293 tep
->start
.section
= SHN_UNDEF
;
5294 tep
->end
.section
= SHN_UNDEF
;
5296 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5297 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5298 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
5299 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
5301 tep
->start
.offset
+= aux
->seg_base
;
5302 tep
->end
.offset
+= aux
->seg_base
;
5304 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
5305 tep
->Millicode
= (tmp1
>> 30) & 0x1;
5306 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
5307 tep
->Region_description
= (tmp1
>> 27) & 0x3;
5308 tep
->reserved1
= (tmp1
>> 26) & 0x1;
5309 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
5310 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
5311 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
5312 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
5313 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
5314 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
5315 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
5316 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
5317 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
5318 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
5319 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
5320 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
5321 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
5322 tep
->reserved2
= (tmp1
>> 5) & 0x1;
5323 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
5324 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
5325 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
5326 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
5327 tep
->Cleanup_defined
= tmp1
& 0x1;
5329 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5330 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5331 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5332 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5333 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5334 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5338 /* Third, apply any relocations to the unwind table. */
5340 for (relsec
= section_headers
;
5341 relsec
< section_headers
+ elf_header
.e_shnum
;
5344 if (relsec
->sh_type
!= SHT_RELA
5345 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
5346 || SECTION_HEADER (relsec
->sh_info
) != sec
)
5349 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5353 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5357 relname
= elf_hppa_reloc_type (ELF32_R_TYPE (rp
->r_info
));
5358 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
5362 relname
= elf_hppa_reloc_type (ELF64_R_TYPE (rp
->r_info
));
5363 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
5366 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5367 if (strncmp (relname
, "R_PARISC_SEGREL", 15) != 0)
5369 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5373 i
= rp
->r_offset
/ unw_ent_size
;
5375 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5378 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5379 aux
->table
[i
].start
.offset
+= sym
->st_value
+ rp
->r_addend
;
5382 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5383 aux
->table
[i
].end
.offset
+= sym
->st_value
+ rp
->r_addend
;
5393 aux
->table_len
= nentries
;
5399 hppa_process_unwind (FILE *file
)
5401 struct hppa_unw_aux_info aux
;
5402 Elf_Internal_Shdr
*unwsec
= NULL
;
5403 Elf_Internal_Shdr
*strsec
;
5404 Elf_Internal_Shdr
*sec
;
5407 memset (& aux
, 0, sizeof (aux
));
5409 if (string_table
== NULL
)
5412 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5414 if (sec
->sh_type
== SHT_SYMTAB
5415 && SECTION_HEADER_INDEX (sec
->sh_link
) < elf_header
.e_shnum
)
5417 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5418 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5420 strsec
= SECTION_HEADER (sec
->sh_link
);
5421 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5422 1, strsec
->sh_size
, _("string table"));
5423 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5425 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5430 printf (_("\nThere are no unwind sections in this file.\n"));
5432 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5434 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5436 printf (_("\nUnwind section "));
5437 printf (_("'%s'"), SECTION_NAME (sec
));
5439 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5440 (unsigned long) sec
->sh_offset
,
5441 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5443 slurp_hppa_unwind_table (file
, &aux
, sec
);
5444 if (aux
.table_len
> 0)
5445 dump_hppa_unwind (&aux
);
5448 free ((char *) aux
.table
);
5456 free ((char *) aux
.strtab
);
5462 process_unwind (FILE *file
)
5464 struct unwind_handler
{
5466 int (*handler
)(FILE *file
);
5468 { EM_IA_64
, ia64_process_unwind
},
5469 { EM_PARISC
, hppa_process_unwind
},
5477 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5478 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5479 return handlers
[i
].handler (file
);
5481 printf (_("\nThere are no unwind sections in this file.\n"));
5486 dynamic_section_mips_val (Elf_Internal_Dyn
*entry
)
5488 switch (entry
->d_tag
)
5491 if (entry
->d_un
.d_val
== 0)
5495 static const char * opts
[] =
5497 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5498 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5499 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5500 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5505 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++cnt
)
5506 if (entry
->d_un
.d_val
& (1 << cnt
))
5508 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5515 case DT_MIPS_IVERSION
:
5516 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5517 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5519 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5522 case DT_MIPS_TIME_STAMP
:
5527 time_t time
= entry
->d_un
.d_val
;
5528 tmp
= gmtime (&time
);
5529 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5530 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5531 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5532 printf ("Time Stamp: %s\n", timebuf
);
5536 case DT_MIPS_RLD_VERSION
:
5537 case DT_MIPS_LOCAL_GOTNO
:
5538 case DT_MIPS_CONFLICTNO
:
5539 case DT_MIPS_LIBLISTNO
:
5540 case DT_MIPS_SYMTABNO
:
5541 case DT_MIPS_UNREFEXTNO
:
5542 case DT_MIPS_HIPAGENO
:
5543 case DT_MIPS_DELTA_CLASS_NO
:
5544 case DT_MIPS_DELTA_INSTANCE_NO
:
5545 case DT_MIPS_DELTA_RELOC_NO
:
5546 case DT_MIPS_DELTA_SYM_NO
:
5547 case DT_MIPS_DELTA_CLASSSYM_NO
:
5548 case DT_MIPS_COMPACT_SIZE
:
5549 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5553 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
5559 dynamic_section_parisc_val (Elf_Internal_Dyn
*entry
)
5561 switch (entry
->d_tag
)
5563 case DT_HP_DLD_FLAGS
:
5572 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5573 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5574 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5575 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5576 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5577 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5578 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5579 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5580 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5581 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5582 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
5583 { DT_HP_GST
, "HP_GST" },
5584 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
5585 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
5586 { DT_HP_NODELETE
, "HP_NODELETE" },
5587 { DT_HP_GROUP
, "HP_GROUP" },
5588 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
5592 bfd_vma val
= entry
->d_un
.d_val
;
5594 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
5595 if (val
& flags
[cnt
].bit
)
5599 fputs (flags
[cnt
].str
, stdout
);
5601 val
^= flags
[cnt
].bit
;
5604 if (val
!= 0 || first
)
5608 print_vma (val
, HEX
);
5614 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5621 dynamic_section_ia64_val (Elf_Internal_Dyn
*entry
)
5623 switch (entry
->d_tag
)
5625 case DT_IA_64_PLT_RESERVE
:
5626 /* First 3 slots reserved. */
5627 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5629 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5633 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5640 get_32bit_dynamic_section (FILE *file
)
5642 Elf32_External_Dyn
*edyn
, *ext
;
5643 Elf_Internal_Dyn
*entry
;
5645 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5646 _("dynamic section"));
5650 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5651 might not have the luxury of section headers. Look for the DT_NULL
5652 terminator to determine the number of entries. */
5653 for (ext
= edyn
, dynamic_nent
= 0;
5654 (char *) ext
< (char *) edyn
+ dynamic_size
;
5658 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5662 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5663 if (dynamic_section
== NULL
)
5665 error (_("Out of memory\n"));
5670 for (ext
= edyn
, entry
= dynamic_section
;
5671 entry
< dynamic_section
+ dynamic_nent
;
5674 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5675 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5684 get_64bit_dynamic_section (FILE *file
)
5686 Elf64_External_Dyn
*edyn
, *ext
;
5687 Elf_Internal_Dyn
*entry
;
5689 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5690 _("dynamic section"));
5694 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5695 might not have the luxury of section headers. Look for the DT_NULL
5696 terminator to determine the number of entries. */
5697 for (ext
= edyn
, dynamic_nent
= 0;
5698 (char *) ext
< (char *) edyn
+ dynamic_size
;
5702 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5706 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5707 if (dynamic_section
== NULL
)
5709 error (_("Out of memory\n"));
5714 for (ext
= edyn
, entry
= dynamic_section
;
5715 entry
< dynamic_section
+ dynamic_nent
;
5718 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5719 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5728 print_dynamic_flags (bfd_vma flags
)
5736 flag
= flags
& - flags
;
5746 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
5747 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
5748 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
5749 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
5750 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
5751 default: fputs ("unknown", stdout
); break;
5757 /* Parse and display the contents of the dynamic section. */
5760 process_dynamic_section (FILE *file
)
5762 Elf_Internal_Dyn
*entry
;
5764 if (dynamic_size
== 0)
5767 printf (_("\nThere is no dynamic section in this file.\n"));
5774 if (! get_32bit_dynamic_section (file
))
5777 else if (! get_64bit_dynamic_section (file
))
5780 /* Find the appropriate symbol table. */
5781 if (dynamic_symbols
== NULL
)
5783 for (entry
= dynamic_section
;
5784 entry
< dynamic_section
+ dynamic_nent
;
5787 Elf_Internal_Shdr section
;
5789 if (entry
->d_tag
!= DT_SYMTAB
)
5792 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
5794 /* Since we do not know how big the symbol table is,
5795 we default to reading in the entire file (!) and
5796 processing that. This is overkill, I know, but it
5798 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5800 if (archive_file_offset
!= 0)
5801 section
.sh_size
= archive_file_size
- section
.sh_offset
;
5804 if (fseek (file
, 0, SEEK_END
))
5805 error (_("Unable to seek to end of file!"));
5807 section
.sh_size
= ftell (file
) - section
.sh_offset
;
5811 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
5813 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
5815 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
5816 if (num_dynamic_syms
< 1)
5818 error (_("Unable to determine the number of symbols to load\n"));
5822 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
5826 /* Similarly find a string table. */
5827 if (dynamic_strings
== NULL
)
5829 for (entry
= dynamic_section
;
5830 entry
< dynamic_section
+ dynamic_nent
;
5833 unsigned long offset
;
5836 if (entry
->d_tag
!= DT_STRTAB
)
5839 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
5841 /* Since we do not know how big the string table is,
5842 we default to reading in the entire file (!) and
5843 processing that. This is overkill, I know, but it
5846 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5848 if (archive_file_offset
!= 0)
5849 str_tab_len
= archive_file_size
- offset
;
5852 if (fseek (file
, 0, SEEK_END
))
5853 error (_("Unable to seek to end of file\n"));
5854 str_tab_len
= ftell (file
) - offset
;
5857 if (str_tab_len
< 1)
5860 (_("Unable to determine the length of the dynamic string table\n"));
5864 dynamic_strings
= get_data (NULL
, file
, offset
, 1, str_tab_len
,
5865 _("dynamic string table"));
5866 dynamic_strings_length
= str_tab_len
;
5871 /* And find the syminfo section if available. */
5872 if (dynamic_syminfo
== NULL
)
5874 unsigned long syminsz
= 0;
5876 for (entry
= dynamic_section
;
5877 entry
< dynamic_section
+ dynamic_nent
;
5880 if (entry
->d_tag
== DT_SYMINENT
)
5882 /* Note: these braces are necessary to avoid a syntax
5883 error from the SunOS4 C compiler. */
5884 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
5886 else if (entry
->d_tag
== DT_SYMINSZ
)
5887 syminsz
= entry
->d_un
.d_val
;
5888 else if (entry
->d_tag
== DT_SYMINFO
)
5889 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
5893 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
5895 Elf_External_Syminfo
*extsyminfo
, *extsym
;
5896 Elf_Internal_Syminfo
*syminfo
;
5898 /* There is a syminfo section. Read the data. */
5899 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, 1,
5900 syminsz
, _("symbol information"));
5904 dynamic_syminfo
= malloc (syminsz
);
5905 if (dynamic_syminfo
== NULL
)
5907 error (_("Out of memory\n"));
5911 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
5912 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
5913 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
5914 ++syminfo
, ++extsym
)
5916 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
5917 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
5924 if (do_dynamic
&& dynamic_addr
)
5925 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
5926 dynamic_addr
, dynamic_nent
);
5928 printf (_(" Tag Type Name/Value\n"));
5930 for (entry
= dynamic_section
;
5931 entry
< dynamic_section
+ dynamic_nent
;
5939 print_vma (entry
->d_tag
, FULL_HEX
);
5940 dtype
= get_dynamic_type (entry
->d_tag
);
5941 printf (" (%s)%*s", dtype
,
5942 ((is_32bit_elf
? 27 : 19)
5943 - (int) strlen (dtype
)),
5947 switch (entry
->d_tag
)
5951 print_dynamic_flags (entry
->d_un
.d_val
);
5961 switch (entry
->d_tag
)
5964 printf (_("Auxiliary library"));
5968 printf (_("Filter library"));
5972 printf (_("Configuration file"));
5976 printf (_("Dependency audit library"));
5980 printf (_("Audit library"));
5984 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5985 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5989 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5998 printf (_("Flags:"));
6000 if (entry
->d_un
.d_val
== 0)
6001 printf (_(" None\n"));
6004 unsigned long int val
= entry
->d_un
.d_val
;
6006 if (val
& DTF_1_PARINIT
)
6008 printf (" PARINIT");
6009 val
^= DTF_1_PARINIT
;
6011 if (val
& DTF_1_CONFEXP
)
6013 printf (" CONFEXP");
6014 val
^= DTF_1_CONFEXP
;
6017 printf (" %lx", val
);
6026 printf (_("Flags:"));
6028 if (entry
->d_un
.d_val
== 0)
6029 printf (_(" None\n"));
6032 unsigned long int val
= entry
->d_un
.d_val
;
6034 if (val
& DF_P1_LAZYLOAD
)
6036 printf (" LAZYLOAD");
6037 val
^= DF_P1_LAZYLOAD
;
6039 if (val
& DF_P1_GROUPPERM
)
6041 printf (" GROUPPERM");
6042 val
^= DF_P1_GROUPPERM
;
6045 printf (" %lx", val
);
6054 printf (_("Flags:"));
6055 if (entry
->d_un
.d_val
== 0)
6056 printf (_(" None\n"));
6059 unsigned long int val
= entry
->d_un
.d_val
;
6066 if (val
& DF_1_GLOBAL
)
6071 if (val
& DF_1_GROUP
)
6076 if (val
& DF_1_NODELETE
)
6078 printf (" NODELETE");
6079 val
^= DF_1_NODELETE
;
6081 if (val
& DF_1_LOADFLTR
)
6083 printf (" LOADFLTR");
6084 val
^= DF_1_LOADFLTR
;
6086 if (val
& DF_1_INITFIRST
)
6088 printf (" INITFIRST");
6089 val
^= DF_1_INITFIRST
;
6091 if (val
& DF_1_NOOPEN
)
6096 if (val
& DF_1_ORIGIN
)
6101 if (val
& DF_1_DIRECT
)
6106 if (val
& DF_1_TRANS
)
6111 if (val
& DF_1_INTERPOSE
)
6113 printf (" INTERPOSE");
6114 val
^= DF_1_INTERPOSE
;
6116 if (val
& DF_1_NODEFLIB
)
6118 printf (" NODEFLIB");
6119 val
^= DF_1_NODEFLIB
;
6121 if (val
& DF_1_NODUMP
)
6126 if (val
& DF_1_CONLFAT
)
6128 printf (" CONLFAT");
6129 val
^= DF_1_CONLFAT
;
6132 printf (" %lx", val
);
6139 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6141 puts (get_dynamic_type (entry
->d_un
.d_val
));
6161 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6167 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6168 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6174 switch (entry
->d_tag
)
6177 printf (_("Shared library: [%s]"), name
);
6179 if (streq (name
, program_interpreter
))
6180 printf (_(" program interpreter"));
6184 printf (_("Library soname: [%s]"), name
);
6188 printf (_("Library rpath: [%s]"), name
);
6192 printf (_("Library runpath: [%s]"), name
);
6196 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6201 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6214 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6218 case DT_INIT_ARRAYSZ
:
6219 case DT_FINI_ARRAYSZ
:
6220 case DT_GNU_CONFLICTSZ
:
6221 case DT_GNU_LIBLISTSZ
:
6224 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6225 printf (" (bytes)\n");
6235 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6248 if (entry
->d_tag
== DT_USED
6249 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6251 char *name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6255 printf (_("Not needed object: [%s]\n"), name
);
6260 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6266 /* The value of this entry is ignored. */
6271 case DT_GNU_PRELINKED
:
6275 time_t time
= entry
->d_un
.d_val
;
6277 tmp
= gmtime (&time
);
6278 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6279 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6280 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6286 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
6287 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
6292 switch (elf_header
.e_machine
)
6295 case EM_MIPS_RS3_LE
:
6296 dynamic_section_mips_val (entry
);
6299 dynamic_section_parisc_val (entry
);
6302 dynamic_section_ia64_val (entry
);
6305 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6317 get_ver_flags (unsigned int flags
)
6319 static char buff
[32];
6326 if (flags
& VER_FLG_BASE
)
6327 strcat (buff
, "BASE ");
6329 if (flags
& VER_FLG_WEAK
)
6331 if (flags
& VER_FLG_BASE
)
6332 strcat (buff
, "| ");
6334 strcat (buff
, "WEAK ");
6337 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
6338 strcat (buff
, "| <unknown>");
6343 /* Display the contents of the version sections. */
6345 process_version_sections (FILE *file
)
6347 Elf_Internal_Shdr
*section
;
6354 for (i
= 0, section
= section_headers
;
6355 i
< elf_header
.e_shnum
;
6358 switch (section
->sh_type
)
6360 case SHT_GNU_verdef
:
6362 Elf_External_Verdef
*edefs
;
6369 (_("\nVersion definition section '%s' contains %ld entries:\n"),
6370 SECTION_NAME (section
), section
->sh_info
);
6372 printf (_(" Addr: 0x"));
6373 printf_vma (section
->sh_addr
);
6374 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6375 (unsigned long) section
->sh_offset
, section
->sh_link
,
6376 SECTION_HEADER_INDEX (section
->sh_link
)
6377 < elf_header
.e_shnum
6378 ? SECTION_NAME (SECTION_HEADER (section
->sh_link
))
6381 edefs
= get_data (NULL
, file
, section
->sh_offset
, 1,
6383 _("version definition section"));
6387 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6390 Elf_External_Verdef
*edef
;
6391 Elf_Internal_Verdef ent
;
6392 Elf_External_Verdaux
*eaux
;
6393 Elf_Internal_Verdaux aux
;
6397 vstart
= ((char *) edefs
) + idx
;
6399 edef
= (Elf_External_Verdef
*) vstart
;
6401 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
6402 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
6403 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
6404 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
6405 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
6406 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
6407 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
6409 printf (_(" %#06x: Rev: %d Flags: %s"),
6410 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
6412 printf (_(" Index: %d Cnt: %d "),
6413 ent
.vd_ndx
, ent
.vd_cnt
);
6415 vstart
+= ent
.vd_aux
;
6417 eaux
= (Elf_External_Verdaux
*) vstart
;
6419 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6420 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6422 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6423 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6425 printf (_("Name index: %ld\n"), aux
.vda_name
);
6427 isum
= idx
+ ent
.vd_aux
;
6429 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6431 isum
+= aux
.vda_next
;
6432 vstart
+= aux
.vda_next
;
6434 eaux
= (Elf_External_Verdaux
*) vstart
;
6436 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6437 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6439 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6440 printf (_(" %#06x: Parent %d: %s\n"),
6441 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6443 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6444 isum
, j
, aux
.vda_name
);
6454 case SHT_GNU_verneed
:
6456 Elf_External_Verneed
*eneed
;
6462 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
6463 SECTION_NAME (section
), section
->sh_info
);
6465 printf (_(" Addr: 0x"));
6466 printf_vma (section
->sh_addr
);
6467 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
6468 (unsigned long) section
->sh_offset
, section
->sh_link
,
6469 SECTION_HEADER_INDEX (section
->sh_link
)
6470 < elf_header
.e_shnum
6471 ? SECTION_NAME (SECTION_HEADER (section
->sh_link
))
6474 eneed
= get_data (NULL
, file
, section
->sh_offset
, 1,
6476 _("version need section"));
6480 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6482 Elf_External_Verneed
*entry
;
6483 Elf_Internal_Verneed ent
;
6488 vstart
= ((char *) eneed
) + idx
;
6490 entry
= (Elf_External_Verneed
*) vstart
;
6492 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6493 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6494 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6495 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6496 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6498 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6500 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6501 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6503 printf (_(" File: %lx"), ent
.vn_file
);
6505 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6507 vstart
+= ent
.vn_aux
;
6509 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6511 Elf_External_Vernaux
*eaux
;
6512 Elf_Internal_Vernaux aux
;
6514 eaux
= (Elf_External_Vernaux
*) vstart
;
6516 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6517 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6518 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6519 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6520 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6522 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6523 printf (_(" %#06x: Name: %s"),
6524 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6526 printf (_(" %#06x: Name index: %lx"),
6527 isum
, aux
.vna_name
);
6529 printf (_(" Flags: %s Version: %d\n"),
6530 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6532 isum
+= aux
.vna_next
;
6533 vstart
+= aux
.vna_next
;
6543 case SHT_GNU_versym
:
6545 Elf_Internal_Shdr
*link_section
;
6548 unsigned char *edata
;
6549 unsigned short *data
;
6551 Elf_Internal_Sym
*symbols
;
6552 Elf_Internal_Shdr
*string_sec
;
6555 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
)
6558 link_section
= SECTION_HEADER (section
->sh_link
);
6559 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
6561 if (SECTION_HEADER_INDEX (link_section
->sh_link
)
6562 >= elf_header
.e_shnum
)
6567 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6569 string_sec
= SECTION_HEADER (link_section
->sh_link
);
6571 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
6572 string_sec
->sh_size
, _("version string table"));
6576 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6577 SECTION_NAME (section
), total
);
6579 printf (_(" Addr: "));
6580 printf_vma (section
->sh_addr
);
6581 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6582 (unsigned long) section
->sh_offset
, section
->sh_link
,
6583 SECTION_NAME (link_section
));
6585 off
= offset_from_vma (file
,
6586 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6587 total
* sizeof (short));
6588 edata
= get_data (NULL
, file
, off
, total
, sizeof (short),
6589 _("version symbol data"));
6596 data
= cmalloc (total
, sizeof (short));
6598 for (cnt
= total
; cnt
--;)
6599 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6604 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6607 int check_def
, check_need
;
6610 printf (" %03x:", cnt
);
6612 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6613 switch (data
[cnt
+ j
])
6616 fputs (_(" 0 (*local*) "), stdout
);
6620 fputs (_(" 1 (*global*) "), stdout
);
6624 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
6625 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
6629 if (SECTION_HEADER_INDEX (symbols
[cnt
+ j
].st_shndx
)
6630 >= elf_header
.e_shnum
6631 || SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
6634 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6641 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6643 Elf_Internal_Verneed ivn
;
6644 unsigned long offset
;
6646 offset
= offset_from_vma
6647 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6648 sizeof (Elf_External_Verneed
));
6652 Elf_Internal_Vernaux ivna
;
6653 Elf_External_Verneed evn
;
6654 Elf_External_Vernaux evna
;
6655 unsigned long a_off
;
6657 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
6660 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6661 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6663 a_off
= offset
+ ivn
.vn_aux
;
6667 get_data (&evna
, file
, a_off
, sizeof (evna
),
6668 1, _("version need aux (2)"));
6670 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6671 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6673 a_off
+= ivna
.vna_next
;
6675 while (ivna
.vna_other
!= data
[cnt
+ j
]
6676 && ivna
.vna_next
!= 0);
6678 if (ivna
.vna_other
== data
[cnt
+ j
])
6680 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6682 name
= strtab
+ ivna
.vna_name
;
6683 nn
+= printf ("(%s%-*s",
6685 12 - (int) strlen (name
),
6691 offset
+= ivn
.vn_next
;
6693 while (ivn
.vn_next
);
6696 if (check_def
&& data
[cnt
+ j
] != 0x8001
6697 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6699 Elf_Internal_Verdef ivd
;
6700 Elf_External_Verdef evd
;
6701 unsigned long offset
;
6703 offset
= offset_from_vma
6704 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6709 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
6712 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6713 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6715 offset
+= ivd
.vd_next
;
6717 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
6718 && ivd
.vd_next
!= 0);
6720 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
6722 Elf_External_Verdaux evda
;
6723 Elf_Internal_Verdaux ivda
;
6725 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6727 get_data (&evda
, file
,
6728 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
6730 _("version def aux"));
6732 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6734 name
= strtab
+ ivda
.vda_name
;
6735 nn
+= printf ("(%s%-*s",
6737 12 - (int) strlen (name
),
6743 printf ("%*c", 18 - nn
, ' ');
6761 printf (_("\nNo version information found in this file.\n"));
6767 get_symbol_binding (unsigned int binding
)
6769 static char buff
[32];
6773 case STB_LOCAL
: return "LOCAL";
6774 case STB_GLOBAL
: return "GLOBAL";
6775 case STB_WEAK
: return "WEAK";
6777 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
6778 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
6780 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
6781 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
6783 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
6789 get_symbol_type (unsigned int type
)
6791 static char buff
[32];
6795 case STT_NOTYPE
: return "NOTYPE";
6796 case STT_OBJECT
: return "OBJECT";
6797 case STT_FUNC
: return "FUNC";
6798 case STT_SECTION
: return "SECTION";
6799 case STT_FILE
: return "FILE";
6800 case STT_COMMON
: return "COMMON";
6801 case STT_TLS
: return "TLS";
6803 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
6805 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
6806 return "THUMB_FUNC";
6808 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
6811 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
6812 return "PARISC_MILLI";
6814 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
6816 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
6818 if (elf_header
.e_machine
== EM_PARISC
)
6820 if (type
== STT_HP_OPAQUE
)
6822 if (type
== STT_HP_STUB
)
6826 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
6829 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
6835 get_symbol_visibility (unsigned int visibility
)
6839 case STV_DEFAULT
: return "DEFAULT";
6840 case STV_INTERNAL
: return "INTERNAL";
6841 case STV_HIDDEN
: return "HIDDEN";
6842 case STV_PROTECTED
: return "PROTECTED";
6848 get_symbol_index_type (unsigned int type
)
6850 static char buff
[32];
6854 case SHN_UNDEF
: return "UND";
6855 case SHN_ABS
: return "ABS";
6856 case SHN_COMMON
: return "COM";
6858 if (type
== SHN_IA_64_ANSI_COMMON
6859 && elf_header
.e_machine
== EM_IA_64
6860 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
6862 else if (elf_header
.e_machine
== EM_X86_64
6863 && type
== SHN_X86_64_LCOMMON
)
6865 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
6866 sprintf (buff
, "PRC[0x%04x]", type
);
6867 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
6868 sprintf (buff
, "OS [0x%04x]", type
);
6869 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
6870 sprintf (buff
, "RSV[0x%04x]", type
);
6872 sprintf (buff
, "%3d", type
);
6880 get_dynamic_data (FILE *file
, unsigned int number
, unsigned int ent_size
)
6882 unsigned char *e_data
;
6885 e_data
= cmalloc (number
, ent_size
);
6889 error (_("Out of memory\n"));
6893 if (fread (e_data
, ent_size
, number
, file
) != number
)
6895 error (_("Unable to read in dynamic data\n"));
6899 i_data
= cmalloc (number
, sizeof (*i_data
));
6903 error (_("Out of memory\n"));
6909 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
6916 /* Dump the symbol table. */
6918 process_symbol_table (FILE *file
)
6920 Elf_Internal_Shdr
*section
;
6921 bfd_vma nbuckets
= 0;
6922 bfd_vma nchains
= 0;
6923 bfd_vma
*buckets
= NULL
;
6924 bfd_vma
*chains
= NULL
;
6926 if (! do_syms
&& !do_histogram
)
6929 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
6932 unsigned char nb
[8];
6933 unsigned char nc
[8];
6934 int hash_ent_size
= 4;
6936 if ((elf_header
.e_machine
== EM_ALPHA
6937 || elf_header
.e_machine
== EM_S390
6938 || elf_header
.e_machine
== EM_S390_OLD
)
6939 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
6943 (archive_file_offset
6944 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
6945 sizeof nb
+ sizeof nc
)),
6948 error (_("Unable to seek to start of dynamic information"));
6952 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
6954 error (_("Failed to read in number of buckets\n"));
6958 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
6960 error (_("Failed to read in number of chains\n"));
6964 nbuckets
= byte_get (nb
, hash_ent_size
);
6965 nchains
= byte_get (nc
, hash_ent_size
);
6967 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
6968 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
6970 if (buckets
== NULL
|| chains
== NULL
)
6975 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
6980 printf (_("\nSymbol table for image:\n"));
6982 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6984 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6986 for (hn
= 0; hn
< nbuckets
; hn
++)
6991 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
6993 Elf_Internal_Sym
*psym
;
6996 psym
= dynamic_symbols
+ si
;
6998 n
= print_vma (si
, DEC_5
);
7000 fputs (" " + n
, stdout
);
7001 printf (" %3lu: ", hn
);
7002 print_vma (psym
->st_value
, LONG_HEX
);
7004 print_vma (psym
->st_size
, DEC_5
);
7006 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7007 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7008 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7009 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
7010 if (VALID_DYNAMIC_NAME (psym
->st_name
))
7011 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
7013 printf (" <corrupt: %14ld>", psym
->st_name
);
7018 else if (do_syms
&& !do_using_dynamic
)
7022 for (i
= 0, section
= section_headers
;
7023 i
< elf_header
.e_shnum
;
7027 char *strtab
= NULL
;
7028 unsigned long int strtab_size
= 0;
7029 Elf_Internal_Sym
*symtab
;
7030 Elf_Internal_Sym
*psym
;
7033 if ( section
->sh_type
!= SHT_SYMTAB
7034 && section
->sh_type
!= SHT_DYNSYM
)
7037 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
7038 SECTION_NAME (section
),
7039 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
7041 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7043 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7045 symtab
= GET_ELF_SYMBOLS (file
, section
);
7049 if (section
->sh_link
== elf_header
.e_shstrndx
)
7051 strtab
= string_table
;
7052 strtab_size
= string_table_length
;
7054 else if (SECTION_HEADER_INDEX (section
->sh_link
) < elf_header
.e_shnum
)
7056 Elf_Internal_Shdr
*string_sec
;
7058 string_sec
= SECTION_HEADER (section
->sh_link
);
7060 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
7061 1, string_sec
->sh_size
, _("string table"));
7062 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
7065 for (si
= 0, psym
= symtab
;
7066 si
< section
->sh_size
/ section
->sh_entsize
;
7069 printf ("%6d: ", si
);
7070 print_vma (psym
->st_value
, LONG_HEX
);
7072 print_vma (psym
->st_size
, DEC_5
);
7073 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7074 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7075 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7076 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
7077 print_symbol (25, psym
->st_name
< strtab_size
7078 ? strtab
+ psym
->st_name
: "<corrupt>");
7080 if (section
->sh_type
== SHT_DYNSYM
&&
7081 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
7083 unsigned char data
[2];
7084 unsigned short vers_data
;
7085 unsigned long offset
;
7089 offset
= offset_from_vma
7090 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
7091 sizeof data
+ si
* sizeof (vers_data
));
7093 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
7094 sizeof (data
), 1, _("version data"));
7096 vers_data
= byte_get (data
, 2);
7098 is_nobits
= (SECTION_HEADER_INDEX (psym
->st_shndx
)
7099 < elf_header
.e_shnum
7100 && SECTION_HEADER (psym
->st_shndx
)->sh_type
7103 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
7105 if ((vers_data
& 0x8000) || vers_data
> 1)
7107 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
7108 && (is_nobits
|| ! check_def
))
7110 Elf_External_Verneed evn
;
7111 Elf_Internal_Verneed ivn
;
7112 Elf_Internal_Vernaux ivna
;
7114 /* We must test both. */
7115 offset
= offset_from_vma
7116 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
7121 unsigned long vna_off
;
7123 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
7126 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
7127 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
7129 vna_off
= offset
+ ivn
.vn_aux
;
7133 Elf_External_Vernaux evna
;
7135 get_data (&evna
, file
, vna_off
,
7137 _("version need aux (3)"));
7139 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
7140 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
7141 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
7143 vna_off
+= ivna
.vna_next
;
7145 while (ivna
.vna_other
!= vers_data
7146 && ivna
.vna_next
!= 0);
7148 if (ivna
.vna_other
== vers_data
)
7151 offset
+= ivn
.vn_next
;
7153 while (ivn
.vn_next
!= 0);
7155 if (ivna
.vna_other
== vers_data
)
7158 ivna
.vna_name
< strtab_size
7159 ? strtab
+ ivna
.vna_name
: "<corrupt>",
7163 else if (! is_nobits
)
7164 error (_("bad dynamic symbol"));
7171 if (vers_data
!= 0x8001
7172 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7174 Elf_Internal_Verdef ivd
;
7175 Elf_Internal_Verdaux ivda
;
7176 Elf_External_Verdaux evda
;
7177 unsigned long offset
;
7179 offset
= offset_from_vma
7181 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7182 sizeof (Elf_External_Verdef
));
7186 Elf_External_Verdef evd
;
7188 get_data (&evd
, file
, offset
, sizeof (evd
),
7189 1, _("version def"));
7191 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7192 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7193 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7195 offset
+= ivd
.vd_next
;
7197 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
7198 && ivd
.vd_next
!= 0);
7200 offset
-= ivd
.vd_next
;
7201 offset
+= ivd
.vd_aux
;
7203 get_data (&evda
, file
, offset
, sizeof (evda
),
7204 1, _("version def aux"));
7206 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7208 if (psym
->st_name
!= ivda
.vda_name
)
7209 printf ((vers_data
& 0x8000)
7211 ivda
.vda_name
< strtab_size
7212 ? strtab
+ ivda
.vda_name
: "<corrupt>");
7222 if (strtab
!= string_table
)
7228 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7230 if (do_histogram
&& buckets
!= NULL
)
7232 unsigned long *lengths
;
7233 unsigned long *counts
;
7236 unsigned long maxlength
= 0;
7237 unsigned long nzero_counts
= 0;
7238 unsigned long nsyms
= 0;
7240 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7241 (unsigned long) nbuckets
);
7242 printf (_(" Length Number %% of total Coverage\n"));
7244 lengths
= calloc (nbuckets
, sizeof (*lengths
));
7245 if (lengths
== NULL
)
7247 error (_("Out of memory"));
7250 for (hn
= 0; hn
< nbuckets
; ++hn
)
7252 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
7255 if (maxlength
< ++lengths
[hn
])
7260 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7263 error (_("Out of memory"));
7267 for (hn
= 0; hn
< nbuckets
; ++hn
)
7268 ++counts
[lengths
[hn
]];
7273 printf (" 0 %-10lu (%5.1f%%)\n",
7274 counts
[0], (counts
[0] * 100.0) / nbuckets
);
7275 for (i
= 1; i
<= maxlength
; ++i
)
7277 nzero_counts
+= counts
[i
] * i
;
7278 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7279 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
7280 (nzero_counts
* 100.0) / nsyms
);
7288 if (buckets
!= NULL
)
7298 process_syminfo (FILE *file ATTRIBUTE_UNUSED
)
7302 if (dynamic_syminfo
== NULL
7304 /* No syminfo, this is ok. */
7307 /* There better should be a dynamic symbol section. */
7308 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
7312 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7313 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
7315 printf (_(" Num: Name BoundTo Flags\n"));
7316 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
7318 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
7320 printf ("%4d: ", i
);
7321 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
7322 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
7324 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
7327 switch (dynamic_syminfo
[i
].si_boundto
)
7329 case SYMINFO_BT_SELF
:
7330 fputs ("SELF ", stdout
);
7332 case SYMINFO_BT_PARENT
:
7333 fputs ("PARENT ", stdout
);
7336 if (dynamic_syminfo
[i
].si_boundto
> 0
7337 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
7338 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
7340 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
7344 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
7348 if (flags
& SYMINFO_FLG_DIRECT
)
7350 if (flags
& SYMINFO_FLG_PASSTHRU
)
7351 printf (" PASSTHRU");
7352 if (flags
& SYMINFO_FLG_COPY
)
7354 if (flags
& SYMINFO_FLG_LAZYLOAD
)
7355 printf (" LAZYLOAD");
7363 #ifdef SUPPORT_DISASSEMBLY
7365 disassemble_section (Elf_Internal_Shdr
*section
, FILE *file
)
7367 printf (_("\nAssembly dump of section %s\n"),
7368 SECTION_NAME (section
));
7370 /* XXX -- to be done --- XXX */
7377 dump_section (Elf_Internal_Shdr
*section
, FILE *file
)
7379 bfd_size_type bytes
;
7381 unsigned char *data
;
7382 unsigned char *start
;
7384 bytes
= section
->sh_size
;
7386 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
7388 printf (_("\nSection '%s' has no data to dump.\n"),
7389 SECTION_NAME (section
));
7393 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
7395 addr
= section
->sh_addr
;
7397 start
= get_data (NULL
, file
, section
->sh_offset
, 1, bytes
,
7410 lbytes
= (bytes
> 16 ? 16 : bytes
);
7412 printf (" 0x%8.8lx ", (unsigned long) addr
);
7414 switch (elf_header
.e_ident
[EI_DATA
])
7418 for (j
= 15; j
>= 0; j
--)
7421 printf ("%2.2x", data
[j
]);
7431 for (j
= 0; j
< 16; j
++)
7434 printf ("%2.2x", data
[j
]);
7444 for (j
= 0; j
< lbytes
; j
++)
7447 if (k
>= ' ' && k
< 0x7f)
7466 static unsigned long int
7467 read_leb128 (unsigned char *data
, unsigned int *length_return
, int sign
)
7469 unsigned long int result
= 0;
7470 unsigned int num_read
= 0;
7471 unsigned int shift
= 0;
7479 result
|= ((unsigned long int) (byte
& 0x7f)) << shift
;
7484 while (byte
& 0x80);
7486 if (length_return
!= NULL
)
7487 *length_return
= num_read
;
7489 if (sign
&& (shift
< 8 * sizeof (result
)) && (byte
& 0x40))
7490 result
|= -1L << shift
;
7495 typedef struct State_Machine_Registers
7497 unsigned long address
;
7500 unsigned int column
;
7504 /* This variable hold the number of the last entry seen
7505 in the File Table. */
7506 unsigned int last_file_entry
;
7509 static SMR state_machine_regs
;
7512 reset_state_machine (int is_stmt
)
7514 state_machine_regs
.address
= 0;
7515 state_machine_regs
.file
= 1;
7516 state_machine_regs
.line
= 1;
7517 state_machine_regs
.column
= 0;
7518 state_machine_regs
.is_stmt
= is_stmt
;
7519 state_machine_regs
.basic_block
= 0;
7520 state_machine_regs
.end_sequence
= 0;
7521 state_machine_regs
.last_file_entry
= 0;
7524 /* Handled an extend line op.
7525 Returns the number of bytes read. */
7528 process_extended_line_op (unsigned char *data
, int is_stmt
, int pointer_size
)
7530 unsigned char op_code
;
7531 unsigned int bytes_read
;
7533 unsigned char *name
;
7536 len
= read_leb128 (data
, & bytes_read
, 0);
7541 warn (_("badly formed extended line op encountered!\n"));
7548 printf (_(" Extended opcode %d: "), op_code
);
7552 case DW_LNE_end_sequence
:
7553 printf (_("End of Sequence\n\n"));
7554 reset_state_machine (is_stmt
);
7557 case DW_LNE_set_address
:
7558 adr
= byte_get (data
, pointer_size
);
7559 printf (_("set Address to 0x%lx\n"), adr
);
7560 state_machine_regs
.address
= adr
;
7563 case DW_LNE_define_file
:
7564 printf (_(" define new File Table entry\n"));
7565 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
7567 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
7569 data
+= strlen ((char *) data
) + 1;
7570 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7572 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7574 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7575 printf (_("%s\n\n"), name
);
7579 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
7586 static const char *debug_str_contents
;
7587 static bfd_vma debug_str_size
;
7590 load_debug_str (FILE *file
)
7592 Elf_Internal_Shdr
*sec
;
7594 /* If it is already loaded, do nothing. */
7595 if (debug_str_contents
!= NULL
)
7598 /* Locate the .debug_str section. */
7599 sec
= find_section (".debug_str");
7603 debug_str_size
= sec
->sh_size
;
7605 debug_str_contents
= get_data (NULL
, file
, sec
->sh_offset
, 1, sec
->sh_size
,
7606 _("debug_str section data"));
7610 free_debug_str (void)
7612 if (debug_str_contents
== NULL
)
7615 free ((char *) debug_str_contents
);
7616 debug_str_contents
= NULL
;
7621 fetch_indirect_string (unsigned long offset
)
7623 if (debug_str_contents
== NULL
)
7624 return _("<no .debug_str section>");
7626 if (offset
> debug_str_size
)
7628 warn (_("DW_FORM_strp offset too big: %lx\n"), offset
);
7629 return _("<offset is too big>");
7632 return debug_str_contents
+ offset
;
7635 static const char *debug_loc_contents
;
7636 static bfd_vma debug_loc_size
;
7639 load_debug_loc (FILE *file
)
7641 Elf_Internal_Shdr
*sec
;
7643 /* If it is already loaded, do nothing. */
7644 if (debug_loc_contents
!= NULL
)
7647 /* Locate the .debug_loc section. */
7648 sec
= find_section (".debug_loc");
7652 debug_loc_size
= sec
->sh_size
;
7654 debug_loc_contents
= get_data (NULL
, file
, sec
->sh_offset
, 1, sec
->sh_size
,
7655 _("debug_loc section data"));
7659 free_debug_loc (void)
7661 if (debug_loc_contents
== NULL
)
7664 free ((char *) debug_loc_contents
);
7665 debug_loc_contents
= NULL
;
7669 static const char * debug_range_contents
;
7670 static unsigned long debug_range_size
;
7673 load_debug_range (FILE *file
)
7675 Elf_Internal_Shdr
*sec
;
7677 /* If it is already loaded, do nothing. */
7678 if (debug_range_contents
!= NULL
)
7681 /* Locate the .debug_ranges section. */
7682 sec
= find_section (".debug_ranges");
7686 debug_range_size
= sec
->sh_size
;
7688 debug_range_contents
= get_data (NULL
, file
, sec
->sh_offset
, 1, sec
->sh_size
,
7689 _("debug_range section data"));
7693 free_debug_range (void)
7695 if (debug_range_contents
== NULL
)
7698 free ((char *) debug_range_contents
);
7699 debug_range_contents
= NULL
;
7700 debug_range_size
= 0;
7703 static unsigned char *debug_abbrev_contents
;
7704 static unsigned long debug_abbrev_size
;
7707 load_debug_abbrev (FILE *file
)
7709 Elf_Internal_Shdr
*sec
;
7711 /* If it is already loaded, do nothing. */
7712 if (debug_abbrev_contents
!= NULL
)
7715 /* Locate the .debug_ranges section. */
7716 sec
= find_section (".debug_abbrev");
7720 debug_abbrev_size
= sec
->sh_size
;
7722 debug_abbrev_contents
= get_data (NULL
, file
, sec
->sh_offset
, 1,
7724 _("debug_abbrev section data"));
7728 free_debug_abbrev (void)
7730 if (debug_abbrev_contents
== NULL
)
7733 free ((char *) debug_abbrev_contents
);
7734 debug_abbrev_contents
= NULL
;
7735 debug_abbrev_size
= 0;
7738 /* Apply addends of RELA relocations. */
7741 debug_apply_rela_addends (FILE *file
,
7742 Elf_Internal_Shdr
*section
,
7744 unsigned char *sec_data
,
7745 unsigned char *start
,
7748 Elf_Internal_Shdr
*relsec
;
7750 if (end
- start
< reloc_size
)
7753 for (relsec
= section_headers
;
7754 relsec
< section_headers
+ elf_header
.e_shnum
;
7757 unsigned long nrelas
;
7758 Elf_Internal_Rela
*rela
, *rp
;
7759 Elf_Internal_Shdr
*symsec
;
7760 Elf_Internal_Sym
*symtab
;
7761 Elf_Internal_Sym
*sym
;
7763 if (relsec
->sh_type
!= SHT_RELA
7764 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
7765 || SECTION_HEADER (relsec
->sh_info
) != section
7766 || relsec
->sh_size
== 0
7767 || SECTION_HEADER_INDEX (relsec
->sh_link
) >= elf_header
.e_shnum
)
7770 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7774 symsec
= SECTION_HEADER (relsec
->sh_link
);
7775 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
7777 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7781 if (rp
->r_offset
>= (bfd_vma
) (start
- sec_data
)
7782 && rp
->r_offset
< (bfd_vma
) (end
- sec_data
) - reloc_size
)
7783 loc
= sec_data
+ rp
->r_offset
;
7789 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
7791 if (ELF32_R_SYM (rp
->r_info
) != 0
7792 && ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
7793 /* Relocations against object symbols can happen,
7794 eg when referencing a global array. For an
7795 example of this see the _clz.o binary in libgcc.a. */
7796 && ELF32_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7798 warn (_("skipping unexpected symbol type %s in relocation in section .rela%s\n"),
7799 get_symbol_type (ELF32_ST_TYPE (sym
->st_info
)),
7800 SECTION_NAME (section
));
7806 /* In MIPS little-endian objects, r_info isn't really a
7807 64-bit little-endian value: it has a 32-bit little-endian
7808 symbol index followed by four individual byte fields.
7809 Reorder INFO accordingly. */
7810 if (elf_header
.e_machine
== EM_MIPS
7811 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
7812 rp
->r_info
= (((rp
->r_info
& 0xffffffff) << 32)
7813 | ((rp
->r_info
>> 56) & 0xff)
7814 | ((rp
->r_info
>> 40) & 0xff00)
7815 | ((rp
->r_info
>> 24) & 0xff0000)
7816 | ((rp
->r_info
>> 8) & 0xff000000));
7818 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
7820 if (ELF64_R_SYM (rp
->r_info
) != 0
7821 && ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
7822 && ELF64_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7824 warn (_("skipping unexpected symbol type %s in relocation in section .rela.%s\n"),
7825 get_symbol_type (ELF64_ST_TYPE (sym
->st_info
)),
7826 SECTION_NAME (section
));
7831 byte_put (loc
, rp
->r_addend
, reloc_size
);
7841 /* FIXME: There are better and more efficient ways to handle
7842 these structures. For now though, I just want something that
7843 is simple to implement. */
7844 typedef struct abbrev_attr
7846 unsigned long attribute
;
7848 struct abbrev_attr
*next
;
7852 typedef struct abbrev_entry
7854 unsigned long entry
;
7857 struct abbrev_attr
*first_attr
;
7858 struct abbrev_attr
*last_attr
;
7859 struct abbrev_entry
*next
;
7863 static abbrev_entry
*first_abbrev
= NULL
;
7864 static abbrev_entry
*last_abbrev
= NULL
;
7869 abbrev_entry
*abbrev
;
7871 for (abbrev
= first_abbrev
; abbrev
;)
7873 abbrev_entry
*next
= abbrev
->next
;
7876 for (attr
= abbrev
->first_attr
; attr
;)
7878 abbrev_attr
*next
= attr
->next
;
7888 last_abbrev
= first_abbrev
= NULL
;
7892 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
7894 abbrev_entry
*entry
;
7896 entry
= malloc (sizeof (*entry
));
7902 entry
->entry
= number
;
7904 entry
->children
= children
;
7905 entry
->first_attr
= NULL
;
7906 entry
->last_attr
= NULL
;
7909 if (first_abbrev
== NULL
)
7910 first_abbrev
= entry
;
7912 last_abbrev
->next
= entry
;
7914 last_abbrev
= entry
;
7918 add_abbrev_attr (unsigned long attribute
, unsigned long form
)
7922 attr
= malloc (sizeof (*attr
));
7928 attr
->attribute
= attribute
;
7932 if (last_abbrev
->first_attr
== NULL
)
7933 last_abbrev
->first_attr
= attr
;
7935 last_abbrev
->last_attr
->next
= attr
;
7937 last_abbrev
->last_attr
= attr
;
7940 /* Processes the (partial) contents of a .debug_abbrev section.
7941 Returns NULL if the end of the section was encountered.
7942 Returns the address after the last byte read if the end of
7943 an abbreviation set was found. */
7945 static unsigned char *
7946 process_abbrev_section (unsigned char *start
, unsigned char *end
)
7948 if (first_abbrev
!= NULL
)
7953 unsigned int bytes_read
;
7954 unsigned long entry
;
7956 unsigned long attribute
;
7959 entry
= read_leb128 (start
, & bytes_read
, 0);
7960 start
+= bytes_read
;
7962 /* A single zero is supposed to end the section according
7963 to the standard. If there's more, then signal that to
7966 return start
== end
? NULL
: start
;
7968 tag
= read_leb128 (start
, & bytes_read
, 0);
7969 start
+= bytes_read
;
7971 children
= *start
++;
7973 add_abbrev (entry
, tag
, children
);
7979 attribute
= read_leb128 (start
, & bytes_read
, 0);
7980 start
+= bytes_read
;
7982 form
= read_leb128 (start
, & bytes_read
, 0);
7983 start
+= bytes_read
;
7986 add_abbrev_attr (attribute
, form
);
7988 while (attribute
!= 0);
7995 get_TAG_name (unsigned long tag
)
7999 case DW_TAG_padding
: return "DW_TAG_padding";
8000 case DW_TAG_array_type
: return "DW_TAG_array_type";
8001 case DW_TAG_class_type
: return "DW_TAG_class_type";
8002 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
8003 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
8004 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
8005 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
8006 case DW_TAG_label
: return "DW_TAG_label";
8007 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
8008 case DW_TAG_member
: return "DW_TAG_member";
8009 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
8010 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
8011 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
8012 case DW_TAG_string_type
: return "DW_TAG_string_type";
8013 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
8014 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
8015 case DW_TAG_typedef
: return "DW_TAG_typedef";
8016 case DW_TAG_union_type
: return "DW_TAG_union_type";
8017 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
8018 case DW_TAG_variant
: return "DW_TAG_variant";
8019 case DW_TAG_common_block
: return "DW_TAG_common_block";
8020 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
8021 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
8022 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
8023 case DW_TAG_module
: return "DW_TAG_module";
8024 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
8025 case DW_TAG_set_type
: return "DW_TAG_set_type";
8026 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
8027 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
8028 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
8029 case DW_TAG_base_type
: return "DW_TAG_base_type";
8030 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
8031 case DW_TAG_const_type
: return "DW_TAG_const_type";
8032 case DW_TAG_constant
: return "DW_TAG_constant";
8033 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
8034 case DW_TAG_file_type
: return "DW_TAG_file_type";
8035 case DW_TAG_friend
: return "DW_TAG_friend";
8036 case DW_TAG_namelist
: return "DW_TAG_namelist";
8037 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
8038 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
8039 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
8040 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
8041 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
8042 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
8043 case DW_TAG_try_block
: return "DW_TAG_try_block";
8044 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
8045 case DW_TAG_variable
: return "DW_TAG_variable";
8046 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
8047 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
8048 case DW_TAG_format_label
: return "DW_TAG_format_label";
8049 case DW_TAG_function_template
: return "DW_TAG_function_template";
8050 case DW_TAG_class_template
: return "DW_TAG_class_template";
8051 /* DWARF 2.1 values. */
8052 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
8053 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
8054 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
8055 case DW_TAG_namespace
: return "DW_TAG_namespace";
8056 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
8057 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
8058 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
8059 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
8061 case DW_TAG_upc_shared_type
: return "DW_TAG_upc_shared_type";
8062 case DW_TAG_upc_strict_type
: return "DW_TAG_upc_strict_type";
8063 case DW_TAG_upc_relaxed_type
: return "DW_TAG_upc_relaxed_type";
8066 static char buffer
[100];
8068 snprintf (buffer
, sizeof (buffer
), _("Unknown TAG value: %lx"), tag
);
8075 get_FORM_name (unsigned long form
)
8079 case DW_FORM_addr
: return "DW_FORM_addr";
8080 case DW_FORM_block2
: return "DW_FORM_block2";
8081 case DW_FORM_block4
: return "DW_FORM_block4";
8082 case DW_FORM_data2
: return "DW_FORM_data2";
8083 case DW_FORM_data4
: return "DW_FORM_data4";
8084 case DW_FORM_data8
: return "DW_FORM_data8";
8085 case DW_FORM_string
: return "DW_FORM_string";
8086 case DW_FORM_block
: return "DW_FORM_block";
8087 case DW_FORM_block1
: return "DW_FORM_block1";
8088 case DW_FORM_data1
: return "DW_FORM_data1";
8089 case DW_FORM_flag
: return "DW_FORM_flag";
8090 case DW_FORM_sdata
: return "DW_FORM_sdata";
8091 case DW_FORM_strp
: return "DW_FORM_strp";
8092 case DW_FORM_udata
: return "DW_FORM_udata";
8093 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
8094 case DW_FORM_ref1
: return "DW_FORM_ref1";
8095 case DW_FORM_ref2
: return "DW_FORM_ref2";
8096 case DW_FORM_ref4
: return "DW_FORM_ref4";
8097 case DW_FORM_ref8
: return "DW_FORM_ref8";
8098 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
8099 case DW_FORM_indirect
: return "DW_FORM_indirect";
8102 static char buffer
[100];
8104 snprintf (buffer
, sizeof (buffer
), _("Unknown FORM value: %lx"), form
);
8110 static unsigned char *
8111 display_block (unsigned char *data
, unsigned long length
)
8113 printf (_(" %lu byte block: "), length
);
8116 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
8122 decode_location_expression (unsigned char * data
,
8123 unsigned int pointer_size
,
8124 unsigned long length
,
8125 unsigned long cu_offset
)
8128 unsigned int bytes_read
;
8129 unsigned long uvalue
;
8130 unsigned char *end
= data
+ length
;
8131 int need_frame_base
= 0;
8140 printf ("DW_OP_addr: %lx",
8141 (unsigned long) byte_get (data
, pointer_size
));
8142 data
+= pointer_size
;
8145 printf ("DW_OP_deref");
8148 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
8151 printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data
++, 1));
8154 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
8158 printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data
, 2));
8162 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
8166 printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data
, 4));
8170 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
8171 (unsigned long) byte_get (data
+ 4, 4));
8175 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
8176 (long) byte_get (data
+ 4, 4));
8180 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
8184 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
8188 printf ("DW_OP_dup");
8191 printf ("DW_OP_drop");
8194 printf ("DW_OP_over");
8197 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
8200 printf ("DW_OP_swap");
8203 printf ("DW_OP_rot");
8206 printf ("DW_OP_xderef");
8209 printf ("DW_OP_abs");
8212 printf ("DW_OP_and");
8215 printf ("DW_OP_div");
8218 printf ("DW_OP_minus");
8221 printf ("DW_OP_mod");
8224 printf ("DW_OP_mul");
8227 printf ("DW_OP_neg");
8230 printf ("DW_OP_not");
8233 printf ("DW_OP_or");
8236 printf ("DW_OP_plus");
8238 case DW_OP_plus_uconst
:
8239 printf ("DW_OP_plus_uconst: %lu",
8240 read_leb128 (data
, &bytes_read
, 0));
8244 printf ("DW_OP_shl");
8247 printf ("DW_OP_shr");
8250 printf ("DW_OP_shra");
8253 printf ("DW_OP_xor");
8256 printf ("DW_OP_bra: %ld", (long) byte_get_signed (data
, 2));
8260 printf ("DW_OP_eq");
8263 printf ("DW_OP_ge");
8266 printf ("DW_OP_gt");
8269 printf ("DW_OP_le");
8272 printf ("DW_OP_lt");
8275 printf ("DW_OP_ne");
8278 printf ("DW_OP_skip: %ld", (long) byte_get_signed (data
, 2));
8314 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
8349 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
8384 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
8385 read_leb128 (data
, &bytes_read
, 1));
8390 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
8394 need_frame_base
= 1;
8395 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
8399 uvalue
= read_leb128 (data
, &bytes_read
, 0);
8401 printf ("DW_OP_bregx: %lu %ld", uvalue
,
8402 read_leb128 (data
, &bytes_read
, 1));
8406 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
8409 case DW_OP_deref_size
:
8410 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
8412 case DW_OP_xderef_size
:
8413 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
8416 printf ("DW_OP_nop");
8419 /* DWARF 3 extensions. */
8420 case DW_OP_push_object_address
:
8421 printf ("DW_OP_push_object_address");
8424 /* XXX: Strictly speaking for 64-bit DWARF3 files
8425 this ought to be an 8-byte wide computation. */
8426 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2) + cu_offset
);
8430 /* XXX: Strictly speaking for 64-bit DWARF3 files
8431 this ought to be an 8-byte wide computation. */
8432 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4) + cu_offset
);
8435 case DW_OP_call_ref
:
8436 printf ("DW_OP_call_ref");
8439 /* GNU extensions. */
8440 case DW_OP_GNU_push_tls_address
:
8441 printf ("DW_OP_GNU_push_tls_address");
8445 if (op
>= DW_OP_lo_user
8446 && op
<= DW_OP_hi_user
)
8447 printf (_("(User defined location op)"));
8449 printf (_("(Unknown location op)"));
8450 /* No way to tell where the next op is, so just bail. */
8451 return need_frame_base
;
8454 /* Separate the ops. */
8459 return need_frame_base
;
8462 /* This structure records the information that
8463 we extract from the.debug_info section. */
8466 unsigned int pointer_size
;
8467 unsigned long cu_offset
;
8468 unsigned long base_address
;
8469 /* This is an array of offsets to the location list table. */
8470 unsigned long *loc_offsets
;
8471 int *have_frame_base
;
8472 unsigned int num_loc_offsets
;
8473 unsigned int max_loc_offsets
;
8474 unsigned long *range_lists
;
8475 unsigned int num_range_lists
;
8476 unsigned int max_range_lists
;
8480 static debug_info
* debug_information
= NULL
;
8481 static unsigned int num_debug_info_entries
= 0;
8482 static unsigned int last_pointer_size
= 0;
8483 static int warned_about_missing_comp_units
= FALSE
;
8485 static unsigned char *
8486 read_and_display_attr_value (unsigned long attribute
,
8488 unsigned char *data
,
8489 unsigned long cu_offset
,
8490 unsigned long pointer_size
,
8491 unsigned long offset_size
,
8493 debug_info
*debug_info_p
,
8496 unsigned long uvalue
= 0;
8497 unsigned char *block_start
= NULL
;
8498 unsigned int bytes_read
;
8505 case DW_FORM_ref_addr
:
8506 if (dwarf_version
== 2)
8508 uvalue
= byte_get (data
, pointer_size
);
8509 data
+= pointer_size
;
8511 else if (dwarf_version
== 3)
8513 uvalue
= byte_get (data
, offset_size
);
8514 data
+= offset_size
;
8518 error (_("Internal error: DWARF version is not 2 or 3.\n"));
8523 uvalue
= byte_get (data
, pointer_size
);
8524 data
+= pointer_size
;
8528 uvalue
= byte_get (data
, offset_size
);
8529 data
+= offset_size
;
8535 uvalue
= byte_get (data
++, 1);
8540 uvalue
= byte_get (data
, 2);
8546 uvalue
= byte_get (data
, 4);
8551 uvalue
= read_leb128 (data
, & bytes_read
, 1);
8555 case DW_FORM_ref_udata
:
8557 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8561 case DW_FORM_indirect
:
8562 form
= read_leb128 (data
, & bytes_read
, 0);
8565 printf (" %s", get_FORM_name (form
));
8566 return read_and_display_attr_value (attribute
, form
, data
,
8567 cu_offset
, pointer_size
,
8568 offset_size
, dwarf_version
,
8569 debug_info_p
, do_loc
);
8574 case DW_FORM_ref_addr
:
8576 printf (" <#%lx>", uvalue
);
8582 case DW_FORM_ref_udata
:
8584 printf (" <%lx>", uvalue
+ cu_offset
);
8590 printf (" %#lx", uvalue
);
8599 printf (" %ld", uvalue
);
8606 uvalue
= byte_get (data
, 4);
8607 printf (" %lx", uvalue
);
8608 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
8610 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8611 && num_debug_info_entries
== 0)
8613 if (sizeof (uvalue
) == 8)
8614 uvalue
= byte_get (data
, 8);
8616 error (_("DW_FORM_data8 is unsupported when sizeof (unsigned long) != 8\n"));
8621 case DW_FORM_string
:
8623 printf (" %s", data
);
8624 data
+= strlen ((char *) data
) + 1;
8628 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8629 block_start
= data
+ bytes_read
;
8631 data
= block_start
+ uvalue
;
8633 data
= display_block (block_start
, uvalue
);
8636 case DW_FORM_block1
:
8637 uvalue
= byte_get (data
, 1);
8638 block_start
= data
+ 1;
8640 data
= block_start
+ uvalue
;
8642 data
= display_block (block_start
, uvalue
);
8645 case DW_FORM_block2
:
8646 uvalue
= byte_get (data
, 2);
8647 block_start
= data
+ 2;
8649 data
= block_start
+ uvalue
;
8651 data
= display_block (block_start
, uvalue
);
8654 case DW_FORM_block4
:
8655 uvalue
= byte_get (data
, 4);
8656 block_start
= data
+ 4;
8658 data
= block_start
+ uvalue
;
8660 data
= display_block (block_start
, uvalue
);
8665 printf (_(" (indirect string, offset: 0x%lx): %s"),
8666 uvalue
, fetch_indirect_string (uvalue
));
8669 case DW_FORM_indirect
:
8670 /* Handled above. */
8674 warn (_("Unrecognized form: %lu\n"), form
);
8678 /* For some attributes we can display further information. */
8679 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8680 && num_debug_info_entries
== 0)
8684 case DW_AT_frame_base
:
8685 have_frame_base
= 1;
8686 case DW_AT_location
:
8687 case DW_AT_data_member_location
:
8688 case DW_AT_vtable_elem_location
:
8689 case DW_AT_allocated
:
8690 case DW_AT_associated
:
8691 case DW_AT_data_location
:
8693 case DW_AT_upper_bound
:
8694 case DW_AT_lower_bound
:
8695 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8697 /* Process location list. */
8698 unsigned int max
= debug_info_p
->max_loc_offsets
;
8699 unsigned int num
= debug_info_p
->num_loc_offsets
;
8701 if (max
== 0 || num
>= max
)
8704 debug_info_p
->loc_offsets
8705 = xcrealloc (debug_info_p
->loc_offsets
,
8706 max
, sizeof (*debug_info_p
->loc_offsets
));
8707 debug_info_p
->have_frame_base
8708 = xcrealloc (debug_info_p
->have_frame_base
,
8709 max
, sizeof (*debug_info_p
->have_frame_base
));
8710 debug_info_p
->max_loc_offsets
= max
;
8712 debug_info_p
->loc_offsets
[num
] = uvalue
;
8713 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
8714 debug_info_p
->num_loc_offsets
++;
8719 if (need_base_address
)
8720 debug_info_p
->base_address
= uvalue
;
8724 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8726 /* Process range list. */
8727 unsigned int max
= debug_info_p
->max_range_lists
;
8728 unsigned int num
= debug_info_p
->num_range_lists
;
8730 if (max
== 0 || num
>= max
)
8733 debug_info_p
->range_lists
8734 = xcrealloc (debug_info_p
->range_lists
,
8735 max
, sizeof (*debug_info_p
->range_lists
));
8736 debug_info_p
->max_range_lists
= max
;
8738 debug_info_p
->range_lists
[num
] = uvalue
;
8739 debug_info_p
->num_range_lists
++;
8758 case DW_INL_not_inlined
:
8759 printf (_("(not inlined)"));
8761 case DW_INL_inlined
:
8762 printf (_("(inlined)"));
8764 case DW_INL_declared_not_inlined
:
8765 printf (_("(declared as inline but ignored)"));
8767 case DW_INL_declared_inlined
:
8768 printf (_("(declared as inline and inlined)"));
8771 printf (_(" (Unknown inline attribute value: %lx)"), uvalue
);
8776 case DW_AT_language
:
8779 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
8780 case DW_LANG_C89
: printf ("(ANSI C)"); break;
8781 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
8782 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
8783 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
8784 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
8785 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
8786 case DW_LANG_Ada83
: printf ("(Ada)"); break;
8787 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
8788 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
8789 /* DWARF 2.1 values. */
8790 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
8791 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
8792 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
8793 /* MIPS extension. */
8794 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
8795 /* UPC extension. */
8796 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
8798 printf ("(Unknown: %lx)", uvalue
);
8803 case DW_AT_encoding
:
8806 case DW_ATE_void
: printf ("(void)"); break;
8807 case DW_ATE_address
: printf ("(machine address)"); break;
8808 case DW_ATE_boolean
: printf ("(boolean)"); break;
8809 case DW_ATE_complex_float
: printf ("(complex float)"); break;
8810 case DW_ATE_float
: printf ("(float)"); break;
8811 case DW_ATE_signed
: printf ("(signed)"); break;
8812 case DW_ATE_signed_char
: printf ("(signed char)"); break;
8813 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
8814 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
8815 /* DWARF 2.1 value. */
8816 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
8817 case DW_ATE_decimal_float
: printf ("(decimal float)"); break;
8819 if (uvalue
>= DW_ATE_lo_user
8820 && uvalue
<= DW_ATE_hi_user
)
8821 printf ("(user defined type)");
8823 printf ("(unknown type)");
8828 case DW_AT_accessibility
:
8831 case DW_ACCESS_public
: printf ("(public)"); break;
8832 case DW_ACCESS_protected
: printf ("(protected)"); break;
8833 case DW_ACCESS_private
: printf ("(private)"); break;
8835 printf ("(unknown accessibility)");
8840 case DW_AT_visibility
:
8843 case DW_VIS_local
: printf ("(local)"); break;
8844 case DW_VIS_exported
: printf ("(exported)"); break;
8845 case DW_VIS_qualified
: printf ("(qualified)"); break;
8846 default: printf ("(unknown visibility)"); break;
8850 case DW_AT_virtuality
:
8853 case DW_VIRTUALITY_none
: printf ("(none)"); break;
8854 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
8855 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
8856 default: printf ("(unknown virtuality)"); break;
8860 case DW_AT_identifier_case
:
8863 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
8864 case DW_ID_up_case
: printf ("(up_case)"); break;
8865 case DW_ID_down_case
: printf ("(down_case)"); break;
8866 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
8867 default: printf ("(unknown case)"); break;
8871 case DW_AT_calling_convention
:
8874 case DW_CC_normal
: printf ("(normal)"); break;
8875 case DW_CC_program
: printf ("(program)"); break;
8876 case DW_CC_nocall
: printf ("(nocall)"); break;
8878 if (uvalue
>= DW_CC_lo_user
8879 && uvalue
<= DW_CC_hi_user
)
8880 printf ("(user defined)");
8882 printf ("(unknown convention)");
8886 case DW_AT_ordering
:
8889 case -1: printf ("(undefined)"); break;
8890 case 0: printf ("(row major)"); break;
8891 case 1: printf ("(column major)"); break;
8895 case DW_AT_frame_base
:
8896 have_frame_base
= 1;
8897 case DW_AT_location
:
8898 case DW_AT_data_member_location
:
8899 case DW_AT_vtable_elem_location
:
8900 case DW_AT_allocated
:
8901 case DW_AT_associated
:
8902 case DW_AT_data_location
:
8904 case DW_AT_upper_bound
:
8905 case DW_AT_lower_bound
:
8908 int need_frame_base
;
8911 need_frame_base
= decode_location_expression (block_start
,
8916 if (need_frame_base
&& !have_frame_base
)
8917 printf (_(" [without DW_AT_frame_base]"));
8919 else if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8920 printf (_("(location list)"));
8932 get_AT_name (unsigned long attribute
)
8936 case DW_AT_sibling
: return "DW_AT_sibling";
8937 case DW_AT_location
: return "DW_AT_location";
8938 case DW_AT_name
: return "DW_AT_name";
8939 case DW_AT_ordering
: return "DW_AT_ordering";
8940 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
8941 case DW_AT_byte_size
: return "DW_AT_byte_size";
8942 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
8943 case DW_AT_bit_size
: return "DW_AT_bit_size";
8944 case DW_AT_element_list
: return "DW_AT_element_list";
8945 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
8946 case DW_AT_low_pc
: return "DW_AT_low_pc";
8947 case DW_AT_high_pc
: return "DW_AT_high_pc";
8948 case DW_AT_language
: return "DW_AT_language";
8949 case DW_AT_member
: return "DW_AT_member";
8950 case DW_AT_discr
: return "DW_AT_discr";
8951 case DW_AT_discr_value
: return "DW_AT_discr_value";
8952 case DW_AT_visibility
: return "DW_AT_visibility";
8953 case DW_AT_import
: return "DW_AT_import";
8954 case DW_AT_string_length
: return "DW_AT_string_length";
8955 case DW_AT_common_reference
: return "DW_AT_common_reference";
8956 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
8957 case DW_AT_const_value
: return "DW_AT_const_value";
8958 case DW_AT_containing_type
: return "DW_AT_containing_type";
8959 case DW_AT_default_value
: return "DW_AT_default_value";
8960 case DW_AT_inline
: return "DW_AT_inline";
8961 case DW_AT_is_optional
: return "DW_AT_is_optional";
8962 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
8963 case DW_AT_producer
: return "DW_AT_producer";
8964 case DW_AT_prototyped
: return "DW_AT_prototyped";
8965 case DW_AT_return_addr
: return "DW_AT_return_addr";
8966 case DW_AT_start_scope
: return "DW_AT_start_scope";
8967 case DW_AT_stride_size
: return "DW_AT_stride_size";
8968 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
8969 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
8970 case DW_AT_accessibility
: return "DW_AT_accessibility";
8971 case DW_AT_address_class
: return "DW_AT_address_class";
8972 case DW_AT_artificial
: return "DW_AT_artificial";
8973 case DW_AT_base_types
: return "DW_AT_base_types";
8974 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
8975 case DW_AT_count
: return "DW_AT_count";
8976 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
8977 case DW_AT_decl_column
: return "DW_AT_decl_column";
8978 case DW_AT_decl_file
: return "DW_AT_decl_file";
8979 case DW_AT_decl_line
: return "DW_AT_decl_line";
8980 case DW_AT_declaration
: return "DW_AT_declaration";
8981 case DW_AT_discr_list
: return "DW_AT_discr_list";
8982 case DW_AT_encoding
: return "DW_AT_encoding";
8983 case DW_AT_external
: return "DW_AT_external";
8984 case DW_AT_frame_base
: return "DW_AT_frame_base";
8985 case DW_AT_friend
: return "DW_AT_friend";
8986 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
8987 case DW_AT_macro_info
: return "DW_AT_macro_info";
8988 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
8989 case DW_AT_priority
: return "DW_AT_priority";
8990 case DW_AT_segment
: return "DW_AT_segment";
8991 case DW_AT_specification
: return "DW_AT_specification";
8992 case DW_AT_static_link
: return "DW_AT_static_link";
8993 case DW_AT_type
: return "DW_AT_type";
8994 case DW_AT_use_location
: return "DW_AT_use_location";
8995 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
8996 case DW_AT_virtuality
: return "DW_AT_virtuality";
8997 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
8998 /* DWARF 2.1 values. */
8999 case DW_AT_allocated
: return "DW_AT_allocated";
9000 case DW_AT_associated
: return "DW_AT_associated";
9001 case DW_AT_data_location
: return "DW_AT_data_location";
9002 case DW_AT_stride
: return "DW_AT_stride";
9003 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
9004 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
9005 case DW_AT_extension
: return "DW_AT_extension";
9006 case DW_AT_ranges
: return "DW_AT_ranges";
9007 case DW_AT_trampoline
: return "DW_AT_trampoline";
9008 case DW_AT_call_column
: return "DW_AT_call_column";
9009 case DW_AT_call_file
: return "DW_AT_call_file";
9010 case DW_AT_call_line
: return "DW_AT_call_line";
9011 /* SGI/MIPS extensions. */
9012 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
9013 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
9014 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
9015 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
9016 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
9017 case DW_AT_MIPS_software_pipeline_depth
:
9018 return "DW_AT_MIPS_software_pipeline_depth";
9019 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
9020 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
9021 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
9022 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
9023 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
9024 /* GNU extensions. */
9025 case DW_AT_sf_names
: return "DW_AT_sf_names";
9026 case DW_AT_src_info
: return "DW_AT_src_info";
9027 case DW_AT_mac_info
: return "DW_AT_mac_info";
9028 case DW_AT_src_coords
: return "DW_AT_src_coords";
9029 case DW_AT_body_begin
: return "DW_AT_body_begin";
9030 case DW_AT_body_end
: return "DW_AT_body_end";
9031 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
9032 /* UPC extension. */
9033 case DW_AT_upc_threads_scaled
: return "DW_AT_upc_threads_scaled";
9036 static char buffer
[100];
9038 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
9045 static unsigned char *
9046 read_and_display_attr (unsigned long attribute
,
9048 unsigned char *data
,
9049 unsigned long cu_offset
,
9050 unsigned long pointer_size
,
9051 unsigned long offset_size
,
9053 debug_info
*debug_info_p
,
9057 printf (" %-18s:", get_AT_name (attribute
));
9058 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
9059 pointer_size
, offset_size
,
9060 dwarf_version
, debug_info_p
,
9068 /* Process the contents of a .debug_info section. If do_loc is non-zero
9069 then we are scanning for location lists and we do not want to display
9070 anything to the user. */
9073 process_debug_info (Elf_Internal_Shdr
*section
, unsigned char *start
,
9074 FILE *file
, int do_loc
)
9076 unsigned char *end
= start
+ section
->sh_size
;
9077 unsigned char *section_begin
;
9079 unsigned int num_units
= 0;
9081 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
9082 && num_debug_info_entries
== 0)
9084 unsigned long length
;
9086 /* First scan the section to get the number of comp units. */
9087 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
9090 /* Read the first 4 bytes. For a 32-bit DWARF section, this
9091 will be the length. For a 64-bit DWARF section, it'll be
9092 the escape code 0xffffffff followed by an 8 byte length. */
9093 length
= byte_get (section_begin
, 4);
9095 if (length
== 0xffffffff)
9097 length
= byte_get (section_begin
+ 4, 8);
9098 section_begin
+= length
+ 12;
9101 section_begin
+= length
+ 4;
9106 error (_("No comp units in .debug_info section ?"));
9110 /* Then allocate an array to hold the information. */
9111 debug_information
= cmalloc (num_units
,
9112 sizeof (* debug_information
));
9113 if (debug_information
== NULL
)
9115 error (_("Not enough memory for a debug info array of %u entries"),
9123 printf (_("The section %s contains:\n\n"),
9124 SECTION_NAME (section
));
9126 load_debug_str (file
);
9127 load_debug_loc (file
);
9128 load_debug_range (file
);
9131 load_debug_abbrev (file
);
9132 if (debug_abbrev_contents
== NULL
)
9134 warn (_("Unable to locate .debug_abbrev section!\n"));
9138 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
9140 DWARF2_Internal_CompUnit compunit
;
9141 unsigned char *hdrptr
;
9142 unsigned char *cu_abbrev_offset_ptr
;
9143 unsigned char *tags
;
9145 unsigned long cu_offset
;
9147 int initial_length_size
;
9151 compunit
.cu_length
= byte_get (hdrptr
, 4);
9154 if (compunit
.cu_length
== 0xffffffff)
9156 compunit
.cu_length
= byte_get (hdrptr
, 8);
9159 initial_length_size
= 12;
9164 initial_length_size
= 4;
9167 compunit
.cu_version
= byte_get (hdrptr
, 2);
9170 cu_offset
= start
- section_begin
;
9171 start
+= compunit
.cu_length
+ initial_length_size
;
9173 if (elf_header
.e_type
== ET_REL
9174 && !debug_apply_rela_addends (file
, section
, offset_size
,
9175 section_begin
, hdrptr
, start
))
9178 cu_abbrev_offset_ptr
= hdrptr
;
9179 compunit
.cu_abbrev_offset
= byte_get (hdrptr
, offset_size
);
9180 hdrptr
+= offset_size
;
9182 compunit
.cu_pointer_size
= byte_get (hdrptr
, 1);
9184 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
9185 && num_debug_info_entries
== 0)
9187 debug_information
[unit
].cu_offset
= cu_offset
;
9188 debug_information
[unit
].pointer_size
9189 = compunit
.cu_pointer_size
;
9190 debug_information
[unit
].base_address
= 0;
9191 debug_information
[unit
].loc_offsets
= NULL
;
9192 debug_information
[unit
].have_frame_base
= NULL
;
9193 debug_information
[unit
].max_loc_offsets
= 0;
9194 debug_information
[unit
].num_loc_offsets
= 0;
9195 debug_information
[unit
].range_lists
= NULL
;
9196 debug_information
[unit
].max_range_lists
= 0;
9197 debug_information
[unit
].num_range_lists
= 0;
9204 printf (_(" Compilation Unit @ offset 0x%lx:\n"), cu_offset
);
9205 printf (_(" Length: %ld\n"), compunit
.cu_length
);
9206 printf (_(" Version: %d\n"), compunit
.cu_version
);
9207 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
9208 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
9211 if (compunit
.cu_version
!= 2 && compunit
.cu_version
!= 3)
9213 warn (_("Only version 2 and 3 DWARF debug information is currently supported.\n"));
9219 /* Process the abbrevs used by this compilation unit. */
9220 process_abbrev_section
9221 (debug_abbrev_contents
+ compunit
.cu_abbrev_offset
,
9222 debug_abbrev_contents
+ debug_abbrev_size
);
9225 while (tags
< start
)
9227 unsigned int bytes_read
;
9228 unsigned long abbrev_number
;
9229 abbrev_entry
*entry
;
9232 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
9235 /* A null DIE marks the end of a list of children. */
9236 if (abbrev_number
== 0)
9242 /* Scan through the abbreviation list until we reach the
9244 for (entry
= first_abbrev
;
9245 entry
&& entry
->entry
!= abbrev_number
;
9246 entry
= entry
->next
)
9251 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
9257 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
9259 (unsigned long) (tags
- section_begin
9262 get_TAG_name (entry
->tag
));
9267 need_base_address
= 0;
9269 case DW_TAG_compile_unit
:
9270 need_base_address
= 1;
9272 case DW_TAG_entry_point
:
9273 case DW_TAG_inlined_subroutine
:
9274 case DW_TAG_subprogram
:
9275 need_base_address
= 0;
9276 /* Assuming that there is no DW_AT_frame_base. */
9277 have_frame_base
= 0;
9281 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
9282 tags
= read_and_display_attr (attr
->attribute
,
9285 compunit
.cu_pointer_size
,
9287 compunit
.cu_version
,
9288 &debug_information
[unit
],
9291 if (entry
->children
)
9296 free_debug_abbrev ();
9298 /* Set num_debug_info_entries here so that it can be used to check if
9299 we need to process .debug_loc and .debug_ranges sections. */
9300 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
9301 && num_debug_info_entries
== 0)
9302 num_debug_info_entries
= num_units
;
9306 free_debug_range ();
9316 /* Retrieve the pointer size associated with the given compilation unit.
9317 Optionally the offset of this unit into the .debug_info section is
9318 also retutned. If there is no .debug_info section then an error
9319 message is issued and 0 is returned. If the requested comp unit has
9320 not been defined in the .debug_info section then a warning message
9321 is issued and the last know pointer size is returned. This message
9322 is only issued once per section dumped per file dumped. */
9325 get_pointer_size_and_offset_of_comp_unit (unsigned int comp_unit
,
9326 const char * section_name
,
9327 unsigned long * offset_return
)
9329 unsigned long offset
= 0;
9331 if (num_debug_info_entries
== 0)
9332 error (_("%s section needs a populated .debug_info section\n"),
9335 else if (comp_unit
>= num_debug_info_entries
)
9337 if (!warned_about_missing_comp_units
)
9339 warn (_("%s section has more comp units than .debug_info section\n"),
9341 warn (_("assuming that the pointer size is %d, from the last comp unit in .debug_info\n\n"),
9343 warned_about_missing_comp_units
= TRUE
;
9348 last_pointer_size
= debug_information
[comp_unit
].pointer_size
;
9349 offset
= debug_information
[comp_unit
].cu_offset
;
9352 if (offset_return
!= NULL
)
9353 * offset_return
= offset
;
9355 return last_pointer_size
;
9358 /* Locate and scan the .debug_info section in the file and record the pointer
9359 sizes and offsets for the compilation units in it. Usually an executable
9360 will have just one pointer size, but this is not guaranteed, and so we try
9361 not to make any assumptions. Returns zero upon failure, or the number of
9362 compilation units upon success. */
9365 get_debug_info (FILE * file
)
9367 Elf_Internal_Shdr
* section
;
9368 unsigned char * start
;
9371 /* Reset the last pointer size so that we can issue correct error
9372 messages if we are displaying the contents of more than one section. */
9373 last_pointer_size
= 0;
9374 warned_about_missing_comp_units
= FALSE
;
9376 /* If we already have the information there is nothing else to do. */
9377 if (num_debug_info_entries
> 0)
9378 return num_debug_info_entries
;
9380 section
= find_section (".debug_info");
9381 if (section
== NULL
)
9384 start
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
9385 _("extracting information from .debug_info section"));
9389 ret
= process_debug_info (section
, start
, file
, 1);
9392 return ret
? num_debug_info_entries
: 0;
9396 display_debug_lines (Elf_Internal_Shdr
*section
,
9397 unsigned char *start
, FILE *file
)
9399 unsigned char *data
= start
;
9400 unsigned char *end
= start
+ section
->sh_size
;
9401 unsigned int comp_unit
= 0;
9403 printf (_("\nDump of debug contents of section %s:\n\n"),
9404 SECTION_NAME (section
));
9406 get_debug_info (file
);
9410 DWARF2_Internal_LineInfo info
;
9411 unsigned char *standard_opcodes
;
9412 unsigned char *end_of_sequence
;
9413 unsigned char *hdrptr
;
9414 unsigned int pointer_size
;
9415 int initial_length_size
;
9421 /* Check the length of the block. */
9422 info
.li_length
= byte_get (hdrptr
, 4);
9425 if (info
.li_length
== 0xffffffff)
9427 /* This section is 64-bit DWARF 3. */
9428 info
.li_length
= byte_get (hdrptr
, 8);
9431 initial_length_size
= 12;
9436 initial_length_size
= 4;
9439 if (info
.li_length
+ initial_length_size
> section
->sh_size
)
9442 (_("The line info appears to be corrupt - the section is too small\n"));
9446 /* Check its version number. */
9447 info
.li_version
= byte_get (hdrptr
, 2);
9449 if (info
.li_version
!= 2 && info
.li_version
!= 3)
9451 warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
9455 info
.li_prologue_length
= byte_get (hdrptr
, offset_size
);
9456 hdrptr
+= offset_size
;
9457 info
.li_min_insn_length
= byte_get (hdrptr
, 1);
9459 info
.li_default_is_stmt
= byte_get (hdrptr
, 1);
9461 info
.li_line_base
= byte_get (hdrptr
, 1);
9463 info
.li_line_range
= byte_get (hdrptr
, 1);
9465 info
.li_opcode_base
= byte_get (hdrptr
, 1);
9468 /* Sign extend the line base field. */
9469 info
.li_line_base
<<= 24;
9470 info
.li_line_base
>>= 24;
9472 /* Get the pointer size from the comp unit associated
9473 with this block of line number information. */
9474 pointer_size
= get_pointer_size_and_offset_of_comp_unit
9475 (comp_unit
, ".debug_line", NULL
);
9478 printf (_(" Length: %ld\n"), info
.li_length
);
9479 printf (_(" DWARF Version: %d\n"), info
.li_version
);
9480 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
9481 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
9482 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
9483 printf (_(" Line Base: %d\n"), info
.li_line_base
);
9484 printf (_(" Line Range: %d\n"), info
.li_line_range
);
9485 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
9486 printf (_(" (Pointer size: %u)%s\n"),
9488 warned_about_missing_comp_units
? " [assumed]" : "" );
9490 end_of_sequence
= data
+ info
.li_length
+ initial_length_size
;
9492 reset_state_machine (info
.li_default_is_stmt
);
9494 /* Display the contents of the Opcodes table. */
9495 standard_opcodes
= hdrptr
;
9497 printf (_("\n Opcodes:\n"));
9499 for (i
= 1; i
< info
.li_opcode_base
; i
++)
9500 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
9502 /* Display the contents of the Directory table. */
9503 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
9506 printf (_("\n The Directory Table is empty.\n"));
9509 printf (_("\n The Directory Table:\n"));
9513 printf (_(" %s\n"), data
);
9515 data
+= strlen ((char *) data
) + 1;
9519 /* Skip the NUL at the end of the table. */
9522 /* Display the contents of the File Name table. */
9524 printf (_("\n The File Name Table is empty.\n"));
9527 printf (_("\n The File Name Table:\n"));
9528 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
9532 unsigned char *name
;
9533 unsigned int bytes_read
;
9535 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
9538 data
+= strlen ((char *) data
) + 1;
9540 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9542 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9544 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9546 printf (_("%s\n"), name
);
9550 /* Skip the NUL at the end of the table. */
9553 /* Now display the statements. */
9554 printf (_("\n Line Number Statements:\n"));
9556 while (data
< end_of_sequence
)
9558 unsigned char op_code
;
9560 unsigned int bytes_read
;
9564 if (op_code
>= info
.li_opcode_base
)
9566 op_code
-= info
.li_opcode_base
;
9567 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
9568 state_machine_regs
.address
+= adv
;
9569 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
9570 op_code
, adv
, state_machine_regs
.address
);
9571 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
9572 state_machine_regs
.line
+= adv
;
9573 printf (_(" and Line by %d to %d\n"),
9574 adv
, state_machine_regs
.line
);
9576 else switch (op_code
)
9578 case DW_LNS_extended_op
:
9579 if (pointer_size
== 0)
9581 warn (_("Extend line ops need a valid pointer size, guessing at 4\n"));
9585 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
9590 printf (_(" Copy\n"));
9593 case DW_LNS_advance_pc
:
9594 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
9596 state_machine_regs
.address
+= adv
;
9597 printf (_(" Advance PC by %d to %lx\n"), adv
,
9598 state_machine_regs
.address
);
9601 case DW_LNS_advance_line
:
9602 adv
= read_leb128 (data
, & bytes_read
, 1);
9604 state_machine_regs
.line
+= adv
;
9605 printf (_(" Advance Line by %d to %d\n"), adv
,
9606 state_machine_regs
.line
);
9609 case DW_LNS_set_file
:
9610 adv
= read_leb128 (data
, & bytes_read
, 0);
9612 printf (_(" Set File Name to entry %d in the File Name Table\n"),
9614 state_machine_regs
.file
= adv
;
9617 case DW_LNS_set_column
:
9618 adv
= read_leb128 (data
, & bytes_read
, 0);
9620 printf (_(" Set column to %d\n"), adv
);
9621 state_machine_regs
.column
= adv
;
9624 case DW_LNS_negate_stmt
:
9625 adv
= state_machine_regs
.is_stmt
;
9627 printf (_(" Set is_stmt to %d\n"), adv
);
9628 state_machine_regs
.is_stmt
= adv
;
9631 case DW_LNS_set_basic_block
:
9632 printf (_(" Set basic block\n"));
9633 state_machine_regs
.basic_block
= 1;
9636 case DW_LNS_const_add_pc
:
9637 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
9638 * info
.li_min_insn_length
);
9639 state_machine_regs
.address
+= adv
;
9640 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
9641 state_machine_regs
.address
);
9644 case DW_LNS_fixed_advance_pc
:
9645 adv
= byte_get (data
, 2);
9647 state_machine_regs
.address
+= adv
;
9648 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
9649 adv
, state_machine_regs
.address
);
9652 case DW_LNS_set_prologue_end
:
9653 printf (_(" Set prologue_end to true\n"));
9656 case DW_LNS_set_epilogue_begin
:
9657 printf (_(" Set epilogue_begin to true\n"));
9660 case DW_LNS_set_isa
:
9661 adv
= read_leb128 (data
, & bytes_read
, 0);
9663 printf (_(" Set ISA to %d\n"), adv
);
9667 printf (_(" Unknown opcode %d with operands: "), op_code
);
9669 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
9671 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
9672 i
== 1 ? "" : ", ");
9686 display_debug_pubnames (Elf_Internal_Shdr
*section
,
9687 unsigned char *start
,
9688 FILE *file ATTRIBUTE_UNUSED
)
9690 DWARF2_Internal_PubNames pubnames
;
9693 end
= start
+ section
->sh_size
;
9695 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9699 unsigned char *data
;
9700 unsigned long offset
;
9701 int offset_size
, initial_length_size
;
9705 pubnames
.pn_length
= byte_get (data
, 4);
9707 if (pubnames
.pn_length
== 0xffffffff)
9709 pubnames
.pn_length
= byte_get (data
, 8);
9712 initial_length_size
= 12;
9717 initial_length_size
= 4;
9720 pubnames
.pn_version
= byte_get (data
, 2);
9722 pubnames
.pn_offset
= byte_get (data
, offset_size
);
9723 data
+= offset_size
;
9724 pubnames
.pn_size
= byte_get (data
, offset_size
);
9725 data
+= offset_size
;
9727 start
+= pubnames
.pn_length
+ initial_length_size
;
9729 if (pubnames
.pn_version
!= 2 && pubnames
.pn_version
!= 3)
9731 static int warned
= 0;
9735 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
9742 printf (_(" Length: %ld\n"),
9743 pubnames
.pn_length
);
9744 printf (_(" Version: %d\n"),
9745 pubnames
.pn_version
);
9746 printf (_(" Offset into .debug_info section: %ld\n"),
9747 pubnames
.pn_offset
);
9748 printf (_(" Size of area in .debug_info section: %ld\n"),
9751 printf (_("\n Offset\tName\n"));
9755 offset
= byte_get (data
, offset_size
);
9759 data
+= offset_size
;
9760 printf (" %-6ld\t\t%s\n", offset
, data
);
9761 data
+= strlen ((char *) data
) + 1;
9764 while (offset
!= 0);
9772 display_debug_macinfo (Elf_Internal_Shdr
*section
,
9773 unsigned char *start
,
9774 FILE *file ATTRIBUTE_UNUSED
)
9776 unsigned char *end
= start
+ section
->sh_size
;
9777 unsigned char *curr
= start
;
9778 unsigned int bytes_read
;
9779 enum dwarf_macinfo_record_type op
;
9781 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9785 unsigned int lineno
;
9793 case DW_MACINFO_start_file
:
9795 unsigned int filenum
;
9797 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9799 filenum
= read_leb128 (curr
, & bytes_read
, 0);
9802 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
9807 case DW_MACINFO_end_file
:
9808 printf (_(" DW_MACINFO_end_file\n"));
9811 case DW_MACINFO_define
:
9812 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9814 string
= (char *) curr
;
9815 curr
+= strlen (string
) + 1;
9816 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
9820 case DW_MACINFO_undef
:
9821 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9823 string
= (char *) curr
;
9824 curr
+= strlen (string
) + 1;
9825 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
9829 case DW_MACINFO_vendor_ext
:
9831 unsigned int constant
;
9833 constant
= read_leb128 (curr
, & bytes_read
, 0);
9835 string
= (char *) curr
;
9836 curr
+= strlen (string
) + 1;
9837 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
9849 display_debug_abbrev (Elf_Internal_Shdr
*section
,
9850 unsigned char *start
,
9851 FILE *file ATTRIBUTE_UNUSED
)
9853 abbrev_entry
*entry
;
9854 unsigned char *end
= start
+ section
->sh_size
;
9856 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9860 start
= process_abbrev_section (start
, end
);
9862 if (first_abbrev
== NULL
)
9865 printf (_(" Number TAG\n"));
9867 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
9871 printf (_(" %ld %s [%s]\n"),
9873 get_TAG_name (entry
->tag
),
9874 entry
->children
? _("has children") : _("no children"));
9876 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
9877 printf (_(" %-18s %s\n"),
9878 get_AT_name (attr
->attribute
),
9879 get_FORM_name (attr
->form
));
9892 display_debug_loc (Elf_Internal_Shdr
*section
,
9893 unsigned char *start
, FILE *file
)
9895 unsigned char *section_end
;
9896 unsigned long bytes
;
9897 unsigned char *section_begin
= start
;
9898 unsigned int num_loc_list
= 0;
9899 unsigned long last_offset
= 0;
9900 unsigned int first
= 0;
9903 int seen_first_offset
= 0;
9904 int use_debug_info
= 1;
9905 unsigned char *next
;
9907 bytes
= section
->sh_size
;
9908 section_end
= start
+ bytes
;
9912 printf (_("\nThe .debug_loc section is empty.\n"));
9916 get_debug_info (file
);
9918 /* Check the order of location list in .debug_info section. If
9919 offsets of location lists are in the ascending order, we can
9920 use `debug_information' directly. */
9921 for (i
= 0; i
< num_debug_info_entries
; i
++)
9925 num
= debug_information
[i
].num_loc_offsets
;
9926 num_loc_list
+= num
;
9928 /* Check if we can use `debug_information' directly. */
9929 if (use_debug_info
&& num
!= 0)
9931 if (!seen_first_offset
)
9933 /* This is the first location list. */
9934 last_offset
= debug_information
[i
].loc_offsets
[0];
9936 seen_first_offset
= 1;
9942 for (; j
< num
; j
++)
9945 debug_information
[i
].loc_offsets
[j
])
9950 last_offset
= debug_information
[i
].loc_offsets
[j
];
9955 if (!use_debug_info
)
9956 /* FIXME: Should we handle this case? */
9957 error (_("Location lists in .debug_info section aren't in ascending order!\n"));
9959 if (!seen_first_offset
)
9960 error (_("No location lists in .debug_info section!\n"));
9962 if (debug_information
[first
].loc_offsets
[0] != 0)
9963 warn (_("Location lists in .debug_loc section start at 0x%lx\n"),
9964 debug_information
[first
].loc_offsets
[0]);
9966 printf (_("Contents of the .debug_loc section:\n\n"));
9967 printf (_(" Offset Begin End Expression\n"));
9969 seen_first_offset
= 0;
9970 for (i
= first
; i
< num_debug_info_entries
; i
++)
9972 unsigned long begin
;
9974 unsigned short length
;
9975 unsigned long offset
;
9976 unsigned int pointer_size
;
9977 unsigned long cu_offset
;
9978 unsigned long base_address
;
9979 int need_frame_base
;
9982 pointer_size
= debug_information
[i
].pointer_size
;
9983 cu_offset
= debug_information
[i
].cu_offset
;
9985 for (j
= 0; j
< debug_information
[i
].num_loc_offsets
; j
++)
9987 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
9988 offset
= debug_information
[i
].loc_offsets
[j
];
9989 next
= section_begin
+ offset
;
9990 base_address
= debug_information
[i
].base_address
;
9992 if (!seen_first_offset
)
9993 seen_first_offset
= 1;
9997 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
9998 (long)(start
- section_begin
), (long)(next
- section_begin
));
9999 else if (start
> next
)
10000 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
10001 (long)(start
- section_begin
), (long)(next
- section_begin
));
10005 if (offset
>= bytes
)
10007 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
10014 if (start
+ 2 * pointer_size
> section_end
)
10016 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
10021 begin
= byte_get (start
, pointer_size
);
10022 start
+= pointer_size
;
10023 end
= byte_get (start
, pointer_size
);
10024 start
+= pointer_size
;
10026 if (begin
== 0 && end
== 0)
10028 printf (_(" %8.8lx <End of list>\n"), offset
);
10032 /* Check base address specifiers. */
10033 if (begin
== -1UL && end
!= -1UL)
10035 base_address
= end
;
10036 printf (_(" %8.8lx %8.8lx %8.8lx (base address)\n"),
10037 offset
, begin
, end
);
10041 if (start
+ 2 > section_end
)
10043 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
10048 length
= byte_get (start
, 2);
10051 if (start
+ length
> section_end
)
10053 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
10058 printf (" %8.8lx %8.8lx %8.8lx (",
10059 offset
, begin
+ base_address
, end
+ base_address
);
10060 need_frame_base
= decode_location_expression (start
,
10066 if (need_frame_base
&& !has_frame_base
)
10067 printf (_(" [without DW_AT_frame_base]"));
10070 fputs (_(" (start == end)"), stdout
);
10071 else if (begin
> end
)
10072 fputs (_(" (start > end)"), stdout
);
10084 display_debug_str (Elf_Internal_Shdr
*section
,
10085 unsigned char *start
,
10086 FILE *file ATTRIBUTE_UNUSED
)
10088 unsigned long bytes
;
10091 addr
= section
->sh_addr
;
10092 bytes
= section
->sh_size
;
10096 printf (_("\nThe .debug_str section is empty.\n"));
10100 printf (_("Contents of the .debug_str section:\n\n"));
10108 lbytes
= (bytes
> 16 ? 16 : bytes
);
10110 printf (" 0x%8.8lx ", (unsigned long) addr
);
10112 for (j
= 0; j
< 16; j
++)
10115 printf ("%2.2x", start
[j
]);
10123 for (j
= 0; j
< lbytes
; j
++)
10126 if (k
>= ' ' && k
< 0x80)
10146 display_debug_info (Elf_Internal_Shdr
* section
,
10147 unsigned char * start
, FILE * file
)
10149 return process_debug_info (section
, start
, file
, 0);
10154 display_debug_aranges (Elf_Internal_Shdr
*section
,
10155 unsigned char *start
,
10156 FILE *file ATTRIBUTE_UNUSED
)
10158 unsigned char *end
= start
+ section
->sh_size
;
10160 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
10162 while (start
< end
)
10164 unsigned char *hdrptr
;
10165 DWARF2_Internal_ARange arange
;
10166 unsigned char *ranges
;
10167 unsigned long length
;
10168 unsigned long address
;
10171 int initial_length_size
;
10175 arange
.ar_length
= byte_get (hdrptr
, 4);
10178 if (arange
.ar_length
== 0xffffffff)
10180 arange
.ar_length
= byte_get (hdrptr
, 8);
10183 initial_length_size
= 12;
10188 initial_length_size
= 4;
10191 arange
.ar_version
= byte_get (hdrptr
, 2);
10194 arange
.ar_info_offset
= byte_get (hdrptr
, offset_size
);
10195 hdrptr
+= offset_size
;
10197 arange
.ar_pointer_size
= byte_get (hdrptr
, 1);
10200 arange
.ar_segment_size
= byte_get (hdrptr
, 1);
10203 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
10205 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
10209 printf (_(" Length: %ld\n"), arange
.ar_length
);
10210 printf (_(" Version: %d\n"), arange
.ar_version
);
10211 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
10212 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
10213 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
10215 printf (_("\n Address Length\n"));
10219 /* Must pad to an alignment boundary that is twice the pointer size. */
10220 excess
= (hdrptr
- start
) % (2 * arange
.ar_pointer_size
);
10222 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
10226 address
= byte_get (ranges
, arange
.ar_pointer_size
);
10228 ranges
+= arange
.ar_pointer_size
;
10230 length
= byte_get (ranges
, arange
.ar_pointer_size
);
10232 ranges
+= arange
.ar_pointer_size
;
10234 /* A pair of zeros marks the end of the list. */
10235 if (address
== 0 && length
== 0)
10238 printf (" %8.8lx %lu\n", address
, length
);
10241 start
+= arange
.ar_length
+ initial_length_size
;
10250 display_debug_ranges (Elf_Internal_Shdr
*section
,
10251 unsigned char *start
,
10252 FILE *file ATTRIBUTE_UNUSED
)
10254 unsigned char *section_end
;
10255 unsigned long bytes
;
10256 unsigned char *section_begin
= start
;
10257 unsigned int num_range_list
= 0;
10258 unsigned long last_offset
= 0;
10259 unsigned int first
= 0;
10262 int seen_first_offset
= 0;
10263 int use_debug_info
= 1;
10264 unsigned char *next
;
10266 bytes
= section
->sh_size
;
10267 section_end
= start
+ bytes
;
10271 printf (_("\nThe .debug_ranges section is empty.\n"));
10275 get_debug_info (file
);
10277 /* Check the order of range list in .debug_info section. If
10278 offsets of range lists are in the ascending order, we can
10279 use `debug_information' directly. */
10280 for (i
= 0; i
< num_debug_info_entries
; i
++)
10284 num
= debug_information
[i
].num_range_lists
;
10285 num_range_list
+= num
;
10287 /* Check if we can use `debug_information' directly. */
10288 if (use_debug_info
&& num
!= 0)
10290 if (!seen_first_offset
)
10292 /* This is the first range list. */
10293 last_offset
= debug_information
[i
].range_lists
[0];
10295 seen_first_offset
= 1;
10301 for (; j
< num
; j
++)
10304 debug_information
[i
].range_lists
[j
])
10306 use_debug_info
= 0;
10309 last_offset
= debug_information
[i
].range_lists
[j
];
10314 if (!use_debug_info
)
10315 /* FIXME: Should we handle this case? */
10316 error (_("Range lists in .debug_info section aren't in ascending order!\n"));
10318 if (!seen_first_offset
)
10319 error (_("No range lists in .debug_info section!\n"));
10321 if (debug_information
[first
].range_lists
[0] != 0)
10322 warn (_("Range lists in .debug_ranges section start at 0x%lx\n"),
10323 debug_information
[first
].range_lists
[0]);
10325 printf (_("Contents of the .debug_ranges section:\n\n"));
10326 printf (_(" Offset Begin End\n"));
10328 seen_first_offset
= 0;
10329 for (i
= first
; i
< num_debug_info_entries
; i
++)
10331 unsigned long begin
;
10333 unsigned long offset
;
10334 unsigned int pointer_size
;
10335 unsigned long base_address
;
10337 pointer_size
= debug_information
[i
].pointer_size
;
10339 for (j
= 0; j
< debug_information
[i
].num_range_lists
; j
++)
10341 offset
= debug_information
[i
].range_lists
[j
];
10342 next
= section_begin
+ offset
;
10343 base_address
= debug_information
[i
].base_address
;
10345 if (!seen_first_offset
)
10346 seen_first_offset
= 1;
10350 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_ranges section.\n"),
10351 (long)(start
- section_begin
), (long)(next
- section_begin
));
10352 else if (start
> next
)
10353 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_ranges section.\n"),
10354 (long)(start
- section_begin
), (long)(next
- section_begin
));
10360 begin
= byte_get (start
, pointer_size
);
10361 start
+= pointer_size
;
10362 end
= byte_get (start
, pointer_size
);
10363 start
+= pointer_size
;
10365 if (begin
== 0 && end
== 0)
10367 printf (_(" %8.8lx <End of list>\n"), offset
);
10371 /* Check base address specifiers. */
10372 if (begin
== -1UL && end
!= -1UL)
10374 base_address
= end
;
10375 printf (" %8.8lx %8.8lx %8.8lx (base address)\n",
10376 offset
, begin
, end
);
10380 printf (" %8.8lx %8.8lx %8.8lx",
10381 offset
, begin
+ base_address
, end
+ base_address
);
10384 fputs (_(" (start == end)"), stdout
);
10385 else if (begin
> end
)
10386 fputs (_(" (start > end)"), stdout
);
10396 typedef struct Frame_Chunk
10398 struct Frame_Chunk
*next
;
10399 unsigned char *chunk_start
;
10401 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
10402 short int *col_type
;
10404 char *augmentation
;
10405 unsigned int code_factor
;
10407 unsigned long pc_begin
;
10408 unsigned long pc_range
;
10412 unsigned char fde_encoding
;
10413 unsigned char cfa_exp
;
10417 /* A marker for a col_type that means this column was never referenced
10418 in the frame info. */
10419 #define DW_CFA_unreferenced (-1)
10422 frame_need_space (Frame_Chunk
*fc
, int reg
)
10424 int prev
= fc
->ncols
;
10426 if (reg
< fc
->ncols
)
10429 fc
->ncols
= reg
+ 1;
10430 fc
->col_type
= xcrealloc (fc
->col_type
, fc
->ncols
, sizeof (short int));
10431 fc
->col_offset
= xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
10433 while (prev
< fc
->ncols
)
10435 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
10436 fc
->col_offset
[prev
] = 0;
10442 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, int *max_regs
)
10447 if (*max_regs
< fc
->ncols
)
10448 *max_regs
= fc
->ncols
;
10450 if (*need_col_headers
)
10452 *need_col_headers
= 0;
10454 printf (" LOC CFA ");
10456 for (r
= 0; r
< *max_regs
; r
++)
10457 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
10462 printf ("r%-4d", r
);
10468 printf ("%08lx ", fc
->pc_begin
);
10470 strcpy (tmp
, "exp");
10472 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
10473 printf ("%-8s ", tmp
);
10475 for (r
= 0; r
< fc
->ncols
; r
++)
10477 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
10479 switch (fc
->col_type
[r
])
10481 case DW_CFA_undefined
:
10484 case DW_CFA_same_value
:
10487 case DW_CFA_offset
:
10488 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
10490 case DW_CFA_register
:
10491 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
10493 case DW_CFA_expression
:
10494 strcpy (tmp
, "exp");
10497 strcpy (tmp
, "n/a");
10500 printf ("%-5s", tmp
);
10507 size_of_encoded_value (int encoding
)
10509 switch (encoding
& 0x7)
10512 case 0: return eh_addr_size
;
10520 get_encoded_value (unsigned char *data
, int encoding
)
10522 int size
= size_of_encoded_value (encoding
);
10523 if (encoding
& DW_EH_PE_signed
)
10524 return byte_get_signed (data
, size
);
10526 return byte_get (data
, size
);
10529 #define GET(N) byte_get (start, N); start += N
10530 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
10531 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
10534 display_debug_frames (Elf_Internal_Shdr
*section
,
10535 unsigned char *start
,
10536 FILE *file ATTRIBUTE_UNUSED
)
10538 unsigned char *end
= start
+ section
->sh_size
;
10539 unsigned char *section_start
= start
;
10540 Frame_Chunk
*chunks
= 0;
10541 Frame_Chunk
*remembered_state
= 0;
10543 int is_eh
= streq (SECTION_NAME (section
), ".eh_frame");
10544 unsigned int length_return
;
10547 printf (_("The section %s contains:\n"), SECTION_NAME (section
));
10549 while (start
< end
)
10551 unsigned char *saved_start
;
10552 unsigned char *block_end
;
10553 unsigned long length
;
10554 unsigned long cie_id
;
10557 int need_col_headers
= 1;
10558 unsigned char *augmentation_data
= NULL
;
10559 unsigned long augmentation_data_len
= 0;
10560 int encoded_ptr_size
= eh_addr_size
;
10562 int initial_length_size
;
10564 saved_start
= start
;
10565 length
= byte_get (start
, 4); start
+= 4;
10569 printf ("\n%08lx ZERO terminator\n\n",
10570 (unsigned long)(saved_start
- section_start
));
10574 if (length
== 0xffffffff)
10576 length
= byte_get (start
, 8);
10579 initial_length_size
= 12;
10584 initial_length_size
= 4;
10587 block_end
= saved_start
+ length
+ initial_length_size
;
10588 cie_id
= byte_get (start
, offset_size
); start
+= offset_size
;
10590 if (elf_header
.e_type
== ET_REL
10591 && !debug_apply_rela_addends (file
, section
, offset_size
,
10592 section_start
, start
, block_end
))
10595 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
10599 fc
= xmalloc (sizeof (Frame_Chunk
));
10600 memset (fc
, 0, sizeof (Frame_Chunk
));
10604 fc
->chunk_start
= saved_start
;
10606 fc
->col_type
= xmalloc (sizeof (short int));
10607 fc
->col_offset
= xmalloc (sizeof (int));
10608 frame_need_space (fc
, max_regs
-1);
10610 version
= *start
++;
10612 fc
->augmentation
= (char *) start
;
10613 start
= (unsigned char *) strchr ((char *) start
, '\0') + 1;
10615 if (fc
->augmentation
[0] == 'z')
10617 fc
->code_factor
= LEB ();
10618 fc
->data_factor
= SLEB ();
10627 augmentation_data_len
= LEB ();
10628 augmentation_data
= start
;
10629 start
+= augmentation_data_len
;
10631 else if (streq (fc
->augmentation
, "eh"))
10633 start
+= eh_addr_size
;
10634 fc
->code_factor
= LEB ();
10635 fc
->data_factor
= SLEB ();
10647 fc
->code_factor
= LEB ();
10648 fc
->data_factor
= SLEB ();
10660 if (do_debug_frames_interp
)
10661 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
10662 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
10663 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
10667 printf ("\n%08lx %08lx %08lx CIE\n",
10668 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
10669 printf (" Version: %d\n", version
);
10670 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
10671 printf (" Code alignment factor: %u\n", fc
->code_factor
);
10672 printf (" Data alignment factor: %d\n", fc
->data_factor
);
10673 printf (" Return address column: %d\n", fc
->ra
);
10675 if (augmentation_data_len
)
10678 printf (" Augmentation data: ");
10679 for (i
= 0; i
< augmentation_data_len
; ++i
)
10680 printf (" %02x", augmentation_data
[i
]);
10686 if (augmentation_data_len
)
10688 unsigned char *p
, *q
;
10689 p
= (unsigned char *) fc
->augmentation
+ 1;
10690 q
= augmentation_data
;
10696 else if (*p
== 'P')
10697 q
+= 1 + size_of_encoded_value (*q
);
10698 else if (*p
== 'R')
10699 fc
->fde_encoding
= *q
++;
10705 if (fc
->fde_encoding
)
10706 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
10709 frame_need_space (fc
, fc
->ra
);
10713 unsigned char *look_for
;
10714 static Frame_Chunk fde_fc
;
10717 memset (fc
, 0, sizeof (Frame_Chunk
));
10719 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
10721 for (cie
= chunks
; cie
; cie
= cie
->next
)
10722 if (cie
->chunk_start
== look_for
)
10727 warn ("Invalid CIE pointer %08lx in FDE at %p\n",
10728 cie_id
, saved_start
);
10731 fc
->col_type
= xmalloc (sizeof (short int));
10732 fc
->col_offset
= xmalloc (sizeof (int));
10733 frame_need_space (fc
, max_regs
- 1);
10735 fc
->augmentation
= "";
10736 fc
->fde_encoding
= 0;
10740 fc
->ncols
= cie
->ncols
;
10741 fc
->col_type
= xcmalloc (fc
->ncols
, sizeof (short int));
10742 fc
->col_offset
= xcmalloc (fc
->ncols
, sizeof (int));
10743 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
10744 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
10745 fc
->augmentation
= cie
->augmentation
;
10746 fc
->code_factor
= cie
->code_factor
;
10747 fc
->data_factor
= cie
->data_factor
;
10748 fc
->cfa_reg
= cie
->cfa_reg
;
10749 fc
->cfa_offset
= cie
->cfa_offset
;
10751 frame_need_space (fc
, max_regs
-1);
10752 fc
->fde_encoding
= cie
->fde_encoding
;
10755 if (fc
->fde_encoding
)
10756 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
10758 fc
->pc_begin
= get_encoded_value (start
, fc
->fde_encoding
);
10759 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
10760 /* Don't adjust for ET_REL since there's invariably a pcrel
10761 reloc here, which we haven't applied. */
10762 && elf_header
.e_type
!= ET_REL
)
10763 fc
->pc_begin
+= section
->sh_addr
+ (start
- section_start
);
10764 start
+= encoded_ptr_size
;
10765 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
10766 start
+= encoded_ptr_size
;
10768 if (cie
->augmentation
[0] == 'z')
10770 augmentation_data_len
= LEB ();
10771 augmentation_data
= start
;
10772 start
+= augmentation_data_len
;
10775 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
10776 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
10777 (unsigned long)(cie
->chunk_start
- section_start
),
10778 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
10779 if (! do_debug_frames_interp
&& augmentation_data_len
)
10783 printf (" Augmentation data: ");
10784 for (i
= 0; i
< augmentation_data_len
; ++i
)
10785 printf (" %02x", augmentation_data
[i
]);
10791 /* At this point, fc is the current chunk, cie (if any) is set, and
10792 we're about to interpret instructions for the chunk. */
10793 /* ??? At present we need to do this always, since this sizes the
10794 fc->col_type and fc->col_offset arrays, which we write into always.
10795 We should probably split the interpreted and non-interpreted bits
10796 into two different routines, since there's so much that doesn't
10797 really overlap between them. */
10798 if (1 || do_debug_frames_interp
)
10800 /* Start by making a pass over the chunk, allocating storage
10801 and taking note of what registers are used. */
10802 unsigned char *tmp
= start
;
10804 while (start
< block_end
)
10807 unsigned long reg
, tmp
;
10814 /* Warning: if you add any more cases to this switch, be
10815 sure to add them to the corresponding switch below. */
10818 case DW_CFA_advance_loc
:
10820 case DW_CFA_offset
:
10822 frame_need_space (fc
, opa
);
10823 fc
->col_type
[opa
] = DW_CFA_undefined
;
10825 case DW_CFA_restore
:
10826 frame_need_space (fc
, opa
);
10827 fc
->col_type
[opa
] = DW_CFA_undefined
;
10829 case DW_CFA_set_loc
:
10830 start
+= encoded_ptr_size
;
10832 case DW_CFA_advance_loc1
:
10835 case DW_CFA_advance_loc2
:
10838 case DW_CFA_advance_loc4
:
10841 case DW_CFA_offset_extended
:
10842 reg
= LEB (); LEB ();
10843 frame_need_space (fc
, reg
);
10844 fc
->col_type
[reg
] = DW_CFA_undefined
;
10846 case DW_CFA_restore_extended
:
10848 frame_need_space (fc
, reg
);
10849 fc
->col_type
[reg
] = DW_CFA_undefined
;
10851 case DW_CFA_undefined
:
10853 frame_need_space (fc
, reg
);
10854 fc
->col_type
[reg
] = DW_CFA_undefined
;
10856 case DW_CFA_same_value
:
10858 frame_need_space (fc
, reg
);
10859 fc
->col_type
[reg
] = DW_CFA_undefined
;
10861 case DW_CFA_register
:
10862 reg
= LEB (); LEB ();
10863 frame_need_space (fc
, reg
);
10864 fc
->col_type
[reg
] = DW_CFA_undefined
;
10866 case DW_CFA_def_cfa
:
10869 case DW_CFA_def_cfa_register
:
10872 case DW_CFA_def_cfa_offset
:
10875 case DW_CFA_def_cfa_expression
:
10879 case DW_CFA_expression
:
10883 frame_need_space (fc
, reg
);
10884 fc
->col_type
[reg
] = DW_CFA_undefined
;
10886 case DW_CFA_offset_extended_sf
:
10887 reg
= LEB (); SLEB ();
10888 frame_need_space (fc
, reg
);
10889 fc
->col_type
[reg
] = DW_CFA_undefined
;
10891 case DW_CFA_def_cfa_sf
:
10894 case DW_CFA_def_cfa_offset_sf
:
10897 case DW_CFA_MIPS_advance_loc8
:
10900 case DW_CFA_GNU_args_size
:
10903 case DW_CFA_GNU_negative_offset_extended
:
10904 reg
= LEB (); LEB ();
10905 frame_need_space (fc
, reg
);
10906 fc
->col_type
[reg
] = DW_CFA_undefined
;
10915 /* Now we know what registers are used, make a second pass over
10916 the chunk, this time actually printing out the info. */
10918 while (start
< block_end
)
10921 unsigned long ul
, reg
, roffs
;
10930 /* Warning: if you add any more cases to this switch, be
10931 sure to add them to the corresponding switch above. */
10934 case DW_CFA_advance_loc
:
10935 if (do_debug_frames_interp
)
10936 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10938 printf (" DW_CFA_advance_loc: %d to %08lx\n",
10939 opa
* fc
->code_factor
,
10940 fc
->pc_begin
+ opa
* fc
->code_factor
);
10941 fc
->pc_begin
+= opa
* fc
->code_factor
;
10944 case DW_CFA_offset
:
10946 if (! do_debug_frames_interp
)
10947 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
10948 opa
, roffs
* fc
->data_factor
);
10949 fc
->col_type
[opa
] = DW_CFA_offset
;
10950 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
10953 case DW_CFA_restore
:
10954 if (! do_debug_frames_interp
)
10955 printf (" DW_CFA_restore: r%d\n", opa
);
10956 fc
->col_type
[opa
] = cie
->col_type
[opa
];
10957 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
10960 case DW_CFA_set_loc
:
10961 vma
= get_encoded_value (start
, fc
->fde_encoding
);
10962 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
10963 && elf_header
.e_type
!= ET_REL
)
10964 vma
+= section
->sh_addr
+ (start
- section_start
);
10965 start
+= encoded_ptr_size
;
10966 if (do_debug_frames_interp
)
10967 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10969 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
10970 fc
->pc_begin
= vma
;
10973 case DW_CFA_advance_loc1
:
10974 ofs
= byte_get (start
, 1); start
+= 1;
10975 if (do_debug_frames_interp
)
10976 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10978 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
10979 ofs
* fc
->code_factor
,
10980 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10981 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10984 case DW_CFA_advance_loc2
:
10985 ofs
= byte_get (start
, 2); start
+= 2;
10986 if (do_debug_frames_interp
)
10987 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10989 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
10990 ofs
* fc
->code_factor
,
10991 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10992 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10995 case DW_CFA_advance_loc4
:
10996 ofs
= byte_get (start
, 4); start
+= 4;
10997 if (do_debug_frames_interp
)
10998 frame_display_row (fc
, &need_col_headers
, &max_regs
);
11000 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
11001 ofs
* fc
->code_factor
,
11002 fc
->pc_begin
+ ofs
* fc
->code_factor
);
11003 fc
->pc_begin
+= ofs
* fc
->code_factor
;
11006 case DW_CFA_offset_extended
:
11009 if (! do_debug_frames_interp
)
11010 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
11011 reg
, roffs
* fc
->data_factor
);
11012 fc
->col_type
[reg
] = DW_CFA_offset
;
11013 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
11016 case DW_CFA_restore_extended
:
11018 if (! do_debug_frames_interp
)
11019 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
11020 fc
->col_type
[reg
] = cie
->col_type
[reg
];
11021 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
11024 case DW_CFA_undefined
:
11026 if (! do_debug_frames_interp
)
11027 printf (" DW_CFA_undefined: r%ld\n", reg
);
11028 fc
->col_type
[reg
] = DW_CFA_undefined
;
11029 fc
->col_offset
[reg
] = 0;
11032 case DW_CFA_same_value
:
11034 if (! do_debug_frames_interp
)
11035 printf (" DW_CFA_same_value: r%ld\n", reg
);
11036 fc
->col_type
[reg
] = DW_CFA_same_value
;
11037 fc
->col_offset
[reg
] = 0;
11040 case DW_CFA_register
:
11043 if (! do_debug_frames_interp
)
11044 printf (" DW_CFA_register: r%ld in r%ld\n", reg
, roffs
);
11045 fc
->col_type
[reg
] = DW_CFA_register
;
11046 fc
->col_offset
[reg
] = roffs
;
11049 case DW_CFA_remember_state
:
11050 if (! do_debug_frames_interp
)
11051 printf (" DW_CFA_remember_state\n");
11052 rs
= xmalloc (sizeof (Frame_Chunk
));
11053 rs
->ncols
= fc
->ncols
;
11054 rs
->col_type
= xcmalloc (rs
->ncols
, sizeof (short int));
11055 rs
->col_offset
= xcmalloc (rs
->ncols
, sizeof (int));
11056 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
11057 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
11058 rs
->next
= remembered_state
;
11059 remembered_state
= rs
;
11062 case DW_CFA_restore_state
:
11063 if (! do_debug_frames_interp
)
11064 printf (" DW_CFA_restore_state\n");
11065 rs
= remembered_state
;
11068 remembered_state
= rs
->next
;
11069 frame_need_space (fc
, rs
->ncols
-1);
11070 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
11071 memcpy (fc
->col_offset
, rs
->col_offset
,
11072 rs
->ncols
* sizeof (int));
11073 free (rs
->col_type
);
11074 free (rs
->col_offset
);
11077 else if (do_debug_frames_interp
)
11078 printf ("Mismatched DW_CFA_restore_state\n");
11081 case DW_CFA_def_cfa
:
11082 fc
->cfa_reg
= LEB ();
11083 fc
->cfa_offset
= LEB ();
11085 if (! do_debug_frames_interp
)
11086 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
11087 fc
->cfa_reg
, fc
->cfa_offset
);
11090 case DW_CFA_def_cfa_register
:
11091 fc
->cfa_reg
= LEB ();
11093 if (! do_debug_frames_interp
)
11094 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
11097 case DW_CFA_def_cfa_offset
:
11098 fc
->cfa_offset
= LEB ();
11099 if (! do_debug_frames_interp
)
11100 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
11104 if (! do_debug_frames_interp
)
11105 printf (" DW_CFA_nop\n");
11108 case DW_CFA_def_cfa_expression
:
11110 if (! do_debug_frames_interp
)
11112 printf (" DW_CFA_def_cfa_expression (");
11113 decode_location_expression (start
, eh_addr_size
, ul
, 0);
11120 case DW_CFA_expression
:
11123 if (! do_debug_frames_interp
)
11125 printf (" DW_CFA_expression: r%ld (", reg
);
11126 decode_location_expression (start
, eh_addr_size
, ul
, 0);
11129 fc
->col_type
[reg
] = DW_CFA_expression
;
11133 case DW_CFA_offset_extended_sf
:
11136 frame_need_space (fc
, reg
);
11137 if (! do_debug_frames_interp
)
11138 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
11139 reg
, l
* fc
->data_factor
);
11140 fc
->col_type
[reg
] = DW_CFA_offset
;
11141 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
11144 case DW_CFA_def_cfa_sf
:
11145 fc
->cfa_reg
= LEB ();
11146 fc
->cfa_offset
= SLEB ();
11147 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
11149 if (! do_debug_frames_interp
)
11150 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
11151 fc
->cfa_reg
, fc
->cfa_offset
);
11154 case DW_CFA_def_cfa_offset_sf
:
11155 fc
->cfa_offset
= SLEB ();
11156 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
11157 if (! do_debug_frames_interp
)
11158 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
11161 case DW_CFA_MIPS_advance_loc8
:
11162 ofs
= byte_get (start
, 8); start
+= 8;
11163 if (do_debug_frames_interp
)
11164 frame_display_row (fc
, &need_col_headers
, &max_regs
);
11166 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
11167 ofs
* fc
->code_factor
,
11168 fc
->pc_begin
+ ofs
* fc
->code_factor
);
11169 fc
->pc_begin
+= ofs
* fc
->code_factor
;
11172 case DW_CFA_GNU_window_save
:
11173 if (! do_debug_frames_interp
)
11174 printf (" DW_CFA_GNU_window_save\n");
11177 case DW_CFA_GNU_args_size
:
11179 if (! do_debug_frames_interp
)
11180 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
11183 case DW_CFA_GNU_negative_offset_extended
:
11186 frame_need_space (fc
, reg
);
11187 if (! do_debug_frames_interp
)
11188 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
11189 reg
, l
* fc
->data_factor
);
11190 fc
->col_type
[reg
] = DW_CFA_offset
;
11191 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
11195 warn (_("unsupported or unknown DW_CFA_%d\n"), op
);
11200 if (do_debug_frames_interp
)
11201 frame_display_row (fc
, &need_col_headers
, &max_regs
);
11216 display_debug_not_supported (Elf_Internal_Shdr
*section
,
11217 unsigned char *start ATTRIBUTE_UNUSED
,
11218 FILE *file ATTRIBUTE_UNUSED
)
11220 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
11221 SECTION_NAME (section
));
11226 /* A structure containing the name of a debug section
11227 and a pointer to a function that can decode it. */
11230 const char *const name
;
11231 int (*display
) (Elf_Internal_Shdr
*, unsigned char *, FILE *);
11235 { ".debug_abbrev", display_debug_abbrev
},
11236 { ".debug_aranges", display_debug_aranges
},
11237 { ".debug_frame", display_debug_frames
},
11238 { ".debug_info", display_debug_info
},
11239 { ".debug_line", display_debug_lines
},
11240 { ".debug_pubnames", display_debug_pubnames
},
11241 { ".eh_frame", display_debug_frames
},
11242 { ".debug_macinfo", display_debug_macinfo
},
11243 { ".debug_str", display_debug_str
},
11244 { ".debug_loc", display_debug_loc
},
11245 { ".debug_pubtypes", display_debug_pubnames
},
11246 { ".debug_ranges", display_debug_ranges
},
11247 { ".debug_static_func", display_debug_not_supported
},
11248 { ".debug_static_vars", display_debug_not_supported
},
11249 { ".debug_types", display_debug_not_supported
},
11250 { ".debug_weaknames", display_debug_not_supported
}
11254 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
11256 char *name
= SECTION_NAME (section
);
11257 bfd_size_type length
;
11261 length
= section
->sh_size
;
11264 printf (_("\nSection '%s' has no debugging data.\n"), name
);
11268 if (strneq (name
, ".gnu.linkonce.wi.", 17))
11269 name
= ".debug_info";
11271 /* See if we know how to display the contents of this section. */
11272 for (i
= NUM_ELEM (debug_displays
); i
--;)
11273 if (streq (debug_displays
[i
].name
, name
))
11275 unsigned char *start
;
11277 start
= get_data (NULL
, file
, section
->sh_offset
, 1, length
,
11278 _("debug section data"));
11285 result
&= debug_displays
[i
].display (section
, start
, file
);
11288 /* If we loaded in the abbrev section
11289 at some point, we must release it here. */
11297 printf (_("Unrecognized debug section: %s\n"), name
);
11305 process_section_contents (FILE *file
)
11307 Elf_Internal_Shdr
*section
;
11313 for (i
= 0, section
= section_headers
;
11314 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
11317 #ifdef SUPPORT_DISASSEMBLY
11318 if (dump_sects
[i
] & DISASS_DUMP
)
11319 disassemble_section (section
, file
);
11321 if (dump_sects
[i
] & HEX_DUMP
)
11322 dump_section (section
, file
);
11324 if (dump_sects
[i
] & DEBUG_DUMP
)
11325 display_debug_section (section
, file
);
11328 /* Check to see if the user requested a
11329 dump of a section that does not exist. */
11330 while (i
++ < num_dump_sects
)
11332 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
11336 process_mips_fpe_exception (int mask
)
11341 if (mask
& OEX_FPU_INEX
)
11342 fputs ("INEX", stdout
), first
= 0;
11343 if (mask
& OEX_FPU_UFLO
)
11344 printf ("%sUFLO", first
? "" : "|"), first
= 0;
11345 if (mask
& OEX_FPU_OFLO
)
11346 printf ("%sOFLO", first
? "" : "|"), first
= 0;
11347 if (mask
& OEX_FPU_DIV0
)
11348 printf ("%sDIV0", first
? "" : "|"), first
= 0;
11349 if (mask
& OEX_FPU_INVAL
)
11350 printf ("%sINVAL", first
? "" : "|");
11353 fputs ("0", stdout
);
11357 process_mips_specific (FILE *file
)
11359 Elf_Internal_Dyn
*entry
;
11360 size_t liblist_offset
= 0;
11361 size_t liblistno
= 0;
11362 size_t conflictsno
= 0;
11363 size_t options_offset
= 0;
11364 size_t conflicts_offset
= 0;
11366 /* We have a lot of special sections. Thanks SGI! */
11367 if (dynamic_section
== NULL
)
11368 /* No information available. */
11371 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
11372 switch (entry
->d_tag
)
11374 case DT_MIPS_LIBLIST
:
11376 = offset_from_vma (file
, entry
->d_un
.d_val
,
11377 liblistno
* sizeof (Elf32_External_Lib
));
11379 case DT_MIPS_LIBLISTNO
:
11380 liblistno
= entry
->d_un
.d_val
;
11382 case DT_MIPS_OPTIONS
:
11383 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
11385 case DT_MIPS_CONFLICT
:
11387 = offset_from_vma (file
, entry
->d_un
.d_val
,
11388 conflictsno
* sizeof (Elf32_External_Conflict
));
11390 case DT_MIPS_CONFLICTNO
:
11391 conflictsno
= entry
->d_un
.d_val
;
11397 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
11399 Elf32_External_Lib
*elib
;
11402 elib
= get_data (NULL
, file
, liblist_offset
,
11403 liblistno
, sizeof (Elf32_External_Lib
),
11407 printf ("\nSection '.liblist' contains %lu entries:\n",
11408 (unsigned long) liblistno
);
11409 fputs (" Library Time Stamp Checksum Version Flags\n",
11412 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
11419 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
11420 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
11421 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
11422 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
11423 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
11425 tmp
= gmtime (&time
);
11426 snprintf (timebuf
, sizeof (timebuf
),
11427 "%04u-%02u-%02uT%02u:%02u:%02u",
11428 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11429 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11431 printf ("%3lu: ", (unsigned long) cnt
);
11432 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
11433 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
11435 printf ("<corrupt: %9ld>", liblist
.l_name
);
11436 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
11437 liblist
.l_version
);
11439 if (liblist
.l_flags
== 0)
11443 static const struct
11450 { " EXACT_MATCH", LL_EXACT_MATCH
},
11451 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
11452 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
11453 { " EXPORTS", LL_EXPORTS
},
11454 { " DELAY_LOAD", LL_DELAY_LOAD
},
11455 { " DELTA", LL_DELTA
}
11457 int flags
= liblist
.l_flags
;
11461 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
11463 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
11465 fputs (l_flags_vals
[fcnt
].name
, stdout
);
11466 flags
^= l_flags_vals
[fcnt
].bit
;
11469 printf (" %#x", (unsigned int) flags
);
11479 if (options_offset
!= 0)
11481 Elf_External_Options
*eopt
;
11482 Elf_Internal_Shdr
*sect
= section_headers
;
11483 Elf_Internal_Options
*iopt
;
11484 Elf_Internal_Options
*option
;
11488 /* Find the section header so that we get the size. */
11489 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
11492 eopt
= get_data (NULL
, file
, options_offset
, 1, sect
->sh_size
,
11496 iopt
= cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (*iopt
));
11499 error (_("Out of memory"));
11506 while (offset
< sect
->sh_size
)
11508 Elf_External_Options
*eoption
;
11510 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
11512 option
->kind
= BYTE_GET (eoption
->kind
);
11513 option
->size
= BYTE_GET (eoption
->size
);
11514 option
->section
= BYTE_GET (eoption
->section
);
11515 option
->info
= BYTE_GET (eoption
->info
);
11517 offset
+= option
->size
;
11523 printf (_("\nSection '%s' contains %d entries:\n"),
11524 SECTION_NAME (sect
), cnt
);
11532 switch (option
->kind
)
11535 /* This shouldn't happen. */
11536 printf (" NULL %d %lx", option
->section
, option
->info
);
11539 printf (" REGINFO ");
11540 if (elf_header
.e_machine
== EM_MIPS
)
11543 Elf32_External_RegInfo
*ereg
;
11544 Elf32_RegInfo reginfo
;
11546 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
11547 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
11548 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
11549 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
11550 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
11551 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
11552 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
11554 printf ("GPR %08lx GP 0x%lx\n",
11555 reginfo
.ri_gprmask
,
11556 (unsigned long) reginfo
.ri_gp_value
);
11557 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11558 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11559 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11564 Elf64_External_RegInfo
*ereg
;
11565 Elf64_Internal_RegInfo reginfo
;
11567 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
11568 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
11569 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
11570 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
11571 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
11572 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
11573 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
11575 printf ("GPR %08lx GP 0x",
11576 reginfo
.ri_gprmask
);
11577 printf_vma (reginfo
.ri_gp_value
);
11580 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11581 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11582 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11586 case ODK_EXCEPTIONS
:
11587 fputs (" EXCEPTIONS fpe_min(", stdout
);
11588 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
11589 fputs (") fpe_max(", stdout
);
11590 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
11591 fputs (")", stdout
);
11593 if (option
->info
& OEX_PAGE0
)
11594 fputs (" PAGE0", stdout
);
11595 if (option
->info
& OEX_SMM
)
11596 fputs (" SMM", stdout
);
11597 if (option
->info
& OEX_FPDBUG
)
11598 fputs (" FPDBUG", stdout
);
11599 if (option
->info
& OEX_DISMISS
)
11600 fputs (" DISMISS", stdout
);
11603 fputs (" PAD ", stdout
);
11604 if (option
->info
& OPAD_PREFIX
)
11605 fputs (" PREFIX", stdout
);
11606 if (option
->info
& OPAD_POSTFIX
)
11607 fputs (" POSTFIX", stdout
);
11608 if (option
->info
& OPAD_SYMBOL
)
11609 fputs (" SYMBOL", stdout
);
11612 fputs (" HWPATCH ", stdout
);
11613 if (option
->info
& OHW_R4KEOP
)
11614 fputs (" R4KEOP", stdout
);
11615 if (option
->info
& OHW_R8KPFETCH
)
11616 fputs (" R8KPFETCH", stdout
);
11617 if (option
->info
& OHW_R5KEOP
)
11618 fputs (" R5KEOP", stdout
);
11619 if (option
->info
& OHW_R5KCVTL
)
11620 fputs (" R5KCVTL", stdout
);
11623 fputs (" FILL ", stdout
);
11624 /* XXX Print content of info word? */
11627 fputs (" TAGS ", stdout
);
11628 /* XXX Print content of info word? */
11631 fputs (" HWAND ", stdout
);
11632 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11633 fputs (" R4KEOP_CHECKED", stdout
);
11634 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11635 fputs (" R4KEOP_CLEAN", stdout
);
11638 fputs (" HWOR ", stdout
);
11639 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11640 fputs (" R4KEOP_CHECKED", stdout
);
11641 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11642 fputs (" R4KEOP_CLEAN", stdout
);
11645 printf (" GP_GROUP %#06lx self-contained %#06lx",
11646 option
->info
& OGP_GROUP
,
11647 (option
->info
& OGP_SELF
) >> 16);
11650 printf (" IDENT %#06lx self-contained %#06lx",
11651 option
->info
& OGP_GROUP
,
11652 (option
->info
& OGP_SELF
) >> 16);
11655 /* This shouldn't happen. */
11656 printf (" %3d ??? %d %lx",
11657 option
->kind
, option
->section
, option
->info
);
11661 len
= sizeof (*eopt
);
11662 while (len
< option
->size
)
11663 if (((char *) option
)[len
] >= ' '
11664 && ((char *) option
)[len
] < 0x7f)
11665 printf ("%c", ((char *) option
)[len
++]);
11667 printf ("\\%03o", ((char *) option
)[len
++]);
11669 fputs ("\n", stdout
);
11677 if (conflicts_offset
!= 0 && conflictsno
!= 0)
11679 Elf32_Conflict
*iconf
;
11682 if (dynamic_symbols
== NULL
)
11684 error (_("conflict list found without a dynamic symbol table"));
11688 iconf
= cmalloc (conflictsno
, sizeof (*iconf
));
11691 error (_("Out of memory"));
11697 Elf32_External_Conflict
*econf32
;
11699 econf32
= get_data (NULL
, file
, conflicts_offset
,
11700 conflictsno
, sizeof (*econf32
), _("conflict"));
11704 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11705 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
11711 Elf64_External_Conflict
*econf64
;
11713 econf64
= get_data (NULL
, file
, conflicts_offset
,
11714 conflictsno
, sizeof (*econf64
), _("conflict"));
11718 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11719 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
11724 printf (_("\nSection '.conflict' contains %lu entries:\n"),
11725 (unsigned long) conflictsno
);
11726 puts (_(" Num: Index Value Name"));
11728 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11730 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
11732 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
11733 print_vma (psym
->st_value
, FULL_HEX
);
11735 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11736 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11738 printf ("<corrupt: %14ld>", psym
->st_name
);
11749 process_gnu_liblist (FILE *file
)
11751 Elf_Internal_Shdr
*section
, *string_sec
;
11752 Elf32_External_Lib
*elib
;
11754 size_t strtab_size
;
11761 for (i
= 0, section
= section_headers
;
11762 i
< elf_header
.e_shnum
;
11765 switch (section
->sh_type
)
11767 case SHT_GNU_LIBLIST
:
11768 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
)
11771 elib
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
11776 string_sec
= SECTION_HEADER (section
->sh_link
);
11778 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
11779 string_sec
->sh_size
, _("liblist string table"));
11780 strtab_size
= string_sec
->sh_size
;
11783 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
11789 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
11790 SECTION_NAME (section
),
11791 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
11793 puts (" Library Time Stamp Checksum Version Flags");
11795 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
11803 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
11804 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
11805 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
11806 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
11807 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
11809 tmp
= gmtime (&time
);
11810 snprintf (timebuf
, sizeof (timebuf
),
11811 "%04u-%02u-%02uT%02u:%02u:%02u",
11812 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11813 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11815 printf ("%3lu: ", (unsigned long) cnt
);
11817 printf ("%-20s", liblist
.l_name
< strtab_size
11818 ? strtab
+ liblist
.l_name
: "<corrupt>");
11820 printf ("%-20.20s", liblist
.l_name
< strtab_size
11821 ? strtab
+ liblist
.l_name
: "<corrupt>");
11822 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
11823 liblist
.l_version
, liblist
.l_flags
);
11833 static const char *
11834 get_note_type (unsigned e_type
)
11836 static char buff
[64];
11838 if (elf_header
.e_type
== ET_CORE
)
11842 return _("NT_AUXV (auxiliary vector)");
11844 return _("NT_PRSTATUS (prstatus structure)");
11846 return _("NT_FPREGSET (floating point registers)");
11848 return _("NT_PRPSINFO (prpsinfo structure)");
11849 case NT_TASKSTRUCT
:
11850 return _("NT_TASKSTRUCT (task structure)");
11852 return _("NT_PRXFPREG (user_xfpregs structure)");
11854 return _("NT_PSTATUS (pstatus structure)");
11856 return _("NT_FPREGS (floating point registers)");
11858 return _("NT_PSINFO (psinfo structure)");
11860 return _("NT_LWPSTATUS (lwpstatus_t structure)");
11862 return _("NT_LWPSINFO (lwpsinfo_t structure)");
11863 case NT_WIN32PSTATUS
:
11864 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
11872 return _("NT_VERSION (version)");
11874 return _("NT_ARCH (architecture)");
11879 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11883 static const char *
11884 get_netbsd_elfcore_note_type (unsigned e_type
)
11886 static char buff
[64];
11888 if (e_type
== NT_NETBSDCORE_PROCINFO
)
11890 /* NetBSD core "procinfo" structure. */
11891 return _("NetBSD procinfo structure");
11894 /* As of Jan 2002 there are no other machine-independent notes
11895 defined for NetBSD core files. If the note type is less
11896 than the start of the machine-dependent note types, we don't
11899 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
11901 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11905 switch (elf_header
.e_machine
)
11907 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
11908 and PT_GETFPREGS == mach+2. */
11913 case EM_SPARC32PLUS
:
11917 case NT_NETBSDCORE_FIRSTMACH
+0:
11918 return _("PT_GETREGS (reg structure)");
11919 case NT_NETBSDCORE_FIRSTMACH
+2:
11920 return _("PT_GETFPREGS (fpreg structure)");
11926 /* On all other arch's, PT_GETREGS == mach+1 and
11927 PT_GETFPREGS == mach+3. */
11931 case NT_NETBSDCORE_FIRSTMACH
+1:
11932 return _("PT_GETREGS (reg structure)");
11933 case NT_NETBSDCORE_FIRSTMACH
+3:
11934 return _("PT_GETFPREGS (fpreg structure)");
11940 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
11941 e_type
- NT_NETBSDCORE_FIRSTMACH
);
11945 /* Note that by the ELF standard, the name field is already null byte
11946 terminated, and namesz includes the terminating null byte.
11947 I.E. the value of namesz for the name "FSF" is 4.
11949 If the value of namesz is zero, there is no name present. */
11951 process_note (Elf_Internal_Note
*pnote
)
11955 if (pnote
->namesz
== 0)
11956 /* If there is no note name, then use the default set of
11957 note type strings. */
11958 nt
= get_note_type (pnote
->type
);
11960 else if (strneq (pnote
->namedata
, "NetBSD-CORE", 11))
11961 /* NetBSD-specific core file notes. */
11962 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
11965 /* Don't recognize this note name; just use the default set of
11966 note type strings. */
11967 nt
= get_note_type (pnote
->type
);
11969 printf (" %s\t\t0x%08lx\t%s\n",
11970 pnote
->namesz
? pnote
->namedata
: "(NONE)",
11971 pnote
->descsz
, nt
);
11977 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
11979 Elf_External_Note
*pnotes
;
11980 Elf_External_Note
*external
;
11986 pnotes
= get_data (NULL
, file
, offset
, 1, length
, _("notes"));
11992 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
11993 (unsigned long) offset
, (unsigned long) length
);
11994 printf (_(" Owner\t\tData size\tDescription\n"));
11996 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
11998 Elf_External_Note
*next
;
11999 Elf_Internal_Note inote
;
12002 inote
.type
= BYTE_GET (external
->type
);
12003 inote
.namesz
= BYTE_GET (external
->namesz
);
12004 inote
.namedata
= external
->name
;
12005 inote
.descsz
= BYTE_GET (external
->descsz
);
12006 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
12007 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
12009 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
12011 if (((char *) next
) > (((char *) pnotes
) + length
))
12013 warn (_("corrupt note found at offset %lx into core notes\n"),
12014 (long)((char *)external
- (char *)pnotes
));
12015 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
12016 inote
.type
, inote
.namesz
, inote
.descsz
);
12022 /* Verify that name is null terminated. It appears that at least
12023 one version of Linux (RedHat 6.0) generates corefiles that don't
12024 comply with the ELF spec by failing to include the null byte in
12026 if (inote
.namedata
[inote
.namesz
] != '\0')
12028 temp
= malloc (inote
.namesz
+ 1);
12032 error (_("Out of memory\n"));
12037 strncpy (temp
, inote
.namedata
, inote
.namesz
);
12038 temp
[inote
.namesz
] = 0;
12040 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
12041 inote
.namedata
= temp
;
12044 res
&= process_note (& inote
);
12059 process_corefile_note_segments (FILE *file
)
12061 Elf_Internal_Phdr
*segment
;
12065 if (! get_program_headers (file
))
12068 for (i
= 0, segment
= program_headers
;
12069 i
< elf_header
.e_phnum
;
12072 if (segment
->p_type
== PT_NOTE
)
12073 res
&= process_corefile_note_segment (file
,
12074 (bfd_vma
) segment
->p_offset
,
12075 (bfd_vma
) segment
->p_filesz
);
12082 process_note_sections (FILE *file
)
12084 Elf_Internal_Shdr
*section
;
12088 for (i
= 0, section
= section_headers
;
12089 i
< elf_header
.e_shnum
;
12091 if (section
->sh_type
== SHT_NOTE
)
12092 res
&= process_corefile_note_segment (file
,
12093 (bfd_vma
) section
->sh_offset
,
12094 (bfd_vma
) section
->sh_size
);
12100 process_notes (FILE *file
)
12102 /* If we have not been asked to display the notes then do nothing. */
12106 if (elf_header
.e_type
!= ET_CORE
)
12107 return process_note_sections (file
);
12109 /* No program headers means no NOTE segment. */
12110 if (elf_header
.e_phnum
> 0)
12111 return process_corefile_note_segments (file
);
12113 printf (_("No note segments present in the core file.\n"));
12118 process_arch_specific (FILE *file
)
12123 switch (elf_header
.e_machine
)
12126 case EM_MIPS_RS3_LE
:
12127 return process_mips_specific (file
);
12136 get_file_header (FILE *file
)
12138 /* Read in the identity array. */
12139 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
12142 /* Determine how to read the rest of the header. */
12143 switch (elf_header
.e_ident
[EI_DATA
])
12145 default: /* fall through */
12146 case ELFDATANONE
: /* fall through */
12148 byte_get
= byte_get_little_endian
;
12149 byte_put
= byte_put_little_endian
;
12152 byte_get
= byte_get_big_endian
;
12153 byte_put
= byte_put_big_endian
;
12157 /* For now we only support 32 bit and 64 bit ELF files. */
12158 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
12160 /* Read in the rest of the header. */
12163 Elf32_External_Ehdr ehdr32
;
12165 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
12168 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
12169 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
12170 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
12171 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
12172 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
12173 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
12174 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
12175 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
12176 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
12177 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
12178 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
12179 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
12180 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
12184 Elf64_External_Ehdr ehdr64
;
12186 /* If we have been compiled with sizeof (bfd_vma) == 4, then
12187 we will not be able to cope with the 64bit data found in
12188 64 ELF files. Detect this now and abort before we start
12189 overwriting things. */
12190 if (sizeof (bfd_vma
) < 8)
12192 error (_("This instance of readelf has been built without support for a\n\
12193 64 bit data type and so it cannot read 64 bit ELF files.\n"));
12197 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
12200 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
12201 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
12202 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
12203 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
12204 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
12205 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
12206 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
12207 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
12208 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
12209 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
12210 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
12211 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
12212 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
12215 if (elf_header
.e_shoff
)
12217 /* There may be some extensions in the first section header. Don't
12218 bomb if we can't read it. */
12220 get_32bit_section_headers (file
, 1);
12222 get_64bit_section_headers (file
, 1);
12228 /* Process one ELF object file according to the command line options.
12229 This file may actually be stored in an archive. The file is
12230 positioned at the start of the ELF object. */
12233 process_object (char *file_name
, FILE *file
)
12237 if (! get_file_header (file
))
12239 error (_("%s: Failed to read file header\n"), file_name
);
12243 /* Initialise per file variables. */
12244 for (i
= NUM_ELEM (version_info
); i
--;)
12245 version_info
[i
] = 0;
12247 for (i
= NUM_ELEM (dynamic_info
); i
--;)
12248 dynamic_info
[i
] = 0;
12250 /* Process the file. */
12252 printf (_("\nFile: %s\n"), file_name
);
12254 /* Initialise the dump_sects array from the cmdline_dump_sects array.
12255 Note we do this even if cmdline_dump_sects is empty because we
12256 must make sure that the dump_sets array is zeroed out before each
12257 object file is processed. */
12258 if (num_dump_sects
> num_cmdline_dump_sects
)
12259 memset (dump_sects
, 0, num_dump_sects
);
12261 if (num_cmdline_dump_sects
> 0)
12263 if (num_dump_sects
== 0)
12264 /* A sneaky way of allocating the dump_sects array. */
12265 request_dump (num_cmdline_dump_sects
, 0);
12267 assert (num_dump_sects
>= num_cmdline_dump_sects
);
12268 memcpy (dump_sects
, cmdline_dump_sects
, num_cmdline_dump_sects
);
12271 if (! process_file_header ())
12274 if (! process_section_headers (file
))
12276 /* Without loaded section headers we cannot process lots of
12278 do_unwind
= do_version
= do_dump
= do_arch
= 0;
12280 if (! do_using_dynamic
)
12281 do_syms
= do_reloc
= 0;
12284 if (! process_section_groups (file
))
12286 /* Without loaded section groups we cannot process unwind. */
12290 if (process_program_headers (file
))
12291 process_dynamic_section (file
);
12293 process_relocs (file
);
12295 process_unwind (file
);
12297 process_symbol_table (file
);
12299 process_syminfo (file
);
12301 process_version_sections (file
);
12303 process_section_contents (file
);
12305 process_notes (file
);
12307 process_gnu_liblist (file
);
12309 process_arch_specific (file
);
12311 if (program_headers
)
12313 free (program_headers
);
12314 program_headers
= NULL
;
12317 if (section_headers
)
12319 free (section_headers
);
12320 section_headers
= NULL
;
12325 free (string_table
);
12326 string_table
= NULL
;
12327 string_table_length
= 0;
12330 if (dynamic_strings
)
12332 free (dynamic_strings
);
12333 dynamic_strings
= NULL
;
12334 dynamic_strings_length
= 0;
12337 if (dynamic_symbols
)
12339 free (dynamic_symbols
);
12340 dynamic_symbols
= NULL
;
12341 num_dynamic_syms
= 0;
12344 if (dynamic_syminfo
)
12346 free (dynamic_syminfo
);
12347 dynamic_syminfo
= NULL
;
12350 if (section_headers_groups
)
12352 free (section_headers_groups
);
12353 section_headers_groups
= NULL
;
12356 if (section_groups
)
12358 struct group_list
*g
, *next
;
12360 for (i
= 0; i
< group_count
; i
++)
12362 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
12369 free (section_groups
);
12370 section_groups
= NULL
;
12373 if (debug_information
)
12375 for (i
= 0; i
< num_debug_info_entries
; i
++)
12377 if (!debug_information
[i
].max_loc_offsets
)
12379 free (debug_information
[i
].loc_offsets
);
12380 free (debug_information
[i
].have_frame_base
);
12382 if (!debug_information
[i
].max_range_lists
)
12383 free (debug_information
[i
].range_lists
);
12385 free (debug_information
);
12386 debug_information
= NULL
;
12387 num_debug_info_entries
= 0;
12393 /* Process an ELF archive. The file is positioned just after the
12397 process_archive (char *file_name
, FILE *file
)
12399 struct ar_hdr arhdr
;
12401 unsigned long size
;
12402 char *longnames
= NULL
;
12403 unsigned long longnames_size
= 0;
12404 size_t file_name_size
;
12409 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12410 if (got
!= sizeof arhdr
)
12415 error (_("%s: failed to read archive header\n"), file_name
);
12419 if (memcmp (arhdr
.ar_name
, "/ ", 16) == 0)
12421 /* This is the archive symbol table. Skip it.
12422 FIXME: We should have an option to dump it. */
12423 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
12424 if (fseek (file
, size
+ (size
& 1), SEEK_CUR
) != 0)
12426 error (_("%s: failed to skip archive symbol table\n"), file_name
);
12430 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12431 if (got
!= sizeof arhdr
)
12436 error (_("%s: failed to read archive header\n"), file_name
);
12441 if (memcmp (arhdr
.ar_name
, "// ", 16) == 0)
12443 /* This is the archive string table holding long member
12446 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
12448 longnames
= malloc (longnames_size
);
12449 if (longnames
== NULL
)
12451 error (_("Out of memory\n"));
12455 if (fread (longnames
, longnames_size
, 1, file
) != 1)
12458 error (_("%s: failed to read string table\n"), file_name
);
12462 if ((longnames_size
& 1) != 0)
12465 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12466 if (got
!= sizeof arhdr
)
12473 error (_("%s: failed to read archive header\n"), file_name
);
12478 file_name_size
= strlen (file_name
);
12487 if (arhdr
.ar_name
[0] == '/')
12491 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
12492 if (off
>= longnames_size
)
12494 error (_("%s: invalid archive string table offset %lu\n"), file_name
, off
);
12499 name
= longnames
+ off
;
12500 nameend
= memchr (name
, '/', longnames_size
- off
);
12504 name
= arhdr
.ar_name
;
12505 nameend
= memchr (name
, '/', 16);
12508 if (nameend
== NULL
)
12510 error (_("%s: bad archive file name\n"), file_name
);
12515 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
12516 if (namealc
== NULL
)
12518 error (_("Out of memory\n"));
12523 memcpy (namealc
, file_name
, file_name_size
);
12524 namealc
[file_name_size
] = '(';
12525 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
12526 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
12527 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
12529 archive_file_offset
= ftell (file
);
12530 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
12532 ret
|= process_object (namealc
, file
);
12537 (archive_file_offset
12538 + archive_file_size
12539 + (archive_file_size
& 1)),
12542 error (_("%s: failed to seek to next archive header\n"), file_name
);
12547 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12548 if (got
!= sizeof arhdr
)
12553 error (_("%s: failed to read archive header\n"), file_name
);
12559 if (longnames
!= 0)
12566 process_file (char *file_name
)
12569 struct stat statbuf
;
12570 char armag
[SARMAG
];
12573 if (stat (file_name
, &statbuf
) < 0)
12575 if (errno
== ENOENT
)
12576 error (_("'%s': No such file\n"), file_name
);
12578 error (_("Could not locate '%s'. System error message: %s\n"),
12579 file_name
, strerror (errno
));
12583 if (! S_ISREG (statbuf
.st_mode
))
12585 error (_("'%s' is not an ordinary file\n"), file_name
);
12589 file
= fopen (file_name
, "rb");
12592 error (_("Input file '%s' is not readable.\n"), file_name
);
12596 if (fread (armag
, SARMAG
, 1, file
) != 1)
12598 error (_("%s: Failed to read file header\n"), file_name
);
12603 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
12604 ret
= process_archive (file_name
, file
);
12608 archive_file_size
= archive_file_offset
= 0;
12609 ret
= process_object (file_name
, file
);
12617 #ifdef SUPPORT_DISASSEMBLY
12618 /* Needed by the i386 disassembler. For extra credit, someone could
12619 fix this so that we insert symbolic addresses here, esp for GOT/PLT
12623 print_address (unsigned int addr
, FILE *outfile
)
12625 fprintf (outfile
,"0x%8.8x", addr
);
12628 /* Needed by the i386 disassembler. */
12630 db_task_printsym (unsigned int addr
)
12632 print_address (addr
, stderr
);
12637 main (int argc
, char **argv
)
12641 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
12642 setlocale (LC_MESSAGES
, "");
12644 #if defined (HAVE_SETLOCALE)
12645 setlocale (LC_CTYPE
, "");
12647 bindtextdomain (PACKAGE
, LOCALEDIR
);
12648 textdomain (PACKAGE
);
12650 parse_args (argc
, argv
);
12652 if (num_dump_sects
> 0)
12654 /* Make a copy of the dump_sects array. */
12655 cmdline_dump_sects
= malloc (num_dump_sects
);
12656 if (cmdline_dump_sects
== NULL
)
12657 error (_("Out of memory allocating dump request table."));
12660 memcpy (cmdline_dump_sects
, dump_sects
, num_dump_sects
);
12661 num_cmdline_dump_sects
= num_dump_sects
;
12665 if (optind
< (argc
- 1))
12669 while (optind
< argc
)
12670 err
|= process_file (argv
[optind
++]);
12672 if (dump_sects
!= NULL
)
12674 if (cmdline_dump_sects
!= NULL
)
12675 free (cmdline_dump_sects
);