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";
2422 get_ia64_segment_type (unsigned long type
)
2426 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2427 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2428 case PT_HP_TLS
: return "HP_TLS";
2429 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2430 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2431 case PT_IA_64_HP_STACK
: return "HP_STACK";
2440 get_segment_type (unsigned long p_type
)
2442 static char buff
[32];
2446 case PT_NULL
: return "NULL";
2447 case PT_LOAD
: return "LOAD";
2448 case PT_DYNAMIC
: return "DYNAMIC";
2449 case PT_INTERP
: return "INTERP";
2450 case PT_NOTE
: return "NOTE";
2451 case PT_SHLIB
: return "SHLIB";
2452 case PT_PHDR
: return "PHDR";
2453 case PT_TLS
: return "TLS";
2455 case PT_GNU_EH_FRAME
:
2456 return "GNU_EH_FRAME";
2457 case PT_GNU_STACK
: return "GNU_STACK";
2458 case PT_GNU_RELRO
: return "GNU_RELRO";
2461 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2465 switch (elf_header
.e_machine
)
2468 result
= get_arm_segment_type (p_type
);
2471 case EM_MIPS_RS3_LE
:
2472 result
= get_mips_segment_type (p_type
);
2475 result
= get_parisc_segment_type (p_type
);
2478 result
= get_ia64_segment_type (p_type
);
2488 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2490 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2494 switch (elf_header
.e_machine
)
2497 result
= get_parisc_segment_type (p_type
);
2500 result
= get_ia64_segment_type (p_type
);
2510 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2513 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2520 get_mips_section_type_name (unsigned int sh_type
)
2524 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2525 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2526 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2527 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2528 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2529 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2530 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2531 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2532 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2533 case SHT_MIPS_RELD
: return "MIPS_RELD";
2534 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2535 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2536 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2537 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2538 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2539 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2540 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2541 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2542 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2543 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2544 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2545 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2546 case SHT_MIPS_LINE
: return "MIPS_LINE";
2547 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2548 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2549 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2550 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2551 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2552 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2553 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2554 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2555 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2556 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2557 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2558 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2559 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2560 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2561 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2562 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2570 get_parisc_section_type_name (unsigned int sh_type
)
2574 case SHT_PARISC_EXT
: return "PARISC_EXT";
2575 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2576 case SHT_PARISC_DOC
: return "PARISC_DOC";
2577 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
2578 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
2579 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
2587 get_ia64_section_type_name (unsigned int sh_type
)
2589 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2590 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2591 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2595 case SHT_IA_64_EXT
: return "IA_64_EXT";
2596 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2597 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2605 get_x86_64_section_type_name (unsigned int sh_type
)
2609 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2617 get_arm_section_type_name (unsigned int sh_type
)
2630 get_section_type_name (unsigned int sh_type
)
2632 static char buff
[32];
2636 case SHT_NULL
: return "NULL";
2637 case SHT_PROGBITS
: return "PROGBITS";
2638 case SHT_SYMTAB
: return "SYMTAB";
2639 case SHT_STRTAB
: return "STRTAB";
2640 case SHT_RELA
: return "RELA";
2641 case SHT_HASH
: return "HASH";
2642 case SHT_DYNAMIC
: return "DYNAMIC";
2643 case SHT_NOTE
: return "NOTE";
2644 case SHT_NOBITS
: return "NOBITS";
2645 case SHT_REL
: return "REL";
2646 case SHT_SHLIB
: return "SHLIB";
2647 case SHT_DYNSYM
: return "DYNSYM";
2648 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2649 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2650 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2651 case SHT_GROUP
: return "GROUP";
2652 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2653 case SHT_GNU_verdef
: return "VERDEF";
2654 case SHT_GNU_verneed
: return "VERNEED";
2655 case SHT_GNU_versym
: return "VERSYM";
2656 case 0x6ffffff0: return "VERSYM";
2657 case 0x6ffffffc: return "VERDEF";
2658 case 0x7ffffffd: return "AUXILIARY";
2659 case 0x7fffffff: return "FILTER";
2660 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2663 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2667 switch (elf_header
.e_machine
)
2670 case EM_MIPS_RS3_LE
:
2671 result
= get_mips_section_type_name (sh_type
);
2674 result
= get_parisc_section_type_name (sh_type
);
2677 result
= get_ia64_section_type_name (sh_type
);
2680 result
= get_x86_64_section_type_name (sh_type
);
2683 result
= get_arm_section_type_name (sh_type
);
2693 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2695 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2696 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2697 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2698 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2700 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
2706 #define OPTION_DEBUG_DUMP 512
2708 static struct option options
[] =
2710 {"all", no_argument
, 0, 'a'},
2711 {"file-header", no_argument
, 0, 'h'},
2712 {"program-headers", no_argument
, 0, 'l'},
2713 {"headers", no_argument
, 0, 'e'},
2714 {"histogram", no_argument
, 0, 'I'},
2715 {"segments", no_argument
, 0, 'l'},
2716 {"sections", no_argument
, 0, 'S'},
2717 {"section-headers", no_argument
, 0, 'S'},
2718 {"section-groups", no_argument
, 0, 'g'},
2719 {"section-details", no_argument
, 0, 't'},
2720 {"full-section-name",no_argument
, 0, 'N'},
2721 {"symbols", no_argument
, 0, 's'},
2722 {"syms", no_argument
, 0, 's'},
2723 {"relocs", no_argument
, 0, 'r'},
2724 {"notes", no_argument
, 0, 'n'},
2725 {"dynamic", no_argument
, 0, 'd'},
2726 {"arch-specific", no_argument
, 0, 'A'},
2727 {"version-info", no_argument
, 0, 'V'},
2728 {"use-dynamic", no_argument
, 0, 'D'},
2729 {"hex-dump", required_argument
, 0, 'x'},
2730 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2731 {"unwind", no_argument
, 0, 'u'},
2732 #ifdef SUPPORT_DISASSEMBLY
2733 {"instruction-dump", required_argument
, 0, 'i'},
2736 {"version", no_argument
, 0, 'v'},
2737 {"wide", no_argument
, 0, 'W'},
2738 {"help", no_argument
, 0, 'H'},
2739 {0, no_argument
, 0, 0}
2745 fprintf (stdout
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2746 fprintf (stdout
, _(" Display information about the contents of ELF format files\n"));
2747 fprintf (stdout
, _(" Options are:\n\
2748 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2749 -h --file-header Display the ELF file header\n\
2750 -l --program-headers Display the program headers\n\
2751 --segments An alias for --program-headers\n\
2752 -S --section-headers Display the sections' header\n\
2753 --sections An alias for --section-headers\n\
2754 -g --section-groups Display the section groups\n\
2755 -t --section-details Display the section details\n\
2756 -e --headers Equivalent to: -h -l -S\n\
2757 -s --syms Display the symbol table\n\
2758 --symbols An alias for --syms\n\
2759 -n --notes Display the core notes (if present)\n\
2760 -r --relocs Display the relocations (if present)\n\
2761 -u --unwind Display the unwind info (if present)\n\
2762 -d --dynamic Display the dynamic section (if present)\n\
2763 -V --version-info Display the version sections (if present)\n\
2764 -A --arch-specific Display architecture specific information (if any).\n\
2765 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2766 -x --hex-dump=<number> Dump the contents of section <number>\n\
2767 -w[liaprmfFsoR] or\n\
2768 --debug-dump[=line,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
2769 Display the contents of DWARF2 debug sections\n"));
2770 #ifdef SUPPORT_DISASSEMBLY
2771 fprintf (stdout
, _("\
2772 -i --instruction-dump=<number>\n\
2773 Disassemble the contents of section <number>\n"));
2775 fprintf (stdout
, _("\
2776 -I --histogram Display histogram of bucket list lengths\n\
2777 -W --wide Allow output width to exceed 80 characters\n\
2778 -H --help Display this information\n\
2779 -v --version Display the version number of readelf\n"));
2780 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2785 /* Record the fact that the user wants the contents of section number
2786 SECTION to be displayed using the method(s) encoded as flags bits
2787 in TYPE. Note, TYPE can be zero if we are creating the array for
2791 request_dump (unsigned int section
, int type
)
2793 if (section
>= num_dump_sects
)
2795 char *new_dump_sects
;
2797 new_dump_sects
= calloc (section
+ 1, 1);
2799 if (new_dump_sects
== NULL
)
2800 error (_("Out of memory allocating dump request table."));
2803 /* Copy current flag settings. */
2804 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2808 dump_sects
= new_dump_sects
;
2809 num_dump_sects
= section
+ 1;
2814 dump_sects
[section
] |= type
;
2820 parse_args (int argc
, char **argv
)
2827 while ((c
= getopt_long
2828 (argc
, argv
, "ersuahnldSDAINtgw::x:i:vVWH", options
, NULL
)) != EOF
)
2849 do_section_groups
++;
2857 do_section_groups
++;
2862 do_section_details
++;
2904 section
= strtoul (optarg
, & cp
, 0);
2905 if (! *cp
&& section
>= 0)
2907 request_dump (section
, HEX_DUMP
);
2917 unsigned int index
= 0;
2921 while (optarg
[index
])
2922 switch (optarg
[index
++])
2931 do_debug_abbrevs
= 1;
2941 do_debug_pubnames
= 1;
2945 do_debug_aranges
= 1;
2949 do_debug_ranges
= 1;
2953 do_debug_frames_interp
= 1;
2955 do_debug_frames
= 1;
2960 do_debug_macinfo
= 1;
2974 warn (_("Unrecognized debug option '%s'\n"), optarg
);
2979 case OPTION_DEBUG_DUMP
:
2987 const char * option
;
2990 debug_dump_long_opts
;
2992 debug_dump_long_opts opts_table
[] =
2994 /* Please keep this table alpha- sorted. */
2995 { "Ranges", & do_debug_ranges
},
2996 { "abbrev", & do_debug_abbrevs
},
2997 { "aranges", & do_debug_aranges
},
2998 { "frames", & do_debug_frames
},
2999 { "frames-interp", & do_debug_frames_interp
},
3000 { "info", & do_debug_info
},
3001 { "line", & do_debug_lines
},
3002 { "loc", & do_debug_loc
},
3003 { "macro", & do_debug_macinfo
},
3004 { "pubnames", & do_debug_pubnames
},
3005 /* This entry is for compatability
3006 with earlier versions of readelf. */
3007 { "ranges", & do_debug_aranges
},
3008 { "str", & do_debug_str
},
3019 debug_dump_long_opts
* entry
;
3021 for (entry
= opts_table
; entry
->option
; entry
++)
3023 size_t len
= strlen (entry
->option
);
3025 if (strneq (p
, entry
->option
, len
)
3026 && (p
[len
] == ',' || p
[len
] == '\0'))
3028 * entry
->variable
= 1;
3030 /* The --debug-dump=frames-interp option also
3031 enables the --debug-dump=frames option. */
3032 if (do_debug_frames_interp
)
3033 do_debug_frames
= 1;
3040 if (entry
->option
== NULL
)
3042 warn (_("Unrecognized debug option '%s'\n"), p
);
3043 p
= strchr (p
, ',');
3053 #ifdef SUPPORT_DISASSEMBLY
3056 section
= strtoul (optarg
, & cp
, 0);
3057 if (! *cp
&& section
>= 0)
3059 request_dump (section
, DISASS_DUMP
);
3065 print_version (program_name
);
3075 /* xgettext:c-format */
3076 error (_("Invalid option '-%c'\n"), c
);
3083 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3084 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3085 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3086 && !do_section_groups
)
3090 warn (_("Nothing to do.\n"));
3096 get_elf_class (unsigned int elf_class
)
3098 static char buff
[32];
3102 case ELFCLASSNONE
: return _("none");
3103 case ELFCLASS32
: return "ELF32";
3104 case ELFCLASS64
: return "ELF64";
3106 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3112 get_data_encoding (unsigned int encoding
)
3114 static char buff
[32];
3118 case ELFDATANONE
: return _("none");
3119 case ELFDATA2LSB
: return _("2's complement, little endian");
3120 case ELFDATA2MSB
: return _("2's complement, big endian");
3122 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3127 /* Decode the data held in 'elf_header'. */
3130 process_file_header (void)
3132 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3133 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3134 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3135 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3138 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3146 printf (_("ELF Header:\n"));
3147 printf (_(" Magic: "));
3148 for (i
= 0; i
< EI_NIDENT
; i
++)
3149 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3151 printf (_(" Class: %s\n"),
3152 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3153 printf (_(" Data: %s\n"),
3154 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3155 printf (_(" Version: %d %s\n"),
3156 elf_header
.e_ident
[EI_VERSION
],
3157 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3159 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3162 printf (_(" OS/ABI: %s\n"),
3163 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3164 printf (_(" ABI Version: %d\n"),
3165 elf_header
.e_ident
[EI_ABIVERSION
]);
3166 printf (_(" Type: %s\n"),
3167 get_file_type (elf_header
.e_type
));
3168 printf (_(" Machine: %s\n"),
3169 get_machine_name (elf_header
.e_machine
));
3170 printf (_(" Version: 0x%lx\n"),
3171 (unsigned long) elf_header
.e_version
);
3173 printf (_(" Entry point address: "));
3174 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3175 printf (_("\n Start of program headers: "));
3176 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3177 printf (_(" (bytes into file)\n Start of section headers: "));
3178 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3179 printf (_(" (bytes into file)\n"));
3181 printf (_(" Flags: 0x%lx%s\n"),
3182 (unsigned long) elf_header
.e_flags
,
3183 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3184 printf (_(" Size of this header: %ld (bytes)\n"),
3185 (long) elf_header
.e_ehsize
);
3186 printf (_(" Size of program headers: %ld (bytes)\n"),
3187 (long) elf_header
.e_phentsize
);
3188 printf (_(" Number of program headers: %ld\n"),
3189 (long) elf_header
.e_phnum
);
3190 printf (_(" Size of section headers: %ld (bytes)\n"),
3191 (long) elf_header
.e_shentsize
);
3192 printf (_(" Number of section headers: %ld"),
3193 (long) elf_header
.e_shnum
);
3194 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
3195 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3196 putc ('\n', stdout
);
3197 printf (_(" Section header string table index: %ld"),
3198 (long) elf_header
.e_shstrndx
);
3199 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
3200 printf (" (%ld)", (long) section_headers
[0].sh_link
);
3201 putc ('\n', stdout
);
3204 if (section_headers
!= NULL
)
3206 if (elf_header
.e_shnum
== 0)
3207 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3208 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
3209 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3210 free (section_headers
);
3211 section_headers
= NULL
;
3219 get_32bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3221 Elf32_External_Phdr
*phdrs
;
3222 Elf32_External_Phdr
*external
;
3223 Elf_Internal_Phdr
*internal
;
3226 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3227 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3228 _("program headers"));
3232 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3233 i
< elf_header
.e_phnum
;
3234 i
++, internal
++, external
++)
3236 internal
->p_type
= BYTE_GET (external
->p_type
);
3237 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3238 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3239 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3240 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3241 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3242 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3243 internal
->p_align
= BYTE_GET (external
->p_align
);
3252 get_64bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3254 Elf64_External_Phdr
*phdrs
;
3255 Elf64_External_Phdr
*external
;
3256 Elf_Internal_Phdr
*internal
;
3259 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3260 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3261 _("program headers"));
3265 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3266 i
< elf_header
.e_phnum
;
3267 i
++, internal
++, external
++)
3269 internal
->p_type
= BYTE_GET (external
->p_type
);
3270 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3271 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3272 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3273 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3274 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3275 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3276 internal
->p_align
= BYTE_GET (external
->p_align
);
3284 /* Returns 1 if the program headers were read into `program_headers'. */
3287 get_program_headers (FILE *file
)
3289 Elf_Internal_Phdr
*phdrs
;
3291 /* Check cache of prior read. */
3292 if (program_headers
!= NULL
)
3295 phdrs
= cmalloc (elf_header
.e_phnum
, sizeof (Elf_Internal_Phdr
));
3299 error (_("Out of memory\n"));
3304 ? get_32bit_program_headers (file
, phdrs
)
3305 : get_64bit_program_headers (file
, phdrs
))
3307 program_headers
= phdrs
;
3315 /* Returns 1 if the program headers were loaded. */
3318 process_program_headers (FILE *file
)
3320 Elf_Internal_Phdr
*segment
;
3323 if (elf_header
.e_phnum
== 0)
3326 printf (_("\nThere are no program headers in this file.\n"));
3330 if (do_segments
&& !do_header
)
3332 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3333 printf (_("Entry point "));
3334 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3335 printf (_("\nThere are %d program headers, starting at offset "),
3336 elf_header
.e_phnum
);
3337 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3341 if (! get_program_headers (file
))
3346 if (elf_header
.e_phnum
> 1)
3347 printf (_("\nProgram Headers:\n"));
3349 printf (_("\nProgram Headers:\n"));
3353 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3356 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3360 (_(" Type Offset VirtAddr PhysAddr\n"));
3362 (_(" FileSiz MemSiz Flags Align\n"));
3369 for (i
= 0, segment
= program_headers
;
3370 i
< elf_header
.e_phnum
;
3375 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3379 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3380 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3381 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3382 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3383 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3385 (segment
->p_flags
& PF_R
? 'R' : ' '),
3386 (segment
->p_flags
& PF_W
? 'W' : ' '),
3387 (segment
->p_flags
& PF_X
? 'E' : ' '));
3388 printf ("%#lx", (unsigned long) segment
->p_align
);
3392 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3393 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3396 print_vma (segment
->p_offset
, FULL_HEX
);
3400 print_vma (segment
->p_vaddr
, FULL_HEX
);
3402 print_vma (segment
->p_paddr
, FULL_HEX
);
3405 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3406 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3409 print_vma (segment
->p_filesz
, FULL_HEX
);
3413 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3414 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3417 print_vma (segment
->p_offset
, FULL_HEX
);
3421 (segment
->p_flags
& PF_R
? 'R' : ' '),
3422 (segment
->p_flags
& PF_W
? 'W' : ' '),
3423 (segment
->p_flags
& PF_X
? 'E' : ' '));
3425 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3426 printf ("%#lx", (unsigned long) segment
->p_align
);
3429 print_vma (segment
->p_align
, PREFIX_HEX
);
3434 print_vma (segment
->p_offset
, FULL_HEX
);
3436 print_vma (segment
->p_vaddr
, FULL_HEX
);
3438 print_vma (segment
->p_paddr
, FULL_HEX
);
3440 print_vma (segment
->p_filesz
, FULL_HEX
);
3442 print_vma (segment
->p_memsz
, FULL_HEX
);
3444 (segment
->p_flags
& PF_R
? 'R' : ' '),
3445 (segment
->p_flags
& PF_W
? 'W' : ' '),
3446 (segment
->p_flags
& PF_X
? 'E' : ' '));
3447 print_vma (segment
->p_align
, HEX
);
3451 switch (segment
->p_type
)
3455 error (_("more than one dynamic segment\n"));
3457 /* Try to locate the .dynamic section. If there is
3458 a section header table, we can easily locate it. */
3459 if (section_headers
!= NULL
)
3461 Elf_Internal_Shdr
*sec
;
3463 sec
= find_section (".dynamic");
3464 if (sec
== NULL
|| sec
->sh_size
== 0)
3466 error (_("no .dynamic section in the dynamic segment"));
3470 dynamic_addr
= sec
->sh_offset
;
3471 dynamic_size
= sec
->sh_size
;
3473 if (dynamic_addr
< segment
->p_offset
3474 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3475 warn (_("the .dynamic section is not contained within the dynamic segment"));
3476 else if (dynamic_addr
> segment
->p_offset
)
3477 warn (_("the .dynamic section is not the first section in the dynamic segment."));
3481 /* Otherwise, we can only assume that the .dynamic
3482 section is the first section in the DYNAMIC segment. */
3483 dynamic_addr
= segment
->p_offset
;
3484 dynamic_size
= segment
->p_filesz
;
3489 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3491 error (_("Unable to find program interpreter name\n"));
3494 program_interpreter
[0] = 0;
3495 fscanf (file
, "%63s", program_interpreter
);
3498 printf (_("\n [Requesting program interpreter: %s]"),
3499 program_interpreter
);
3505 putc ('\n', stdout
);
3508 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3510 printf (_("\n Section to Segment mapping:\n"));
3511 printf (_(" Segment Sections...\n"));
3513 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3516 Elf_Internal_Shdr
*section
;
3518 segment
= program_headers
+ i
;
3519 section
= section_headers
;
3521 printf (" %2.2d ", i
);
3523 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3525 if (section
->sh_size
> 0
3526 /* Compare allocated sections by VMA, unallocated
3527 sections by file offset. */
3528 && (section
->sh_flags
& SHF_ALLOC
3529 ? (section
->sh_addr
>= segment
->p_vaddr
3530 && section
->sh_addr
+ section
->sh_size
3531 <= segment
->p_vaddr
+ segment
->p_memsz
)
3532 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
3533 && (section
->sh_offset
+ section
->sh_size
3534 <= segment
->p_offset
+ segment
->p_filesz
)))
3535 /* .tbss is special. It doesn't contribute memory space
3536 to normal segments. */
3537 && (!((section
->sh_flags
& SHF_TLS
) != 0
3538 && section
->sh_type
== SHT_NOBITS
)
3539 || segment
->p_type
== PT_TLS
))
3540 printf ("%s ", SECTION_NAME (section
));
3551 /* Find the file offset corresponding to VMA by using the program headers. */
3554 offset_from_vma (FILE *file
, bfd_vma vma
, bfd_size_type size
)
3556 Elf_Internal_Phdr
*seg
;
3558 if (! get_program_headers (file
))
3560 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3564 for (seg
= program_headers
;
3565 seg
< program_headers
+ elf_header
.e_phnum
;
3568 if (seg
->p_type
!= PT_LOAD
)
3571 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3572 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3573 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3576 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3583 get_32bit_section_headers (FILE *file
, unsigned int num
)
3585 Elf32_External_Shdr
*shdrs
;
3586 Elf_Internal_Shdr
*internal
;
3589 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3590 elf_header
.e_shentsize
, num
, _("section headers"));
3594 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3596 if (section_headers
== NULL
)
3598 error (_("Out of memory\n"));
3602 for (i
= 0, internal
= section_headers
;
3606 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3607 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3608 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3609 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3610 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3611 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3612 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3613 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3614 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3615 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3624 get_64bit_section_headers (FILE *file
, unsigned int num
)
3626 Elf64_External_Shdr
*shdrs
;
3627 Elf_Internal_Shdr
*internal
;
3630 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3631 elf_header
.e_shentsize
, num
, _("section headers"));
3635 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3637 if (section_headers
== NULL
)
3639 error (_("Out of memory\n"));
3643 for (i
= 0, internal
= section_headers
;
3647 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3648 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3649 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3650 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3651 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3652 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3653 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3654 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3655 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3656 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3664 static Elf_Internal_Sym
*
3665 get_32bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3667 unsigned long number
;
3668 Elf32_External_Sym
*esyms
;
3669 Elf_External_Sym_Shndx
*shndx
;
3670 Elf_Internal_Sym
*isyms
;
3671 Elf_Internal_Sym
*psym
;
3674 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3680 if (symtab_shndx_hdr
!= NULL
3681 && (symtab_shndx_hdr
->sh_link
3682 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3684 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3685 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3693 number
= section
->sh_size
/ section
->sh_entsize
;
3694 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3698 error (_("Out of memory\n"));
3705 for (j
= 0, psym
= isyms
;
3709 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3710 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3711 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3712 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3713 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3715 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3716 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3717 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3727 static Elf_Internal_Sym
*
3728 get_64bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3730 unsigned long number
;
3731 Elf64_External_Sym
*esyms
;
3732 Elf_External_Sym_Shndx
*shndx
;
3733 Elf_Internal_Sym
*isyms
;
3734 Elf_Internal_Sym
*psym
;
3737 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3743 if (symtab_shndx_hdr
!= NULL
3744 && (symtab_shndx_hdr
->sh_link
3745 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3747 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3748 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3756 number
= section
->sh_size
/ section
->sh_entsize
;
3757 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3761 error (_("Out of memory\n"));
3768 for (j
= 0, psym
= isyms
;
3772 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3773 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3774 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3775 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3776 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3778 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3779 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3780 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3791 get_elf_section_flags (bfd_vma sh_flags
)
3793 static char buff
[1024];
3795 int index
, size
= sizeof (buff
) - (8 + 4 + 1);
3809 { "LINK ORDER", 10 },
3810 { "OS NONCONF", 10 },
3815 if (do_section_details
)
3817 sprintf (buff
, "[%8.8lx]: ", (unsigned long) sh_flags
);
3825 flag
= sh_flags
& - sh_flags
;
3828 if (do_section_details
)
3832 case SHF_WRITE
: index
= 0; break;
3833 case SHF_ALLOC
: index
= 1; break;
3834 case SHF_EXECINSTR
: index
= 2; break;
3835 case SHF_MERGE
: index
= 3; break;
3836 case SHF_STRINGS
: index
= 4; break;
3837 case SHF_INFO_LINK
: index
= 5; break;
3838 case SHF_LINK_ORDER
: index
= 6; break;
3839 case SHF_OS_NONCONFORMING
: index
= 7; break;
3840 case SHF_GROUP
: index
= 8; break;
3841 case SHF_TLS
: index
= 9; break;
3848 if (p
!= buff
+ 8 + 4)
3859 size
-= flags
[index
].len
;
3860 p
= stpcpy (p
, flags
[index
].str
);
3862 else if (flag
& SHF_MASKOS
)
3865 sprintf (p
, "OS (%8.8lx)", (unsigned long) flag
);
3868 else if (flag
& SHF_MASKPROC
)
3871 sprintf (p
, "PROC (%8.8lx)", (unsigned long) flag
);
3877 sprintf (p
, "UNKNOWN (%8.8lx)", (unsigned long) flag
);
3885 case SHF_WRITE
: *p
= 'W'; break;
3886 case SHF_ALLOC
: *p
= 'A'; break;
3887 case SHF_EXECINSTR
: *p
= 'X'; break;
3888 case SHF_MERGE
: *p
= 'M'; break;
3889 case SHF_STRINGS
: *p
= 'S'; break;
3890 case SHF_INFO_LINK
: *p
= 'I'; break;
3891 case SHF_LINK_ORDER
: *p
= 'L'; break;
3892 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
3893 case SHF_GROUP
: *p
= 'G'; break;
3894 case SHF_TLS
: *p
= 'T'; break;
3897 if (elf_header
.e_machine
== EM_X86_64
3898 && flag
== SHF_X86_64_LARGE
)
3900 else if (flag
& SHF_MASKOS
)
3903 sh_flags
&= ~ SHF_MASKOS
;
3905 else if (flag
& SHF_MASKPROC
)
3908 sh_flags
&= ~ SHF_MASKPROC
;
3923 process_section_headers (FILE *file
)
3925 Elf_Internal_Shdr
*section
;
3928 section_headers
= NULL
;
3930 if (elf_header
.e_shnum
== 0)
3933 printf (_("\nThere are no sections in this file.\n"));
3938 if (do_sections
&& !do_header
)
3939 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3940 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
3944 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
3947 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
3950 /* Read in the string table, so that we have names to display. */
3951 if (SECTION_HEADER_INDEX (elf_header
.e_shstrndx
) < elf_header
.e_shnum
)
3953 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
3955 if (section
->sh_size
!= 0)
3957 string_table
= get_data (NULL
, file
, section
->sh_offset
,
3958 1, section
->sh_size
, _("string table"));
3960 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
3964 /* Scan the sections for the dynamic symbol table
3965 and dynamic string table and debug sections. */
3966 dynamic_symbols
= NULL
;
3967 dynamic_strings
= NULL
;
3968 dynamic_syminfo
= NULL
;
3969 symtab_shndx_hdr
= NULL
;
3971 eh_addr_size
= is_32bit_elf
? 4 : 8;
3972 switch (elf_header
.e_machine
)
3975 case EM_MIPS_RS3_LE
:
3976 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
3977 FDE addresses. However, the ABI also has a semi-official ILP32
3978 variant for which the normal FDE address size rules apply.
3980 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
3981 section, where XX is the size of longs in bits. Unfortunately,
3982 earlier compilers provided no way of distinguishing ILP32 objects
3983 from LP64 objects, so if there's any doubt, we should assume that
3984 the official LP64 form is being used. */
3985 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
3986 && find_section (".gcc_compiled_long32") == NULL
)
3991 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
3994 size_t expected_entsize \
3995 = is_32bit_elf ? size32 : size64; \
3996 if (section->sh_entsize != expected_entsize) \
3997 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
3998 i, (unsigned long int) section->sh_entsize, \
3999 (unsigned long int) expected_entsize); \
4000 section->sh_entsize = expected_entsize; \
4003 #define CHECK_ENTSIZE(section, i, type) \
4004 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4005 sizeof (Elf64_External_##type))
4007 for (i
= 0, section
= section_headers
;
4008 i
< elf_header
.e_shnum
;
4011 char *name
= SECTION_NAME (section
);
4013 if (section
->sh_type
== SHT_DYNSYM
)
4015 if (dynamic_symbols
!= NULL
)
4017 error (_("File contains multiple dynamic symbol tables\n"));
4021 CHECK_ENTSIZE (section
, i
, Sym
);
4022 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
4023 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
4025 else if (section
->sh_type
== SHT_STRTAB
4026 && streq (name
, ".dynstr"))
4028 if (dynamic_strings
!= NULL
)
4030 error (_("File contains multiple dynamic string tables\n"));
4034 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
4035 1, section
->sh_size
, _("dynamic strings"));
4036 dynamic_strings_length
= section
->sh_size
;
4038 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4040 if (symtab_shndx_hdr
!= NULL
)
4042 error (_("File contains multiple symtab shndx tables\n"));
4045 symtab_shndx_hdr
= section
;
4047 else if (section
->sh_type
== SHT_SYMTAB
)
4048 CHECK_ENTSIZE (section
, i
, Sym
);
4049 else if (section
->sh_type
== SHT_GROUP
)
4050 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4051 else if (section
->sh_type
== SHT_REL
)
4052 CHECK_ENTSIZE (section
, i
, Rel
);
4053 else if (section
->sh_type
== SHT_RELA
)
4054 CHECK_ENTSIZE (section
, i
, Rela
);
4055 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4056 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
4057 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
4058 || do_debug_loc
|| do_debug_ranges
)
4059 && strneq (name
, ".debug_", 7))
4064 || (do_debug_info
&& streq (name
, "info"))
4065 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
4066 || (do_debug_lines
&& streq (name
, "line"))
4067 || (do_debug_pubnames
&& streq (name
, "pubnames"))
4068 || (do_debug_aranges
&& streq (name
, "aranges"))
4069 || (do_debug_ranges
&& streq (name
, "ranges"))
4070 || (do_debug_frames
&& streq (name
, "frame"))
4071 || (do_debug_macinfo
&& streq (name
, "macinfo"))
4072 || (do_debug_str
&& streq (name
, "str"))
4073 || (do_debug_loc
&& streq (name
, "loc"))
4075 request_dump (i
, DEBUG_DUMP
);
4077 /* linkonce section to be combined with .debug_info at link time. */
4078 else if ((do_debugging
|| do_debug_info
)
4079 && strneq (name
, ".gnu.linkonce.wi.", 17))
4080 request_dump (i
, DEBUG_DUMP
);
4081 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4082 request_dump (i
, DEBUG_DUMP
);
4088 if (elf_header
.e_shnum
> 1)
4089 printf (_("\nSection Headers:\n"));
4091 printf (_("\nSection Header:\n"));
4095 if (do_section_details
)
4097 printf (_(" [Nr] Name\n"));
4098 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4102 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4106 if (do_section_details
)
4108 printf (_(" [Nr] Name\n"));
4109 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4113 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4117 if (do_section_details
)
4119 printf (_(" [Nr] Name\n"));
4120 printf (_(" Type Address Offset Link\n"));
4121 printf (_(" Size EntSize Info Align\n"));
4125 printf (_(" [Nr] Name Type Address Offset\n"));
4126 printf (_(" Size EntSize Flags Link Info Align\n"));
4130 if (do_section_details
)
4131 printf (_(" Flags\n"));
4133 for (i
= 0, section
= section_headers
;
4134 i
< elf_header
.e_shnum
;
4137 if (do_section_details
)
4139 printf (" [%2u] %s\n",
4140 SECTION_HEADER_NUM (i
),
4141 SECTION_NAME (section
));
4142 if (is_32bit_elf
|| do_wide
)
4143 printf (" %-15.15s ",
4144 get_section_type_name (section
->sh_type
));
4147 printf (" [%2u] %-17.17s %-15.15s ",
4148 SECTION_HEADER_NUM (i
),
4149 SECTION_NAME (section
),
4150 get_section_type_name (section
->sh_type
));
4154 print_vma (section
->sh_addr
, LONG_HEX
);
4156 printf ( " %6.6lx %6.6lx %2.2lx",
4157 (unsigned long) section
->sh_offset
,
4158 (unsigned long) section
->sh_size
,
4159 (unsigned long) section
->sh_entsize
);
4161 if (do_section_details
)
4162 fputs (" ", stdout
);
4164 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4166 printf ("%2ld %3lu %2ld\n",
4167 (unsigned long) section
->sh_link
,
4168 (unsigned long) section
->sh_info
,
4169 (unsigned long) section
->sh_addralign
);
4173 print_vma (section
->sh_addr
, LONG_HEX
);
4175 if ((long) section
->sh_offset
== section
->sh_offset
)
4176 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4180 print_vma (section
->sh_offset
, LONG_HEX
);
4183 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4184 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4188 print_vma (section
->sh_size
, LONG_HEX
);
4191 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4192 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4196 print_vma (section
->sh_entsize
, LONG_HEX
);
4199 if (do_section_details
)
4200 fputs (" ", stdout
);
4202 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4204 printf ("%2ld %3lu ",
4205 (unsigned long) section
->sh_link
,
4206 (unsigned long) section
->sh_info
);
4208 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4209 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
4212 print_vma (section
->sh_addralign
, DEC
);
4216 else if (do_section_details
)
4218 printf (" %-15.15s ",
4219 get_section_type_name (section
->sh_type
));
4220 print_vma (section
->sh_addr
, LONG_HEX
);
4221 if ((long) section
->sh_offset
== section
->sh_offset
)
4222 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4226 print_vma (section
->sh_offset
, LONG_HEX
);
4228 printf (" %ld\n ", (unsigned long) section
->sh_link
);
4229 print_vma (section
->sh_size
, LONG_HEX
);
4231 print_vma (section
->sh_entsize
, LONG_HEX
);
4233 printf (" %-16lu %ld\n",
4234 (unsigned long) section
->sh_info
,
4235 (unsigned long) section
->sh_addralign
);
4240 print_vma (section
->sh_addr
, LONG_HEX
);
4241 if ((long) section
->sh_offset
== section
->sh_offset
)
4242 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4246 print_vma (section
->sh_offset
, LONG_HEX
);
4249 print_vma (section
->sh_size
, LONG_HEX
);
4251 print_vma (section
->sh_entsize
, LONG_HEX
);
4253 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4255 printf (" %2ld %3lu %ld\n",
4256 (unsigned long) section
->sh_link
,
4257 (unsigned long) section
->sh_info
,
4258 (unsigned long) section
->sh_addralign
);
4261 if (do_section_details
)
4262 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
4265 if (!do_section_details
)
4266 printf (_("Key to Flags:\n\
4267 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4268 I (info), L (link order), G (group), x (unknown)\n\
4269 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4275 get_group_flags (unsigned int flags
)
4277 static char buff
[32];
4284 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x]"), flags
);
4291 process_section_groups (FILE *file
)
4293 Elf_Internal_Shdr
*section
;
4295 struct group
*group
;
4296 Elf_Internal_Shdr
*symtab_sec
, *strtab_sec
;
4297 Elf_Internal_Sym
*symtab
;
4301 /* Don't process section groups unless needed. */
4302 if (!do_unwind
&& !do_section_groups
)
4305 if (elf_header
.e_shnum
== 0)
4307 if (do_section_groups
)
4308 printf (_("\nThere are no sections in this file.\n"));
4313 if (section_headers
== NULL
)
4315 error (_("Section headers are not available!\n"));
4319 section_headers_groups
= calloc (elf_header
.e_shnum
,
4320 sizeof (struct group
*));
4322 if (section_headers_groups
== NULL
)
4324 error (_("Out of memory\n"));
4328 /* Scan the sections for the group section. */
4330 for (i
= 0, section
= section_headers
;
4331 i
< elf_header
.e_shnum
;
4333 if (section
->sh_type
== SHT_GROUP
)
4336 if (group_count
== 0)
4338 if (do_section_groups
)
4339 printf (_("\nThere are no section groups in this file.\n"));
4344 section_groups
= calloc (group_count
, sizeof (struct group
));
4346 if (section_groups
== NULL
)
4348 error (_("Out of memory\n"));
4357 for (i
= 0, section
= section_headers
, group
= section_groups
;
4358 i
< elf_header
.e_shnum
;
4361 if (section
->sh_type
== SHT_GROUP
)
4363 char *name
= SECTION_NAME (section
);
4365 unsigned char *start
, *indices
;
4366 unsigned int entry
, j
, size
;
4367 Elf_Internal_Shdr
*sec
;
4368 Elf_Internal_Sym
*sym
;
4370 /* Get the symbol table. */
4371 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
4372 || ((sec
= SECTION_HEADER (section
->sh_link
))->sh_type
4375 error (_("Bad sh_link in group section `%s'\n"), name
);
4379 if (symtab_sec
!= sec
)
4384 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4387 sym
= symtab
+ section
->sh_info
;
4389 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4391 bfd_vma sec_index
= SECTION_HEADER_INDEX (sym
->st_shndx
);
4394 error (_("Bad sh_info in group section `%s'\n"), name
);
4398 group_name
= SECTION_NAME (section_headers
+ sec_index
);
4407 /* Get the string table. */
4408 if (SECTION_HEADER_INDEX (symtab_sec
->sh_link
)
4409 >= elf_header
.e_shnum
)
4418 != (sec
= SECTION_HEADER (symtab_sec
->sh_link
)))
4423 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
4424 1, strtab_sec
->sh_size
,
4426 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
4428 group_name
= sym
->st_name
< strtab_size
4429 ? strtab
+ sym
->st_name
: "<corrupt>";
4432 start
= get_data (NULL
, file
, section
->sh_offset
,
4433 1, section
->sh_size
, _("section data"));
4436 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4437 entry
= byte_get (indices
, 4);
4440 if (do_section_groups
)
4442 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4443 get_group_flags (entry
), i
, name
, group_name
, size
);
4445 printf (_(" [Index] Name\n"));
4448 group
->group_index
= i
;
4450 for (j
= 0; j
< size
; j
++)
4452 struct group_list
*g
;
4454 entry
= byte_get (indices
, 4);
4457 if (SECTION_HEADER_INDEX (entry
) >= elf_header
.e_shnum
)
4459 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4460 entry
, i
, elf_header
.e_shnum
- 1);
4463 else if (entry
>= SHN_LORESERVE
&& entry
<= SHN_HIRESERVE
)
4465 error (_("invalid section [%5u] in group section [%5u]\n"),
4470 if (section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4475 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4477 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4482 /* Intel C/C++ compiler may put section 0 in a
4483 section group. We just warn it the first time
4484 and ignore it afterwards. */
4485 static int warned
= 0;
4488 error (_("section 0 in group section [%5u]\n"),
4489 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4495 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4498 if (do_section_groups
)
4500 sec
= SECTION_HEADER (entry
);
4501 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
4504 g
= xmalloc (sizeof (struct group_list
));
4505 g
->section_index
= entry
;
4506 g
->next
= group
->root
;
4530 } dynamic_relocations
[] =
4532 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4533 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4534 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4537 /* Process the reloc section. */
4540 process_relocs (FILE *file
)
4542 unsigned long rel_size
;
4543 unsigned long rel_offset
;
4549 if (do_using_dynamic
)
4553 int has_dynamic_reloc
;
4556 has_dynamic_reloc
= 0;
4558 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4560 is_rela
= dynamic_relocations
[i
].rela
;
4561 name
= dynamic_relocations
[i
].name
;
4562 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4563 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4565 has_dynamic_reloc
|= rel_size
;
4567 if (is_rela
== UNKNOWN
)
4569 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4570 switch (dynamic_info
[DT_PLTREL
])
4584 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4585 name
, rel_offset
, rel_size
);
4587 dump_relocations (file
,
4588 offset_from_vma (file
, rel_offset
, rel_size
),
4590 dynamic_symbols
, num_dynamic_syms
,
4591 dynamic_strings
, dynamic_strings_length
, is_rela
);
4595 if (! has_dynamic_reloc
)
4596 printf (_("\nThere are no dynamic relocations in this file.\n"));
4600 Elf_Internal_Shdr
*section
;
4604 for (i
= 0, section
= section_headers
;
4605 i
< elf_header
.e_shnum
;
4608 if ( section
->sh_type
!= SHT_RELA
4609 && section
->sh_type
!= SHT_REL
)
4612 rel_offset
= section
->sh_offset
;
4613 rel_size
= section
->sh_size
;
4617 Elf_Internal_Shdr
*strsec
;
4620 printf (_("\nRelocation section "));
4622 if (string_table
== NULL
)
4623 printf ("%d", section
->sh_name
);
4625 printf (_("'%s'"), SECTION_NAME (section
));
4627 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4628 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4630 is_rela
= section
->sh_type
== SHT_RELA
;
4632 if (section
->sh_link
4633 && SECTION_HEADER_INDEX (section
->sh_link
)
4634 < elf_header
.e_shnum
)
4636 Elf_Internal_Shdr
*symsec
;
4637 Elf_Internal_Sym
*symtab
;
4638 unsigned long nsyms
;
4639 unsigned long strtablen
= 0;
4640 char *strtab
= NULL
;
4642 symsec
= SECTION_HEADER (section
->sh_link
);
4643 if (symsec
->sh_type
!= SHT_SYMTAB
4644 && symsec
->sh_type
!= SHT_DYNSYM
)
4647 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4648 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4653 if (SECTION_HEADER_INDEX (symsec
->sh_link
)
4654 < elf_header
.e_shnum
)
4656 strsec
= SECTION_HEADER (symsec
->sh_link
);
4658 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4661 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4664 dump_relocations (file
, rel_offset
, rel_size
,
4665 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4671 dump_relocations (file
, rel_offset
, rel_size
,
4672 NULL
, 0, NULL
, 0, is_rela
);
4679 printf (_("\nThere are no relocations in this file.\n"));
4685 /* Process the unwind section. */
4687 #include "unwind-ia64.h"
4689 /* An absolute address consists of a section and an offset. If the
4690 section is NULL, the offset itself is the address, otherwise, the
4691 address equals to LOAD_ADDRESS(section) + offset. */
4695 unsigned short section
;
4699 struct ia64_unw_aux_info
4701 struct ia64_unw_table_entry
4703 struct absaddr start
;
4705 struct absaddr info
;
4707 *table
; /* Unwind table. */
4708 unsigned long table_len
; /* Length of unwind table. */
4709 unsigned char *info
; /* Unwind info. */
4710 unsigned long info_size
; /* Size of unwind info. */
4711 bfd_vma info_addr
; /* starting address of unwind info. */
4712 bfd_vma seg_base
; /* Starting address of segment. */
4713 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4714 unsigned long nsyms
; /* Number of symbols. */
4715 char *strtab
; /* The string table. */
4716 unsigned long strtab_size
; /* Size of string table. */
4720 find_symbol_for_address (Elf_Internal_Sym
*symtab
,
4721 unsigned long nsyms
,
4723 unsigned long strtab_size
,
4724 struct absaddr addr
,
4725 const char **symname
,
4728 bfd_vma dist
= 0x100000;
4729 Elf_Internal_Sym
*sym
, *best
= NULL
;
4732 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
4734 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4735 && sym
->st_name
!= 0
4736 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4737 && addr
.offset
>= sym
->st_value
4738 && addr
.offset
- sym
->st_value
< dist
)
4741 dist
= addr
.offset
- sym
->st_value
;
4748 *symname
= (best
->st_name
>= strtab_size
4749 ? "<corrupt>" : strtab
+ best
->st_name
);
4754 *offset
= addr
.offset
;
4758 dump_ia64_unwind (struct ia64_unw_aux_info
*aux
)
4760 struct ia64_unw_table_entry
*tp
;
4763 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4767 const unsigned char *dp
;
4768 const unsigned char *head
;
4769 const char *procname
;
4771 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4772 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
4774 fputs ("\n<", stdout
);
4778 fputs (procname
, stdout
);
4781 printf ("+%lx", (unsigned long) offset
);
4784 fputs (">: [", stdout
);
4785 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4786 fputc ('-', stdout
);
4787 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4788 printf ("], info at +0x%lx\n",
4789 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4791 head
= aux
->info
+ (tp
->info
.offset
- aux
->info_addr
);
4792 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
4794 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4795 (unsigned) UNW_VER (stamp
),
4796 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4797 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4798 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4799 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
4801 if (UNW_VER (stamp
) != 1)
4803 printf ("\tUnknown version.\n");
4808 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
4809 dp
= unw_decode (dp
, in_body
, & in_body
);
4814 slurp_ia64_unwind_table (FILE *file
,
4815 struct ia64_unw_aux_info
*aux
,
4816 Elf_Internal_Shdr
*sec
)
4818 unsigned long size
, nrelas
, i
;
4819 Elf_Internal_Phdr
*seg
;
4820 struct ia64_unw_table_entry
*tep
;
4821 Elf_Internal_Shdr
*relsec
;
4822 Elf_Internal_Rela
*rela
, *rp
;
4823 unsigned char *table
, *tp
;
4824 Elf_Internal_Sym
*sym
;
4825 const char *relname
;
4827 /* First, find the starting address of the segment that includes
4830 if (elf_header
.e_phnum
)
4832 if (! get_program_headers (file
))
4835 for (seg
= program_headers
;
4836 seg
< program_headers
+ elf_header
.e_phnum
;
4839 if (seg
->p_type
!= PT_LOAD
)
4842 if (sec
->sh_addr
>= seg
->p_vaddr
4843 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4845 aux
->seg_base
= seg
->p_vaddr
;
4851 /* Second, build the unwind table from the contents of the unwind section: */
4852 size
= sec
->sh_size
;
4853 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
4857 aux
->table
= xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
4859 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * eh_addr_size
, ++tep
)
4861 tep
->start
.section
= SHN_UNDEF
;
4862 tep
->end
.section
= SHN_UNDEF
;
4863 tep
->info
.section
= SHN_UNDEF
;
4866 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4867 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4868 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
4872 tep
->start
.offset
= BYTE_GET ((unsigned char *) tp
+ 0);
4873 tep
->end
.offset
= BYTE_GET ((unsigned char *) tp
+ 8);
4874 tep
->info
.offset
= BYTE_GET ((unsigned char *) tp
+ 16);
4876 tep
->start
.offset
+= aux
->seg_base
;
4877 tep
->end
.offset
+= aux
->seg_base
;
4878 tep
->info
.offset
+= aux
->seg_base
;
4882 /* Third, apply any relocations to the unwind table: */
4884 for (relsec
= section_headers
;
4885 relsec
< section_headers
+ elf_header
.e_shnum
;
4888 if (relsec
->sh_type
!= SHT_RELA
4889 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
4890 || SECTION_HEADER (relsec
->sh_info
) != sec
)
4893 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
4897 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4901 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4902 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4906 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4907 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4910 if (! strneq (relname
, "R_IA64_SEGREL", 13))
4912 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4916 i
= rp
->r_offset
/ (3 * eh_addr_size
);
4918 switch (rp
->r_offset
/eh_addr_size
% 3)
4921 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4922 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
4925 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4926 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
4929 aux
->table
[i
].info
.section
= sym
->st_shndx
;
4930 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
4940 aux
->table_len
= size
/ (3 * eh_addr_size
);
4945 ia64_process_unwind (FILE *file
)
4947 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
4948 unsigned long i
, unwcount
= 0, unwstart
= 0;
4949 struct ia64_unw_aux_info aux
;
4951 memset (& aux
, 0, sizeof (aux
));
4953 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4955 if (sec
->sh_type
== SHT_SYMTAB
4956 && SECTION_HEADER_INDEX (sec
->sh_link
) < elf_header
.e_shnum
)
4958 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
4959 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
4961 strsec
= SECTION_HEADER (sec
->sh_link
);
4962 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4963 1, strsec
->sh_size
, _("string table"));
4964 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
4966 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4971 printf (_("\nThere are no unwind sections in this file.\n"));
4973 while (unwcount
-- > 0)
4978 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
4979 i
< elf_header
.e_shnum
; ++i
, ++sec
)
4980 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4987 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
4989 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
4991 /* We need to find which section group it is in. */
4992 struct group_list
*g
= section_headers_groups
[i
]->root
;
4994 for (; g
!= NULL
; g
= g
->next
)
4996 sec
= SECTION_HEADER (g
->section_index
);
4998 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
5003 i
= elf_header
.e_shnum
;
5005 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
5007 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5008 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
5009 suffix
= SECTION_NAME (unwsec
) + len
;
5010 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5012 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
5013 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5018 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5019 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5020 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
5021 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
5023 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
5024 suffix
= SECTION_NAME (unwsec
) + len
;
5025 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5027 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
5028 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5032 if (i
== elf_header
.e_shnum
)
5034 printf (_("\nCould not find unwind info section for "));
5036 if (string_table
== NULL
)
5037 printf ("%d", unwsec
->sh_name
);
5039 printf (_("'%s'"), SECTION_NAME (unwsec
));
5043 aux
.info_size
= sec
->sh_size
;
5044 aux
.info_addr
= sec
->sh_addr
;
5045 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, 1, aux
.info_size
,
5048 printf (_("\nUnwind section "));
5050 if (string_table
== NULL
)
5051 printf ("%d", unwsec
->sh_name
);
5053 printf (_("'%s'"), SECTION_NAME (unwsec
));
5055 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5056 (unsigned long) unwsec
->sh_offset
,
5057 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
5059 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
5061 if (aux
.table_len
> 0)
5062 dump_ia64_unwind (& aux
);
5065 free ((char *) aux
.table
);
5067 free ((char *) aux
.info
);
5076 free ((char *) aux
.strtab
);
5081 struct hppa_unw_aux_info
5083 struct hppa_unw_table_entry
5085 struct absaddr start
;
5087 unsigned int Cannot_unwind
:1; /* 0 */
5088 unsigned int Millicode
:1; /* 1 */
5089 unsigned int Millicode_save_sr0
:1; /* 2 */
5090 unsigned int Region_description
:2; /* 3..4 */
5091 unsigned int reserved1
:1; /* 5 */
5092 unsigned int Entry_SR
:1; /* 6 */
5093 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
5094 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
5095 unsigned int Args_stored
:1; /* 16 */
5096 unsigned int Variable_Frame
:1; /* 17 */
5097 unsigned int Separate_Package_Body
:1; /* 18 */
5098 unsigned int Frame_Extension_Millicode
:1; /* 19 */
5099 unsigned int Stack_Overflow_Check
:1; /* 20 */
5100 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
5101 unsigned int Ada_Region
:1; /* 22 */
5102 unsigned int cxx_info
:1; /* 23 */
5103 unsigned int cxx_try_catch
:1; /* 24 */
5104 unsigned int sched_entry_seq
:1; /* 25 */
5105 unsigned int reserved2
:1; /* 26 */
5106 unsigned int Save_SP
:1; /* 27 */
5107 unsigned int Save_RP
:1; /* 28 */
5108 unsigned int Save_MRP_in_frame
:1; /* 29 */
5109 unsigned int extn_ptr_defined
:1; /* 30 */
5110 unsigned int Cleanup_defined
:1; /* 31 */
5112 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
5113 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
5114 unsigned int Large_frame
:1; /* 2 */
5115 unsigned int Pseudo_SP_Set
:1; /* 3 */
5116 unsigned int reserved4
:1; /* 4 */
5117 unsigned int Total_frame_size
:27; /* 5..31 */
5119 *table
; /* Unwind table. */
5120 unsigned long table_len
; /* Length of unwind table. */
5121 bfd_vma seg_base
; /* Starting address of segment. */
5122 Elf_Internal_Sym
*symtab
; /* The symbol table. */
5123 unsigned long nsyms
; /* Number of symbols. */
5124 char *strtab
; /* The string table. */
5125 unsigned long strtab_size
; /* Size of string table. */
5129 dump_hppa_unwind (struct hppa_unw_aux_info
*aux
)
5131 struct hppa_unw_table_entry
*tp
;
5133 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5136 const char *procname
;
5138 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5139 aux
->strtab_size
, tp
->start
, &procname
,
5142 fputs ("\n<", stdout
);
5146 fputs (procname
, stdout
);
5149 printf ("+%lx", (unsigned long) offset
);
5152 fputs (">: [", stdout
);
5153 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5154 fputc ('-', stdout
);
5155 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5158 #define PF(_m) if (tp->_m) printf (#_m " ");
5159 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5162 PF(Millicode_save_sr0
);
5163 /* PV(Region_description); */
5169 PF(Separate_Package_Body
);
5170 PF(Frame_Extension_Millicode
);
5171 PF(Stack_Overflow_Check
);
5172 PF(Two_Instruction_SP_Increment
);
5176 PF(sched_entry_seq
);
5179 PF(Save_MRP_in_frame
);
5180 PF(extn_ptr_defined
);
5181 PF(Cleanup_defined
);
5182 PF(MPE_XL_interrupt_marker
);
5183 PF(HP_UX_interrupt_marker
);
5186 PV(Total_frame_size
);
5195 slurp_hppa_unwind_table (FILE *file
,
5196 struct hppa_unw_aux_info
*aux
,
5197 Elf_Internal_Shdr
*sec
)
5199 unsigned long size
, unw_ent_size
, nrelas
, i
;
5200 Elf_Internal_Phdr
*seg
;
5201 struct hppa_unw_table_entry
*tep
;
5202 Elf_Internal_Shdr
*relsec
;
5203 Elf_Internal_Rela
*rela
, *rp
;
5204 unsigned char *table
, *tp
;
5205 Elf_Internal_Sym
*sym
;
5206 const char *relname
;
5208 /* First, find the starting address of the segment that includes
5211 if (elf_header
.e_phnum
)
5213 if (! get_program_headers (file
))
5216 for (seg
= program_headers
;
5217 seg
< program_headers
+ elf_header
.e_phnum
;
5220 if (seg
->p_type
!= PT_LOAD
)
5223 if (sec
->sh_addr
>= seg
->p_vaddr
5224 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5226 aux
->seg_base
= seg
->p_vaddr
;
5232 /* Second, build the unwind table from the contents of the unwind
5234 size
= sec
->sh_size
;
5235 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
5239 unw_ent_size
= 2 * eh_addr_size
+ 8;
5241 tep
= aux
->table
= xcmalloc (size
/ unw_ent_size
, sizeof (aux
->table
[0]));
5243 for (tp
= table
; tp
< table
+ size
; tp
+= (2 * eh_addr_size
+ 8), ++tep
)
5245 unsigned int tmp1
, tmp2
;
5247 tep
->start
.section
= SHN_UNDEF
;
5248 tep
->end
.section
= SHN_UNDEF
;
5252 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5253 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5254 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
5255 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
5259 tep
->start
.offset
= BYTE_GET ((unsigned char *) tp
+ 0);
5260 tep
->end
.offset
= BYTE_GET ((unsigned char *) tp
+ 8);
5261 tmp1
= byte_get ((unsigned char *) tp
+ 16, 4);
5262 tmp2
= byte_get ((unsigned char *) tp
+ 20, 4);
5265 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
5266 tep
->Millicode
= (tmp1
>> 30) & 0x1;
5267 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
5268 tep
->Region_description
= (tmp1
>> 27) & 0x3;
5269 tep
->reserved1
= (tmp1
>> 26) & 0x1;
5270 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
5271 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
5272 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
5273 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
5274 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
5275 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
5276 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
5277 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
5278 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
5279 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
5280 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
5281 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
5282 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
5283 tep
->reserved2
= (tmp1
>> 5) & 0x1;
5284 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
5285 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
5286 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
5287 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
5288 tep
->Cleanup_defined
= tmp1
& 0x1;
5290 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5291 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5292 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5293 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5294 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5295 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5297 tep
->start
.offset
+= aux
->seg_base
;
5298 tep
->end
.offset
+= aux
->seg_base
;
5302 /* Third, apply any relocations to the unwind table. */
5304 for (relsec
= section_headers
;
5305 relsec
< section_headers
+ elf_header
.e_shnum
;
5308 if (relsec
->sh_type
!= SHT_RELA
5309 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
5310 || SECTION_HEADER (relsec
->sh_info
) != sec
)
5313 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5317 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5321 relname
= elf_hppa_reloc_type (ELF32_R_TYPE (rp
->r_info
));
5322 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
5326 relname
= elf_hppa_reloc_type (ELF64_R_TYPE (rp
->r_info
));
5327 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
5330 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5331 if (strncmp (relname
, "R_PARISC_SEGREL", 15) != 0)
5333 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5337 i
= rp
->r_offset
/ unw_ent_size
;
5339 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5342 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5343 aux
->table
[i
].start
.offset
+= sym
->st_value
+ rp
->r_addend
;
5346 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5347 aux
->table
[i
].end
.offset
+= sym
->st_value
+ rp
->r_addend
;
5357 aux
->table_len
= size
/ unw_ent_size
;
5363 hppa_process_unwind (FILE *file
)
5365 struct hppa_unw_aux_info aux
;
5366 Elf_Internal_Shdr
*unwsec
= NULL
;
5367 Elf_Internal_Shdr
*strsec
;
5368 Elf_Internal_Shdr
*sec
;
5371 memset (& aux
, 0, sizeof (aux
));
5373 if (string_table
== NULL
)
5376 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5378 if (sec
->sh_type
== SHT_SYMTAB
5379 && SECTION_HEADER_INDEX (sec
->sh_link
) < elf_header
.e_shnum
)
5381 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5382 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5384 strsec
= SECTION_HEADER (sec
->sh_link
);
5385 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5386 1, strsec
->sh_size
, _("string table"));
5387 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5389 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5394 printf (_("\nThere are no unwind sections in this file.\n"));
5396 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5398 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5400 printf (_("\nUnwind section "));
5401 printf (_("'%s'"), SECTION_NAME (sec
));
5403 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5404 (unsigned long) sec
->sh_offset
,
5405 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5407 slurp_hppa_unwind_table (file
, &aux
, sec
);
5408 if (aux
.table_len
> 0)
5409 dump_hppa_unwind (&aux
);
5412 free ((char *) aux
.table
);
5420 free ((char *) aux
.strtab
);
5426 process_unwind (FILE *file
)
5428 struct unwind_handler
{
5430 int (*handler
)(FILE *file
);
5432 { EM_IA_64
, ia64_process_unwind
},
5433 { EM_PARISC
, hppa_process_unwind
},
5441 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5442 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5443 return handlers
[i
].handler (file
);
5445 printf (_("\nThere are no unwind sections in this file.\n"));
5450 dynamic_section_mips_val (Elf_Internal_Dyn
*entry
)
5452 switch (entry
->d_tag
)
5455 if (entry
->d_un
.d_val
== 0)
5459 static const char * opts
[] =
5461 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5462 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5463 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5464 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5469 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++cnt
)
5470 if (entry
->d_un
.d_val
& (1 << cnt
))
5472 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5479 case DT_MIPS_IVERSION
:
5480 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5481 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5483 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5486 case DT_MIPS_TIME_STAMP
:
5491 time_t time
= entry
->d_un
.d_val
;
5492 tmp
= gmtime (&time
);
5493 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5494 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5495 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5496 printf ("Time Stamp: %s\n", timebuf
);
5500 case DT_MIPS_RLD_VERSION
:
5501 case DT_MIPS_LOCAL_GOTNO
:
5502 case DT_MIPS_CONFLICTNO
:
5503 case DT_MIPS_LIBLISTNO
:
5504 case DT_MIPS_SYMTABNO
:
5505 case DT_MIPS_UNREFEXTNO
:
5506 case DT_MIPS_HIPAGENO
:
5507 case DT_MIPS_DELTA_CLASS_NO
:
5508 case DT_MIPS_DELTA_INSTANCE_NO
:
5509 case DT_MIPS_DELTA_RELOC_NO
:
5510 case DT_MIPS_DELTA_SYM_NO
:
5511 case DT_MIPS_DELTA_CLASSSYM_NO
:
5512 case DT_MIPS_COMPACT_SIZE
:
5513 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5517 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
5523 dynamic_section_parisc_val (Elf_Internal_Dyn
*entry
)
5525 switch (entry
->d_tag
)
5527 case DT_HP_DLD_FLAGS
:
5536 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5537 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5538 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5539 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5540 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5541 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5542 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5543 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5544 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5545 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5546 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
5547 { DT_HP_GST
, "HP_GST" },
5548 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
5549 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
5550 { DT_HP_NODELETE
, "HP_NODELETE" },
5551 { DT_HP_GROUP
, "HP_GROUP" },
5552 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
5556 bfd_vma val
= entry
->d_un
.d_val
;
5558 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
5559 if (val
& flags
[cnt
].bit
)
5563 fputs (flags
[cnt
].str
, stdout
);
5565 val
^= flags
[cnt
].bit
;
5568 if (val
!= 0 || first
)
5572 print_vma (val
, HEX
);
5578 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5585 dynamic_section_ia64_val (Elf_Internal_Dyn
*entry
)
5587 switch (entry
->d_tag
)
5589 case DT_IA_64_PLT_RESERVE
:
5590 /* First 3 slots reserved. */
5591 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5593 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5597 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5604 get_32bit_dynamic_section (FILE *file
)
5606 Elf32_External_Dyn
*edyn
, *ext
;
5607 Elf_Internal_Dyn
*entry
;
5609 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5610 _("dynamic section"));
5614 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5615 might not have the luxury of section headers. Look for the DT_NULL
5616 terminator to determine the number of entries. */
5617 for (ext
= edyn
, dynamic_nent
= 0;
5618 (char *) ext
< (char *) edyn
+ dynamic_size
;
5622 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5626 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5627 if (dynamic_section
== NULL
)
5629 error (_("Out of memory\n"));
5634 for (ext
= edyn
, entry
= dynamic_section
;
5635 entry
< dynamic_section
+ dynamic_nent
;
5638 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5639 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5648 get_64bit_dynamic_section (FILE *file
)
5650 Elf64_External_Dyn
*edyn
, *ext
;
5651 Elf_Internal_Dyn
*entry
;
5653 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5654 _("dynamic section"));
5658 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5659 might not have the luxury of section headers. Look for the DT_NULL
5660 terminator to determine the number of entries. */
5661 for (ext
= edyn
, dynamic_nent
= 0;
5662 (char *) ext
< (char *) edyn
+ dynamic_size
;
5666 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5670 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5671 if (dynamic_section
== NULL
)
5673 error (_("Out of memory\n"));
5678 for (ext
= edyn
, entry
= dynamic_section
;
5679 entry
< dynamic_section
+ dynamic_nent
;
5682 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5683 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5692 print_dynamic_flags (bfd_vma flags
)
5700 flag
= flags
& - flags
;
5710 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
5711 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
5712 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
5713 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
5714 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
5715 default: fputs ("unknown", stdout
); break;
5721 /* Parse and display the contents of the dynamic section. */
5724 process_dynamic_section (FILE *file
)
5726 Elf_Internal_Dyn
*entry
;
5728 if (dynamic_size
== 0)
5731 printf (_("\nThere is no dynamic section in this file.\n"));
5738 if (! get_32bit_dynamic_section (file
))
5741 else if (! get_64bit_dynamic_section (file
))
5744 /* Find the appropriate symbol table. */
5745 if (dynamic_symbols
== NULL
)
5747 for (entry
= dynamic_section
;
5748 entry
< dynamic_section
+ dynamic_nent
;
5751 Elf_Internal_Shdr section
;
5753 if (entry
->d_tag
!= DT_SYMTAB
)
5756 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
5758 /* Since we do not know how big the symbol table is,
5759 we default to reading in the entire file (!) and
5760 processing that. This is overkill, I know, but it
5762 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5764 if (archive_file_offset
!= 0)
5765 section
.sh_size
= archive_file_size
- section
.sh_offset
;
5768 if (fseek (file
, 0, SEEK_END
))
5769 error (_("Unable to seek to end of file!"));
5771 section
.sh_size
= ftell (file
) - section
.sh_offset
;
5775 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
5777 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
5779 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
5780 if (num_dynamic_syms
< 1)
5782 error (_("Unable to determine the number of symbols to load\n"));
5786 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
5790 /* Similarly find a string table. */
5791 if (dynamic_strings
== NULL
)
5793 for (entry
= dynamic_section
;
5794 entry
< dynamic_section
+ dynamic_nent
;
5797 unsigned long offset
;
5800 if (entry
->d_tag
!= DT_STRTAB
)
5803 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
5805 /* Since we do not know how big the string table is,
5806 we default to reading in the entire file (!) and
5807 processing that. This is overkill, I know, but it
5810 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5812 if (archive_file_offset
!= 0)
5813 str_tab_len
= archive_file_size
- offset
;
5816 if (fseek (file
, 0, SEEK_END
))
5817 error (_("Unable to seek to end of file\n"));
5818 str_tab_len
= ftell (file
) - offset
;
5821 if (str_tab_len
< 1)
5824 (_("Unable to determine the length of the dynamic string table\n"));
5828 dynamic_strings
= get_data (NULL
, file
, offset
, 1, str_tab_len
,
5829 _("dynamic string table"));
5830 dynamic_strings_length
= str_tab_len
;
5835 /* And find the syminfo section if available. */
5836 if (dynamic_syminfo
== NULL
)
5838 unsigned long syminsz
= 0;
5840 for (entry
= dynamic_section
;
5841 entry
< dynamic_section
+ dynamic_nent
;
5844 if (entry
->d_tag
== DT_SYMINENT
)
5846 /* Note: these braces are necessary to avoid a syntax
5847 error from the SunOS4 C compiler. */
5848 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
5850 else if (entry
->d_tag
== DT_SYMINSZ
)
5851 syminsz
= entry
->d_un
.d_val
;
5852 else if (entry
->d_tag
== DT_SYMINFO
)
5853 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
5857 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
5859 Elf_External_Syminfo
*extsyminfo
, *extsym
;
5860 Elf_Internal_Syminfo
*syminfo
;
5862 /* There is a syminfo section. Read the data. */
5863 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, 1,
5864 syminsz
, _("symbol information"));
5868 dynamic_syminfo
= malloc (syminsz
);
5869 if (dynamic_syminfo
== NULL
)
5871 error (_("Out of memory\n"));
5875 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
5876 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
5877 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
5878 ++syminfo
, ++extsym
)
5880 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
5881 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
5888 if (do_dynamic
&& dynamic_addr
)
5889 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
5890 dynamic_addr
, dynamic_nent
);
5892 printf (_(" Tag Type Name/Value\n"));
5894 for (entry
= dynamic_section
;
5895 entry
< dynamic_section
+ dynamic_nent
;
5903 print_vma (entry
->d_tag
, FULL_HEX
);
5904 dtype
= get_dynamic_type (entry
->d_tag
);
5905 printf (" (%s)%*s", dtype
,
5906 ((is_32bit_elf
? 27 : 19)
5907 - (int) strlen (dtype
)),
5911 switch (entry
->d_tag
)
5915 print_dynamic_flags (entry
->d_un
.d_val
);
5925 switch (entry
->d_tag
)
5928 printf (_("Auxiliary library"));
5932 printf (_("Filter library"));
5936 printf (_("Configuration file"));
5940 printf (_("Dependency audit library"));
5944 printf (_("Audit library"));
5948 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5949 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5953 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5962 printf (_("Flags:"));
5964 if (entry
->d_un
.d_val
== 0)
5965 printf (_(" None\n"));
5968 unsigned long int val
= entry
->d_un
.d_val
;
5970 if (val
& DTF_1_PARINIT
)
5972 printf (" PARINIT");
5973 val
^= DTF_1_PARINIT
;
5975 if (val
& DTF_1_CONFEXP
)
5977 printf (" CONFEXP");
5978 val
^= DTF_1_CONFEXP
;
5981 printf (" %lx", val
);
5990 printf (_("Flags:"));
5992 if (entry
->d_un
.d_val
== 0)
5993 printf (_(" None\n"));
5996 unsigned long int val
= entry
->d_un
.d_val
;
5998 if (val
& DF_P1_LAZYLOAD
)
6000 printf (" LAZYLOAD");
6001 val
^= DF_P1_LAZYLOAD
;
6003 if (val
& DF_P1_GROUPPERM
)
6005 printf (" GROUPPERM");
6006 val
^= DF_P1_GROUPPERM
;
6009 printf (" %lx", val
);
6018 printf (_("Flags:"));
6019 if (entry
->d_un
.d_val
== 0)
6020 printf (_(" None\n"));
6023 unsigned long int val
= entry
->d_un
.d_val
;
6030 if (val
& DF_1_GLOBAL
)
6035 if (val
& DF_1_GROUP
)
6040 if (val
& DF_1_NODELETE
)
6042 printf (" NODELETE");
6043 val
^= DF_1_NODELETE
;
6045 if (val
& DF_1_LOADFLTR
)
6047 printf (" LOADFLTR");
6048 val
^= DF_1_LOADFLTR
;
6050 if (val
& DF_1_INITFIRST
)
6052 printf (" INITFIRST");
6053 val
^= DF_1_INITFIRST
;
6055 if (val
& DF_1_NOOPEN
)
6060 if (val
& DF_1_ORIGIN
)
6065 if (val
& DF_1_DIRECT
)
6070 if (val
& DF_1_TRANS
)
6075 if (val
& DF_1_INTERPOSE
)
6077 printf (" INTERPOSE");
6078 val
^= DF_1_INTERPOSE
;
6080 if (val
& DF_1_NODEFLIB
)
6082 printf (" NODEFLIB");
6083 val
^= DF_1_NODEFLIB
;
6085 if (val
& DF_1_NODUMP
)
6090 if (val
& DF_1_CONLFAT
)
6092 printf (" CONLFAT");
6093 val
^= DF_1_CONLFAT
;
6096 printf (" %lx", val
);
6103 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6105 puts (get_dynamic_type (entry
->d_un
.d_val
));
6125 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6131 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6132 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6138 switch (entry
->d_tag
)
6141 printf (_("Shared library: [%s]"), name
);
6143 if (streq (name
, program_interpreter
))
6144 printf (_(" program interpreter"));
6148 printf (_("Library soname: [%s]"), name
);
6152 printf (_("Library rpath: [%s]"), name
);
6156 printf (_("Library runpath: [%s]"), name
);
6160 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6165 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6178 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6182 case DT_INIT_ARRAYSZ
:
6183 case DT_FINI_ARRAYSZ
:
6184 case DT_GNU_CONFLICTSZ
:
6185 case DT_GNU_LIBLISTSZ
:
6188 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6189 printf (" (bytes)\n");
6199 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6212 if (entry
->d_tag
== DT_USED
6213 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6215 char *name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6219 printf (_("Not needed object: [%s]\n"), name
);
6224 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6230 /* The value of this entry is ignored. */
6235 case DT_GNU_PRELINKED
:
6239 time_t time
= entry
->d_un
.d_val
;
6241 tmp
= gmtime (&time
);
6242 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6243 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6244 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6250 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
6251 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
6256 switch (elf_header
.e_machine
)
6259 case EM_MIPS_RS3_LE
:
6260 dynamic_section_mips_val (entry
);
6263 dynamic_section_parisc_val (entry
);
6266 dynamic_section_ia64_val (entry
);
6269 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6281 get_ver_flags (unsigned int flags
)
6283 static char buff
[32];
6290 if (flags
& VER_FLG_BASE
)
6291 strcat (buff
, "BASE ");
6293 if (flags
& VER_FLG_WEAK
)
6295 if (flags
& VER_FLG_BASE
)
6296 strcat (buff
, "| ");
6298 strcat (buff
, "WEAK ");
6301 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
6302 strcat (buff
, "| <unknown>");
6307 /* Display the contents of the version sections. */
6309 process_version_sections (FILE *file
)
6311 Elf_Internal_Shdr
*section
;
6318 for (i
= 0, section
= section_headers
;
6319 i
< elf_header
.e_shnum
;
6322 switch (section
->sh_type
)
6324 case SHT_GNU_verdef
:
6326 Elf_External_Verdef
*edefs
;
6333 (_("\nVersion definition section '%s' contains %ld entries:\n"),
6334 SECTION_NAME (section
), section
->sh_info
);
6336 printf (_(" Addr: 0x"));
6337 printf_vma (section
->sh_addr
);
6338 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6339 (unsigned long) section
->sh_offset
, section
->sh_link
,
6340 SECTION_HEADER_INDEX (section
->sh_link
)
6341 < elf_header
.e_shnum
6342 ? SECTION_NAME (SECTION_HEADER (section
->sh_link
))
6345 edefs
= get_data (NULL
, file
, section
->sh_offset
, 1,
6347 _("version definition section"));
6351 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6354 Elf_External_Verdef
*edef
;
6355 Elf_Internal_Verdef ent
;
6356 Elf_External_Verdaux
*eaux
;
6357 Elf_Internal_Verdaux aux
;
6361 vstart
= ((char *) edefs
) + idx
;
6363 edef
= (Elf_External_Verdef
*) vstart
;
6365 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
6366 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
6367 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
6368 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
6369 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
6370 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
6371 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
6373 printf (_(" %#06x: Rev: %d Flags: %s"),
6374 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
6376 printf (_(" Index: %d Cnt: %d "),
6377 ent
.vd_ndx
, ent
.vd_cnt
);
6379 vstart
+= ent
.vd_aux
;
6381 eaux
= (Elf_External_Verdaux
*) vstart
;
6383 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6384 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6386 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6387 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6389 printf (_("Name index: %ld\n"), aux
.vda_name
);
6391 isum
= idx
+ ent
.vd_aux
;
6393 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6395 isum
+= aux
.vda_next
;
6396 vstart
+= aux
.vda_next
;
6398 eaux
= (Elf_External_Verdaux
*) vstart
;
6400 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6401 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6403 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6404 printf (_(" %#06x: Parent %d: %s\n"),
6405 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6407 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6408 isum
, j
, aux
.vda_name
);
6418 case SHT_GNU_verneed
:
6420 Elf_External_Verneed
*eneed
;
6426 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
6427 SECTION_NAME (section
), section
->sh_info
);
6429 printf (_(" Addr: 0x"));
6430 printf_vma (section
->sh_addr
);
6431 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
6432 (unsigned long) section
->sh_offset
, section
->sh_link
,
6433 SECTION_HEADER_INDEX (section
->sh_link
)
6434 < elf_header
.e_shnum
6435 ? SECTION_NAME (SECTION_HEADER (section
->sh_link
))
6438 eneed
= get_data (NULL
, file
, section
->sh_offset
, 1,
6440 _("version need section"));
6444 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6446 Elf_External_Verneed
*entry
;
6447 Elf_Internal_Verneed ent
;
6452 vstart
= ((char *) eneed
) + idx
;
6454 entry
= (Elf_External_Verneed
*) vstart
;
6456 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6457 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6458 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6459 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6460 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6462 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6464 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6465 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6467 printf (_(" File: %lx"), ent
.vn_file
);
6469 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6471 vstart
+= ent
.vn_aux
;
6473 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6475 Elf_External_Vernaux
*eaux
;
6476 Elf_Internal_Vernaux aux
;
6478 eaux
= (Elf_External_Vernaux
*) vstart
;
6480 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6481 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6482 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6483 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6484 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6486 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6487 printf (_(" %#06x: Name: %s"),
6488 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6490 printf (_(" %#06x: Name index: %lx"),
6491 isum
, aux
.vna_name
);
6493 printf (_(" Flags: %s Version: %d\n"),
6494 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6496 isum
+= aux
.vna_next
;
6497 vstart
+= aux
.vna_next
;
6507 case SHT_GNU_versym
:
6509 Elf_Internal_Shdr
*link_section
;
6512 unsigned char *edata
;
6513 unsigned short *data
;
6515 Elf_Internal_Sym
*symbols
;
6516 Elf_Internal_Shdr
*string_sec
;
6519 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
)
6522 link_section
= SECTION_HEADER (section
->sh_link
);
6523 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
6525 if (SECTION_HEADER_INDEX (link_section
->sh_link
)
6526 >= elf_header
.e_shnum
)
6531 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6533 string_sec
= SECTION_HEADER (link_section
->sh_link
);
6535 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
6536 string_sec
->sh_size
, _("version string table"));
6540 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6541 SECTION_NAME (section
), total
);
6543 printf (_(" Addr: "));
6544 printf_vma (section
->sh_addr
);
6545 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6546 (unsigned long) section
->sh_offset
, section
->sh_link
,
6547 SECTION_NAME (link_section
));
6549 off
= offset_from_vma (file
,
6550 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6551 total
* sizeof (short));
6552 edata
= get_data (NULL
, file
, off
, total
, sizeof (short),
6553 _("version symbol data"));
6560 data
= cmalloc (total
, sizeof (short));
6562 for (cnt
= total
; cnt
--;)
6563 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6568 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6571 int check_def
, check_need
;
6574 printf (" %03x:", cnt
);
6576 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6577 switch (data
[cnt
+ j
])
6580 fputs (_(" 0 (*local*) "), stdout
);
6584 fputs (_(" 1 (*global*) "), stdout
);
6588 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
6589 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
6593 if (SECTION_HEADER_INDEX (symbols
[cnt
+ j
].st_shndx
)
6594 >= elf_header
.e_shnum
6595 || SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
6598 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6605 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6607 Elf_Internal_Verneed ivn
;
6608 unsigned long offset
;
6610 offset
= offset_from_vma
6611 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6612 sizeof (Elf_External_Verneed
));
6616 Elf_Internal_Vernaux ivna
;
6617 Elf_External_Verneed evn
;
6618 Elf_External_Vernaux evna
;
6619 unsigned long a_off
;
6621 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
6624 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6625 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6627 a_off
= offset
+ ivn
.vn_aux
;
6631 get_data (&evna
, file
, a_off
, sizeof (evna
),
6632 1, _("version need aux (2)"));
6634 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6635 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6637 a_off
+= ivna
.vna_next
;
6639 while (ivna
.vna_other
!= data
[cnt
+ j
]
6640 && ivna
.vna_next
!= 0);
6642 if (ivna
.vna_other
== data
[cnt
+ j
])
6644 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6646 name
= strtab
+ ivna
.vna_name
;
6647 nn
+= printf ("(%s%-*s",
6649 12 - (int) strlen (name
),
6655 offset
+= ivn
.vn_next
;
6657 while (ivn
.vn_next
);
6660 if (check_def
&& data
[cnt
+ j
] != 0x8001
6661 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6663 Elf_Internal_Verdef ivd
;
6664 Elf_External_Verdef evd
;
6665 unsigned long offset
;
6667 offset
= offset_from_vma
6668 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6673 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
6676 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6677 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6679 offset
+= ivd
.vd_next
;
6681 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
6682 && ivd
.vd_next
!= 0);
6684 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
6686 Elf_External_Verdaux evda
;
6687 Elf_Internal_Verdaux ivda
;
6689 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6691 get_data (&evda
, file
,
6692 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
6694 _("version def aux"));
6696 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6698 name
= strtab
+ ivda
.vda_name
;
6699 nn
+= printf ("(%s%-*s",
6701 12 - (int) strlen (name
),
6707 printf ("%*c", 18 - nn
, ' ');
6725 printf (_("\nNo version information found in this file.\n"));
6731 get_symbol_binding (unsigned int binding
)
6733 static char buff
[32];
6737 case STB_LOCAL
: return "LOCAL";
6738 case STB_GLOBAL
: return "GLOBAL";
6739 case STB_WEAK
: return "WEAK";
6741 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
6742 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
6744 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
6745 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
6747 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
6753 get_symbol_type (unsigned int type
)
6755 static char buff
[32];
6759 case STT_NOTYPE
: return "NOTYPE";
6760 case STT_OBJECT
: return "OBJECT";
6761 case STT_FUNC
: return "FUNC";
6762 case STT_SECTION
: return "SECTION";
6763 case STT_FILE
: return "FILE";
6764 case STT_COMMON
: return "COMMON";
6765 case STT_TLS
: return "TLS";
6767 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
6769 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
6770 return "THUMB_FUNC";
6772 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
6775 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
6776 return "PARISC_MILLI";
6778 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
6780 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
6782 if (elf_header
.e_machine
== EM_PARISC
)
6784 if (type
== STT_HP_OPAQUE
)
6786 if (type
== STT_HP_STUB
)
6790 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
6793 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
6799 get_symbol_visibility (unsigned int visibility
)
6803 case STV_DEFAULT
: return "DEFAULT";
6804 case STV_INTERNAL
: return "INTERNAL";
6805 case STV_HIDDEN
: return "HIDDEN";
6806 case STV_PROTECTED
: return "PROTECTED";
6812 get_symbol_index_type (unsigned int type
)
6814 static char buff
[32];
6818 case SHN_UNDEF
: return "UND";
6819 case SHN_ABS
: return "ABS";
6820 case SHN_COMMON
: return "COM";
6822 if (type
== SHN_IA_64_ANSI_COMMON
6823 && elf_header
.e_machine
== EM_IA_64
6824 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
6826 else if (elf_header
.e_machine
== EM_X86_64
6827 && type
== SHN_X86_64_LCOMMON
)
6829 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
6830 sprintf (buff
, "PRC[0x%04x]", type
);
6831 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
6832 sprintf (buff
, "OS [0x%04x]", type
);
6833 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
6834 sprintf (buff
, "RSV[0x%04x]", type
);
6836 sprintf (buff
, "%3d", type
);
6844 get_dynamic_data (FILE *file
, unsigned int number
, unsigned int ent_size
)
6846 unsigned char *e_data
;
6849 e_data
= cmalloc (number
, ent_size
);
6853 error (_("Out of memory\n"));
6857 if (fread (e_data
, ent_size
, number
, file
) != number
)
6859 error (_("Unable to read in dynamic data\n"));
6863 i_data
= cmalloc (number
, sizeof (*i_data
));
6867 error (_("Out of memory\n"));
6873 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
6880 /* Dump the symbol table. */
6882 process_symbol_table (FILE *file
)
6884 Elf_Internal_Shdr
*section
;
6885 bfd_vma nbuckets
= 0;
6886 bfd_vma nchains
= 0;
6887 bfd_vma
*buckets
= NULL
;
6888 bfd_vma
*chains
= NULL
;
6890 if (! do_syms
&& !do_histogram
)
6893 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
6896 unsigned char nb
[8];
6897 unsigned char nc
[8];
6898 int hash_ent_size
= 4;
6900 if ((elf_header
.e_machine
== EM_ALPHA
6901 || elf_header
.e_machine
== EM_S390
6902 || elf_header
.e_machine
== EM_S390_OLD
)
6903 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
6907 (archive_file_offset
6908 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
6909 sizeof nb
+ sizeof nc
)),
6912 error (_("Unable to seek to start of dynamic information"));
6916 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
6918 error (_("Failed to read in number of buckets\n"));
6922 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
6924 error (_("Failed to read in number of chains\n"));
6928 nbuckets
= byte_get (nb
, hash_ent_size
);
6929 nchains
= byte_get (nc
, hash_ent_size
);
6931 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
6932 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
6934 if (buckets
== NULL
|| chains
== NULL
)
6939 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
6944 printf (_("\nSymbol table for image:\n"));
6946 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6948 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6950 for (hn
= 0; hn
< nbuckets
; hn
++)
6955 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
6957 Elf_Internal_Sym
*psym
;
6960 psym
= dynamic_symbols
+ si
;
6962 n
= print_vma (si
, DEC_5
);
6964 fputs (" " + n
, stdout
);
6965 printf (" %3lu: ", hn
);
6966 print_vma (psym
->st_value
, LONG_HEX
);
6968 print_vma (psym
->st_size
, DEC_5
);
6970 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6971 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6972 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6973 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
6974 if (VALID_DYNAMIC_NAME (psym
->st_name
))
6975 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
6977 printf (" <corrupt: %14ld>", psym
->st_name
);
6982 else if (do_syms
&& !do_using_dynamic
)
6986 for (i
= 0, section
= section_headers
;
6987 i
< elf_header
.e_shnum
;
6991 char *strtab
= NULL
;
6992 unsigned long int strtab_size
= 0;
6993 Elf_Internal_Sym
*symtab
;
6994 Elf_Internal_Sym
*psym
;
6997 if ( section
->sh_type
!= SHT_SYMTAB
6998 && section
->sh_type
!= SHT_DYNSYM
)
7001 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
7002 SECTION_NAME (section
),
7003 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
7005 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7007 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7009 symtab
= GET_ELF_SYMBOLS (file
, section
);
7013 if (section
->sh_link
== elf_header
.e_shstrndx
)
7015 strtab
= string_table
;
7016 strtab_size
= string_table_length
;
7018 else if (SECTION_HEADER_INDEX (section
->sh_link
) < elf_header
.e_shnum
)
7020 Elf_Internal_Shdr
*string_sec
;
7022 string_sec
= SECTION_HEADER (section
->sh_link
);
7024 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
7025 1, string_sec
->sh_size
, _("string table"));
7026 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
7029 for (si
= 0, psym
= symtab
;
7030 si
< section
->sh_size
/ section
->sh_entsize
;
7033 printf ("%6d: ", si
);
7034 print_vma (psym
->st_value
, LONG_HEX
);
7036 print_vma (psym
->st_size
, DEC_5
);
7037 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7038 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7039 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7040 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
7041 print_symbol (25, psym
->st_name
< strtab_size
7042 ? strtab
+ psym
->st_name
: "<corrupt>");
7044 if (section
->sh_type
== SHT_DYNSYM
&&
7045 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
7047 unsigned char data
[2];
7048 unsigned short vers_data
;
7049 unsigned long offset
;
7053 offset
= offset_from_vma
7054 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
7055 sizeof data
+ si
* sizeof (vers_data
));
7057 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
7058 sizeof (data
), 1, _("version data"));
7060 vers_data
= byte_get (data
, 2);
7062 is_nobits
= (SECTION_HEADER_INDEX (psym
->st_shndx
)
7063 < elf_header
.e_shnum
7064 && SECTION_HEADER (psym
->st_shndx
)->sh_type
7067 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
7069 if ((vers_data
& 0x8000) || vers_data
> 1)
7071 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
7072 && (is_nobits
|| ! check_def
))
7074 Elf_External_Verneed evn
;
7075 Elf_Internal_Verneed ivn
;
7076 Elf_Internal_Vernaux ivna
;
7078 /* We must test both. */
7079 offset
= offset_from_vma
7080 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
7085 unsigned long vna_off
;
7087 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
7090 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
7091 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
7093 vna_off
= offset
+ ivn
.vn_aux
;
7097 Elf_External_Vernaux evna
;
7099 get_data (&evna
, file
, vna_off
,
7101 _("version need aux (3)"));
7103 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
7104 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
7105 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
7107 vna_off
+= ivna
.vna_next
;
7109 while (ivna
.vna_other
!= vers_data
7110 && ivna
.vna_next
!= 0);
7112 if (ivna
.vna_other
== vers_data
)
7115 offset
+= ivn
.vn_next
;
7117 while (ivn
.vn_next
!= 0);
7119 if (ivna
.vna_other
== vers_data
)
7122 ivna
.vna_name
< strtab_size
7123 ? strtab
+ ivna
.vna_name
: "<corrupt>",
7127 else if (! is_nobits
)
7128 error (_("bad dynamic symbol"));
7135 if (vers_data
!= 0x8001
7136 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7138 Elf_Internal_Verdef ivd
;
7139 Elf_Internal_Verdaux ivda
;
7140 Elf_External_Verdaux evda
;
7141 unsigned long offset
;
7143 offset
= offset_from_vma
7145 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7146 sizeof (Elf_External_Verdef
));
7150 Elf_External_Verdef evd
;
7152 get_data (&evd
, file
, offset
, sizeof (evd
),
7153 1, _("version def"));
7155 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7156 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7157 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7159 offset
+= ivd
.vd_next
;
7161 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
7162 && ivd
.vd_next
!= 0);
7164 offset
-= ivd
.vd_next
;
7165 offset
+= ivd
.vd_aux
;
7167 get_data (&evda
, file
, offset
, sizeof (evda
),
7168 1, _("version def aux"));
7170 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7172 if (psym
->st_name
!= ivda
.vda_name
)
7173 printf ((vers_data
& 0x8000)
7175 ivda
.vda_name
< strtab_size
7176 ? strtab
+ ivda
.vda_name
: "<corrupt>");
7186 if (strtab
!= string_table
)
7192 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7194 if (do_histogram
&& buckets
!= NULL
)
7196 unsigned long *lengths
;
7197 unsigned long *counts
;
7200 unsigned long maxlength
= 0;
7201 unsigned long nzero_counts
= 0;
7202 unsigned long nsyms
= 0;
7204 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7205 (unsigned long) nbuckets
);
7206 printf (_(" Length Number %% of total Coverage\n"));
7208 lengths
= calloc (nbuckets
, sizeof (*lengths
));
7209 if (lengths
== NULL
)
7211 error (_("Out of memory"));
7214 for (hn
= 0; hn
< nbuckets
; ++hn
)
7216 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
7219 if (maxlength
< ++lengths
[hn
])
7224 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7227 error (_("Out of memory"));
7231 for (hn
= 0; hn
< nbuckets
; ++hn
)
7232 ++counts
[lengths
[hn
]];
7237 printf (" 0 %-10lu (%5.1f%%)\n",
7238 counts
[0], (counts
[0] * 100.0) / nbuckets
);
7239 for (i
= 1; i
<= maxlength
; ++i
)
7241 nzero_counts
+= counts
[i
] * i
;
7242 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7243 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
7244 (nzero_counts
* 100.0) / nsyms
);
7252 if (buckets
!= NULL
)
7262 process_syminfo (FILE *file ATTRIBUTE_UNUSED
)
7266 if (dynamic_syminfo
== NULL
7268 /* No syminfo, this is ok. */
7271 /* There better should be a dynamic symbol section. */
7272 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
7276 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7277 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
7279 printf (_(" Num: Name BoundTo Flags\n"));
7280 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
7282 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
7284 printf ("%4d: ", i
);
7285 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
7286 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
7288 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
7291 switch (dynamic_syminfo
[i
].si_boundto
)
7293 case SYMINFO_BT_SELF
:
7294 fputs ("SELF ", stdout
);
7296 case SYMINFO_BT_PARENT
:
7297 fputs ("PARENT ", stdout
);
7300 if (dynamic_syminfo
[i
].si_boundto
> 0
7301 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
7302 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
7304 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
7308 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
7312 if (flags
& SYMINFO_FLG_DIRECT
)
7314 if (flags
& SYMINFO_FLG_PASSTHRU
)
7315 printf (" PASSTHRU");
7316 if (flags
& SYMINFO_FLG_COPY
)
7318 if (flags
& SYMINFO_FLG_LAZYLOAD
)
7319 printf (" LAZYLOAD");
7327 #ifdef SUPPORT_DISASSEMBLY
7329 disassemble_section (Elf_Internal_Shdr
*section
, FILE *file
)
7331 printf (_("\nAssembly dump of section %s\n"),
7332 SECTION_NAME (section
));
7334 /* XXX -- to be done --- XXX */
7341 dump_section (Elf_Internal_Shdr
*section
, FILE *file
)
7343 bfd_size_type bytes
;
7345 unsigned char *data
;
7346 unsigned char *start
;
7348 bytes
= section
->sh_size
;
7350 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
7352 printf (_("\nSection '%s' has no data to dump.\n"),
7353 SECTION_NAME (section
));
7357 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
7359 addr
= section
->sh_addr
;
7361 start
= get_data (NULL
, file
, section
->sh_offset
, 1, bytes
,
7374 lbytes
= (bytes
> 16 ? 16 : bytes
);
7376 printf (" 0x%8.8lx ", (unsigned long) addr
);
7378 switch (elf_header
.e_ident
[EI_DATA
])
7382 for (j
= 15; j
>= 0; j
--)
7385 printf ("%2.2x", data
[j
]);
7395 for (j
= 0; j
< 16; j
++)
7398 printf ("%2.2x", data
[j
]);
7408 for (j
= 0; j
< lbytes
; j
++)
7411 if (k
>= ' ' && k
< 0x7f)
7430 static unsigned long int
7431 read_leb128 (unsigned char *data
, unsigned int *length_return
, int sign
)
7433 unsigned long int result
= 0;
7434 unsigned int num_read
= 0;
7435 unsigned int shift
= 0;
7443 result
|= ((unsigned long int) (byte
& 0x7f)) << shift
;
7448 while (byte
& 0x80);
7450 if (length_return
!= NULL
)
7451 *length_return
= num_read
;
7453 if (sign
&& (shift
< 8 * sizeof (result
)) && (byte
& 0x40))
7454 result
|= -1L << shift
;
7459 typedef struct State_Machine_Registers
7461 unsigned long address
;
7464 unsigned int column
;
7468 /* This variable hold the number of the last entry seen
7469 in the File Table. */
7470 unsigned int last_file_entry
;
7473 static SMR state_machine_regs
;
7476 reset_state_machine (int is_stmt
)
7478 state_machine_regs
.address
= 0;
7479 state_machine_regs
.file
= 1;
7480 state_machine_regs
.line
= 1;
7481 state_machine_regs
.column
= 0;
7482 state_machine_regs
.is_stmt
= is_stmt
;
7483 state_machine_regs
.basic_block
= 0;
7484 state_machine_regs
.end_sequence
= 0;
7485 state_machine_regs
.last_file_entry
= 0;
7488 /* Handled an extend line op.
7489 Returns the number of bytes read. */
7492 process_extended_line_op (unsigned char *data
, int is_stmt
, int pointer_size
)
7494 unsigned char op_code
;
7495 unsigned int bytes_read
;
7497 unsigned char *name
;
7500 len
= read_leb128 (data
, & bytes_read
, 0);
7505 warn (_("badly formed extended line op encountered!\n"));
7512 printf (_(" Extended opcode %d: "), op_code
);
7516 case DW_LNE_end_sequence
:
7517 printf (_("End of Sequence\n\n"));
7518 reset_state_machine (is_stmt
);
7521 case DW_LNE_set_address
:
7522 adr
= byte_get (data
, pointer_size
);
7523 printf (_("set Address to 0x%lx\n"), adr
);
7524 state_machine_regs
.address
= adr
;
7527 case DW_LNE_define_file
:
7528 printf (_(" define new File Table entry\n"));
7529 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
7531 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
7533 data
+= strlen ((char *) data
) + 1;
7534 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7536 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7538 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7539 printf (_("%s\n\n"), name
);
7543 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
7550 static const char *debug_str_contents
;
7551 static bfd_vma debug_str_size
;
7554 load_debug_str (FILE *file
)
7556 Elf_Internal_Shdr
*sec
;
7558 /* If it is already loaded, do nothing. */
7559 if (debug_str_contents
!= NULL
)
7562 /* Locate the .debug_str section. */
7563 sec
= find_section (".debug_str");
7567 debug_str_size
= sec
->sh_size
;
7569 debug_str_contents
= get_data (NULL
, file
, sec
->sh_offset
, 1, sec
->sh_size
,
7570 _("debug_str section data"));
7574 free_debug_str (void)
7576 if (debug_str_contents
== NULL
)
7579 free ((char *) debug_str_contents
);
7580 debug_str_contents
= NULL
;
7585 fetch_indirect_string (unsigned long offset
)
7587 if (debug_str_contents
== NULL
)
7588 return _("<no .debug_str section>");
7590 if (offset
> debug_str_size
)
7592 warn (_("DW_FORM_strp offset too big: %lx\n"), offset
);
7593 return _("<offset is too big>");
7596 return debug_str_contents
+ offset
;
7599 static const char *debug_loc_contents
;
7600 static bfd_vma debug_loc_size
;
7603 load_debug_loc (FILE *file
)
7605 Elf_Internal_Shdr
*sec
;
7607 /* If it is already loaded, do nothing. */
7608 if (debug_loc_contents
!= NULL
)
7611 /* Locate the .debug_loc section. */
7612 sec
= find_section (".debug_loc");
7616 debug_loc_size
= sec
->sh_size
;
7618 debug_loc_contents
= get_data (NULL
, file
, sec
->sh_offset
, 1, sec
->sh_size
,
7619 _("debug_loc section data"));
7623 free_debug_loc (void)
7625 if (debug_loc_contents
== NULL
)
7628 free ((char *) debug_loc_contents
);
7629 debug_loc_contents
= NULL
;
7633 static const char * debug_range_contents
;
7634 static unsigned long debug_range_size
;
7637 load_debug_range (FILE *file
)
7639 Elf_Internal_Shdr
*sec
;
7641 /* If it is already loaded, do nothing. */
7642 if (debug_range_contents
!= NULL
)
7645 /* Locate the .debug_ranges section. */
7646 sec
= find_section (".debug_ranges");
7650 debug_range_size
= sec
->sh_size
;
7652 debug_range_contents
= get_data (NULL
, file
, sec
->sh_offset
, 1, sec
->sh_size
,
7653 _("debug_range section data"));
7657 free_debug_range (void)
7659 if (debug_range_contents
== NULL
)
7662 free ((char *) debug_range_contents
);
7663 debug_range_contents
= NULL
;
7664 debug_range_size
= 0;
7667 /* Apply addends of RELA relocations. */
7670 debug_apply_rela_addends (FILE *file
,
7671 Elf_Internal_Shdr
*section
,
7673 unsigned char *sec_data
,
7674 unsigned char *start
,
7677 Elf_Internal_Shdr
*relsec
;
7679 if (end
- start
< reloc_size
)
7682 for (relsec
= section_headers
;
7683 relsec
< section_headers
+ elf_header
.e_shnum
;
7686 unsigned long nrelas
;
7687 Elf_Internal_Rela
*rela
, *rp
;
7688 Elf_Internal_Shdr
*symsec
;
7689 Elf_Internal_Sym
*symtab
;
7690 Elf_Internal_Sym
*sym
;
7692 if (relsec
->sh_type
!= SHT_RELA
7693 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
7694 || SECTION_HEADER (relsec
->sh_info
) != section
7695 || relsec
->sh_size
== 0
7696 || SECTION_HEADER_INDEX (relsec
->sh_link
) >= elf_header
.e_shnum
)
7699 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7703 symsec
= SECTION_HEADER (relsec
->sh_link
);
7704 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
7706 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7710 if (rp
->r_offset
>= (bfd_vma
) (start
- sec_data
)
7711 && rp
->r_offset
< (bfd_vma
) (end
- sec_data
) - reloc_size
)
7712 loc
= sec_data
+ rp
->r_offset
;
7718 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
7720 if (ELF32_R_SYM (rp
->r_info
) != 0
7721 && ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
7722 /* Relocations against object symbols can happen,
7723 eg when referencing a global array. For an
7724 example of this see the _clz.o binary in libgcc.a. */
7725 && ELF32_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7727 warn (_("skipping unexpected symbol type %s in relocation in section .rela%s\n"),
7728 get_symbol_type (ELF32_ST_TYPE (sym
->st_info
)),
7729 SECTION_NAME (section
));
7735 /* In MIPS little-endian objects, r_info isn't really a
7736 64-bit little-endian value: it has a 32-bit little-endian
7737 symbol index followed by four individual byte fields.
7738 Reorder INFO accordingly. */
7739 if (elf_header
.e_machine
== EM_MIPS
7740 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
7741 rp
->r_info
= (((rp
->r_info
& 0xffffffff) << 32)
7742 | ((rp
->r_info
>> 56) & 0xff)
7743 | ((rp
->r_info
>> 40) & 0xff00)
7744 | ((rp
->r_info
>> 24) & 0xff0000)
7745 | ((rp
->r_info
>> 8) & 0xff000000));
7747 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
7749 if (ELF64_R_SYM (rp
->r_info
) != 0
7750 && ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
7751 && ELF64_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7753 warn (_("skipping unexpected symbol type %s in relocation in section .rela.%s\n"),
7754 get_symbol_type (ELF64_ST_TYPE (sym
->st_info
)),
7755 SECTION_NAME (section
));
7760 byte_put (loc
, rp
->r_addend
, reloc_size
);
7770 /* FIXME: There are better and more efficient ways to handle
7771 these structures. For now though, I just want something that
7772 is simple to implement. */
7773 typedef struct abbrev_attr
7775 unsigned long attribute
;
7777 struct abbrev_attr
*next
;
7781 typedef struct abbrev_entry
7783 unsigned long entry
;
7786 struct abbrev_attr
*first_attr
;
7787 struct abbrev_attr
*last_attr
;
7788 struct abbrev_entry
*next
;
7792 static abbrev_entry
*first_abbrev
= NULL
;
7793 static abbrev_entry
*last_abbrev
= NULL
;
7798 abbrev_entry
*abbrev
;
7800 for (abbrev
= first_abbrev
; abbrev
;)
7802 abbrev_entry
*next
= abbrev
->next
;
7805 for (attr
= abbrev
->first_attr
; attr
;)
7807 abbrev_attr
*next
= attr
->next
;
7817 last_abbrev
= first_abbrev
= NULL
;
7821 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
7823 abbrev_entry
*entry
;
7825 entry
= malloc (sizeof (*entry
));
7831 entry
->entry
= number
;
7833 entry
->children
= children
;
7834 entry
->first_attr
= NULL
;
7835 entry
->last_attr
= NULL
;
7838 if (first_abbrev
== NULL
)
7839 first_abbrev
= entry
;
7841 last_abbrev
->next
= entry
;
7843 last_abbrev
= entry
;
7847 add_abbrev_attr (unsigned long attribute
, unsigned long form
)
7851 attr
= malloc (sizeof (*attr
));
7857 attr
->attribute
= attribute
;
7861 if (last_abbrev
->first_attr
== NULL
)
7862 last_abbrev
->first_attr
= attr
;
7864 last_abbrev
->last_attr
->next
= attr
;
7866 last_abbrev
->last_attr
= attr
;
7869 /* Processes the (partial) contents of a .debug_abbrev section.
7870 Returns NULL if the end of the section was encountered.
7871 Returns the address after the last byte read if the end of
7872 an abbreviation set was found. */
7874 static unsigned char *
7875 process_abbrev_section (unsigned char *start
, unsigned char *end
)
7877 if (first_abbrev
!= NULL
)
7882 unsigned int bytes_read
;
7883 unsigned long entry
;
7885 unsigned long attribute
;
7888 entry
= read_leb128 (start
, & bytes_read
, 0);
7889 start
+= bytes_read
;
7891 /* A single zero is supposed to end the section according
7892 to the standard. If there's more, then signal that to
7895 return start
== end
? NULL
: start
;
7897 tag
= read_leb128 (start
, & bytes_read
, 0);
7898 start
+= bytes_read
;
7900 children
= *start
++;
7902 add_abbrev (entry
, tag
, children
);
7908 attribute
= read_leb128 (start
, & bytes_read
, 0);
7909 start
+= bytes_read
;
7911 form
= read_leb128 (start
, & bytes_read
, 0);
7912 start
+= bytes_read
;
7915 add_abbrev_attr (attribute
, form
);
7917 while (attribute
!= 0);
7924 get_TAG_name (unsigned long tag
)
7928 case DW_TAG_padding
: return "DW_TAG_padding";
7929 case DW_TAG_array_type
: return "DW_TAG_array_type";
7930 case DW_TAG_class_type
: return "DW_TAG_class_type";
7931 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
7932 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
7933 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
7934 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
7935 case DW_TAG_label
: return "DW_TAG_label";
7936 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
7937 case DW_TAG_member
: return "DW_TAG_member";
7938 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
7939 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
7940 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
7941 case DW_TAG_string_type
: return "DW_TAG_string_type";
7942 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
7943 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
7944 case DW_TAG_typedef
: return "DW_TAG_typedef";
7945 case DW_TAG_union_type
: return "DW_TAG_union_type";
7946 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
7947 case DW_TAG_variant
: return "DW_TAG_variant";
7948 case DW_TAG_common_block
: return "DW_TAG_common_block";
7949 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
7950 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
7951 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
7952 case DW_TAG_module
: return "DW_TAG_module";
7953 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
7954 case DW_TAG_set_type
: return "DW_TAG_set_type";
7955 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
7956 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
7957 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
7958 case DW_TAG_base_type
: return "DW_TAG_base_type";
7959 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
7960 case DW_TAG_const_type
: return "DW_TAG_const_type";
7961 case DW_TAG_constant
: return "DW_TAG_constant";
7962 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
7963 case DW_TAG_file_type
: return "DW_TAG_file_type";
7964 case DW_TAG_friend
: return "DW_TAG_friend";
7965 case DW_TAG_namelist
: return "DW_TAG_namelist";
7966 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
7967 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
7968 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
7969 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
7970 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
7971 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
7972 case DW_TAG_try_block
: return "DW_TAG_try_block";
7973 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
7974 case DW_TAG_variable
: return "DW_TAG_variable";
7975 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
7976 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
7977 case DW_TAG_format_label
: return "DW_TAG_format_label";
7978 case DW_TAG_function_template
: return "DW_TAG_function_template";
7979 case DW_TAG_class_template
: return "DW_TAG_class_template";
7980 /* DWARF 2.1 values. */
7981 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
7982 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
7983 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
7984 case DW_TAG_namespace
: return "DW_TAG_namespace";
7985 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
7986 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
7987 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
7988 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
7990 case DW_TAG_upc_shared_type
: return "DW_TAG_upc_shared_type";
7991 case DW_TAG_upc_strict_type
: return "DW_TAG_upc_strict_type";
7992 case DW_TAG_upc_relaxed_type
: return "DW_TAG_upc_relaxed_type";
7995 static char buffer
[100];
7997 snprintf (buffer
, sizeof (buffer
), _("Unknown TAG value: %lx"), tag
);
8004 get_FORM_name (unsigned long form
)
8008 case DW_FORM_addr
: return "DW_FORM_addr";
8009 case DW_FORM_block2
: return "DW_FORM_block2";
8010 case DW_FORM_block4
: return "DW_FORM_block4";
8011 case DW_FORM_data2
: return "DW_FORM_data2";
8012 case DW_FORM_data4
: return "DW_FORM_data4";
8013 case DW_FORM_data8
: return "DW_FORM_data8";
8014 case DW_FORM_string
: return "DW_FORM_string";
8015 case DW_FORM_block
: return "DW_FORM_block";
8016 case DW_FORM_block1
: return "DW_FORM_block1";
8017 case DW_FORM_data1
: return "DW_FORM_data1";
8018 case DW_FORM_flag
: return "DW_FORM_flag";
8019 case DW_FORM_sdata
: return "DW_FORM_sdata";
8020 case DW_FORM_strp
: return "DW_FORM_strp";
8021 case DW_FORM_udata
: return "DW_FORM_udata";
8022 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
8023 case DW_FORM_ref1
: return "DW_FORM_ref1";
8024 case DW_FORM_ref2
: return "DW_FORM_ref2";
8025 case DW_FORM_ref4
: return "DW_FORM_ref4";
8026 case DW_FORM_ref8
: return "DW_FORM_ref8";
8027 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
8028 case DW_FORM_indirect
: return "DW_FORM_indirect";
8031 static char buffer
[100];
8033 snprintf (buffer
, sizeof (buffer
), _("Unknown FORM value: %lx"), form
);
8039 static unsigned char *
8040 display_block (unsigned char *data
, unsigned long length
)
8042 printf (_(" %lu byte block: "), length
);
8045 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
8051 decode_location_expression (unsigned char * data
,
8052 unsigned int pointer_size
,
8053 unsigned long length
,
8054 unsigned long cu_offset
)
8057 unsigned int bytes_read
;
8058 unsigned long uvalue
;
8059 unsigned char *end
= data
+ length
;
8060 int need_frame_base
= 0;
8069 printf ("DW_OP_addr: %lx",
8070 (unsigned long) byte_get (data
, pointer_size
));
8071 data
+= pointer_size
;
8074 printf ("DW_OP_deref");
8077 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
8080 printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data
++, 1));
8083 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
8087 printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data
, 2));
8091 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
8095 printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data
, 4));
8099 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
8100 (unsigned long) byte_get (data
+ 4, 4));
8104 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
8105 (long) byte_get (data
+ 4, 4));
8109 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
8113 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
8117 printf ("DW_OP_dup");
8120 printf ("DW_OP_drop");
8123 printf ("DW_OP_over");
8126 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
8129 printf ("DW_OP_swap");
8132 printf ("DW_OP_rot");
8135 printf ("DW_OP_xderef");
8138 printf ("DW_OP_abs");
8141 printf ("DW_OP_and");
8144 printf ("DW_OP_div");
8147 printf ("DW_OP_minus");
8150 printf ("DW_OP_mod");
8153 printf ("DW_OP_mul");
8156 printf ("DW_OP_neg");
8159 printf ("DW_OP_not");
8162 printf ("DW_OP_or");
8165 printf ("DW_OP_plus");
8167 case DW_OP_plus_uconst
:
8168 printf ("DW_OP_plus_uconst: %lu",
8169 read_leb128 (data
, &bytes_read
, 0));
8173 printf ("DW_OP_shl");
8176 printf ("DW_OP_shr");
8179 printf ("DW_OP_shra");
8182 printf ("DW_OP_xor");
8185 printf ("DW_OP_bra: %ld", (long) byte_get_signed (data
, 2));
8189 printf ("DW_OP_eq");
8192 printf ("DW_OP_ge");
8195 printf ("DW_OP_gt");
8198 printf ("DW_OP_le");
8201 printf ("DW_OP_lt");
8204 printf ("DW_OP_ne");
8207 printf ("DW_OP_skip: %ld", (long) byte_get_signed (data
, 2));
8243 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
8278 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
8313 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
8314 read_leb128 (data
, &bytes_read
, 1));
8319 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
8323 need_frame_base
= 1;
8324 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
8328 uvalue
= read_leb128 (data
, &bytes_read
, 0);
8330 printf ("DW_OP_bregx: %lu %ld", uvalue
,
8331 read_leb128 (data
, &bytes_read
, 1));
8335 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
8338 case DW_OP_deref_size
:
8339 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
8341 case DW_OP_xderef_size
:
8342 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
8345 printf ("DW_OP_nop");
8348 /* DWARF 3 extensions. */
8349 case DW_OP_push_object_address
:
8350 printf ("DW_OP_push_object_address");
8353 /* XXX: Strictly speaking for 64-bit DWARF3 files
8354 this ought to be an 8-byte wide computation. */
8355 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2) + cu_offset
);
8359 /* XXX: Strictly speaking for 64-bit DWARF3 files
8360 this ought to be an 8-byte wide computation. */
8361 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4) + cu_offset
);
8364 case DW_OP_call_ref
:
8365 printf ("DW_OP_call_ref");
8368 /* GNU extensions. */
8369 case DW_OP_GNU_push_tls_address
:
8370 printf ("DW_OP_GNU_push_tls_address");
8374 if (op
>= DW_OP_lo_user
8375 && op
<= DW_OP_hi_user
)
8376 printf (_("(User defined location op)"));
8378 printf (_("(Unknown location op)"));
8379 /* No way to tell where the next op is, so just bail. */
8380 return need_frame_base
;
8383 /* Separate the ops. */
8388 return need_frame_base
;
8391 /* This structure records the information that
8392 we extract from the.debug_info section. */
8395 unsigned int pointer_size
;
8396 unsigned long cu_offset
;
8397 unsigned long base_address
;
8398 /* This is an array of offsets to the location list table. */
8399 unsigned long *loc_offsets
;
8400 int *have_frame_base
;
8401 unsigned int num_loc_offsets
;
8402 unsigned int max_loc_offsets
;
8403 unsigned long *range_lists
;
8404 unsigned int num_range_lists
;
8405 unsigned int max_range_lists
;
8409 static debug_info
* debug_information
= NULL
;
8410 static unsigned int num_debug_info_entries
= 0;
8411 static unsigned int last_pointer_size
= 0;
8412 static int warned_about_missing_comp_units
= FALSE
;
8414 static unsigned char *
8415 read_and_display_attr_value (unsigned long attribute
,
8417 unsigned char *data
,
8418 unsigned long cu_offset
,
8419 unsigned long pointer_size
,
8420 unsigned long offset_size
,
8422 debug_info
*debug_info_p
,
8425 unsigned long uvalue
= 0;
8426 unsigned char *block_start
= NULL
;
8427 unsigned int bytes_read
;
8434 case DW_FORM_ref_addr
:
8435 if (dwarf_version
== 2)
8437 uvalue
= byte_get (data
, pointer_size
);
8438 data
+= pointer_size
;
8440 else if (dwarf_version
== 3)
8442 uvalue
= byte_get (data
, offset_size
);
8443 data
+= offset_size
;
8447 error (_("Internal error: DWARF version is not 2 or 3.\n"));
8452 uvalue
= byte_get (data
, pointer_size
);
8453 data
+= pointer_size
;
8457 uvalue
= byte_get (data
, offset_size
);
8458 data
+= offset_size
;
8464 uvalue
= byte_get (data
++, 1);
8469 uvalue
= byte_get (data
, 2);
8475 uvalue
= byte_get (data
, 4);
8480 uvalue
= read_leb128 (data
, & bytes_read
, 1);
8484 case DW_FORM_ref_udata
:
8486 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8490 case DW_FORM_indirect
:
8491 form
= read_leb128 (data
, & bytes_read
, 0);
8494 printf (" %s", get_FORM_name (form
));
8495 return read_and_display_attr_value (attribute
, form
, data
,
8496 cu_offset
, pointer_size
,
8497 offset_size
, dwarf_version
,
8498 debug_info_p
, do_loc
);
8503 case DW_FORM_ref_addr
:
8505 printf (" <#%lx>", uvalue
);
8511 case DW_FORM_ref_udata
:
8513 printf (" <%lx>", uvalue
+ cu_offset
);
8519 printf (" %#lx", uvalue
);
8528 printf (" %ld", uvalue
);
8535 uvalue
= byte_get (data
, 4);
8536 printf (" %lx", uvalue
);
8537 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
8539 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8540 && num_debug_info_entries
== 0)
8542 if (sizeof (uvalue
) == 8)
8543 uvalue
= byte_get (data
, 8);
8545 error (_("DW_FORM_data8 is unsupported when sizeof (unsigned long) != 8\n"));
8550 case DW_FORM_string
:
8552 printf (" %s", data
);
8553 data
+= strlen ((char *) data
) + 1;
8557 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8558 block_start
= data
+ bytes_read
;
8560 data
= block_start
+ uvalue
;
8562 data
= display_block (block_start
, uvalue
);
8565 case DW_FORM_block1
:
8566 uvalue
= byte_get (data
, 1);
8567 block_start
= data
+ 1;
8569 data
= block_start
+ uvalue
;
8571 data
= display_block (block_start
, uvalue
);
8574 case DW_FORM_block2
:
8575 uvalue
= byte_get (data
, 2);
8576 block_start
= data
+ 2;
8578 data
= block_start
+ uvalue
;
8580 data
= display_block (block_start
, uvalue
);
8583 case DW_FORM_block4
:
8584 uvalue
= byte_get (data
, 4);
8585 block_start
= data
+ 4;
8587 data
= block_start
+ uvalue
;
8589 data
= display_block (block_start
, uvalue
);
8594 printf (_(" (indirect string, offset: 0x%lx): %s"),
8595 uvalue
, fetch_indirect_string (uvalue
));
8598 case DW_FORM_indirect
:
8599 /* Handled above. */
8603 warn (_("Unrecognized form: %lu\n"), form
);
8607 /* For some attributes we can display further information. */
8608 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8609 && num_debug_info_entries
== 0)
8613 case DW_AT_frame_base
:
8614 have_frame_base
= 1;
8615 case DW_AT_location
:
8616 case DW_AT_data_member_location
:
8617 case DW_AT_vtable_elem_location
:
8618 case DW_AT_allocated
:
8619 case DW_AT_associated
:
8620 case DW_AT_data_location
:
8622 case DW_AT_upper_bound
:
8623 case DW_AT_lower_bound
:
8624 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8626 /* Process location list. */
8627 unsigned int max
= debug_info_p
->max_loc_offsets
;
8628 unsigned int num
= debug_info_p
->num_loc_offsets
;
8630 if (max
== 0 || num
>= max
)
8633 debug_info_p
->loc_offsets
8634 = xcrealloc (debug_info_p
->loc_offsets
,
8635 max
, sizeof (*debug_info_p
->loc_offsets
));
8636 debug_info_p
->have_frame_base
8637 = xcrealloc (debug_info_p
->have_frame_base
,
8638 max
, sizeof (*debug_info_p
->have_frame_base
));
8639 debug_info_p
->max_loc_offsets
= max
;
8641 debug_info_p
->loc_offsets
[num
] = uvalue
;
8642 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
8643 debug_info_p
->num_loc_offsets
++;
8648 if (need_base_address
)
8649 debug_info_p
->base_address
= uvalue
;
8653 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8655 /* Process range list. */
8656 unsigned int max
= debug_info_p
->max_range_lists
;
8657 unsigned int num
= debug_info_p
->num_range_lists
;
8659 if (max
== 0 || num
>= max
)
8662 debug_info_p
->range_lists
8663 = xcrealloc (debug_info_p
->range_lists
,
8664 max
, sizeof (*debug_info_p
->range_lists
));
8665 debug_info_p
->max_range_lists
= max
;
8667 debug_info_p
->range_lists
[num
] = uvalue
;
8668 debug_info_p
->num_range_lists
++;
8687 case DW_INL_not_inlined
:
8688 printf (_("(not inlined)"));
8690 case DW_INL_inlined
:
8691 printf (_("(inlined)"));
8693 case DW_INL_declared_not_inlined
:
8694 printf (_("(declared as inline but ignored)"));
8696 case DW_INL_declared_inlined
:
8697 printf (_("(declared as inline and inlined)"));
8700 printf (_(" (Unknown inline attribute value: %lx)"), uvalue
);
8705 case DW_AT_language
:
8708 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
8709 case DW_LANG_C89
: printf ("(ANSI C)"); break;
8710 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
8711 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
8712 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
8713 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
8714 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
8715 case DW_LANG_Ada83
: printf ("(Ada)"); break;
8716 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
8717 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
8718 /* DWARF 2.1 values. */
8719 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
8720 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
8721 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
8722 /* MIPS extension. */
8723 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
8724 /* UPC extension. */
8725 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
8727 printf ("(Unknown: %lx)", uvalue
);
8732 case DW_AT_encoding
:
8735 case DW_ATE_void
: printf ("(void)"); break;
8736 case DW_ATE_address
: printf ("(machine address)"); break;
8737 case DW_ATE_boolean
: printf ("(boolean)"); break;
8738 case DW_ATE_complex_float
: printf ("(complex float)"); break;
8739 case DW_ATE_float
: printf ("(float)"); break;
8740 case DW_ATE_signed
: printf ("(signed)"); break;
8741 case DW_ATE_signed_char
: printf ("(signed char)"); break;
8742 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
8743 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
8744 /* DWARF 2.1 value. */
8745 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
8746 case DW_ATE_decimal_float
: printf ("(decimal float)"); break;
8748 if (uvalue
>= DW_ATE_lo_user
8749 && uvalue
<= DW_ATE_hi_user
)
8750 printf ("(user defined type)");
8752 printf ("(unknown type)");
8757 case DW_AT_accessibility
:
8760 case DW_ACCESS_public
: printf ("(public)"); break;
8761 case DW_ACCESS_protected
: printf ("(protected)"); break;
8762 case DW_ACCESS_private
: printf ("(private)"); break;
8764 printf ("(unknown accessibility)");
8769 case DW_AT_visibility
:
8772 case DW_VIS_local
: printf ("(local)"); break;
8773 case DW_VIS_exported
: printf ("(exported)"); break;
8774 case DW_VIS_qualified
: printf ("(qualified)"); break;
8775 default: printf ("(unknown visibility)"); break;
8779 case DW_AT_virtuality
:
8782 case DW_VIRTUALITY_none
: printf ("(none)"); break;
8783 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
8784 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
8785 default: printf ("(unknown virtuality)"); break;
8789 case DW_AT_identifier_case
:
8792 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
8793 case DW_ID_up_case
: printf ("(up_case)"); break;
8794 case DW_ID_down_case
: printf ("(down_case)"); break;
8795 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
8796 default: printf ("(unknown case)"); break;
8800 case DW_AT_calling_convention
:
8803 case DW_CC_normal
: printf ("(normal)"); break;
8804 case DW_CC_program
: printf ("(program)"); break;
8805 case DW_CC_nocall
: printf ("(nocall)"); break;
8807 if (uvalue
>= DW_CC_lo_user
8808 && uvalue
<= DW_CC_hi_user
)
8809 printf ("(user defined)");
8811 printf ("(unknown convention)");
8815 case DW_AT_ordering
:
8818 case -1: printf ("(undefined)"); break;
8819 case 0: printf ("(row major)"); break;
8820 case 1: printf ("(column major)"); break;
8824 case DW_AT_frame_base
:
8825 have_frame_base
= 1;
8826 case DW_AT_location
:
8827 case DW_AT_data_member_location
:
8828 case DW_AT_vtable_elem_location
:
8829 case DW_AT_allocated
:
8830 case DW_AT_associated
:
8831 case DW_AT_data_location
:
8833 case DW_AT_upper_bound
:
8834 case DW_AT_lower_bound
:
8837 int need_frame_base
;
8840 need_frame_base
= decode_location_expression (block_start
,
8845 if (need_frame_base
&& !have_frame_base
)
8846 printf (_(" [without DW_AT_frame_base]"));
8848 else if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8849 printf (_("(location list)"));
8861 get_AT_name (unsigned long attribute
)
8865 case DW_AT_sibling
: return "DW_AT_sibling";
8866 case DW_AT_location
: return "DW_AT_location";
8867 case DW_AT_name
: return "DW_AT_name";
8868 case DW_AT_ordering
: return "DW_AT_ordering";
8869 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
8870 case DW_AT_byte_size
: return "DW_AT_byte_size";
8871 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
8872 case DW_AT_bit_size
: return "DW_AT_bit_size";
8873 case DW_AT_element_list
: return "DW_AT_element_list";
8874 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
8875 case DW_AT_low_pc
: return "DW_AT_low_pc";
8876 case DW_AT_high_pc
: return "DW_AT_high_pc";
8877 case DW_AT_language
: return "DW_AT_language";
8878 case DW_AT_member
: return "DW_AT_member";
8879 case DW_AT_discr
: return "DW_AT_discr";
8880 case DW_AT_discr_value
: return "DW_AT_discr_value";
8881 case DW_AT_visibility
: return "DW_AT_visibility";
8882 case DW_AT_import
: return "DW_AT_import";
8883 case DW_AT_string_length
: return "DW_AT_string_length";
8884 case DW_AT_common_reference
: return "DW_AT_common_reference";
8885 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
8886 case DW_AT_const_value
: return "DW_AT_const_value";
8887 case DW_AT_containing_type
: return "DW_AT_containing_type";
8888 case DW_AT_default_value
: return "DW_AT_default_value";
8889 case DW_AT_inline
: return "DW_AT_inline";
8890 case DW_AT_is_optional
: return "DW_AT_is_optional";
8891 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
8892 case DW_AT_producer
: return "DW_AT_producer";
8893 case DW_AT_prototyped
: return "DW_AT_prototyped";
8894 case DW_AT_return_addr
: return "DW_AT_return_addr";
8895 case DW_AT_start_scope
: return "DW_AT_start_scope";
8896 case DW_AT_stride_size
: return "DW_AT_stride_size";
8897 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
8898 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
8899 case DW_AT_accessibility
: return "DW_AT_accessibility";
8900 case DW_AT_address_class
: return "DW_AT_address_class";
8901 case DW_AT_artificial
: return "DW_AT_artificial";
8902 case DW_AT_base_types
: return "DW_AT_base_types";
8903 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
8904 case DW_AT_count
: return "DW_AT_count";
8905 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
8906 case DW_AT_decl_column
: return "DW_AT_decl_column";
8907 case DW_AT_decl_file
: return "DW_AT_decl_file";
8908 case DW_AT_decl_line
: return "DW_AT_decl_line";
8909 case DW_AT_declaration
: return "DW_AT_declaration";
8910 case DW_AT_discr_list
: return "DW_AT_discr_list";
8911 case DW_AT_encoding
: return "DW_AT_encoding";
8912 case DW_AT_external
: return "DW_AT_external";
8913 case DW_AT_frame_base
: return "DW_AT_frame_base";
8914 case DW_AT_friend
: return "DW_AT_friend";
8915 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
8916 case DW_AT_macro_info
: return "DW_AT_macro_info";
8917 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
8918 case DW_AT_priority
: return "DW_AT_priority";
8919 case DW_AT_segment
: return "DW_AT_segment";
8920 case DW_AT_specification
: return "DW_AT_specification";
8921 case DW_AT_static_link
: return "DW_AT_static_link";
8922 case DW_AT_type
: return "DW_AT_type";
8923 case DW_AT_use_location
: return "DW_AT_use_location";
8924 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
8925 case DW_AT_virtuality
: return "DW_AT_virtuality";
8926 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
8927 /* DWARF 2.1 values. */
8928 case DW_AT_allocated
: return "DW_AT_allocated";
8929 case DW_AT_associated
: return "DW_AT_associated";
8930 case DW_AT_data_location
: return "DW_AT_data_location";
8931 case DW_AT_stride
: return "DW_AT_stride";
8932 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
8933 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
8934 case DW_AT_extension
: return "DW_AT_extension";
8935 case DW_AT_ranges
: return "DW_AT_ranges";
8936 case DW_AT_trampoline
: return "DW_AT_trampoline";
8937 case DW_AT_call_column
: return "DW_AT_call_column";
8938 case DW_AT_call_file
: return "DW_AT_call_file";
8939 case DW_AT_call_line
: return "DW_AT_call_line";
8940 /* SGI/MIPS extensions. */
8941 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
8942 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
8943 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
8944 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
8945 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
8946 case DW_AT_MIPS_software_pipeline_depth
:
8947 return "DW_AT_MIPS_software_pipeline_depth";
8948 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
8949 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
8950 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
8951 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
8952 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
8953 /* GNU extensions. */
8954 case DW_AT_sf_names
: return "DW_AT_sf_names";
8955 case DW_AT_src_info
: return "DW_AT_src_info";
8956 case DW_AT_mac_info
: return "DW_AT_mac_info";
8957 case DW_AT_src_coords
: return "DW_AT_src_coords";
8958 case DW_AT_body_begin
: return "DW_AT_body_begin";
8959 case DW_AT_body_end
: return "DW_AT_body_end";
8960 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
8961 /* UPC extension. */
8962 case DW_AT_upc_threads_scaled
: return "DW_AT_upc_threads_scaled";
8965 static char buffer
[100];
8967 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
8974 static unsigned char *
8975 read_and_display_attr (unsigned long attribute
,
8977 unsigned char *data
,
8978 unsigned long cu_offset
,
8979 unsigned long pointer_size
,
8980 unsigned long offset_size
,
8982 debug_info
*debug_info_p
,
8986 printf (" %-18s:", get_AT_name (attribute
));
8987 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
8988 pointer_size
, offset_size
,
8989 dwarf_version
, debug_info_p
,
8997 /* Process the contents of a .debug_info section. If do_loc is non-zero
8998 then we are scanning for location lists and we do not want to display
8999 anything to the user. */
9002 process_debug_info (Elf_Internal_Shdr
*section
, unsigned char *start
,
9003 FILE *file
, int do_loc
)
9005 unsigned char *end
= start
+ section
->sh_size
;
9006 unsigned char *section_begin
;
9008 unsigned int num_units
= 0;
9010 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
9011 && num_debug_info_entries
== 0)
9013 unsigned long length
;
9015 /* First scan the section to get the number of comp units. */
9016 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
9019 /* Read the first 4 bytes. For a 32-bit DWARF section, this
9020 will be the length. For a 64-bit DWARF section, it'll be
9021 the escape code 0xffffffff followed by an 8 byte length. */
9022 length
= byte_get (section_begin
, 4);
9024 if (length
== 0xffffffff)
9026 length
= byte_get (section_begin
+ 4, 8);
9027 section_begin
+= length
+ 12;
9030 section_begin
+= length
+ 4;
9035 error (_("No comp units in .debug_info section ?"));
9039 /* Then allocate an array to hold the information. */
9040 debug_information
= cmalloc (num_units
,
9041 sizeof (* debug_information
));
9042 if (debug_information
== NULL
)
9044 error (_("Not enough memory for a debug info array of %u entries"),
9052 printf (_("The section %s contains:\n\n"),
9053 SECTION_NAME (section
));
9055 load_debug_str (file
);
9056 load_debug_loc (file
);
9057 load_debug_range (file
);
9060 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
9062 DWARF2_Internal_CompUnit compunit
;
9063 unsigned char *hdrptr
;
9064 unsigned char *cu_abbrev_offset_ptr
;
9065 unsigned char *tags
;
9067 unsigned long cu_offset
;
9069 int initial_length_size
;
9073 compunit
.cu_length
= byte_get (hdrptr
, 4);
9076 if (compunit
.cu_length
== 0xffffffff)
9078 compunit
.cu_length
= byte_get (hdrptr
, 8);
9081 initial_length_size
= 12;
9086 initial_length_size
= 4;
9089 compunit
.cu_version
= byte_get (hdrptr
, 2);
9092 cu_offset
= start
- section_begin
;
9093 start
+= compunit
.cu_length
+ initial_length_size
;
9095 if (elf_header
.e_type
== ET_REL
9096 && !debug_apply_rela_addends (file
, section
, offset_size
,
9097 section_begin
, hdrptr
, start
))
9100 cu_abbrev_offset_ptr
= hdrptr
;
9101 compunit
.cu_abbrev_offset
= byte_get (hdrptr
, offset_size
);
9102 hdrptr
+= offset_size
;
9104 compunit
.cu_pointer_size
= byte_get (hdrptr
, 1);
9106 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
9107 && num_debug_info_entries
== 0)
9109 debug_information
[unit
].cu_offset
= cu_offset
;
9110 debug_information
[unit
].pointer_size
9111 = compunit
.cu_pointer_size
;
9112 debug_information
[unit
].base_address
= 0;
9113 debug_information
[unit
].loc_offsets
= NULL
;
9114 debug_information
[unit
].have_frame_base
= NULL
;
9115 debug_information
[unit
].max_loc_offsets
= 0;
9116 debug_information
[unit
].num_loc_offsets
= 0;
9117 debug_information
[unit
].range_lists
= NULL
;
9118 debug_information
[unit
].max_range_lists
= 0;
9119 debug_information
[unit
].num_range_lists
= 0;
9126 printf (_(" Compilation Unit @ offset 0x%lx:\n"), cu_offset
);
9127 printf (_(" Length: %ld\n"), compunit
.cu_length
);
9128 printf (_(" Version: %d\n"), compunit
.cu_version
);
9129 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
9130 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
9133 if (compunit
.cu_version
!= 2 && compunit
.cu_version
!= 3)
9135 warn (_("Only version 2 and 3 DWARF debug information is currently supported.\n"));
9141 /* Read in the abbrevs used by this compilation unit. */
9143 Elf_Internal_Shdr
*sec
;
9144 unsigned char *begin
;
9146 /* Locate the .debug_abbrev section and process it. */
9147 sec
= find_section (".debug_abbrev");
9150 warn (_("Unable to locate .debug_abbrev section!\n"));
9154 begin
= get_data (NULL
, file
, sec
->sh_offset
, 1, sec
->sh_size
,
9155 _("debug_abbrev section data"));
9159 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
9160 begin
+ sec
->sh_size
);
9166 while (tags
< start
)
9168 unsigned int bytes_read
;
9169 unsigned long abbrev_number
;
9170 abbrev_entry
*entry
;
9173 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
9176 /* A null DIE marks the end of a list of children. */
9177 if (abbrev_number
== 0)
9183 /* Scan through the abbreviation list until we reach the
9185 for (entry
= first_abbrev
;
9186 entry
&& entry
->entry
!= abbrev_number
;
9187 entry
= entry
->next
)
9192 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
9198 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
9200 (unsigned long) (tags
- section_begin
9203 get_TAG_name (entry
->tag
));
9208 need_base_address
= 0;
9210 case DW_TAG_compile_unit
:
9211 need_base_address
= 1;
9213 case DW_TAG_entry_point
:
9214 case DW_TAG_inlined_subroutine
:
9215 case DW_TAG_subprogram
:
9216 need_base_address
= 0;
9217 /* Assuming that there is no DW_AT_frame_base. */
9218 have_frame_base
= 0;
9222 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
9223 tags
= read_and_display_attr (attr
->attribute
,
9226 compunit
.cu_pointer_size
,
9228 compunit
.cu_version
,
9229 &debug_information
[unit
],
9232 if (entry
->children
)
9237 /* Set num_debug_info_entries here so that it can be used to check if
9238 we need to process .debug_loc and .debug_ranges sections. */
9239 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
9240 && num_debug_info_entries
== 0)
9241 num_debug_info_entries
= num_units
;
9245 free_debug_range ();
9255 /* Retrieve the pointer size associated with the given compilation unit.
9256 Optionally the offset of this unit into the .debug_info section is
9257 also retutned. If there is no .debug_info section then an error
9258 message is issued and 0 is returned. If the requested comp unit has
9259 not been defined in the .debug_info section then a warning message
9260 is issued and the last know pointer size is returned. This message
9261 is only issued once per section dumped per file dumped. */
9264 get_pointer_size_and_offset_of_comp_unit (unsigned int comp_unit
,
9265 const char * section_name
,
9266 unsigned long * offset_return
)
9268 unsigned long offset
= 0;
9270 if (num_debug_info_entries
== 0)
9271 error (_("%s section needs a populated .debug_info section\n"),
9274 else if (comp_unit
>= num_debug_info_entries
)
9276 if (!warned_about_missing_comp_units
)
9278 warn (_("%s section has more comp units than .debug_info section\n"),
9280 warn (_("assuming that the pointer size is %d, from the last comp unit in .debug_info\n\n"),
9282 warned_about_missing_comp_units
= TRUE
;
9287 last_pointer_size
= debug_information
[comp_unit
].pointer_size
;
9288 offset
= debug_information
[comp_unit
].cu_offset
;
9291 if (offset_return
!= NULL
)
9292 * offset_return
= offset
;
9294 return last_pointer_size
;
9297 /* Locate and scan the .debug_info section in the file and record the pointer
9298 sizes and offsets for the compilation units in it. Usually an executable
9299 will have just one pointer size, but this is not guaranteed, and so we try
9300 not to make any assumptions. Returns zero upon failure, or the number of
9301 compilation units upon success. */
9304 get_debug_info (FILE * file
)
9306 Elf_Internal_Shdr
* section
;
9307 unsigned char * start
;
9310 /* Reset the last pointer size so that we can issue correct error
9311 messages if we are displaying the contents of more than one section. */
9312 last_pointer_size
= 0;
9313 warned_about_missing_comp_units
= FALSE
;
9315 /* If we already have the information there is nothing else to do. */
9316 if (num_debug_info_entries
> 0)
9317 return num_debug_info_entries
;
9319 section
= find_section (".debug_info");
9320 if (section
== NULL
)
9323 start
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
9324 _("extracting information from .debug_info section"));
9328 ret
= process_debug_info (section
, start
, file
, 1);
9331 return ret
? num_debug_info_entries
: 0;
9335 display_debug_lines (Elf_Internal_Shdr
*section
,
9336 unsigned char *start
, FILE *file
)
9338 unsigned char *data
= start
;
9339 unsigned char *end
= start
+ section
->sh_size
;
9340 unsigned int comp_unit
= 0;
9342 printf (_("\nDump of debug contents of section %s:\n\n"),
9343 SECTION_NAME (section
));
9345 get_debug_info (file
);
9349 DWARF2_Internal_LineInfo info
;
9350 unsigned char *standard_opcodes
;
9351 unsigned char *end_of_sequence
;
9352 unsigned char *hdrptr
;
9353 unsigned int pointer_size
;
9354 int initial_length_size
;
9360 /* Check the length of the block. */
9361 info
.li_length
= byte_get (hdrptr
, 4);
9364 if (info
.li_length
== 0xffffffff)
9366 /* This section is 64-bit DWARF 3. */
9367 info
.li_length
= byte_get (hdrptr
, 8);
9370 initial_length_size
= 12;
9375 initial_length_size
= 4;
9378 if (info
.li_length
+ initial_length_size
> section
->sh_size
)
9381 (_("The line info appears to be corrupt - the section is too small\n"));
9385 /* Check its version number. */
9386 info
.li_version
= byte_get (hdrptr
, 2);
9388 if (info
.li_version
!= 2 && info
.li_version
!= 3)
9390 warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
9394 info
.li_prologue_length
= byte_get (hdrptr
, offset_size
);
9395 hdrptr
+= offset_size
;
9396 info
.li_min_insn_length
= byte_get (hdrptr
, 1);
9398 info
.li_default_is_stmt
= byte_get (hdrptr
, 1);
9400 info
.li_line_base
= byte_get (hdrptr
, 1);
9402 info
.li_line_range
= byte_get (hdrptr
, 1);
9404 info
.li_opcode_base
= byte_get (hdrptr
, 1);
9407 /* Sign extend the line base field. */
9408 info
.li_line_base
<<= 24;
9409 info
.li_line_base
>>= 24;
9411 /* Get the pointer size from the comp unit associated
9412 with this block of line number information. */
9413 pointer_size
= get_pointer_size_and_offset_of_comp_unit
9414 (comp_unit
, ".debug_line", NULL
);
9417 printf (_(" Length: %ld\n"), info
.li_length
);
9418 printf (_(" DWARF Version: %d\n"), info
.li_version
);
9419 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
9420 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
9421 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
9422 printf (_(" Line Base: %d\n"), info
.li_line_base
);
9423 printf (_(" Line Range: %d\n"), info
.li_line_range
);
9424 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
9425 printf (_(" (Pointer size: %u)%s\n"),
9427 warned_about_missing_comp_units
? " [assumed]" : "" );
9429 end_of_sequence
= data
+ info
.li_length
+ initial_length_size
;
9431 reset_state_machine (info
.li_default_is_stmt
);
9433 /* Display the contents of the Opcodes table. */
9434 standard_opcodes
= hdrptr
;
9436 printf (_("\n Opcodes:\n"));
9438 for (i
= 1; i
< info
.li_opcode_base
; i
++)
9439 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
9441 /* Display the contents of the Directory table. */
9442 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
9445 printf (_("\n The Directory Table is empty.\n"));
9448 printf (_("\n The Directory Table:\n"));
9452 printf (_(" %s\n"), data
);
9454 data
+= strlen ((char *) data
) + 1;
9458 /* Skip the NUL at the end of the table. */
9461 /* Display the contents of the File Name table. */
9463 printf (_("\n The File Name Table is empty.\n"));
9466 printf (_("\n The File Name Table:\n"));
9467 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
9471 unsigned char *name
;
9472 unsigned int bytes_read
;
9474 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
9477 data
+= strlen ((char *) data
) + 1;
9479 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9481 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9483 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9485 printf (_("%s\n"), name
);
9489 /* Skip the NUL at the end of the table. */
9492 /* Now display the statements. */
9493 printf (_("\n Line Number Statements:\n"));
9495 while (data
< end_of_sequence
)
9497 unsigned char op_code
;
9499 unsigned int bytes_read
;
9503 if (op_code
>= info
.li_opcode_base
)
9505 op_code
-= info
.li_opcode_base
;
9506 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
9507 state_machine_regs
.address
+= adv
;
9508 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
9509 op_code
, adv
, state_machine_regs
.address
);
9510 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
9511 state_machine_regs
.line
+= adv
;
9512 printf (_(" and Line by %d to %d\n"),
9513 adv
, state_machine_regs
.line
);
9515 else switch (op_code
)
9517 case DW_LNS_extended_op
:
9518 if (pointer_size
== 0)
9520 warn (_("Extend line ops need a valid pointer size, guessing at 4\n"));
9524 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
9529 printf (_(" Copy\n"));
9532 case DW_LNS_advance_pc
:
9533 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
9535 state_machine_regs
.address
+= adv
;
9536 printf (_(" Advance PC by %d to %lx\n"), adv
,
9537 state_machine_regs
.address
);
9540 case DW_LNS_advance_line
:
9541 adv
= read_leb128 (data
, & bytes_read
, 1);
9543 state_machine_regs
.line
+= adv
;
9544 printf (_(" Advance Line by %d to %d\n"), adv
,
9545 state_machine_regs
.line
);
9548 case DW_LNS_set_file
:
9549 adv
= read_leb128 (data
, & bytes_read
, 0);
9551 printf (_(" Set File Name to entry %d in the File Name Table\n"),
9553 state_machine_regs
.file
= adv
;
9556 case DW_LNS_set_column
:
9557 adv
= read_leb128 (data
, & bytes_read
, 0);
9559 printf (_(" Set column to %d\n"), adv
);
9560 state_machine_regs
.column
= adv
;
9563 case DW_LNS_negate_stmt
:
9564 adv
= state_machine_regs
.is_stmt
;
9566 printf (_(" Set is_stmt to %d\n"), adv
);
9567 state_machine_regs
.is_stmt
= adv
;
9570 case DW_LNS_set_basic_block
:
9571 printf (_(" Set basic block\n"));
9572 state_machine_regs
.basic_block
= 1;
9575 case DW_LNS_const_add_pc
:
9576 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
9577 * info
.li_min_insn_length
);
9578 state_machine_regs
.address
+= adv
;
9579 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
9580 state_machine_regs
.address
);
9583 case DW_LNS_fixed_advance_pc
:
9584 adv
= byte_get (data
, 2);
9586 state_machine_regs
.address
+= adv
;
9587 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
9588 adv
, state_machine_regs
.address
);
9591 case DW_LNS_set_prologue_end
:
9592 printf (_(" Set prologue_end to true\n"));
9595 case DW_LNS_set_epilogue_begin
:
9596 printf (_(" Set epilogue_begin to true\n"));
9599 case DW_LNS_set_isa
:
9600 adv
= read_leb128 (data
, & bytes_read
, 0);
9602 printf (_(" Set ISA to %d\n"), adv
);
9606 printf (_(" Unknown opcode %d with operands: "), op_code
);
9608 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
9610 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
9611 i
== 1 ? "" : ", ");
9625 display_debug_pubnames (Elf_Internal_Shdr
*section
,
9626 unsigned char *start
,
9627 FILE *file ATTRIBUTE_UNUSED
)
9629 DWARF2_Internal_PubNames pubnames
;
9632 end
= start
+ section
->sh_size
;
9634 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9638 unsigned char *data
;
9639 unsigned long offset
;
9640 int offset_size
, initial_length_size
;
9644 pubnames
.pn_length
= byte_get (data
, 4);
9646 if (pubnames
.pn_length
== 0xffffffff)
9648 pubnames
.pn_length
= byte_get (data
, 8);
9651 initial_length_size
= 12;
9656 initial_length_size
= 4;
9659 pubnames
.pn_version
= byte_get (data
, 2);
9661 pubnames
.pn_offset
= byte_get (data
, offset_size
);
9662 data
+= offset_size
;
9663 pubnames
.pn_size
= byte_get (data
, offset_size
);
9664 data
+= offset_size
;
9666 start
+= pubnames
.pn_length
+ initial_length_size
;
9668 if (pubnames
.pn_version
!= 2 && pubnames
.pn_version
!= 3)
9670 static int warned
= 0;
9674 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
9681 printf (_(" Length: %ld\n"),
9682 pubnames
.pn_length
);
9683 printf (_(" Version: %d\n"),
9684 pubnames
.pn_version
);
9685 printf (_(" Offset into .debug_info section: %ld\n"),
9686 pubnames
.pn_offset
);
9687 printf (_(" Size of area in .debug_info section: %ld\n"),
9690 printf (_("\n Offset\tName\n"));
9694 offset
= byte_get (data
, offset_size
);
9698 data
+= offset_size
;
9699 printf (" %-6ld\t\t%s\n", offset
, data
);
9700 data
+= strlen ((char *) data
) + 1;
9703 while (offset
!= 0);
9711 display_debug_macinfo (Elf_Internal_Shdr
*section
,
9712 unsigned char *start
,
9713 FILE *file ATTRIBUTE_UNUSED
)
9715 unsigned char *end
= start
+ section
->sh_size
;
9716 unsigned char *curr
= start
;
9717 unsigned int bytes_read
;
9718 enum dwarf_macinfo_record_type op
;
9720 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9724 unsigned int lineno
;
9732 case DW_MACINFO_start_file
:
9734 unsigned int filenum
;
9736 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9738 filenum
= read_leb128 (curr
, & bytes_read
, 0);
9741 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
9746 case DW_MACINFO_end_file
:
9747 printf (_(" DW_MACINFO_end_file\n"));
9750 case DW_MACINFO_define
:
9751 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9753 string
= (char *) curr
;
9754 curr
+= strlen (string
) + 1;
9755 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
9759 case DW_MACINFO_undef
:
9760 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9762 string
= (char *) curr
;
9763 curr
+= strlen (string
) + 1;
9764 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
9768 case DW_MACINFO_vendor_ext
:
9770 unsigned int constant
;
9772 constant
= read_leb128 (curr
, & bytes_read
, 0);
9774 string
= (char *) curr
;
9775 curr
+= strlen (string
) + 1;
9776 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
9788 display_debug_abbrev (Elf_Internal_Shdr
*section
,
9789 unsigned char *start
,
9790 FILE *file ATTRIBUTE_UNUSED
)
9792 abbrev_entry
*entry
;
9793 unsigned char *end
= start
+ section
->sh_size
;
9795 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9799 start
= process_abbrev_section (start
, end
);
9801 if (first_abbrev
== NULL
)
9804 printf (_(" Number TAG\n"));
9806 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
9810 printf (_(" %ld %s [%s]\n"),
9812 get_TAG_name (entry
->tag
),
9813 entry
->children
? _("has children") : _("no children"));
9815 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
9816 printf (_(" %-18s %s\n"),
9817 get_AT_name (attr
->attribute
),
9818 get_FORM_name (attr
->form
));
9831 display_debug_loc (Elf_Internal_Shdr
*section
,
9832 unsigned char *start
, FILE *file
)
9834 unsigned char *section_end
;
9835 unsigned long bytes
;
9836 unsigned char *section_begin
= start
;
9837 unsigned int num_loc_list
= 0;
9838 unsigned long last_offset
= 0;
9839 unsigned int first
= 0;
9842 int seen_first_offset
= 0;
9843 int use_debug_info
= 1;
9844 unsigned char *next
;
9846 bytes
= section
->sh_size
;
9847 section_end
= start
+ bytes
;
9851 printf (_("\nThe .debug_loc section is empty.\n"));
9855 get_debug_info (file
);
9857 /* Check the order of location list in .debug_info section. If
9858 offsets of location lists are in the ascending order, we can
9859 use `debug_information' directly. */
9860 for (i
= 0; i
< num_debug_info_entries
; i
++)
9864 num
= debug_information
[i
].num_loc_offsets
;
9865 num_loc_list
+= num
;
9867 /* Check if we can use `debug_information' directly. */
9868 if (use_debug_info
&& num
!= 0)
9870 if (!seen_first_offset
)
9872 /* This is the first location list. */
9873 last_offset
= debug_information
[i
].loc_offsets
[0];
9875 seen_first_offset
= 1;
9881 for (; j
< num
; j
++)
9884 debug_information
[i
].loc_offsets
[j
])
9889 last_offset
= debug_information
[i
].loc_offsets
[j
];
9894 if (!use_debug_info
)
9895 /* FIXME: Should we handle this case? */
9896 error (_("Location lists in .debug_info section aren't in ascending order!\n"));
9898 if (!seen_first_offset
)
9899 error (_("No location lists in .debug_info section!\n"));
9901 if (debug_information
[first
].loc_offsets
[0] != 0)
9902 warn (_("Location lists in .debug_loc section start at 0x%lx\n"),
9903 debug_information
[first
].loc_offsets
[0]);
9905 printf (_("Contents of the .debug_loc section:\n\n"));
9906 printf (_(" Offset Begin End Expression\n"));
9908 seen_first_offset
= 0;
9909 for (i
= first
; i
< num_debug_info_entries
; i
++)
9911 unsigned long begin
;
9913 unsigned short length
;
9914 unsigned long offset
;
9915 unsigned int pointer_size
;
9916 unsigned long cu_offset
;
9917 unsigned long base_address
;
9918 int need_frame_base
;
9921 pointer_size
= debug_information
[i
].pointer_size
;
9922 cu_offset
= debug_information
[i
].cu_offset
;
9924 for (j
= 0; j
< debug_information
[i
].num_loc_offsets
; j
++)
9926 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
9927 offset
= debug_information
[i
].loc_offsets
[j
];
9928 next
= section_begin
+ offset
;
9929 base_address
= debug_information
[i
].base_address
;
9931 if (!seen_first_offset
)
9932 seen_first_offset
= 1;
9936 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
9937 (long)(start
- section_begin
), (long)(next
- section_begin
));
9938 else if (start
> next
)
9939 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
9940 (long)(start
- section_begin
), (long)(next
- section_begin
));
9944 if (offset
>= bytes
)
9946 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
9953 if (start
+ 2 * pointer_size
> section_end
)
9955 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
9960 begin
= byte_get (start
, pointer_size
);
9961 start
+= pointer_size
;
9962 end
= byte_get (start
, pointer_size
);
9963 start
+= pointer_size
;
9965 if (begin
== 0 && end
== 0)
9967 printf (_(" %8.8lx <End of list>\n"), offset
);
9971 /* Check base address specifiers. */
9972 if (begin
== -1UL && end
!= -1UL)
9975 printf (_(" %8.8lx %8.8lx %8.8lx (base address)\n"),
9976 offset
, begin
, end
);
9980 if (start
+ 2 > section_end
)
9982 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
9987 length
= byte_get (start
, 2);
9990 if (start
+ length
> section_end
)
9992 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
9997 printf (" %8.8lx %8.8lx %8.8lx (",
9998 offset
, begin
+ base_address
, end
+ base_address
);
9999 need_frame_base
= decode_location_expression (start
,
10005 if (need_frame_base
&& !has_frame_base
)
10006 printf (_(" [without DW_AT_frame_base]"));
10009 fputs (_(" (start == end)"), stdout
);
10010 else if (begin
> end
)
10011 fputs (_(" (start > end)"), stdout
);
10023 display_debug_str (Elf_Internal_Shdr
*section
,
10024 unsigned char *start
,
10025 FILE *file ATTRIBUTE_UNUSED
)
10027 unsigned long bytes
;
10030 addr
= section
->sh_addr
;
10031 bytes
= section
->sh_size
;
10035 printf (_("\nThe .debug_str section is empty.\n"));
10039 printf (_("Contents of the .debug_str section:\n\n"));
10047 lbytes
= (bytes
> 16 ? 16 : bytes
);
10049 printf (" 0x%8.8lx ", (unsigned long) addr
);
10051 for (j
= 0; j
< 16; j
++)
10054 printf ("%2.2x", start
[j
]);
10062 for (j
= 0; j
< lbytes
; j
++)
10065 if (k
>= ' ' && k
< 0x80)
10085 display_debug_info (Elf_Internal_Shdr
* section
,
10086 unsigned char * start
, FILE * file
)
10088 return process_debug_info (section
, start
, file
, 0);
10093 display_debug_aranges (Elf_Internal_Shdr
*section
,
10094 unsigned char *start
,
10095 FILE *file ATTRIBUTE_UNUSED
)
10097 unsigned char *end
= start
+ section
->sh_size
;
10099 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
10101 while (start
< end
)
10103 unsigned char *hdrptr
;
10104 DWARF2_Internal_ARange arange
;
10105 unsigned char *ranges
;
10106 unsigned long length
;
10107 unsigned long address
;
10110 int initial_length_size
;
10114 arange
.ar_length
= byte_get (hdrptr
, 4);
10117 if (arange
.ar_length
== 0xffffffff)
10119 arange
.ar_length
= byte_get (hdrptr
, 8);
10122 initial_length_size
= 12;
10127 initial_length_size
= 4;
10130 arange
.ar_version
= byte_get (hdrptr
, 2);
10133 arange
.ar_info_offset
= byte_get (hdrptr
, offset_size
);
10134 hdrptr
+= offset_size
;
10136 arange
.ar_pointer_size
= byte_get (hdrptr
, 1);
10139 arange
.ar_segment_size
= byte_get (hdrptr
, 1);
10142 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
10144 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
10148 printf (_(" Length: %ld\n"), arange
.ar_length
);
10149 printf (_(" Version: %d\n"), arange
.ar_version
);
10150 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
10151 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
10152 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
10154 printf (_("\n Address Length\n"));
10158 /* Must pad to an alignment boundary that is twice the pointer size. */
10159 excess
= (hdrptr
- start
) % (2 * arange
.ar_pointer_size
);
10161 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
10165 address
= byte_get (ranges
, arange
.ar_pointer_size
);
10167 ranges
+= arange
.ar_pointer_size
;
10169 length
= byte_get (ranges
, arange
.ar_pointer_size
);
10171 ranges
+= arange
.ar_pointer_size
;
10173 /* A pair of zeros marks the end of the list. */
10174 if (address
== 0 && length
== 0)
10177 printf (" %8.8lx %lu\n", address
, length
);
10180 start
+= arange
.ar_length
+ initial_length_size
;
10189 display_debug_ranges (Elf_Internal_Shdr
*section
,
10190 unsigned char *start
,
10191 FILE *file ATTRIBUTE_UNUSED
)
10193 unsigned char *section_end
;
10194 unsigned long bytes
;
10195 unsigned char *section_begin
= start
;
10196 unsigned int num_range_list
= 0;
10197 unsigned long last_offset
= 0;
10198 unsigned int first
= 0;
10201 int seen_first_offset
= 0;
10202 int use_debug_info
= 1;
10203 unsigned char *next
;
10205 bytes
= section
->sh_size
;
10206 section_end
= start
+ bytes
;
10210 printf (_("\nThe .debug_ranges section is empty.\n"));
10214 get_debug_info (file
);
10216 /* Check the order of range list in .debug_info section. If
10217 offsets of range lists are in the ascending order, we can
10218 use `debug_information' directly. */
10219 for (i
= 0; i
< num_debug_info_entries
; i
++)
10223 num
= debug_information
[i
].num_range_lists
;
10224 num_range_list
+= num
;
10226 /* Check if we can use `debug_information' directly. */
10227 if (use_debug_info
&& num
!= 0)
10229 if (!seen_first_offset
)
10231 /* This is the first range list. */
10232 last_offset
= debug_information
[i
].range_lists
[0];
10234 seen_first_offset
= 1;
10240 for (; j
< num
; j
++)
10243 debug_information
[i
].range_lists
[j
])
10245 use_debug_info
= 0;
10248 last_offset
= debug_information
[i
].range_lists
[j
];
10253 if (!use_debug_info
)
10254 /* FIXME: Should we handle this case? */
10255 error (_("Range lists in .debug_info section aren't in ascending order!\n"));
10257 if (!seen_first_offset
)
10258 error (_("No range lists in .debug_info section!\n"));
10260 if (debug_information
[first
].range_lists
[0] != 0)
10261 warn (_("Range lists in .debug_ranges section start at 0x%lx\n"),
10262 debug_information
[first
].range_lists
[0]);
10264 printf (_("Contents of the .debug_ranges section:\n\n"));
10265 printf (_(" Offset Begin End\n"));
10267 seen_first_offset
= 0;
10268 for (i
= first
; i
< num_debug_info_entries
; i
++)
10270 unsigned long begin
;
10272 unsigned long offset
;
10273 unsigned int pointer_size
;
10274 unsigned long base_address
;
10276 pointer_size
= debug_information
[i
].pointer_size
;
10278 for (j
= 0; j
< debug_information
[i
].num_range_lists
; j
++)
10280 offset
= debug_information
[i
].range_lists
[j
];
10281 next
= section_begin
+ offset
;
10282 base_address
= debug_information
[i
].base_address
;
10284 if (!seen_first_offset
)
10285 seen_first_offset
= 1;
10289 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_ranges section.\n"),
10290 (long)(start
- section_begin
), (long)(next
- section_begin
));
10291 else if (start
> next
)
10292 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_ranges section.\n"),
10293 (long)(start
- section_begin
), (long)(next
- section_begin
));
10299 begin
= byte_get (start
, pointer_size
);
10300 start
+= pointer_size
;
10301 end
= byte_get (start
, pointer_size
);
10302 start
+= pointer_size
;
10304 if (begin
== 0 && end
== 0)
10306 printf (_(" %8.8lx <End of list>\n"), offset
);
10310 /* Check base address specifiers. */
10311 if (begin
== -1UL && end
!= -1UL)
10313 base_address
= end
;
10314 printf (" %8.8lx %8.8lx %8.8lx (base address)\n",
10315 offset
, begin
, end
);
10319 printf (" %8.8lx %8.8lx %8.8lx",
10320 offset
, begin
+ base_address
, end
+ base_address
);
10323 fputs (_(" (start == end)"), stdout
);
10324 else if (begin
> end
)
10325 fputs (_(" (start > end)"), stdout
);
10335 typedef struct Frame_Chunk
10337 struct Frame_Chunk
*next
;
10338 unsigned char *chunk_start
;
10340 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
10341 short int *col_type
;
10343 char *augmentation
;
10344 unsigned int code_factor
;
10346 unsigned long pc_begin
;
10347 unsigned long pc_range
;
10351 unsigned char fde_encoding
;
10352 unsigned char cfa_exp
;
10356 /* A marker for a col_type that means this column was never referenced
10357 in the frame info. */
10358 #define DW_CFA_unreferenced (-1)
10361 frame_need_space (Frame_Chunk
*fc
, int reg
)
10363 int prev
= fc
->ncols
;
10365 if (reg
< fc
->ncols
)
10368 fc
->ncols
= reg
+ 1;
10369 fc
->col_type
= xcrealloc (fc
->col_type
, fc
->ncols
, sizeof (short int));
10370 fc
->col_offset
= xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
10372 while (prev
< fc
->ncols
)
10374 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
10375 fc
->col_offset
[prev
] = 0;
10381 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, int *max_regs
)
10386 if (*max_regs
< fc
->ncols
)
10387 *max_regs
= fc
->ncols
;
10389 if (*need_col_headers
)
10391 *need_col_headers
= 0;
10393 printf (" LOC CFA ");
10395 for (r
= 0; r
< *max_regs
; r
++)
10396 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
10401 printf ("r%-4d", r
);
10407 printf ("%08lx ", fc
->pc_begin
);
10409 strcpy (tmp
, "exp");
10411 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
10412 printf ("%-8s ", tmp
);
10414 for (r
= 0; r
< fc
->ncols
; r
++)
10416 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
10418 switch (fc
->col_type
[r
])
10420 case DW_CFA_undefined
:
10423 case DW_CFA_same_value
:
10426 case DW_CFA_offset
:
10427 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
10429 case DW_CFA_register
:
10430 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
10432 case DW_CFA_expression
:
10433 strcpy (tmp
, "exp");
10436 strcpy (tmp
, "n/a");
10439 printf ("%-5s", tmp
);
10446 size_of_encoded_value (int encoding
)
10448 switch (encoding
& 0x7)
10451 case 0: return eh_addr_size
;
10459 get_encoded_value (unsigned char *data
, int encoding
)
10461 int size
= size_of_encoded_value (encoding
);
10462 if (encoding
& DW_EH_PE_signed
)
10463 return byte_get_signed (data
, size
);
10465 return byte_get (data
, size
);
10468 #define GET(N) byte_get (start, N); start += N
10469 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
10470 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
10473 display_debug_frames (Elf_Internal_Shdr
*section
,
10474 unsigned char *start
,
10475 FILE *file ATTRIBUTE_UNUSED
)
10477 unsigned char *end
= start
+ section
->sh_size
;
10478 unsigned char *section_start
= start
;
10479 Frame_Chunk
*chunks
= 0;
10480 Frame_Chunk
*remembered_state
= 0;
10482 int is_eh
= streq (SECTION_NAME (section
), ".eh_frame");
10483 unsigned int length_return
;
10486 printf (_("The section %s contains:\n"), SECTION_NAME (section
));
10488 while (start
< end
)
10490 unsigned char *saved_start
;
10491 unsigned char *block_end
;
10492 unsigned long length
;
10493 unsigned long cie_id
;
10496 int need_col_headers
= 1;
10497 unsigned char *augmentation_data
= NULL
;
10498 unsigned long augmentation_data_len
= 0;
10499 int encoded_ptr_size
= eh_addr_size
;
10501 int initial_length_size
;
10503 saved_start
= start
;
10504 length
= byte_get (start
, 4); start
+= 4;
10508 printf ("\n%08lx ZERO terminator\n\n",
10509 (unsigned long)(saved_start
- section_start
));
10513 if (length
== 0xffffffff)
10515 length
= byte_get (start
, 8);
10518 initial_length_size
= 12;
10523 initial_length_size
= 4;
10526 block_end
= saved_start
+ length
+ initial_length_size
;
10527 cie_id
= byte_get (start
, offset_size
); start
+= offset_size
;
10529 if (elf_header
.e_type
== ET_REL
10530 && !debug_apply_rela_addends (file
, section
, offset_size
,
10531 section_start
, start
, block_end
))
10534 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
10538 fc
= xmalloc (sizeof (Frame_Chunk
));
10539 memset (fc
, 0, sizeof (Frame_Chunk
));
10543 fc
->chunk_start
= saved_start
;
10545 fc
->col_type
= xmalloc (sizeof (short int));
10546 fc
->col_offset
= xmalloc (sizeof (int));
10547 frame_need_space (fc
, max_regs
-1);
10549 version
= *start
++;
10551 fc
->augmentation
= (char *) start
;
10552 start
= (unsigned char *) strchr ((char *) start
, '\0') + 1;
10554 if (fc
->augmentation
[0] == 'z')
10556 fc
->code_factor
= LEB ();
10557 fc
->data_factor
= SLEB ();
10566 augmentation_data_len
= LEB ();
10567 augmentation_data
= start
;
10568 start
+= augmentation_data_len
;
10570 else if (streq (fc
->augmentation
, "eh"))
10572 start
+= eh_addr_size
;
10573 fc
->code_factor
= LEB ();
10574 fc
->data_factor
= SLEB ();
10586 fc
->code_factor
= LEB ();
10587 fc
->data_factor
= SLEB ();
10599 if (do_debug_frames_interp
)
10600 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
10601 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
10602 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
10606 printf ("\n%08lx %08lx %08lx CIE\n",
10607 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
10608 printf (" Version: %d\n", version
);
10609 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
10610 printf (" Code alignment factor: %u\n", fc
->code_factor
);
10611 printf (" Data alignment factor: %d\n", fc
->data_factor
);
10612 printf (" Return address column: %d\n", fc
->ra
);
10614 if (augmentation_data_len
)
10617 printf (" Augmentation data: ");
10618 for (i
= 0; i
< augmentation_data_len
; ++i
)
10619 printf (" %02x", augmentation_data
[i
]);
10625 if (augmentation_data_len
)
10627 unsigned char *p
, *q
;
10628 p
= (unsigned char *) fc
->augmentation
+ 1;
10629 q
= augmentation_data
;
10635 else if (*p
== 'P')
10636 q
+= 1 + size_of_encoded_value (*q
);
10637 else if (*p
== 'R')
10638 fc
->fde_encoding
= *q
++;
10644 if (fc
->fde_encoding
)
10645 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
10648 frame_need_space (fc
, fc
->ra
);
10652 unsigned char *look_for
;
10653 static Frame_Chunk fde_fc
;
10656 memset (fc
, 0, sizeof (Frame_Chunk
));
10658 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
10660 for (cie
= chunks
; cie
; cie
= cie
->next
)
10661 if (cie
->chunk_start
== look_for
)
10666 warn ("Invalid CIE pointer %08lx in FDE at %p\n",
10667 cie_id
, saved_start
);
10670 fc
->col_type
= xmalloc (sizeof (short int));
10671 fc
->col_offset
= xmalloc (sizeof (int));
10672 frame_need_space (fc
, max_regs
- 1);
10674 fc
->augmentation
= "";
10675 fc
->fde_encoding
= 0;
10679 fc
->ncols
= cie
->ncols
;
10680 fc
->col_type
= xcmalloc (fc
->ncols
, sizeof (short int));
10681 fc
->col_offset
= xcmalloc (fc
->ncols
, sizeof (int));
10682 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
10683 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
10684 fc
->augmentation
= cie
->augmentation
;
10685 fc
->code_factor
= cie
->code_factor
;
10686 fc
->data_factor
= cie
->data_factor
;
10687 fc
->cfa_reg
= cie
->cfa_reg
;
10688 fc
->cfa_offset
= cie
->cfa_offset
;
10690 frame_need_space (fc
, max_regs
-1);
10691 fc
->fde_encoding
= cie
->fde_encoding
;
10694 if (fc
->fde_encoding
)
10695 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
10697 fc
->pc_begin
= get_encoded_value (start
, fc
->fde_encoding
);
10698 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
10699 /* Don't adjust for ET_REL since there's invariably a pcrel
10700 reloc here, which we haven't applied. */
10701 && elf_header
.e_type
!= ET_REL
)
10702 fc
->pc_begin
+= section
->sh_addr
+ (start
- section_start
);
10703 start
+= encoded_ptr_size
;
10704 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
10705 start
+= encoded_ptr_size
;
10707 if (cie
->augmentation
[0] == 'z')
10709 augmentation_data_len
= LEB ();
10710 augmentation_data
= start
;
10711 start
+= augmentation_data_len
;
10714 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
10715 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
10716 (unsigned long)(cie
->chunk_start
- section_start
),
10717 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
10718 if (! do_debug_frames_interp
&& augmentation_data_len
)
10722 printf (" Augmentation data: ");
10723 for (i
= 0; i
< augmentation_data_len
; ++i
)
10724 printf (" %02x", augmentation_data
[i
]);
10730 /* At this point, fc is the current chunk, cie (if any) is set, and
10731 we're about to interpret instructions for the chunk. */
10732 /* ??? At present we need to do this always, since this sizes the
10733 fc->col_type and fc->col_offset arrays, which we write into always.
10734 We should probably split the interpreted and non-interpreted bits
10735 into two different routines, since there's so much that doesn't
10736 really overlap between them. */
10737 if (1 || do_debug_frames_interp
)
10739 /* Start by making a pass over the chunk, allocating storage
10740 and taking note of what registers are used. */
10741 unsigned char *tmp
= start
;
10743 while (start
< block_end
)
10746 unsigned long reg
, tmp
;
10753 /* Warning: if you add any more cases to this switch, be
10754 sure to add them to the corresponding switch below. */
10757 case DW_CFA_advance_loc
:
10759 case DW_CFA_offset
:
10761 frame_need_space (fc
, opa
);
10762 fc
->col_type
[opa
] = DW_CFA_undefined
;
10764 case DW_CFA_restore
:
10765 frame_need_space (fc
, opa
);
10766 fc
->col_type
[opa
] = DW_CFA_undefined
;
10768 case DW_CFA_set_loc
:
10769 start
+= encoded_ptr_size
;
10771 case DW_CFA_advance_loc1
:
10774 case DW_CFA_advance_loc2
:
10777 case DW_CFA_advance_loc4
:
10780 case DW_CFA_offset_extended
:
10781 reg
= LEB (); LEB ();
10782 frame_need_space (fc
, reg
);
10783 fc
->col_type
[reg
] = DW_CFA_undefined
;
10785 case DW_CFA_restore_extended
:
10787 frame_need_space (fc
, reg
);
10788 fc
->col_type
[reg
] = DW_CFA_undefined
;
10790 case DW_CFA_undefined
:
10792 frame_need_space (fc
, reg
);
10793 fc
->col_type
[reg
] = DW_CFA_undefined
;
10795 case DW_CFA_same_value
:
10797 frame_need_space (fc
, reg
);
10798 fc
->col_type
[reg
] = DW_CFA_undefined
;
10800 case DW_CFA_register
:
10801 reg
= LEB (); LEB ();
10802 frame_need_space (fc
, reg
);
10803 fc
->col_type
[reg
] = DW_CFA_undefined
;
10805 case DW_CFA_def_cfa
:
10808 case DW_CFA_def_cfa_register
:
10811 case DW_CFA_def_cfa_offset
:
10814 case DW_CFA_def_cfa_expression
:
10818 case DW_CFA_expression
:
10822 frame_need_space (fc
, reg
);
10823 fc
->col_type
[reg
] = DW_CFA_undefined
;
10825 case DW_CFA_offset_extended_sf
:
10826 reg
= LEB (); SLEB ();
10827 frame_need_space (fc
, reg
);
10828 fc
->col_type
[reg
] = DW_CFA_undefined
;
10830 case DW_CFA_def_cfa_sf
:
10833 case DW_CFA_def_cfa_offset_sf
:
10836 case DW_CFA_MIPS_advance_loc8
:
10839 case DW_CFA_GNU_args_size
:
10842 case DW_CFA_GNU_negative_offset_extended
:
10843 reg
= LEB (); LEB ();
10844 frame_need_space (fc
, reg
);
10845 fc
->col_type
[reg
] = DW_CFA_undefined
;
10854 /* Now we know what registers are used, make a second pass over
10855 the chunk, this time actually printing out the info. */
10857 while (start
< block_end
)
10860 unsigned long ul
, reg
, roffs
;
10869 /* Warning: if you add any more cases to this switch, be
10870 sure to add them to the corresponding switch above. */
10873 case DW_CFA_advance_loc
:
10874 if (do_debug_frames_interp
)
10875 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10877 printf (" DW_CFA_advance_loc: %d to %08lx\n",
10878 opa
* fc
->code_factor
,
10879 fc
->pc_begin
+ opa
* fc
->code_factor
);
10880 fc
->pc_begin
+= opa
* fc
->code_factor
;
10883 case DW_CFA_offset
:
10885 if (! do_debug_frames_interp
)
10886 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
10887 opa
, roffs
* fc
->data_factor
);
10888 fc
->col_type
[opa
] = DW_CFA_offset
;
10889 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
10892 case DW_CFA_restore
:
10893 if (! do_debug_frames_interp
)
10894 printf (" DW_CFA_restore: r%d\n", opa
);
10895 fc
->col_type
[opa
] = cie
->col_type
[opa
];
10896 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
10899 case DW_CFA_set_loc
:
10900 vma
= get_encoded_value (start
, fc
->fde_encoding
);
10901 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
10902 && elf_header
.e_type
!= ET_REL
)
10903 vma
+= section
->sh_addr
+ (start
- section_start
);
10904 start
+= encoded_ptr_size
;
10905 if (do_debug_frames_interp
)
10906 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10908 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
10909 fc
->pc_begin
= vma
;
10912 case DW_CFA_advance_loc1
:
10913 ofs
= byte_get (start
, 1); start
+= 1;
10914 if (do_debug_frames_interp
)
10915 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10917 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
10918 ofs
* fc
->code_factor
,
10919 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10920 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10923 case DW_CFA_advance_loc2
:
10924 ofs
= byte_get (start
, 2); start
+= 2;
10925 if (do_debug_frames_interp
)
10926 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10928 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
10929 ofs
* fc
->code_factor
,
10930 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10931 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10934 case DW_CFA_advance_loc4
:
10935 ofs
= byte_get (start
, 4); start
+= 4;
10936 if (do_debug_frames_interp
)
10937 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10939 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
10940 ofs
* fc
->code_factor
,
10941 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10942 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10945 case DW_CFA_offset_extended
:
10948 if (! do_debug_frames_interp
)
10949 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
10950 reg
, roffs
* fc
->data_factor
);
10951 fc
->col_type
[reg
] = DW_CFA_offset
;
10952 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
10955 case DW_CFA_restore_extended
:
10957 if (! do_debug_frames_interp
)
10958 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
10959 fc
->col_type
[reg
] = cie
->col_type
[reg
];
10960 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
10963 case DW_CFA_undefined
:
10965 if (! do_debug_frames_interp
)
10966 printf (" DW_CFA_undefined: r%ld\n", reg
);
10967 fc
->col_type
[reg
] = DW_CFA_undefined
;
10968 fc
->col_offset
[reg
] = 0;
10971 case DW_CFA_same_value
:
10973 if (! do_debug_frames_interp
)
10974 printf (" DW_CFA_same_value: r%ld\n", reg
);
10975 fc
->col_type
[reg
] = DW_CFA_same_value
;
10976 fc
->col_offset
[reg
] = 0;
10979 case DW_CFA_register
:
10982 if (! do_debug_frames_interp
)
10983 printf (" DW_CFA_register: r%ld in r%ld\n", reg
, roffs
);
10984 fc
->col_type
[reg
] = DW_CFA_register
;
10985 fc
->col_offset
[reg
] = roffs
;
10988 case DW_CFA_remember_state
:
10989 if (! do_debug_frames_interp
)
10990 printf (" DW_CFA_remember_state\n");
10991 rs
= xmalloc (sizeof (Frame_Chunk
));
10992 rs
->ncols
= fc
->ncols
;
10993 rs
->col_type
= xcmalloc (rs
->ncols
, sizeof (short int));
10994 rs
->col_offset
= xcmalloc (rs
->ncols
, sizeof (int));
10995 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
10996 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
10997 rs
->next
= remembered_state
;
10998 remembered_state
= rs
;
11001 case DW_CFA_restore_state
:
11002 if (! do_debug_frames_interp
)
11003 printf (" DW_CFA_restore_state\n");
11004 rs
= remembered_state
;
11007 remembered_state
= rs
->next
;
11008 frame_need_space (fc
, rs
->ncols
-1);
11009 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
11010 memcpy (fc
->col_offset
, rs
->col_offset
,
11011 rs
->ncols
* sizeof (int));
11012 free (rs
->col_type
);
11013 free (rs
->col_offset
);
11016 else if (do_debug_frames_interp
)
11017 printf ("Mismatched DW_CFA_restore_state\n");
11020 case DW_CFA_def_cfa
:
11021 fc
->cfa_reg
= LEB ();
11022 fc
->cfa_offset
= LEB ();
11024 if (! do_debug_frames_interp
)
11025 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
11026 fc
->cfa_reg
, fc
->cfa_offset
);
11029 case DW_CFA_def_cfa_register
:
11030 fc
->cfa_reg
= LEB ();
11032 if (! do_debug_frames_interp
)
11033 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
11036 case DW_CFA_def_cfa_offset
:
11037 fc
->cfa_offset
= LEB ();
11038 if (! do_debug_frames_interp
)
11039 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
11043 if (! do_debug_frames_interp
)
11044 printf (" DW_CFA_nop\n");
11047 case DW_CFA_def_cfa_expression
:
11049 if (! do_debug_frames_interp
)
11051 printf (" DW_CFA_def_cfa_expression (");
11052 decode_location_expression (start
, eh_addr_size
, ul
, 0);
11059 case DW_CFA_expression
:
11062 if (! do_debug_frames_interp
)
11064 printf (" DW_CFA_expression: r%ld (", reg
);
11065 decode_location_expression (start
, eh_addr_size
, ul
, 0);
11068 fc
->col_type
[reg
] = DW_CFA_expression
;
11072 case DW_CFA_offset_extended_sf
:
11075 frame_need_space (fc
, reg
);
11076 if (! do_debug_frames_interp
)
11077 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
11078 reg
, l
* fc
->data_factor
);
11079 fc
->col_type
[reg
] = DW_CFA_offset
;
11080 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
11083 case DW_CFA_def_cfa_sf
:
11084 fc
->cfa_reg
= LEB ();
11085 fc
->cfa_offset
= SLEB ();
11086 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
11088 if (! do_debug_frames_interp
)
11089 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
11090 fc
->cfa_reg
, fc
->cfa_offset
);
11093 case DW_CFA_def_cfa_offset_sf
:
11094 fc
->cfa_offset
= SLEB ();
11095 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
11096 if (! do_debug_frames_interp
)
11097 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
11100 case DW_CFA_MIPS_advance_loc8
:
11101 ofs
= byte_get (start
, 8); start
+= 8;
11102 if (do_debug_frames_interp
)
11103 frame_display_row (fc
, &need_col_headers
, &max_regs
);
11105 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
11106 ofs
* fc
->code_factor
,
11107 fc
->pc_begin
+ ofs
* fc
->code_factor
);
11108 fc
->pc_begin
+= ofs
* fc
->code_factor
;
11111 case DW_CFA_GNU_window_save
:
11112 if (! do_debug_frames_interp
)
11113 printf (" DW_CFA_GNU_window_save\n");
11116 case DW_CFA_GNU_args_size
:
11118 if (! do_debug_frames_interp
)
11119 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
11122 case DW_CFA_GNU_negative_offset_extended
:
11125 frame_need_space (fc
, reg
);
11126 if (! do_debug_frames_interp
)
11127 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
11128 reg
, l
* fc
->data_factor
);
11129 fc
->col_type
[reg
] = DW_CFA_offset
;
11130 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
11134 warn (_("unsupported or unknown DW_CFA_%d\n"), op
);
11139 if (do_debug_frames_interp
)
11140 frame_display_row (fc
, &need_col_headers
, &max_regs
);
11155 display_debug_not_supported (Elf_Internal_Shdr
*section
,
11156 unsigned char *start ATTRIBUTE_UNUSED
,
11157 FILE *file ATTRIBUTE_UNUSED
)
11159 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
11160 SECTION_NAME (section
));
11165 /* A structure containing the name of a debug section
11166 and a pointer to a function that can decode it. */
11169 const char *const name
;
11170 int (*display
) (Elf_Internal_Shdr
*, unsigned char *, FILE *);
11174 { ".debug_abbrev", display_debug_abbrev
},
11175 { ".debug_aranges", display_debug_aranges
},
11176 { ".debug_frame", display_debug_frames
},
11177 { ".debug_info", display_debug_info
},
11178 { ".debug_line", display_debug_lines
},
11179 { ".debug_pubnames", display_debug_pubnames
},
11180 { ".eh_frame", display_debug_frames
},
11181 { ".debug_macinfo", display_debug_macinfo
},
11182 { ".debug_str", display_debug_str
},
11183 { ".debug_loc", display_debug_loc
},
11184 { ".debug_pubtypes", display_debug_pubnames
},
11185 { ".debug_ranges", display_debug_ranges
},
11186 { ".debug_static_func", display_debug_not_supported
},
11187 { ".debug_static_vars", display_debug_not_supported
},
11188 { ".debug_types", display_debug_not_supported
},
11189 { ".debug_weaknames", display_debug_not_supported
}
11193 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
11195 char *name
= SECTION_NAME (section
);
11196 bfd_size_type length
;
11200 length
= section
->sh_size
;
11203 printf (_("\nSection '%s' has no debugging data.\n"), name
);
11207 if (strneq (name
, ".gnu.linkonce.wi.", 17))
11208 name
= ".debug_info";
11210 /* See if we know how to display the contents of this section. */
11211 for (i
= NUM_ELEM (debug_displays
); i
--;)
11212 if (streq (debug_displays
[i
].name
, name
))
11214 unsigned char *start
;
11216 start
= get_data (NULL
, file
, section
->sh_offset
, 1, length
,
11217 _("debug section data"));
11224 result
&= debug_displays
[i
].display (section
, start
, file
);
11227 /* If we loaded in the abbrev section
11228 at some point, we must release it here. */
11236 printf (_("Unrecognized debug section: %s\n"), name
);
11244 process_section_contents (FILE *file
)
11246 Elf_Internal_Shdr
*section
;
11252 for (i
= 0, section
= section_headers
;
11253 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
11256 #ifdef SUPPORT_DISASSEMBLY
11257 if (dump_sects
[i
] & DISASS_DUMP
)
11258 disassemble_section (section
, file
);
11260 if (dump_sects
[i
] & HEX_DUMP
)
11261 dump_section (section
, file
);
11263 if (dump_sects
[i
] & DEBUG_DUMP
)
11264 display_debug_section (section
, file
);
11267 /* Check to see if the user requested a
11268 dump of a section that does not exist. */
11269 while (i
++ < num_dump_sects
)
11271 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
11275 process_mips_fpe_exception (int mask
)
11280 if (mask
& OEX_FPU_INEX
)
11281 fputs ("INEX", stdout
), first
= 0;
11282 if (mask
& OEX_FPU_UFLO
)
11283 printf ("%sUFLO", first
? "" : "|"), first
= 0;
11284 if (mask
& OEX_FPU_OFLO
)
11285 printf ("%sOFLO", first
? "" : "|"), first
= 0;
11286 if (mask
& OEX_FPU_DIV0
)
11287 printf ("%sDIV0", first
? "" : "|"), first
= 0;
11288 if (mask
& OEX_FPU_INVAL
)
11289 printf ("%sINVAL", first
? "" : "|");
11292 fputs ("0", stdout
);
11296 process_mips_specific (FILE *file
)
11298 Elf_Internal_Dyn
*entry
;
11299 size_t liblist_offset
= 0;
11300 size_t liblistno
= 0;
11301 size_t conflictsno
= 0;
11302 size_t options_offset
= 0;
11303 size_t conflicts_offset
= 0;
11305 /* We have a lot of special sections. Thanks SGI! */
11306 if (dynamic_section
== NULL
)
11307 /* No information available. */
11310 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
11311 switch (entry
->d_tag
)
11313 case DT_MIPS_LIBLIST
:
11315 = offset_from_vma (file
, entry
->d_un
.d_val
,
11316 liblistno
* sizeof (Elf32_External_Lib
));
11318 case DT_MIPS_LIBLISTNO
:
11319 liblistno
= entry
->d_un
.d_val
;
11321 case DT_MIPS_OPTIONS
:
11322 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
11324 case DT_MIPS_CONFLICT
:
11326 = offset_from_vma (file
, entry
->d_un
.d_val
,
11327 conflictsno
* sizeof (Elf32_External_Conflict
));
11329 case DT_MIPS_CONFLICTNO
:
11330 conflictsno
= entry
->d_un
.d_val
;
11336 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
11338 Elf32_External_Lib
*elib
;
11341 elib
= get_data (NULL
, file
, liblist_offset
,
11342 liblistno
, sizeof (Elf32_External_Lib
),
11346 printf ("\nSection '.liblist' contains %lu entries:\n",
11347 (unsigned long) liblistno
);
11348 fputs (" Library Time Stamp Checksum Version Flags\n",
11351 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
11358 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
11359 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
11360 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
11361 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
11362 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
11364 tmp
= gmtime (&time
);
11365 snprintf (timebuf
, sizeof (timebuf
),
11366 "%04u-%02u-%02uT%02u:%02u:%02u",
11367 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11368 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11370 printf ("%3lu: ", (unsigned long) cnt
);
11371 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
11372 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
11374 printf ("<corrupt: %9ld>", liblist
.l_name
);
11375 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
11376 liblist
.l_version
);
11378 if (liblist
.l_flags
== 0)
11382 static const struct
11389 { " EXACT_MATCH", LL_EXACT_MATCH
},
11390 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
11391 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
11392 { " EXPORTS", LL_EXPORTS
},
11393 { " DELAY_LOAD", LL_DELAY_LOAD
},
11394 { " DELTA", LL_DELTA
}
11396 int flags
= liblist
.l_flags
;
11400 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
11402 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
11404 fputs (l_flags_vals
[fcnt
].name
, stdout
);
11405 flags
^= l_flags_vals
[fcnt
].bit
;
11408 printf (" %#x", (unsigned int) flags
);
11418 if (options_offset
!= 0)
11420 Elf_External_Options
*eopt
;
11421 Elf_Internal_Shdr
*sect
= section_headers
;
11422 Elf_Internal_Options
*iopt
;
11423 Elf_Internal_Options
*option
;
11427 /* Find the section header so that we get the size. */
11428 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
11431 eopt
= get_data (NULL
, file
, options_offset
, 1, sect
->sh_size
,
11435 iopt
= cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (*iopt
));
11438 error (_("Out of memory"));
11445 while (offset
< sect
->sh_size
)
11447 Elf_External_Options
*eoption
;
11449 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
11451 option
->kind
= BYTE_GET (eoption
->kind
);
11452 option
->size
= BYTE_GET (eoption
->size
);
11453 option
->section
= BYTE_GET (eoption
->section
);
11454 option
->info
= BYTE_GET (eoption
->info
);
11456 offset
+= option
->size
;
11462 printf (_("\nSection '%s' contains %d entries:\n"),
11463 SECTION_NAME (sect
), cnt
);
11471 switch (option
->kind
)
11474 /* This shouldn't happen. */
11475 printf (" NULL %d %lx", option
->section
, option
->info
);
11478 printf (" REGINFO ");
11479 if (elf_header
.e_machine
== EM_MIPS
)
11482 Elf32_External_RegInfo
*ereg
;
11483 Elf32_RegInfo reginfo
;
11485 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
11486 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
11487 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
11488 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
11489 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
11490 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
11491 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
11493 printf ("GPR %08lx GP 0x%lx\n",
11494 reginfo
.ri_gprmask
,
11495 (unsigned long) reginfo
.ri_gp_value
);
11496 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11497 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11498 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11503 Elf64_External_RegInfo
*ereg
;
11504 Elf64_Internal_RegInfo reginfo
;
11506 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
11507 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
11508 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
11509 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
11510 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
11511 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
11512 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
11514 printf ("GPR %08lx GP 0x",
11515 reginfo
.ri_gprmask
);
11516 printf_vma (reginfo
.ri_gp_value
);
11519 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11520 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11521 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11525 case ODK_EXCEPTIONS
:
11526 fputs (" EXCEPTIONS fpe_min(", stdout
);
11527 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
11528 fputs (") fpe_max(", stdout
);
11529 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
11530 fputs (")", stdout
);
11532 if (option
->info
& OEX_PAGE0
)
11533 fputs (" PAGE0", stdout
);
11534 if (option
->info
& OEX_SMM
)
11535 fputs (" SMM", stdout
);
11536 if (option
->info
& OEX_FPDBUG
)
11537 fputs (" FPDBUG", stdout
);
11538 if (option
->info
& OEX_DISMISS
)
11539 fputs (" DISMISS", stdout
);
11542 fputs (" PAD ", stdout
);
11543 if (option
->info
& OPAD_PREFIX
)
11544 fputs (" PREFIX", stdout
);
11545 if (option
->info
& OPAD_POSTFIX
)
11546 fputs (" POSTFIX", stdout
);
11547 if (option
->info
& OPAD_SYMBOL
)
11548 fputs (" SYMBOL", stdout
);
11551 fputs (" HWPATCH ", stdout
);
11552 if (option
->info
& OHW_R4KEOP
)
11553 fputs (" R4KEOP", stdout
);
11554 if (option
->info
& OHW_R8KPFETCH
)
11555 fputs (" R8KPFETCH", stdout
);
11556 if (option
->info
& OHW_R5KEOP
)
11557 fputs (" R5KEOP", stdout
);
11558 if (option
->info
& OHW_R5KCVTL
)
11559 fputs (" R5KCVTL", stdout
);
11562 fputs (" FILL ", stdout
);
11563 /* XXX Print content of info word? */
11566 fputs (" TAGS ", stdout
);
11567 /* XXX Print content of info word? */
11570 fputs (" HWAND ", stdout
);
11571 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11572 fputs (" R4KEOP_CHECKED", stdout
);
11573 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11574 fputs (" R4KEOP_CLEAN", stdout
);
11577 fputs (" HWOR ", stdout
);
11578 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11579 fputs (" R4KEOP_CHECKED", stdout
);
11580 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11581 fputs (" R4KEOP_CLEAN", stdout
);
11584 printf (" GP_GROUP %#06lx self-contained %#06lx",
11585 option
->info
& OGP_GROUP
,
11586 (option
->info
& OGP_SELF
) >> 16);
11589 printf (" IDENT %#06lx self-contained %#06lx",
11590 option
->info
& OGP_GROUP
,
11591 (option
->info
& OGP_SELF
) >> 16);
11594 /* This shouldn't happen. */
11595 printf (" %3d ??? %d %lx",
11596 option
->kind
, option
->section
, option
->info
);
11600 len
= sizeof (*eopt
);
11601 while (len
< option
->size
)
11602 if (((char *) option
)[len
] >= ' '
11603 && ((char *) option
)[len
] < 0x7f)
11604 printf ("%c", ((char *) option
)[len
++]);
11606 printf ("\\%03o", ((char *) option
)[len
++]);
11608 fputs ("\n", stdout
);
11616 if (conflicts_offset
!= 0 && conflictsno
!= 0)
11618 Elf32_Conflict
*iconf
;
11621 if (dynamic_symbols
== NULL
)
11623 error (_("conflict list found without a dynamic symbol table"));
11627 iconf
= cmalloc (conflictsno
, sizeof (*iconf
));
11630 error (_("Out of memory"));
11636 Elf32_External_Conflict
*econf32
;
11638 econf32
= get_data (NULL
, file
, conflicts_offset
,
11639 conflictsno
, sizeof (*econf32
), _("conflict"));
11643 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11644 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
11650 Elf64_External_Conflict
*econf64
;
11652 econf64
= get_data (NULL
, file
, conflicts_offset
,
11653 conflictsno
, sizeof (*econf64
), _("conflict"));
11657 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11658 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
11663 printf (_("\nSection '.conflict' contains %lu entries:\n"),
11664 (unsigned long) conflictsno
);
11665 puts (_(" Num: Index Value Name"));
11667 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11669 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
11671 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
11672 print_vma (psym
->st_value
, FULL_HEX
);
11674 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11675 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11677 printf ("<corrupt: %14ld>", psym
->st_name
);
11688 process_gnu_liblist (FILE *file
)
11690 Elf_Internal_Shdr
*section
, *string_sec
;
11691 Elf32_External_Lib
*elib
;
11693 size_t strtab_size
;
11700 for (i
= 0, section
= section_headers
;
11701 i
< elf_header
.e_shnum
;
11704 switch (section
->sh_type
)
11706 case SHT_GNU_LIBLIST
:
11707 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
)
11710 elib
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
11715 string_sec
= SECTION_HEADER (section
->sh_link
);
11717 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
11718 string_sec
->sh_size
, _("liblist string table"));
11719 strtab_size
= string_sec
->sh_size
;
11722 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
11728 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
11729 SECTION_NAME (section
),
11730 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
11732 puts (" Library Time Stamp Checksum Version Flags");
11734 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
11742 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
11743 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
11744 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
11745 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
11746 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
11748 tmp
= gmtime (&time
);
11749 snprintf (timebuf
, sizeof (timebuf
),
11750 "%04u-%02u-%02uT%02u:%02u:%02u",
11751 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11752 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11754 printf ("%3lu: ", (unsigned long) cnt
);
11756 printf ("%-20s", liblist
.l_name
< strtab_size
11757 ? strtab
+ liblist
.l_name
: "<corrupt>");
11759 printf ("%-20.20s", liblist
.l_name
< strtab_size
11760 ? strtab
+ liblist
.l_name
: "<corrupt>");
11761 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
11762 liblist
.l_version
, liblist
.l_flags
);
11772 static const char *
11773 get_note_type (unsigned e_type
)
11775 static char buff
[64];
11777 if (elf_header
.e_type
== ET_CORE
)
11781 return _("NT_AUXV (auxiliary vector)");
11783 return _("NT_PRSTATUS (prstatus structure)");
11785 return _("NT_FPREGSET (floating point registers)");
11787 return _("NT_PRPSINFO (prpsinfo structure)");
11788 case NT_TASKSTRUCT
:
11789 return _("NT_TASKSTRUCT (task structure)");
11791 return _("NT_PRXFPREG (user_xfpregs structure)");
11793 return _("NT_PSTATUS (pstatus structure)");
11795 return _("NT_FPREGS (floating point registers)");
11797 return _("NT_PSINFO (psinfo structure)");
11799 return _("NT_LWPSTATUS (lwpstatus_t structure)");
11801 return _("NT_LWPSINFO (lwpsinfo_t structure)");
11802 case NT_WIN32PSTATUS
:
11803 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
11811 return _("NT_VERSION (version)");
11813 return _("NT_ARCH (architecture)");
11818 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11822 static const char *
11823 get_netbsd_elfcore_note_type (unsigned e_type
)
11825 static char buff
[64];
11827 if (e_type
== NT_NETBSDCORE_PROCINFO
)
11829 /* NetBSD core "procinfo" structure. */
11830 return _("NetBSD procinfo structure");
11833 /* As of Jan 2002 there are no other machine-independent notes
11834 defined for NetBSD core files. If the note type is less
11835 than the start of the machine-dependent note types, we don't
11838 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
11840 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11844 switch (elf_header
.e_machine
)
11846 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
11847 and PT_GETFPREGS == mach+2. */
11852 case EM_SPARC32PLUS
:
11856 case NT_NETBSDCORE_FIRSTMACH
+0:
11857 return _("PT_GETREGS (reg structure)");
11858 case NT_NETBSDCORE_FIRSTMACH
+2:
11859 return _("PT_GETFPREGS (fpreg structure)");
11865 /* On all other arch's, PT_GETREGS == mach+1 and
11866 PT_GETFPREGS == mach+3. */
11870 case NT_NETBSDCORE_FIRSTMACH
+1:
11871 return _("PT_GETREGS (reg structure)");
11872 case NT_NETBSDCORE_FIRSTMACH
+3:
11873 return _("PT_GETFPREGS (fpreg structure)");
11879 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
11880 e_type
- NT_NETBSDCORE_FIRSTMACH
);
11884 /* Note that by the ELF standard, the name field is already null byte
11885 terminated, and namesz includes the terminating null byte.
11886 I.E. the value of namesz for the name "FSF" is 4.
11888 If the value of namesz is zero, there is no name present. */
11890 process_note (Elf_Internal_Note
*pnote
)
11894 if (pnote
->namesz
== 0)
11895 /* If there is no note name, then use the default set of
11896 note type strings. */
11897 nt
= get_note_type (pnote
->type
);
11899 else if (strneq (pnote
->namedata
, "NetBSD-CORE", 11))
11900 /* NetBSD-specific core file notes. */
11901 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
11904 /* Don't recognize this note name; just use the default set of
11905 note type strings. */
11906 nt
= get_note_type (pnote
->type
);
11908 printf (" %s\t\t0x%08lx\t%s\n",
11909 pnote
->namesz
? pnote
->namedata
: "(NONE)",
11910 pnote
->descsz
, nt
);
11916 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
11918 Elf_External_Note
*pnotes
;
11919 Elf_External_Note
*external
;
11925 pnotes
= get_data (NULL
, file
, offset
, 1, length
, _("notes"));
11931 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
11932 (unsigned long) offset
, (unsigned long) length
);
11933 printf (_(" Owner\t\tData size\tDescription\n"));
11935 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
11937 Elf_External_Note
*next
;
11938 Elf_Internal_Note inote
;
11941 inote
.type
= BYTE_GET (external
->type
);
11942 inote
.namesz
= BYTE_GET (external
->namesz
);
11943 inote
.namedata
= external
->name
;
11944 inote
.descsz
= BYTE_GET (external
->descsz
);
11945 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
11946 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
11948 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
11950 if (((char *) next
) > (((char *) pnotes
) + length
))
11952 warn (_("corrupt note found at offset %lx into core notes\n"),
11953 (long)((char *)external
- (char *)pnotes
));
11954 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
11955 inote
.type
, inote
.namesz
, inote
.descsz
);
11961 /* Verify that name is null terminated. It appears that at least
11962 one version of Linux (RedHat 6.0) generates corefiles that don't
11963 comply with the ELF spec by failing to include the null byte in
11965 if (inote
.namedata
[inote
.namesz
] != '\0')
11967 temp
= malloc (inote
.namesz
+ 1);
11971 error (_("Out of memory\n"));
11976 strncpy (temp
, inote
.namedata
, inote
.namesz
);
11977 temp
[inote
.namesz
] = 0;
11979 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
11980 inote
.namedata
= temp
;
11983 res
&= process_note (& inote
);
11998 process_corefile_note_segments (FILE *file
)
12000 Elf_Internal_Phdr
*segment
;
12004 if (! get_program_headers (file
))
12007 for (i
= 0, segment
= program_headers
;
12008 i
< elf_header
.e_phnum
;
12011 if (segment
->p_type
== PT_NOTE
)
12012 res
&= process_corefile_note_segment (file
,
12013 (bfd_vma
) segment
->p_offset
,
12014 (bfd_vma
) segment
->p_filesz
);
12021 process_note_sections (FILE *file
)
12023 Elf_Internal_Shdr
*section
;
12027 for (i
= 0, section
= section_headers
;
12028 i
< elf_header
.e_shnum
;
12030 if (section
->sh_type
== SHT_NOTE
)
12031 res
&= process_corefile_note_segment (file
,
12032 (bfd_vma
) section
->sh_offset
,
12033 (bfd_vma
) section
->sh_size
);
12039 process_notes (FILE *file
)
12041 /* If we have not been asked to display the notes then do nothing. */
12045 if (elf_header
.e_type
!= ET_CORE
)
12046 return process_note_sections (file
);
12048 /* No program headers means no NOTE segment. */
12049 if (elf_header
.e_phnum
> 0)
12050 return process_corefile_note_segments (file
);
12052 printf (_("No note segments present in the core file.\n"));
12057 process_arch_specific (FILE *file
)
12062 switch (elf_header
.e_machine
)
12065 case EM_MIPS_RS3_LE
:
12066 return process_mips_specific (file
);
12075 get_file_header (FILE *file
)
12077 /* Read in the identity array. */
12078 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
12081 /* Determine how to read the rest of the header. */
12082 switch (elf_header
.e_ident
[EI_DATA
])
12084 default: /* fall through */
12085 case ELFDATANONE
: /* fall through */
12087 byte_get
= byte_get_little_endian
;
12088 byte_put
= byte_put_little_endian
;
12091 byte_get
= byte_get_big_endian
;
12092 byte_put
= byte_put_big_endian
;
12096 /* For now we only support 32 bit and 64 bit ELF files. */
12097 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
12099 /* Read in the rest of the header. */
12102 Elf32_External_Ehdr ehdr32
;
12104 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
12107 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
12108 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
12109 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
12110 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
12111 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
12112 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
12113 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
12114 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
12115 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
12116 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
12117 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
12118 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
12119 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
12123 Elf64_External_Ehdr ehdr64
;
12125 /* If we have been compiled with sizeof (bfd_vma) == 4, then
12126 we will not be able to cope with the 64bit data found in
12127 64 ELF files. Detect this now and abort before we start
12128 overwriting things. */
12129 if (sizeof (bfd_vma
) < 8)
12131 error (_("This instance of readelf has been built without support for a\n\
12132 64 bit data type and so it cannot read 64 bit ELF files.\n"));
12136 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
12139 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
12140 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
12141 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
12142 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
12143 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
12144 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
12145 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
12146 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
12147 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
12148 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
12149 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
12150 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
12151 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
12154 if (elf_header
.e_shoff
)
12156 /* There may be some extensions in the first section header. Don't
12157 bomb if we can't read it. */
12159 get_32bit_section_headers (file
, 1);
12161 get_64bit_section_headers (file
, 1);
12167 /* Process one ELF object file according to the command line options.
12168 This file may actually be stored in an archive. The file is
12169 positioned at the start of the ELF object. */
12172 process_object (char *file_name
, FILE *file
)
12176 if (! get_file_header (file
))
12178 error (_("%s: Failed to read file header\n"), file_name
);
12182 /* Initialise per file variables. */
12183 for (i
= NUM_ELEM (version_info
); i
--;)
12184 version_info
[i
] = 0;
12186 for (i
= NUM_ELEM (dynamic_info
); i
--;)
12187 dynamic_info
[i
] = 0;
12189 /* Process the file. */
12191 printf (_("\nFile: %s\n"), file_name
);
12193 /* Initialise the dump_sects array from the cmdline_dump_sects array.
12194 Note we do this even if cmdline_dump_sects is empty because we
12195 must make sure that the dump_sets array is zeroed out before each
12196 object file is processed. */
12197 if (num_dump_sects
> num_cmdline_dump_sects
)
12198 memset (dump_sects
, 0, num_dump_sects
);
12200 if (num_cmdline_dump_sects
> 0)
12202 if (num_dump_sects
== 0)
12203 /* A sneaky way of allocating the dump_sects array. */
12204 request_dump (num_cmdline_dump_sects
, 0);
12206 assert (num_dump_sects
>= num_cmdline_dump_sects
);
12207 memcpy (dump_sects
, cmdline_dump_sects
, num_cmdline_dump_sects
);
12210 if (! process_file_header ())
12213 if (! process_section_headers (file
))
12215 /* Without loaded section headers we cannot process lots of
12217 do_unwind
= do_version
= do_dump
= do_arch
= 0;
12219 if (! do_using_dynamic
)
12220 do_syms
= do_reloc
= 0;
12223 if (! process_section_groups (file
))
12225 /* Without loaded section groups we cannot process unwind. */
12229 if (process_program_headers (file
))
12230 process_dynamic_section (file
);
12232 process_relocs (file
);
12234 process_unwind (file
);
12236 process_symbol_table (file
);
12238 process_syminfo (file
);
12240 process_version_sections (file
);
12242 process_section_contents (file
);
12244 process_notes (file
);
12246 process_gnu_liblist (file
);
12248 process_arch_specific (file
);
12250 if (program_headers
)
12252 free (program_headers
);
12253 program_headers
= NULL
;
12256 if (section_headers
)
12258 free (section_headers
);
12259 section_headers
= NULL
;
12264 free (string_table
);
12265 string_table
= NULL
;
12266 string_table_length
= 0;
12269 if (dynamic_strings
)
12271 free (dynamic_strings
);
12272 dynamic_strings
= NULL
;
12273 dynamic_strings_length
= 0;
12276 if (dynamic_symbols
)
12278 free (dynamic_symbols
);
12279 dynamic_symbols
= NULL
;
12280 num_dynamic_syms
= 0;
12283 if (dynamic_syminfo
)
12285 free (dynamic_syminfo
);
12286 dynamic_syminfo
= NULL
;
12289 if (section_headers_groups
)
12291 free (section_headers_groups
);
12292 section_headers_groups
= NULL
;
12295 if (section_groups
)
12297 struct group_list
*g
, *next
;
12299 for (i
= 0; i
< group_count
; i
++)
12301 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
12308 free (section_groups
);
12309 section_groups
= NULL
;
12312 if (debug_information
)
12314 for (i
= 0; i
< num_debug_info_entries
; i
++)
12316 if (!debug_information
[i
].max_loc_offsets
)
12318 free (debug_information
[i
].loc_offsets
);
12319 free (debug_information
[i
].have_frame_base
);
12321 if (!debug_information
[i
].max_range_lists
)
12322 free (debug_information
[i
].range_lists
);
12324 free (debug_information
);
12325 debug_information
= NULL
;
12326 num_debug_info_entries
= 0;
12332 /* Process an ELF archive. The file is positioned just after the
12336 process_archive (char *file_name
, FILE *file
)
12338 struct ar_hdr arhdr
;
12340 unsigned long size
;
12341 char *longnames
= NULL
;
12342 unsigned long longnames_size
= 0;
12343 size_t file_name_size
;
12348 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12349 if (got
!= sizeof arhdr
)
12354 error (_("%s: failed to read archive header\n"), file_name
);
12358 if (memcmp (arhdr
.ar_name
, "/ ", 16) == 0)
12360 /* This is the archive symbol table. Skip it.
12361 FIXME: We should have an option to dump it. */
12362 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
12363 if (fseek (file
, size
+ (size
& 1), SEEK_CUR
) != 0)
12365 error (_("%s: failed to skip archive symbol table\n"), file_name
);
12369 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12370 if (got
!= sizeof arhdr
)
12375 error (_("%s: failed to read archive header\n"), file_name
);
12380 if (memcmp (arhdr
.ar_name
, "// ", 16) == 0)
12382 /* This is the archive string table holding long member
12385 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
12387 longnames
= malloc (longnames_size
);
12388 if (longnames
== NULL
)
12390 error (_("Out of memory\n"));
12394 if (fread (longnames
, longnames_size
, 1, file
) != 1)
12397 error (_("%s: failed to read string table\n"), file_name
);
12401 if ((longnames_size
& 1) != 0)
12404 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12405 if (got
!= sizeof arhdr
)
12412 error (_("%s: failed to read archive header\n"), file_name
);
12417 file_name_size
= strlen (file_name
);
12426 if (arhdr
.ar_name
[0] == '/')
12430 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
12431 if (off
>= longnames_size
)
12433 error (_("%s: invalid archive string table offset %lu\n"), file_name
, off
);
12438 name
= longnames
+ off
;
12439 nameend
= memchr (name
, '/', longnames_size
- off
);
12443 name
= arhdr
.ar_name
;
12444 nameend
= memchr (name
, '/', 16);
12447 if (nameend
== NULL
)
12449 error (_("%s: bad archive file name\n"), file_name
);
12454 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
12455 if (namealc
== NULL
)
12457 error (_("Out of memory\n"));
12462 memcpy (namealc
, file_name
, file_name_size
);
12463 namealc
[file_name_size
] = '(';
12464 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
12465 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
12466 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
12468 archive_file_offset
= ftell (file
);
12469 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
12471 ret
|= process_object (namealc
, file
);
12476 (archive_file_offset
12477 + archive_file_size
12478 + (archive_file_size
& 1)),
12481 error (_("%s: failed to seek to next archive header\n"), file_name
);
12486 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12487 if (got
!= sizeof arhdr
)
12492 error (_("%s: failed to read archive header\n"), file_name
);
12498 if (longnames
!= 0)
12505 process_file (char *file_name
)
12508 struct stat statbuf
;
12509 char armag
[SARMAG
];
12512 if (stat (file_name
, &statbuf
) < 0)
12514 if (errno
== ENOENT
)
12515 error (_("'%s': No such file\n"), file_name
);
12517 error (_("Could not locate '%s'. System error message: %s\n"),
12518 file_name
, strerror (errno
));
12522 if (! S_ISREG (statbuf
.st_mode
))
12524 error (_("'%s' is not an ordinary file\n"), file_name
);
12528 file
= fopen (file_name
, "rb");
12531 error (_("Input file '%s' is not readable.\n"), file_name
);
12535 if (fread (armag
, SARMAG
, 1, file
) != 1)
12537 error (_("%s: Failed to read file header\n"), file_name
);
12542 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
12543 ret
= process_archive (file_name
, file
);
12547 archive_file_size
= archive_file_offset
= 0;
12548 ret
= process_object (file_name
, file
);
12556 #ifdef SUPPORT_DISASSEMBLY
12557 /* Needed by the i386 disassembler. For extra credit, someone could
12558 fix this so that we insert symbolic addresses here, esp for GOT/PLT
12562 print_address (unsigned int addr
, FILE *outfile
)
12564 fprintf (outfile
,"0x%8.8x", addr
);
12567 /* Needed by the i386 disassembler. */
12569 db_task_printsym (unsigned int addr
)
12571 print_address (addr
, stderr
);
12576 main (int argc
, char **argv
)
12580 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
12581 setlocale (LC_MESSAGES
, "");
12583 #if defined (HAVE_SETLOCALE)
12584 setlocale (LC_CTYPE
, "");
12586 bindtextdomain (PACKAGE
, LOCALEDIR
);
12587 textdomain (PACKAGE
);
12589 parse_args (argc
, argv
);
12591 if (num_dump_sects
> 0)
12593 /* Make a copy of the dump_sects array. */
12594 cmdline_dump_sects
= malloc (num_dump_sects
);
12595 if (cmdline_dump_sects
== NULL
)
12596 error (_("Out of memory allocating dump request table."));
12599 memcpy (cmdline_dump_sects
, dump_sects
, num_dump_sects
);
12600 num_cmdline_dump_sects
= num_dump_sects
;
12604 if (optind
< (argc
- 1))
12608 while (optind
< argc
)
12609 err
|= process_file (argv
[optind
++]);
12611 if (dump_sects
!= NULL
)
12613 if (cmdline_dump_sects
!= NULL
)
12614 free (cmdline_dump_sects
);