1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
3 Free Software Foundation, Inc.
5 Originally developed by Eric Youngdale <eric@andante.jic.com>
6 Modifications by Nick Clifton <nickc@redhat.com>
8 This file is part of GNU Binutils.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
25 /* The difference between readelf and objdump:
27 Both programs are capable of displaying the contents of ELF format files,
28 so why does the binutils project have two file dumpers ?
30 The reason is that objdump sees an ELF file through a BFD filter of the
31 world; if BFD has a bug where, say, it disagrees about a machine constant
32 in e_flags, then the odds are good that it will remain internally
33 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
34 GAS sees it the BFD way. There was need for a tool to go find out what
35 the file actually says.
37 This is why the readelf program does not link against the BFD library - it
38 exists as an independent program to help verify the correct working of BFD.
40 There is also the case that readelf can provide more information about an
41 ELF file than is provided by objdump. In particular it can display DWARF
42 debugging information which (at the moment) objdump cannot. */
45 #include <sys/types.h>
51 /* Define BFD64 here, even if our default architecture is 32 bit ELF
52 as this will allow us to read in and parse 64bit and 32bit ELF files.
53 Only do this if we believe that the compiler can support a 64 bit
54 data type. For now we only rely on GCC being able to do this. */
60 #include "elf/common.h"
61 #include "elf/external.h"
62 #include "elf/internal.h"
63 #include "elf/dwarf2.h"
65 /* The following headers use the elf/reloc-macros.h file to
66 automatically generate relocation recognition functions
67 such as elf_mips_reloc_type() */
69 #define RELOC_MACROS_GEN_FUNC
71 #include "elf/alpha.h"
92 #include "elf/m68hc11.h"
93 #include "elf/mcore.h"
96 #include "elf/mn10200.h"
97 #include "elf/mn10300.h"
99 #include "elf/msp430.h"
100 #include "elf/or32.h"
103 #include "elf/ppc64.h"
104 #include "elf/s390.h"
106 #include "elf/sparc.h"
107 #include "elf/v850.h"
109 #include "elf/x86-64.h"
110 #include "elf/xstormy16.h"
112 #include "elf/iq2000.h"
113 #include "elf/xtensa.h"
119 #include "libiberty.h"
121 char *program_name
= "readelf";
122 static long archive_file_offset
;
123 static unsigned long archive_file_size
;
124 static unsigned long dynamic_addr
;
125 static bfd_size_type dynamic_size
;
126 static unsigned int dynamic_nent
;
127 static char *dynamic_strings
;
128 static unsigned long dynamic_strings_length
;
129 static char *string_table
;
130 static unsigned long string_table_length
;
131 static unsigned long num_dynamic_syms
;
132 static Elf_Internal_Sym
*dynamic_symbols
;
133 static Elf_Internal_Syminfo
*dynamic_syminfo
;
134 static unsigned long dynamic_syminfo_offset
;
135 static unsigned int dynamic_syminfo_nent
;
136 static char program_interpreter
[64];
137 static bfd_vma dynamic_info
[DT_JMPREL
+ 1];
138 static bfd_vma version_info
[16];
139 static Elf_Internal_Ehdr elf_header
;
140 static Elf_Internal_Shdr
*section_headers
;
141 static Elf_Internal_Phdr
*program_headers
;
142 static Elf_Internal_Dyn
*dynamic_section
;
143 static Elf_Internal_Shdr
*symtab_shndx_hdr
;
144 static int show_name
;
145 static int do_dynamic
;
148 static int do_sections
;
149 static int do_section_groups
;
150 static int do_section_details
;
151 static int do_segments
;
152 static int do_unwind
;
153 static int do_using_dynamic
;
154 static int do_header
;
156 static int do_version
;
158 static int do_histogram
;
159 static int do_debugging
;
160 static int do_debug_info
;
161 static int do_debug_abbrevs
;
162 static int do_debug_lines
;
163 static int do_debug_pubnames
;
164 static int do_debug_aranges
;
165 static int do_debug_ranges
;
166 static int do_debug_frames
;
167 static int do_debug_frames_interp
;
168 static int do_debug_macinfo
;
169 static int do_debug_str
;
170 static int do_debug_loc
;
173 static int is_32bit_elf
;
174 static int have_frame_base
;
175 static int need_base_address
;
176 static bfd_vma eh_addr_size
;
180 struct group_list
*next
;
181 unsigned int section_index
;
186 struct group_list
*root
;
187 unsigned int group_index
;
190 static size_t group_count
;
191 static struct group
*section_groups
;
192 static struct group
**section_headers_groups
;
194 /* A dynamic array of flags indicating for which sections a hex dump
195 has been requested (via the -x switch) and/or a disassembly dump
196 (via the -i switch). */
197 char *cmdline_dump_sects
= NULL
;
198 unsigned num_cmdline_dump_sects
= 0;
200 /* A dynamic array of flags indicating for which sections a dump of
201 some kind has been requested. It is reset on a per-object file
202 basis and then initialised from the cmdline_dump_sects array and
203 the results of interpreting the -w switch. */
204 char *dump_sects
= NULL
;
205 unsigned int num_dump_sects
= 0;
207 #define HEX_DUMP (1 << 0)
208 #define DISASS_DUMP (1 << 1)
209 #define DEBUG_DUMP (1 << 2)
211 /* How to print a vma value. */
212 typedef enum print_mode
224 static bfd_vma (*byte_get
) (unsigned char *, int);
225 static void (*byte_put
) (unsigned char *, bfd_vma
, int);
229 #define SECTION_NAME(X) ((X) == NULL ? "<none>" : \
230 ((X)->sh_name >= string_table_length \
231 ? "<corrupt>" : string_table + (X)->sh_name))
233 /* Given st_shndx I, map to section_headers index. */
234 #define SECTION_HEADER_INDEX(I) \
235 ((I) < SHN_LORESERVE \
237 : ((I) <= SHN_HIRESERVE \
239 : (I) - (SHN_HIRESERVE + 1 - SHN_LORESERVE)))
241 /* Reverse of the above. */
242 #define SECTION_HEADER_NUM(N) \
243 ((N) < SHN_LORESERVE \
245 : (N) + (SHN_HIRESERVE + 1 - SHN_LORESERVE))
247 #define SECTION_HEADER(I) (section_headers + SECTION_HEADER_INDEX (I))
249 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
251 #define BYTE_GET(field) byte_get (field, sizeof (field))
253 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
255 #define GET_ELF_SYMBOLS(file, section) \
256 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
257 : get_64bit_elf_symbols (file, section))
259 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
260 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
261 already been called and verified that the string exists. */
262 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
264 /* This is just a bit of syntatic sugar. */
265 #define streq(a,b) (strcmp ((a), (b)) == 0)
266 #define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
268 static void ATTRIBUTE_PRINTF_1
269 error (const char *message
, ...)
273 va_start (args
, message
);
274 fprintf (stderr
, _("%s: Error: "), program_name
);
275 vfprintf (stderr
, message
, args
);
279 static void ATTRIBUTE_PRINTF_1
280 warn (const char *message
, ...)
284 va_start (args
, message
);
285 fprintf (stderr
, _("%s: Warning: "), program_name
);
286 vfprintf (stderr
, message
, args
);
291 cmalloc (size_t nmemb
, size_t size
)
293 /* Check for overflow. */
294 if (nmemb
>= ~(size_t) 0 / size
)
297 return malloc (nmemb
* size
);
301 xcmalloc (size_t nmemb
, size_t size
)
303 /* Check for overflow. */
304 if (nmemb
>= ~(size_t) 0 / size
)
307 return xmalloc (nmemb
* size
);
311 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
313 /* Check for overflow. */
314 if (nmemb
>= ~(size_t) 0 / size
)
317 return xrealloc (ptr
, nmemb
* size
);
321 get_data (void *var
, FILE *file
, long offset
, size_t size
, size_t nmemb
,
326 if (size
== 0 || nmemb
== 0)
329 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
331 error (_("Unable to seek to 0x%lx for %s\n"),
332 archive_file_offset
+ offset
, reason
);
339 /* Check for overflow. */
340 if (nmemb
< (~(size_t) 0 - 1) / size
)
341 /* + 1 so that we can '\0' terminate invalid string table sections. */
342 mvar
= malloc (size
* nmemb
+ 1);
346 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
347 (unsigned long)(size
* nmemb
), reason
);
351 ((char *) mvar
)[size
* nmemb
] = '\0';
354 if (fread (mvar
, size
, nmemb
, file
) != nmemb
)
356 error (_("Unable to read in 0x%lx bytes of %s\n"),
357 (unsigned long)(size
* nmemb
), reason
);
367 byte_get_little_endian (unsigned char *field
, int size
)
375 return ((unsigned int) (field
[0]))
376 | (((unsigned int) (field
[1])) << 8);
380 /* We want to extract data from an 8 byte wide field and
381 place it into a 4 byte wide field. Since this is a little
382 endian source we can just use the 4 byte extraction code. */
386 return ((unsigned long) (field
[0]))
387 | (((unsigned long) (field
[1])) << 8)
388 | (((unsigned long) (field
[2])) << 16)
389 | (((unsigned long) (field
[3])) << 24);
393 return ((bfd_vma
) (field
[0]))
394 | (((bfd_vma
) (field
[1])) << 8)
395 | (((bfd_vma
) (field
[2])) << 16)
396 | (((bfd_vma
) (field
[3])) << 24)
397 | (((bfd_vma
) (field
[4])) << 32)
398 | (((bfd_vma
) (field
[5])) << 40)
399 | (((bfd_vma
) (field
[6])) << 48)
400 | (((bfd_vma
) (field
[7])) << 56);
403 error (_("Unhandled data length: %d\n"), size
);
409 byte_get_signed (unsigned char *field
, int size
)
411 bfd_vma x
= byte_get (field
, size
);
416 return (x
^ 0x80) - 0x80;
418 return (x
^ 0x8000) - 0x8000;
420 return (x
^ 0x80000000) - 0x80000000;
429 byte_put_little_endian (unsigned char *field
, bfd_vma value
, int size
)
434 field
[7] = (((value
>> 24) >> 24) >> 8) & 0xff;
435 field
[6] = ((value
>> 24) >> 24) & 0xff;
436 field
[5] = ((value
>> 24) >> 16) & 0xff;
437 field
[4] = ((value
>> 24) >> 8) & 0xff;
440 field
[3] = (value
>> 24) & 0xff;
441 field
[2] = (value
>> 16) & 0xff;
444 field
[1] = (value
>> 8) & 0xff;
447 field
[0] = value
& 0xff;
451 error (_("Unhandled data length: %d\n"), size
);
456 #if defined BFD64 && !BFD_HOST_64BIT_LONG
458 print_dec_vma (bfd_vma vma
, int is_signed
)
464 if (is_signed
&& (bfd_signed_vma
) vma
< 0)
473 *bufp
++ = '0' + vma
% 10;
485 print_hex_vma (bfd_vma vma
)
493 char digit
= '0' + (vma
& 0x0f);
495 digit
+= 'a' - '0' - 10;
508 /* Print a VMA value. */
510 print_vma (bfd_vma vma
, print_mode mode
)
519 return printf ("0x%8.8lx", (unsigned long) vma
);
522 return printf ("%8.8lx", (unsigned long) vma
);
526 return printf ("%5ld", (long) vma
);
530 return printf ("0x%lx", (unsigned long) vma
);
533 return printf ("%lx", (unsigned long) vma
);
536 return printf ("%ld", (unsigned long) vma
);
539 return printf ("%lu", (unsigned long) vma
);
562 #if BFD_HOST_64BIT_LONG
563 return nc
+ printf ("%lx", vma
);
565 return nc
+ print_hex_vma (vma
);
569 #if BFD_HOST_64BIT_LONG
570 return printf ("%ld", vma
);
572 return print_dec_vma (vma
, 1);
576 #if BFD_HOST_64BIT_LONG
578 return printf ("%5ld", vma
);
580 return printf ("%#lx", vma
);
583 return printf ("%5ld", _bfd_int64_low (vma
));
585 return print_hex_vma (vma
);
589 #if BFD_HOST_64BIT_LONG
590 return printf ("%lu", vma
);
592 return print_dec_vma (vma
, 0);
600 /* Display a symbol on stdout. If do_wide is not true then
601 format the symbol to be at most WIDTH characters,
602 truncating as necessary. If WIDTH is negative then
603 format the string to be exactly - WIDTH characters,
604 truncating or padding as necessary. */
607 print_symbol (int width
, const char *symbol
)
610 printf ("%s", symbol
);
612 printf ("%-*.*s", width
, width
, symbol
);
614 printf ("%-.*s", width
, symbol
);
618 byte_get_big_endian (unsigned char *field
, int size
)
626 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
630 /* Although we are extracing data from an 8 byte wide field,
631 we are returning only 4 bytes of data. */
636 return ((unsigned long) (field
[3]))
637 | (((unsigned long) (field
[2])) << 8)
638 | (((unsigned long) (field
[1])) << 16)
639 | (((unsigned long) (field
[0])) << 24);
643 return ((bfd_vma
) (field
[7]))
644 | (((bfd_vma
) (field
[6])) << 8)
645 | (((bfd_vma
) (field
[5])) << 16)
646 | (((bfd_vma
) (field
[4])) << 24)
647 | (((bfd_vma
) (field
[3])) << 32)
648 | (((bfd_vma
) (field
[2])) << 40)
649 | (((bfd_vma
) (field
[1])) << 48)
650 | (((bfd_vma
) (field
[0])) << 56);
654 error (_("Unhandled data length: %d\n"), size
);
660 byte_put_big_endian (unsigned char *field
, bfd_vma value
, int size
)
665 field
[7] = value
& 0xff;
666 field
[6] = (value
>> 8) & 0xff;
667 field
[5] = (value
>> 16) & 0xff;
668 field
[4] = (value
>> 24) & 0xff;
673 field
[3] = value
& 0xff;
674 field
[2] = (value
>> 8) & 0xff;
678 field
[1] = value
& 0xff;
682 field
[0] = value
& 0xff;
686 error (_("Unhandled data length: %d\n"), size
);
691 /* Return a pointer to section NAME, or NULL if no such section exists. */
693 static Elf_Internal_Shdr
*
694 find_section (const char *name
)
698 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
699 if (streq (SECTION_NAME (section_headers
+ i
), name
))
700 return section_headers
+ i
;
705 /* Guess the relocation size commonly used by the specific machines. */
708 guess_is_rela (unsigned long e_machine
)
712 /* Targets that use REL relocations. */
727 /* Targets that use RELA relocations. */
742 case EM_CYGNUS_MN10200
:
744 case EM_CYGNUS_MN10300
:
793 warn (_("Don't know about relocations on this machine architecture\n"));
799 slurp_rela_relocs (FILE *file
,
800 unsigned long rel_offset
,
801 unsigned long rel_size
,
802 Elf_Internal_Rela
**relasp
,
803 unsigned long *nrelasp
)
805 Elf_Internal_Rela
*relas
;
806 unsigned long nrelas
;
811 Elf32_External_Rela
*erelas
;
813 erelas
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
817 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
819 relas
= cmalloc (nrelas
, sizeof (Elf_Internal_Rela
));
824 error (_("out of memory parsing relocs"));
828 for (i
= 0; i
< nrelas
; i
++)
830 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
831 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
832 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
839 Elf64_External_Rela
*erelas
;
841 erelas
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
845 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
847 relas
= cmalloc (nrelas
, sizeof (Elf_Internal_Rela
));
852 error (_("out of memory parsing relocs"));
856 for (i
= 0; i
< nrelas
; i
++)
858 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
859 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
860 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
871 slurp_rel_relocs (FILE *file
,
872 unsigned long rel_offset
,
873 unsigned long rel_size
,
874 Elf_Internal_Rela
**relsp
,
875 unsigned long *nrelsp
)
877 Elf_Internal_Rela
*rels
;
883 Elf32_External_Rel
*erels
;
885 erels
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
889 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
891 rels
= cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
896 error (_("out of memory parsing relocs"));
900 for (i
= 0; i
< nrels
; i
++)
902 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
903 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
904 rels
[i
].r_addend
= 0;
911 Elf64_External_Rel
*erels
;
913 erels
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
917 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
919 rels
= cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
924 error (_("out of memory parsing relocs"));
928 for (i
= 0; i
< nrels
; i
++)
930 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
931 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
932 rels
[i
].r_addend
= 0;
942 /* Display the contents of the relocation data found at the specified
946 dump_relocations (FILE *file
,
947 unsigned long rel_offset
,
948 unsigned long rel_size
,
949 Elf_Internal_Sym
*symtab
,
952 unsigned long strtablen
,
956 Elf_Internal_Rela
*rels
;
959 if (is_rela
== UNKNOWN
)
960 is_rela
= guess_is_rela (elf_header
.e_machine
);
964 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
969 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
978 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
980 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
985 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
987 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
995 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
997 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1002 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1004 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1008 for (i
= 0; i
< rel_size
; i
++)
1011 const char *rtype2
= NULL
;
1012 const char *rtype3
= NULL
;
1015 bfd_vma symtab_index
;
1020 offset
= rels
[i
].r_offset
;
1021 info
= rels
[i
].r_info
;
1025 type
= ELF32_R_TYPE (info
);
1026 symtab_index
= ELF32_R_SYM (info
);
1030 /* The #ifdef BFD64 below is to prevent a compile time warning.
1031 We know that if we do not have a 64 bit data type that we
1032 will never execute this code anyway. */
1034 if (elf_header
.e_machine
== EM_MIPS
)
1036 /* In little-endian objects, r_info isn't really a 64-bit
1037 little-endian value: it has a 32-bit little-endian
1038 symbol index followed by four individual byte fields.
1039 Reorder INFO accordingly. */
1040 if (elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1041 info
= (((info
& 0xffffffff) << 32)
1042 | ((info
>> 56) & 0xff)
1043 | ((info
>> 40) & 0xff00)
1044 | ((info
>> 24) & 0xff0000)
1045 | ((info
>> 8) & 0xff000000));
1046 type
= ELF64_MIPS_R_TYPE (info
);
1047 type2
= ELF64_MIPS_R_TYPE2 (info
);
1048 type3
= ELF64_MIPS_R_TYPE3 (info
);
1050 else if (elf_header
.e_machine
== EM_SPARCV9
)
1051 type
= ELF64_R_TYPE_ID (info
);
1053 type
= ELF64_R_TYPE (info
);
1055 symtab_index
= ELF64_R_SYM (info
);
1061 #ifdef _bfd_int64_low
1062 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset
), _bfd_int64_low (info
));
1064 printf ("%8.8lx %8.8lx ", offset
, info
);
1069 #ifdef _bfd_int64_low
1071 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1072 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1073 _bfd_int64_high (offset
),
1074 _bfd_int64_low (offset
),
1075 _bfd_int64_high (info
),
1076 _bfd_int64_low (info
));
1079 ? "%16.16lx %16.16lx "
1080 : "%12.12lx %12.12lx ",
1085 switch (elf_header
.e_machine
)
1092 case EM_CYGNUS_M32R
:
1093 rtype
= elf_m32r_reloc_type (type
);
1098 rtype
= elf_i386_reloc_type (type
);
1103 rtype
= elf_m68hc11_reloc_type (type
);
1107 rtype
= elf_m68k_reloc_type (type
);
1111 rtype
= elf_i960_reloc_type (type
);
1116 rtype
= elf_avr_reloc_type (type
);
1119 case EM_OLD_SPARCV9
:
1120 case EM_SPARC32PLUS
:
1123 rtype
= elf_sparc_reloc_type (type
);
1127 case EM_CYGNUS_V850
:
1128 rtype
= v850_reloc_type (type
);
1132 case EM_CYGNUS_D10V
:
1133 rtype
= elf_d10v_reloc_type (type
);
1137 case EM_CYGNUS_D30V
:
1138 rtype
= elf_d30v_reloc_type (type
);
1142 rtype
= elf_dlx_reloc_type (type
);
1146 rtype
= elf_sh_reloc_type (type
);
1150 case EM_CYGNUS_MN10300
:
1151 rtype
= elf_mn10300_reloc_type (type
);
1155 case EM_CYGNUS_MN10200
:
1156 rtype
= elf_mn10200_reloc_type (type
);
1160 case EM_CYGNUS_FR30
:
1161 rtype
= elf_fr30_reloc_type (type
);
1165 rtype
= elf_frv_reloc_type (type
);
1169 rtype
= elf_mcore_reloc_type (type
);
1173 rtype
= elf_mmix_reloc_type (type
);
1178 rtype
= elf_msp430_reloc_type (type
);
1182 rtype
= elf_ppc_reloc_type (type
);
1186 rtype
= elf_ppc64_reloc_type (type
);
1190 case EM_MIPS_RS3_LE
:
1191 rtype
= elf_mips_reloc_type (type
);
1194 rtype2
= elf_mips_reloc_type (type2
);
1195 rtype3
= elf_mips_reloc_type (type3
);
1200 rtype
= elf_alpha_reloc_type (type
);
1204 rtype
= elf_arm_reloc_type (type
);
1208 rtype
= elf_arc_reloc_type (type
);
1212 rtype
= elf_hppa_reloc_type (type
);
1218 rtype
= elf_h8_reloc_type (type
);
1223 rtype
= elf_or32_reloc_type (type
);
1228 rtype
= elf_pj_reloc_type (type
);
1231 rtype
= elf_ia64_reloc_type (type
);
1235 rtype
= elf_cris_reloc_type (type
);
1239 rtype
= elf_i860_reloc_type (type
);
1243 rtype
= elf_x86_64_reloc_type (type
);
1247 rtype
= i370_reloc_type (type
);
1252 rtype
= elf_s390_reloc_type (type
);
1256 rtype
= elf_xstormy16_reloc_type (type
);
1260 rtype
= elf_crx_reloc_type (type
);
1264 rtype
= elf_vax_reloc_type (type
);
1269 rtype
= elf_ip2k_reloc_type (type
);
1273 rtype
= elf_iq2000_reloc_type (type
);
1278 rtype
= elf_xtensa_reloc_type (type
);
1282 rtype
= elf_m32c_reloc_type (type
);
1286 rtype
= elf_ms1_reloc_type (type
);
1291 #ifdef _bfd_int64_low
1292 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type
));
1294 printf (_("unrecognized: %-7lx"), type
);
1297 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1299 if (elf_header
.e_machine
== EM_ALPHA
1300 && streq (rtype
, "R_ALPHA_LITUSE")
1303 switch (rels
[i
].r_addend
)
1305 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1306 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1307 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1308 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1309 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1310 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1311 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1312 default: rtype
= NULL
;
1315 printf (" (%s)", rtype
);
1319 printf (_("<unknown addend: %lx>"),
1320 (unsigned long) rels
[i
].r_addend
);
1323 else if (symtab_index
)
1325 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1326 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1329 Elf_Internal_Sym
*psym
;
1331 psym
= symtab
+ symtab_index
;
1334 print_vma (psym
->st_value
, LONG_HEX
);
1335 printf (is_32bit_elf
? " " : " ");
1337 if (psym
->st_name
== 0)
1339 const char *sec_name
= "<null>";
1342 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1344 bfd_vma sec_index
= (bfd_vma
) -1;
1346 if (psym
->st_shndx
< SHN_LORESERVE
)
1347 sec_index
= psym
->st_shndx
;
1348 else if (psym
->st_shndx
> SHN_HIRESERVE
)
1349 sec_index
= psym
->st_shndx
- (SHN_HIRESERVE
+ 1
1352 if (sec_index
!= (bfd_vma
) -1)
1353 sec_name
= SECTION_NAME (section_headers
+ sec_index
);
1354 else if (psym
->st_shndx
== SHN_ABS
)
1356 else if (psym
->st_shndx
== SHN_COMMON
)
1357 sec_name
= "COMMON";
1358 else if (elf_header
.e_machine
== EM_X86_64
1359 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1360 sec_name
= "LARGE_COMMON";
1361 else if (elf_header
.e_machine
== EM_IA_64
1362 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1363 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1364 sec_name
= "ANSI_COM";
1367 sprintf (name_buf
, "<section 0x%x>",
1368 (unsigned int) psym
->st_shndx
);
1369 sec_name
= name_buf
;
1372 print_symbol (22, sec_name
);
1374 else if (strtab
== NULL
)
1375 printf (_("<string table index: %3ld>"), psym
->st_name
);
1376 else if (psym
->st_name
>= strtablen
)
1377 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1379 print_symbol (22, strtab
+ psym
->st_name
);
1382 printf (" + %lx", (unsigned long) rels
[i
].r_addend
);
1387 printf ("%*c", is_32bit_elf
?
1388 (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1389 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1392 if (elf_header
.e_machine
== EM_SPARCV9
&& streq (rtype
, "R_SPARC_OLO10"))
1393 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1397 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1399 printf (" Type2: ");
1402 #ifdef _bfd_int64_low
1403 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2
));
1405 printf (_("unrecognized: %-7lx"), type2
);
1408 printf ("%-17.17s", rtype2
);
1410 printf ("\n Type3: ");
1413 #ifdef _bfd_int64_low
1414 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3
));
1416 printf (_("unrecognized: %-7lx"), type3
);
1419 printf ("%-17.17s", rtype3
);
1431 get_mips_dynamic_type (unsigned long type
)
1435 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1436 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1437 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1438 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1439 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1440 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1441 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1442 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1443 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1444 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1445 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1446 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1447 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1448 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1449 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1450 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1451 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1452 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1453 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1454 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1455 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1456 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1457 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1458 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1459 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1460 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1461 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1462 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1463 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1464 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1465 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1466 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1467 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1468 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1469 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1470 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1471 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1472 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1473 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1474 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1475 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1476 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1477 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1484 get_sparc64_dynamic_type (unsigned long type
)
1488 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1495 get_ppc_dynamic_type (unsigned long type
)
1499 case DT_PPC_GOT
: return "PPC_GOT";
1506 get_ppc64_dynamic_type (unsigned long type
)
1510 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1511 case DT_PPC64_OPD
: return "PPC64_OPD";
1512 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1519 get_parisc_dynamic_type (unsigned long type
)
1523 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1524 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1525 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1526 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1527 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1528 case DT_HP_PREINIT
: return "HP_PREINIT";
1529 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1530 case DT_HP_NEEDED
: return "HP_NEEDED";
1531 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1532 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1533 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1534 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1535 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1536 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1537 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1538 case DT_HP_FILTERED
: return "HP_FILTERED";
1539 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1540 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1541 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1542 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1543 case DT_PLT
: return "PLT";
1544 case DT_PLT_SIZE
: return "PLT_SIZE";
1545 case DT_DLT
: return "DLT";
1546 case DT_DLT_SIZE
: return "DLT_SIZE";
1553 get_ia64_dynamic_type (unsigned long type
)
1557 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1564 get_alpha_dynamic_type (unsigned long type
)
1568 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1575 get_dynamic_type (unsigned long type
)
1577 static char buff
[64];
1581 case DT_NULL
: return "NULL";
1582 case DT_NEEDED
: return "NEEDED";
1583 case DT_PLTRELSZ
: return "PLTRELSZ";
1584 case DT_PLTGOT
: return "PLTGOT";
1585 case DT_HASH
: return "HASH";
1586 case DT_STRTAB
: return "STRTAB";
1587 case DT_SYMTAB
: return "SYMTAB";
1588 case DT_RELA
: return "RELA";
1589 case DT_RELASZ
: return "RELASZ";
1590 case DT_RELAENT
: return "RELAENT";
1591 case DT_STRSZ
: return "STRSZ";
1592 case DT_SYMENT
: return "SYMENT";
1593 case DT_INIT
: return "INIT";
1594 case DT_FINI
: return "FINI";
1595 case DT_SONAME
: return "SONAME";
1596 case DT_RPATH
: return "RPATH";
1597 case DT_SYMBOLIC
: return "SYMBOLIC";
1598 case DT_REL
: return "REL";
1599 case DT_RELSZ
: return "RELSZ";
1600 case DT_RELENT
: return "RELENT";
1601 case DT_PLTREL
: return "PLTREL";
1602 case DT_DEBUG
: return "DEBUG";
1603 case DT_TEXTREL
: return "TEXTREL";
1604 case DT_JMPREL
: return "JMPREL";
1605 case DT_BIND_NOW
: return "BIND_NOW";
1606 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1607 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1608 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1609 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1610 case DT_RUNPATH
: return "RUNPATH";
1611 case DT_FLAGS
: return "FLAGS";
1613 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1614 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1616 case DT_CHECKSUM
: return "CHECKSUM";
1617 case DT_PLTPADSZ
: return "PLTPADSZ";
1618 case DT_MOVEENT
: return "MOVEENT";
1619 case DT_MOVESZ
: return "MOVESZ";
1620 case DT_FEATURE
: return "FEATURE";
1621 case DT_POSFLAG_1
: return "POSFLAG_1";
1622 case DT_SYMINSZ
: return "SYMINSZ";
1623 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1625 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1626 case DT_CONFIG
: return "CONFIG";
1627 case DT_DEPAUDIT
: return "DEPAUDIT";
1628 case DT_AUDIT
: return "AUDIT";
1629 case DT_PLTPAD
: return "PLTPAD";
1630 case DT_MOVETAB
: return "MOVETAB";
1631 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1633 case DT_VERSYM
: return "VERSYM";
1635 case DT_RELACOUNT
: return "RELACOUNT";
1636 case DT_RELCOUNT
: return "RELCOUNT";
1637 case DT_FLAGS_1
: return "FLAGS_1";
1638 case DT_VERDEF
: return "VERDEF";
1639 case DT_VERDEFNUM
: return "VERDEFNUM";
1640 case DT_VERNEED
: return "VERNEED";
1641 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1643 case DT_AUXILIARY
: return "AUXILIARY";
1644 case DT_USED
: return "USED";
1645 case DT_FILTER
: return "FILTER";
1647 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1648 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1649 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1650 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1651 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1654 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1658 switch (elf_header
.e_machine
)
1661 case EM_MIPS_RS3_LE
:
1662 result
= get_mips_dynamic_type (type
);
1665 result
= get_sparc64_dynamic_type (type
);
1668 result
= get_ppc_dynamic_type (type
);
1671 result
= get_ppc64_dynamic_type (type
);
1674 result
= get_ia64_dynamic_type (type
);
1677 result
= get_alpha_dynamic_type (type
);
1687 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1689 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1690 || (elf_header
.e_machine
== EM_PARISC
1691 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1695 switch (elf_header
.e_machine
)
1698 result
= get_parisc_dynamic_type (type
);
1708 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1712 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1719 get_file_type (unsigned e_type
)
1721 static char buff
[32];
1725 case ET_NONE
: return _("NONE (None)");
1726 case ET_REL
: return _("REL (Relocatable file)");
1727 case ET_EXEC
: return _("EXEC (Executable file)");
1728 case ET_DYN
: return _("DYN (Shared object file)");
1729 case ET_CORE
: return _("CORE (Core file)");
1732 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1733 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1734 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1735 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1737 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1743 get_machine_name (unsigned e_machine
)
1745 static char buff
[64]; /* XXX */
1749 case EM_NONE
: return _("None");
1750 case EM_M32
: return "WE32100";
1751 case EM_SPARC
: return "Sparc";
1752 case EM_386
: return "Intel 80386";
1753 case EM_68K
: return "MC68000";
1754 case EM_88K
: return "MC88000";
1755 case EM_486
: return "Intel 80486";
1756 case EM_860
: return "Intel 80860";
1757 case EM_MIPS
: return "MIPS R3000";
1758 case EM_S370
: return "IBM System/370";
1759 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1760 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1761 case EM_PARISC
: return "HPPA";
1762 case EM_PPC_OLD
: return "Power PC (old)";
1763 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1764 case EM_960
: return "Intel 90860";
1765 case EM_PPC
: return "PowerPC";
1766 case EM_PPC64
: return "PowerPC64";
1767 case EM_V800
: return "NEC V800";
1768 case EM_FR20
: return "Fujitsu FR20";
1769 case EM_RH32
: return "TRW RH32";
1770 case EM_MCORE
: return "MCORE";
1771 case EM_ARM
: return "ARM";
1772 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1773 case EM_SH
: return "Renesas / SuperH SH";
1774 case EM_SPARCV9
: return "Sparc v9";
1775 case EM_TRICORE
: return "Siemens Tricore";
1776 case EM_ARC
: return "ARC";
1777 case EM_H8_300
: return "Renesas H8/300";
1778 case EM_H8_300H
: return "Renesas H8/300H";
1779 case EM_H8S
: return "Renesas H8S";
1780 case EM_H8_500
: return "Renesas H8/500";
1781 case EM_IA_64
: return "Intel IA-64";
1782 case EM_MIPS_X
: return "Stanford MIPS-X";
1783 case EM_COLDFIRE
: return "Motorola Coldfire";
1784 case EM_68HC12
: return "Motorola M68HC12";
1785 case EM_ALPHA
: return "Alpha";
1786 case EM_CYGNUS_D10V
:
1787 case EM_D10V
: return "d10v";
1788 case EM_CYGNUS_D30V
:
1789 case EM_D30V
: return "d30v";
1790 case EM_CYGNUS_M32R
:
1791 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1792 case EM_CYGNUS_V850
:
1793 case EM_V850
: return "NEC v850";
1794 case EM_CYGNUS_MN10300
:
1795 case EM_MN10300
: return "mn10300";
1796 case EM_CYGNUS_MN10200
:
1797 case EM_MN10200
: return "mn10200";
1798 case EM_CYGNUS_FR30
:
1799 case EM_FR30
: return "Fujitsu FR30";
1800 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1802 case EM_PJ
: return "picoJava";
1803 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1804 case EM_PCP
: return "Siemens PCP";
1805 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1806 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1807 case EM_STARCORE
: return "Motorola Star*Core processor";
1808 case EM_ME16
: return "Toyota ME16 processor";
1809 case EM_ST100
: return "STMicroelectronics ST100 processor";
1810 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1811 case EM_FX66
: return "Siemens FX66 microcontroller";
1812 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1813 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1814 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1815 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1816 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1817 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1818 case EM_SVX
: return "Silicon Graphics SVx";
1819 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1820 case EM_VAX
: return "Digital VAX";
1822 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1823 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1824 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1825 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1826 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1827 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1828 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1829 case EM_PRISM
: return "Vitesse Prism";
1830 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1832 case EM_S390
: return "IBM S/390";
1833 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1835 case EM_OR32
: return "OpenRISC";
1836 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1837 case EM_DLX
: return "OpenDLX";
1839 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1840 case EM_IQ2000
: return "Vitesse IQ2000";
1842 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1843 case EM_M32C
: return "Renesas M32c";
1844 case EM_MS1
: return "Morpho Techologies MS1 processor";
1846 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_machine
);
1852 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
1857 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1858 e_flags
&= ~ EF_ARM_EABIMASK
;
1860 /* Handle "generic" ARM flags. */
1861 if (e_flags
& EF_ARM_RELEXEC
)
1863 strcat (buf
, ", relocatable executable");
1864 e_flags
&= ~ EF_ARM_RELEXEC
;
1867 if (e_flags
& EF_ARM_HASENTRY
)
1869 strcat (buf
, ", has entry point");
1870 e_flags
&= ~ EF_ARM_HASENTRY
;
1873 /* Now handle EABI specific flags. */
1877 strcat (buf
, ", <unrecognized EABI>");
1882 case EF_ARM_EABI_VER1
:
1883 strcat (buf
, ", Version1 EABI");
1888 /* Process flags one bit at a time. */
1889 flag
= e_flags
& - e_flags
;
1894 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1895 strcat (buf
, ", sorted symbol tables");
1905 case EF_ARM_EABI_VER2
:
1906 strcat (buf
, ", Version2 EABI");
1911 /* Process flags one bit at a time. */
1912 flag
= e_flags
& - e_flags
;
1917 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1918 strcat (buf
, ", sorted symbol tables");
1921 case EF_ARM_DYNSYMSUSESEGIDX
:
1922 strcat (buf
, ", dynamic symbols use segment index");
1925 case EF_ARM_MAPSYMSFIRST
:
1926 strcat (buf
, ", mapping symbols precede others");
1936 case EF_ARM_EABI_VER3
:
1937 strcat (buf
, ", Version3 EABI");
1940 case EF_ARM_EABI_VER4
:
1941 strcat (buf
, ", Version4 EABI");
1946 /* Process flags one bit at a time. */
1947 flag
= e_flags
& - e_flags
;
1953 strcat (buf
, ", BE8");
1957 strcat (buf
, ", LE8");
1967 case EF_ARM_EABI_UNKNOWN
:
1968 strcat (buf
, ", GNU EABI");
1973 /* Process flags one bit at a time. */
1974 flag
= e_flags
& - e_flags
;
1979 case EF_ARM_INTERWORK
:
1980 strcat (buf
, ", interworking enabled");
1983 case EF_ARM_APCS_26
:
1984 strcat (buf
, ", uses APCS/26");
1987 case EF_ARM_APCS_FLOAT
:
1988 strcat (buf
, ", uses APCS/float");
1992 strcat (buf
, ", position independent");
1996 strcat (buf
, ", 8 bit structure alignment");
1999 case EF_ARM_NEW_ABI
:
2000 strcat (buf
, ", uses new ABI");
2003 case EF_ARM_OLD_ABI
:
2004 strcat (buf
, ", uses old ABI");
2007 case EF_ARM_SOFT_FLOAT
:
2008 strcat (buf
, ", software FP");
2011 case EF_ARM_VFP_FLOAT
:
2012 strcat (buf
, ", VFP");
2015 case EF_ARM_MAVERICK_FLOAT
:
2016 strcat (buf
, ", Maverick FP");
2027 strcat (buf
,", <unknown>");
2031 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2033 static char buf
[1024];
2045 decode_ARM_machine_flags (e_flags
, buf
);
2049 switch (e_flags
& EF_FRV_CPU_MASK
)
2051 case EF_FRV_CPU_GENERIC
:
2055 strcat (buf
, ", fr???");
2058 case EF_FRV_CPU_FR300
:
2059 strcat (buf
, ", fr300");
2062 case EF_FRV_CPU_FR400
:
2063 strcat (buf
, ", fr400");
2065 case EF_FRV_CPU_FR405
:
2066 strcat (buf
, ", fr405");
2069 case EF_FRV_CPU_FR450
:
2070 strcat (buf
, ", fr450");
2073 case EF_FRV_CPU_FR500
:
2074 strcat (buf
, ", fr500");
2076 case EF_FRV_CPU_FR550
:
2077 strcat (buf
, ", fr550");
2080 case EF_FRV_CPU_SIMPLE
:
2081 strcat (buf
, ", simple");
2083 case EF_FRV_CPU_TOMCAT
:
2084 strcat (buf
, ", tomcat");
2090 if (e_flags
& EF_CPU32
)
2091 strcat (buf
, ", cpu32");
2092 if (e_flags
& EF_M68000
)
2093 strcat (buf
, ", m68000");
2097 if (e_flags
& EF_PPC_EMB
)
2098 strcat (buf
, ", emb");
2100 if (e_flags
& EF_PPC_RELOCATABLE
)
2101 strcat (buf
, ", relocatable");
2103 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2104 strcat (buf
, ", relocatable-lib");
2108 case EM_CYGNUS_V850
:
2109 switch (e_flags
& EF_V850_ARCH
)
2112 strcat (buf
, ", v850e1");
2115 strcat (buf
, ", v850e");
2118 strcat (buf
, ", v850");
2121 strcat (buf
, ", unknown v850 architecture variant");
2127 case EM_CYGNUS_M32R
:
2128 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2129 strcat (buf
, ", m32r");
2134 case EM_MIPS_RS3_LE
:
2135 if (e_flags
& EF_MIPS_NOREORDER
)
2136 strcat (buf
, ", noreorder");
2138 if (e_flags
& EF_MIPS_PIC
)
2139 strcat (buf
, ", pic");
2141 if (e_flags
& EF_MIPS_CPIC
)
2142 strcat (buf
, ", cpic");
2144 if (e_flags
& EF_MIPS_UCODE
)
2145 strcat (buf
, ", ugen_reserved");
2147 if (e_flags
& EF_MIPS_ABI2
)
2148 strcat (buf
, ", abi2");
2150 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2151 strcat (buf
, ", odk first");
2153 if (e_flags
& EF_MIPS_32BITMODE
)
2154 strcat (buf
, ", 32bitmode");
2156 switch ((e_flags
& EF_MIPS_MACH
))
2158 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2159 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2160 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2161 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2162 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2163 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2164 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2165 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2166 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2167 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2169 /* We simply ignore the field in this case to avoid confusion:
2170 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2173 default: strcat (buf
, ", unknown CPU"); break;
2176 switch ((e_flags
& EF_MIPS_ABI
))
2178 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2179 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2180 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2181 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2183 /* We simply ignore the field in this case to avoid confusion:
2184 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2185 This means it is likely to be an o32 file, but not for
2188 default: strcat (buf
, ", unknown ABI"); break;
2191 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2192 strcat (buf
, ", mdmx");
2194 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2195 strcat (buf
, ", mips16");
2197 switch ((e_flags
& EF_MIPS_ARCH
))
2199 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2200 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2201 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2202 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2203 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2204 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2205 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2206 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2207 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2208 default: strcat (buf
, ", unknown ISA"); break;
2214 switch ((e_flags
& EF_SH_MACH_MASK
))
2216 case EF_SH1
: strcat (buf
, ", sh1"); break;
2217 case EF_SH2
: strcat (buf
, ", sh2"); break;
2218 case EF_SH3
: strcat (buf
, ", sh3"); break;
2219 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2220 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2221 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2222 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2223 case EF_SH4
: strcat (buf
, ", sh4"); break;
2224 case EF_SH5
: strcat (buf
, ", sh5"); break;
2225 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2226 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2227 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2228 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2229 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2230 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2231 default: strcat (buf
, ", unknown ISA"); break;
2237 if (e_flags
& EF_SPARC_32PLUS
)
2238 strcat (buf
, ", v8+");
2240 if (e_flags
& EF_SPARC_SUN_US1
)
2241 strcat (buf
, ", ultrasparcI");
2243 if (e_flags
& EF_SPARC_SUN_US3
)
2244 strcat (buf
, ", ultrasparcIII");
2246 if (e_flags
& EF_SPARC_HAL_R1
)
2247 strcat (buf
, ", halr1");
2249 if (e_flags
& EF_SPARC_LEDATA
)
2250 strcat (buf
, ", ledata");
2252 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2253 strcat (buf
, ", tso");
2255 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2256 strcat (buf
, ", pso");
2258 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2259 strcat (buf
, ", rmo");
2263 switch (e_flags
& EF_PARISC_ARCH
)
2265 case EFA_PARISC_1_0
:
2266 strcpy (buf
, ", PA-RISC 1.0");
2268 case EFA_PARISC_1_1
:
2269 strcpy (buf
, ", PA-RISC 1.1");
2271 case EFA_PARISC_2_0
:
2272 strcpy (buf
, ", PA-RISC 2.0");
2277 if (e_flags
& EF_PARISC_TRAPNIL
)
2278 strcat (buf
, ", trapnil");
2279 if (e_flags
& EF_PARISC_EXT
)
2280 strcat (buf
, ", ext");
2281 if (e_flags
& EF_PARISC_LSB
)
2282 strcat (buf
, ", lsb");
2283 if (e_flags
& EF_PARISC_WIDE
)
2284 strcat (buf
, ", wide");
2285 if (e_flags
& EF_PARISC_NO_KABP
)
2286 strcat (buf
, ", no kabp");
2287 if (e_flags
& EF_PARISC_LAZYSWAP
)
2288 strcat (buf
, ", lazyswap");
2293 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2294 strcat (buf
, ", new calling convention");
2296 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2297 strcat (buf
, ", gnu calling convention");
2301 if ((e_flags
& EF_IA_64_ABI64
))
2302 strcat (buf
, ", 64-bit");
2304 strcat (buf
, ", 32-bit");
2305 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2306 strcat (buf
, ", reduced fp model");
2307 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2308 strcat (buf
, ", no function descriptors, constant gp");
2309 else if ((e_flags
& EF_IA_64_CONS_GP
))
2310 strcat (buf
, ", constant gp");
2311 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2312 strcat (buf
, ", absolute");
2316 if ((e_flags
& EF_VAX_NONPIC
))
2317 strcat (buf
, ", non-PIC");
2318 if ((e_flags
& EF_VAX_DFLOAT
))
2319 strcat (buf
, ", D-Float");
2320 if ((e_flags
& EF_VAX_GFLOAT
))
2321 strcat (buf
, ", G-Float");
2330 get_osabi_name (unsigned int osabi
)
2332 static char buff
[32];
2336 case ELFOSABI_NONE
: return "UNIX - System V";
2337 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2338 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2339 case ELFOSABI_LINUX
: return "UNIX - Linux";
2340 case ELFOSABI_HURD
: return "GNU/Hurd";
2341 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2342 case ELFOSABI_AIX
: return "UNIX - AIX";
2343 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2344 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2345 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2346 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2347 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2348 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2349 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2350 case ELFOSABI_AROS
: return "Amiga Research OS";
2351 case ELFOSABI_STANDALONE
: return _("Standalone App");
2352 case ELFOSABI_ARM
: return "ARM";
2354 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2360 get_arm_segment_type (unsigned long type
)
2374 get_mips_segment_type (unsigned long type
)
2378 case PT_MIPS_REGINFO
:
2380 case PT_MIPS_RTPROC
:
2382 case PT_MIPS_OPTIONS
:
2392 get_parisc_segment_type (unsigned long type
)
2396 case PT_HP_TLS
: return "HP_TLS";
2397 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2398 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2399 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2400 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2401 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2402 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2403 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2404 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2405 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2406 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2407 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2408 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2409 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2410 case PT_HP_STACK
: return "HP_STACK";
2411 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2412 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2413 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2414 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2423 get_ia64_segment_type (unsigned long type
)
2427 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2428 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2429 case PT_HP_TLS
: return "HP_TLS";
2430 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2431 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2432 case PT_IA_64_HP_STACK
: return "HP_STACK";
2441 get_segment_type (unsigned long p_type
)
2443 static char buff
[32];
2447 case PT_NULL
: return "NULL";
2448 case PT_LOAD
: return "LOAD";
2449 case PT_DYNAMIC
: return "DYNAMIC";
2450 case PT_INTERP
: return "INTERP";
2451 case PT_NOTE
: return "NOTE";
2452 case PT_SHLIB
: return "SHLIB";
2453 case PT_PHDR
: return "PHDR";
2454 case PT_TLS
: return "TLS";
2456 case PT_GNU_EH_FRAME
:
2457 return "GNU_EH_FRAME";
2458 case PT_GNU_STACK
: return "GNU_STACK";
2459 case PT_GNU_RELRO
: return "GNU_RELRO";
2462 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2466 switch (elf_header
.e_machine
)
2469 result
= get_arm_segment_type (p_type
);
2472 case EM_MIPS_RS3_LE
:
2473 result
= get_mips_segment_type (p_type
);
2476 result
= get_parisc_segment_type (p_type
);
2479 result
= get_ia64_segment_type (p_type
);
2489 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2491 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2495 switch (elf_header
.e_machine
)
2498 result
= get_parisc_segment_type (p_type
);
2501 result
= get_ia64_segment_type (p_type
);
2511 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2514 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2521 get_mips_section_type_name (unsigned int sh_type
)
2525 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2526 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2527 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2528 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2529 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2530 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2531 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2532 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2533 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2534 case SHT_MIPS_RELD
: return "MIPS_RELD";
2535 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2536 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2537 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2538 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2539 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2540 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2541 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2542 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2543 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2544 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2545 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2546 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2547 case SHT_MIPS_LINE
: return "MIPS_LINE";
2548 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2549 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2550 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2551 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2552 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2553 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2554 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2555 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2556 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2557 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2558 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2559 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2560 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2561 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2562 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2563 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2571 get_parisc_section_type_name (unsigned int sh_type
)
2575 case SHT_PARISC_EXT
: return "PARISC_EXT";
2576 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2577 case SHT_PARISC_DOC
: return "PARISC_DOC";
2578 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
2579 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
2580 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
2581 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
2589 get_ia64_section_type_name (unsigned int sh_type
)
2591 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2592 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2593 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2597 case SHT_IA_64_EXT
: return "IA_64_EXT";
2598 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2599 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2607 get_x86_64_section_type_name (unsigned int sh_type
)
2611 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2619 get_arm_section_type_name (unsigned int sh_type
)
2632 get_section_type_name (unsigned int sh_type
)
2634 static char buff
[32];
2638 case SHT_NULL
: return "NULL";
2639 case SHT_PROGBITS
: return "PROGBITS";
2640 case SHT_SYMTAB
: return "SYMTAB";
2641 case SHT_STRTAB
: return "STRTAB";
2642 case SHT_RELA
: return "RELA";
2643 case SHT_HASH
: return "HASH";
2644 case SHT_DYNAMIC
: return "DYNAMIC";
2645 case SHT_NOTE
: return "NOTE";
2646 case SHT_NOBITS
: return "NOBITS";
2647 case SHT_REL
: return "REL";
2648 case SHT_SHLIB
: return "SHLIB";
2649 case SHT_DYNSYM
: return "DYNSYM";
2650 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2651 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2652 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2653 case SHT_GROUP
: return "GROUP";
2654 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2655 case SHT_GNU_verdef
: return "VERDEF";
2656 case SHT_GNU_verneed
: return "VERNEED";
2657 case SHT_GNU_versym
: return "VERSYM";
2658 case 0x6ffffff0: return "VERSYM";
2659 case 0x6ffffffc: return "VERDEF";
2660 case 0x7ffffffd: return "AUXILIARY";
2661 case 0x7fffffff: return "FILTER";
2662 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2665 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2669 switch (elf_header
.e_machine
)
2672 case EM_MIPS_RS3_LE
:
2673 result
= get_mips_section_type_name (sh_type
);
2676 result
= get_parisc_section_type_name (sh_type
);
2679 result
= get_ia64_section_type_name (sh_type
);
2682 result
= get_x86_64_section_type_name (sh_type
);
2685 result
= get_arm_section_type_name (sh_type
);
2695 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2697 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2698 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2699 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2700 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2702 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
2708 #define OPTION_DEBUG_DUMP 512
2710 static struct option options
[] =
2712 {"all", no_argument
, 0, 'a'},
2713 {"file-header", no_argument
, 0, 'h'},
2714 {"program-headers", no_argument
, 0, 'l'},
2715 {"headers", no_argument
, 0, 'e'},
2716 {"histogram", no_argument
, 0, 'I'},
2717 {"segments", no_argument
, 0, 'l'},
2718 {"sections", no_argument
, 0, 'S'},
2719 {"section-headers", no_argument
, 0, 'S'},
2720 {"section-groups", no_argument
, 0, 'g'},
2721 {"section-details", no_argument
, 0, 't'},
2722 {"full-section-name",no_argument
, 0, 'N'},
2723 {"symbols", no_argument
, 0, 's'},
2724 {"syms", no_argument
, 0, 's'},
2725 {"relocs", no_argument
, 0, 'r'},
2726 {"notes", no_argument
, 0, 'n'},
2727 {"dynamic", no_argument
, 0, 'd'},
2728 {"arch-specific", no_argument
, 0, 'A'},
2729 {"version-info", no_argument
, 0, 'V'},
2730 {"use-dynamic", no_argument
, 0, 'D'},
2731 {"hex-dump", required_argument
, 0, 'x'},
2732 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2733 {"unwind", no_argument
, 0, 'u'},
2734 #ifdef SUPPORT_DISASSEMBLY
2735 {"instruction-dump", required_argument
, 0, 'i'},
2738 {"version", no_argument
, 0, 'v'},
2739 {"wide", no_argument
, 0, 'W'},
2740 {"help", no_argument
, 0, 'H'},
2741 {0, no_argument
, 0, 0}
2747 fprintf (stdout
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2748 fprintf (stdout
, _(" Display information about the contents of ELF format files\n"));
2749 fprintf (stdout
, _(" Options are:\n\
2750 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2751 -h --file-header Display the ELF file header\n\
2752 -l --program-headers Display the program headers\n\
2753 --segments An alias for --program-headers\n\
2754 -S --section-headers Display the sections' header\n\
2755 --sections An alias for --section-headers\n\
2756 -g --section-groups Display the section groups\n\
2757 -t --section-details Display the section details\n\
2758 -e --headers Equivalent to: -h -l -S\n\
2759 -s --syms Display the symbol table\n\
2760 --symbols An alias for --syms\n\
2761 -n --notes Display the core notes (if present)\n\
2762 -r --relocs Display the relocations (if present)\n\
2763 -u --unwind Display the unwind info (if present)\n\
2764 -d --dynamic Display the dynamic section (if present)\n\
2765 -V --version-info Display the version sections (if present)\n\
2766 -A --arch-specific Display architecture specific information (if any).\n\
2767 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2768 -x --hex-dump=<number> Dump the contents of section <number>\n\
2769 -w[liaprmfFsoR] or\n\
2770 --debug-dump[=line,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
2771 Display the contents of DWARF2 debug sections\n"));
2772 #ifdef SUPPORT_DISASSEMBLY
2773 fprintf (stdout
, _("\
2774 -i --instruction-dump=<number>\n\
2775 Disassemble the contents of section <number>\n"));
2777 fprintf (stdout
, _("\
2778 -I --histogram Display histogram of bucket list lengths\n\
2779 -W --wide Allow output width to exceed 80 characters\n\
2780 -H --help Display this information\n\
2781 -v --version Display the version number of readelf\n"));
2782 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2787 /* Record the fact that the user wants the contents of section number
2788 SECTION to be displayed using the method(s) encoded as flags bits
2789 in TYPE. Note, TYPE can be zero if we are creating the array for
2793 request_dump (unsigned int section
, int type
)
2795 if (section
>= num_dump_sects
)
2797 char *new_dump_sects
;
2799 new_dump_sects
= calloc (section
+ 1, 1);
2801 if (new_dump_sects
== NULL
)
2802 error (_("Out of memory allocating dump request table."));
2805 /* Copy current flag settings. */
2806 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2810 dump_sects
= new_dump_sects
;
2811 num_dump_sects
= section
+ 1;
2816 dump_sects
[section
] |= type
;
2822 parse_args (int argc
, char **argv
)
2829 while ((c
= getopt_long
2830 (argc
, argv
, "ersuahnldSDAINtgw::x:i:vVWH", options
, NULL
)) != EOF
)
2851 do_section_groups
++;
2859 do_section_groups
++;
2864 do_section_details
++;
2906 section
= strtoul (optarg
, & cp
, 0);
2907 if (! *cp
&& section
>= 0)
2909 request_dump (section
, HEX_DUMP
);
2919 unsigned int index
= 0;
2923 while (optarg
[index
])
2924 switch (optarg
[index
++])
2933 do_debug_abbrevs
= 1;
2943 do_debug_pubnames
= 1;
2947 do_debug_aranges
= 1;
2951 do_debug_ranges
= 1;
2955 do_debug_frames_interp
= 1;
2957 do_debug_frames
= 1;
2962 do_debug_macinfo
= 1;
2976 warn (_("Unrecognized debug option '%s'\n"), optarg
);
2981 case OPTION_DEBUG_DUMP
:
2989 const char * option
;
2992 debug_dump_long_opts
;
2994 debug_dump_long_opts opts_table
[] =
2996 /* Please keep this table alpha- sorted. */
2997 { "Ranges", & do_debug_ranges
},
2998 { "abbrev", & do_debug_abbrevs
},
2999 { "aranges", & do_debug_aranges
},
3000 { "frames", & do_debug_frames
},
3001 { "frames-interp", & do_debug_frames_interp
},
3002 { "info", & do_debug_info
},
3003 { "line", & do_debug_lines
},
3004 { "loc", & do_debug_loc
},
3005 { "macro", & do_debug_macinfo
},
3006 { "pubnames", & do_debug_pubnames
},
3007 /* This entry is for compatability
3008 with earlier versions of readelf. */
3009 { "ranges", & do_debug_aranges
},
3010 { "str", & do_debug_str
},
3021 debug_dump_long_opts
* entry
;
3023 for (entry
= opts_table
; entry
->option
; entry
++)
3025 size_t len
= strlen (entry
->option
);
3027 if (strneq (p
, entry
->option
, len
)
3028 && (p
[len
] == ',' || p
[len
] == '\0'))
3030 * entry
->variable
= 1;
3032 /* The --debug-dump=frames-interp option also
3033 enables the --debug-dump=frames option. */
3034 if (do_debug_frames_interp
)
3035 do_debug_frames
= 1;
3042 if (entry
->option
== NULL
)
3044 warn (_("Unrecognized debug option '%s'\n"), p
);
3045 p
= strchr (p
, ',');
3055 #ifdef SUPPORT_DISASSEMBLY
3058 section
= strtoul (optarg
, & cp
, 0);
3059 if (! *cp
&& section
>= 0)
3061 request_dump (section
, DISASS_DUMP
);
3067 print_version (program_name
);
3077 /* xgettext:c-format */
3078 error (_("Invalid option '-%c'\n"), c
);
3085 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3086 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3087 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3088 && !do_section_groups
)
3092 warn (_("Nothing to do.\n"));
3098 get_elf_class (unsigned int elf_class
)
3100 static char buff
[32];
3104 case ELFCLASSNONE
: return _("none");
3105 case ELFCLASS32
: return "ELF32";
3106 case ELFCLASS64
: return "ELF64";
3108 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3114 get_data_encoding (unsigned int encoding
)
3116 static char buff
[32];
3120 case ELFDATANONE
: return _("none");
3121 case ELFDATA2LSB
: return _("2's complement, little endian");
3122 case ELFDATA2MSB
: return _("2's complement, big endian");
3124 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3129 /* Decode the data held in 'elf_header'. */
3132 process_file_header (void)
3134 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3135 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3136 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3137 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3140 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3148 printf (_("ELF Header:\n"));
3149 printf (_(" Magic: "));
3150 for (i
= 0; i
< EI_NIDENT
; i
++)
3151 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3153 printf (_(" Class: %s\n"),
3154 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3155 printf (_(" Data: %s\n"),
3156 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3157 printf (_(" Version: %d %s\n"),
3158 elf_header
.e_ident
[EI_VERSION
],
3159 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3161 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3164 printf (_(" OS/ABI: %s\n"),
3165 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3166 printf (_(" ABI Version: %d\n"),
3167 elf_header
.e_ident
[EI_ABIVERSION
]);
3168 printf (_(" Type: %s\n"),
3169 get_file_type (elf_header
.e_type
));
3170 printf (_(" Machine: %s\n"),
3171 get_machine_name (elf_header
.e_machine
));
3172 printf (_(" Version: 0x%lx\n"),
3173 (unsigned long) elf_header
.e_version
);
3175 printf (_(" Entry point address: "));
3176 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3177 printf (_("\n Start of program headers: "));
3178 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3179 printf (_(" (bytes into file)\n Start of section headers: "));
3180 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3181 printf (_(" (bytes into file)\n"));
3183 printf (_(" Flags: 0x%lx%s\n"),
3184 (unsigned long) elf_header
.e_flags
,
3185 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3186 printf (_(" Size of this header: %ld (bytes)\n"),
3187 (long) elf_header
.e_ehsize
);
3188 printf (_(" Size of program headers: %ld (bytes)\n"),
3189 (long) elf_header
.e_phentsize
);
3190 printf (_(" Number of program headers: %ld\n"),
3191 (long) elf_header
.e_phnum
);
3192 printf (_(" Size of section headers: %ld (bytes)\n"),
3193 (long) elf_header
.e_shentsize
);
3194 printf (_(" Number of section headers: %ld"),
3195 (long) elf_header
.e_shnum
);
3196 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
3197 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3198 putc ('\n', stdout
);
3199 printf (_(" Section header string table index: %ld"),
3200 (long) elf_header
.e_shstrndx
);
3201 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
3202 printf (" (%ld)", (long) section_headers
[0].sh_link
);
3203 putc ('\n', stdout
);
3206 if (section_headers
!= NULL
)
3208 if (elf_header
.e_shnum
== 0)
3209 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3210 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
3211 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3212 free (section_headers
);
3213 section_headers
= NULL
;
3221 get_32bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3223 Elf32_External_Phdr
*phdrs
;
3224 Elf32_External_Phdr
*external
;
3225 Elf_Internal_Phdr
*internal
;
3228 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3229 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3230 _("program headers"));
3234 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3235 i
< elf_header
.e_phnum
;
3236 i
++, internal
++, external
++)
3238 internal
->p_type
= BYTE_GET (external
->p_type
);
3239 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3240 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3241 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3242 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3243 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3244 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3245 internal
->p_align
= BYTE_GET (external
->p_align
);
3254 get_64bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3256 Elf64_External_Phdr
*phdrs
;
3257 Elf64_External_Phdr
*external
;
3258 Elf_Internal_Phdr
*internal
;
3261 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3262 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3263 _("program headers"));
3267 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3268 i
< elf_header
.e_phnum
;
3269 i
++, internal
++, external
++)
3271 internal
->p_type
= BYTE_GET (external
->p_type
);
3272 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3273 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3274 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3275 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3276 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3277 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3278 internal
->p_align
= BYTE_GET (external
->p_align
);
3286 /* Returns 1 if the program headers were read into `program_headers'. */
3289 get_program_headers (FILE *file
)
3291 Elf_Internal_Phdr
*phdrs
;
3293 /* Check cache of prior read. */
3294 if (program_headers
!= NULL
)
3297 phdrs
= cmalloc (elf_header
.e_phnum
, sizeof (Elf_Internal_Phdr
));
3301 error (_("Out of memory\n"));
3306 ? get_32bit_program_headers (file
, phdrs
)
3307 : get_64bit_program_headers (file
, phdrs
))
3309 program_headers
= phdrs
;
3317 /* Returns 1 if the program headers were loaded. */
3320 process_program_headers (FILE *file
)
3322 Elf_Internal_Phdr
*segment
;
3325 if (elf_header
.e_phnum
== 0)
3328 printf (_("\nThere are no program headers in this file.\n"));
3332 if (do_segments
&& !do_header
)
3334 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3335 printf (_("Entry point "));
3336 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3337 printf (_("\nThere are %d program headers, starting at offset "),
3338 elf_header
.e_phnum
);
3339 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3343 if (! get_program_headers (file
))
3348 if (elf_header
.e_phnum
> 1)
3349 printf (_("\nProgram Headers:\n"));
3351 printf (_("\nProgram Headers:\n"));
3355 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3358 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3362 (_(" Type Offset VirtAddr PhysAddr\n"));
3364 (_(" FileSiz MemSiz Flags Align\n"));
3371 for (i
= 0, segment
= program_headers
;
3372 i
< elf_header
.e_phnum
;
3377 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3381 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3382 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3383 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3384 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3385 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3387 (segment
->p_flags
& PF_R
? 'R' : ' '),
3388 (segment
->p_flags
& PF_W
? 'W' : ' '),
3389 (segment
->p_flags
& PF_X
? 'E' : ' '));
3390 printf ("%#lx", (unsigned long) segment
->p_align
);
3394 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3395 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3398 print_vma (segment
->p_offset
, FULL_HEX
);
3402 print_vma (segment
->p_vaddr
, FULL_HEX
);
3404 print_vma (segment
->p_paddr
, FULL_HEX
);
3407 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3408 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3411 print_vma (segment
->p_filesz
, FULL_HEX
);
3415 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3416 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3419 print_vma (segment
->p_offset
, FULL_HEX
);
3423 (segment
->p_flags
& PF_R
? 'R' : ' '),
3424 (segment
->p_flags
& PF_W
? 'W' : ' '),
3425 (segment
->p_flags
& PF_X
? 'E' : ' '));
3427 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3428 printf ("%#lx", (unsigned long) segment
->p_align
);
3431 print_vma (segment
->p_align
, PREFIX_HEX
);
3436 print_vma (segment
->p_offset
, FULL_HEX
);
3438 print_vma (segment
->p_vaddr
, FULL_HEX
);
3440 print_vma (segment
->p_paddr
, FULL_HEX
);
3442 print_vma (segment
->p_filesz
, FULL_HEX
);
3444 print_vma (segment
->p_memsz
, FULL_HEX
);
3446 (segment
->p_flags
& PF_R
? 'R' : ' '),
3447 (segment
->p_flags
& PF_W
? 'W' : ' '),
3448 (segment
->p_flags
& PF_X
? 'E' : ' '));
3449 print_vma (segment
->p_align
, HEX
);
3453 switch (segment
->p_type
)
3457 error (_("more than one dynamic segment\n"));
3459 /* Try to locate the .dynamic section. If there is
3460 a section header table, we can easily locate it. */
3461 if (section_headers
!= NULL
)
3463 Elf_Internal_Shdr
*sec
;
3465 sec
= find_section (".dynamic");
3466 if (sec
== NULL
|| sec
->sh_size
== 0)
3468 error (_("no .dynamic section in the dynamic segment"));
3472 dynamic_addr
= sec
->sh_offset
;
3473 dynamic_size
= sec
->sh_size
;
3475 if (dynamic_addr
< segment
->p_offset
3476 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3477 warn (_("the .dynamic section is not contained within the dynamic segment"));
3478 else if (dynamic_addr
> segment
->p_offset
)
3479 warn (_("the .dynamic section is not the first section in the dynamic segment."));
3483 /* Otherwise, we can only assume that the .dynamic
3484 section is the first section in the DYNAMIC segment. */
3485 dynamic_addr
= segment
->p_offset
;
3486 dynamic_size
= segment
->p_filesz
;
3491 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3493 error (_("Unable to find program interpreter name\n"));
3496 program_interpreter
[0] = 0;
3497 fscanf (file
, "%63s", program_interpreter
);
3500 printf (_("\n [Requesting program interpreter: %s]"),
3501 program_interpreter
);
3507 putc ('\n', stdout
);
3510 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3512 printf (_("\n Section to Segment mapping:\n"));
3513 printf (_(" Segment Sections...\n"));
3515 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3518 Elf_Internal_Shdr
*section
;
3520 segment
= program_headers
+ i
;
3521 section
= section_headers
;
3523 printf (" %2.2d ", i
);
3525 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3527 if (section
->sh_size
> 0
3528 /* Compare allocated sections by VMA, unallocated
3529 sections by file offset. */
3530 && (section
->sh_flags
& SHF_ALLOC
3531 ? (section
->sh_addr
>= segment
->p_vaddr
3532 && section
->sh_addr
+ section
->sh_size
3533 <= segment
->p_vaddr
+ segment
->p_memsz
)
3534 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
3535 && (section
->sh_offset
+ section
->sh_size
3536 <= segment
->p_offset
+ segment
->p_filesz
)))
3537 /* .tbss is special. It doesn't contribute memory space
3538 to normal segments. */
3539 && (!((section
->sh_flags
& SHF_TLS
) != 0
3540 && section
->sh_type
== SHT_NOBITS
)
3541 || segment
->p_type
== PT_TLS
))
3542 printf ("%s ", SECTION_NAME (section
));
3553 /* Find the file offset corresponding to VMA by using the program headers. */
3556 offset_from_vma (FILE *file
, bfd_vma vma
, bfd_size_type size
)
3558 Elf_Internal_Phdr
*seg
;
3560 if (! get_program_headers (file
))
3562 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3566 for (seg
= program_headers
;
3567 seg
< program_headers
+ elf_header
.e_phnum
;
3570 if (seg
->p_type
!= PT_LOAD
)
3573 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3574 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3575 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3578 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3585 get_32bit_section_headers (FILE *file
, unsigned int num
)
3587 Elf32_External_Shdr
*shdrs
;
3588 Elf_Internal_Shdr
*internal
;
3591 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3592 elf_header
.e_shentsize
, num
, _("section headers"));
3596 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3598 if (section_headers
== NULL
)
3600 error (_("Out of memory\n"));
3604 for (i
= 0, internal
= section_headers
;
3608 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3609 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3610 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3611 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3612 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3613 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3614 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3615 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3616 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3617 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3626 get_64bit_section_headers (FILE *file
, unsigned int num
)
3628 Elf64_External_Shdr
*shdrs
;
3629 Elf_Internal_Shdr
*internal
;
3632 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3633 elf_header
.e_shentsize
, num
, _("section headers"));
3637 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3639 if (section_headers
== NULL
)
3641 error (_("Out of memory\n"));
3645 for (i
= 0, internal
= section_headers
;
3649 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3650 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3651 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3652 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3653 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3654 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3655 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3656 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3657 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3658 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3666 static Elf_Internal_Sym
*
3667 get_32bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3669 unsigned long number
;
3670 Elf32_External_Sym
*esyms
;
3671 Elf_External_Sym_Shndx
*shndx
;
3672 Elf_Internal_Sym
*isyms
;
3673 Elf_Internal_Sym
*psym
;
3676 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3682 if (symtab_shndx_hdr
!= NULL
3683 && (symtab_shndx_hdr
->sh_link
3684 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3686 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3687 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3695 number
= section
->sh_size
/ section
->sh_entsize
;
3696 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3700 error (_("Out of memory\n"));
3707 for (j
= 0, psym
= isyms
;
3711 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3712 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3713 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3714 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3715 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3717 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3718 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3719 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3729 static Elf_Internal_Sym
*
3730 get_64bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3732 unsigned long number
;
3733 Elf64_External_Sym
*esyms
;
3734 Elf_External_Sym_Shndx
*shndx
;
3735 Elf_Internal_Sym
*isyms
;
3736 Elf_Internal_Sym
*psym
;
3739 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3745 if (symtab_shndx_hdr
!= NULL
3746 && (symtab_shndx_hdr
->sh_link
3747 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3749 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3750 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3758 number
= section
->sh_size
/ section
->sh_entsize
;
3759 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3763 error (_("Out of memory\n"));
3770 for (j
= 0, psym
= isyms
;
3774 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3775 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3776 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3777 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3778 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3780 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3781 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3782 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3793 get_elf_section_flags (bfd_vma sh_flags
)
3795 static char buff
[1024];
3797 int index
, size
= sizeof (buff
) - (8 + 4 + 1);
3811 { "LINK ORDER", 10 },
3812 { "OS NONCONF", 10 },
3817 if (do_section_details
)
3819 sprintf (buff
, "[%8.8lx]: ", (unsigned long) sh_flags
);
3827 flag
= sh_flags
& - sh_flags
;
3830 if (do_section_details
)
3834 case SHF_WRITE
: index
= 0; break;
3835 case SHF_ALLOC
: index
= 1; break;
3836 case SHF_EXECINSTR
: index
= 2; break;
3837 case SHF_MERGE
: index
= 3; break;
3838 case SHF_STRINGS
: index
= 4; break;
3839 case SHF_INFO_LINK
: index
= 5; break;
3840 case SHF_LINK_ORDER
: index
= 6; break;
3841 case SHF_OS_NONCONFORMING
: index
= 7; break;
3842 case SHF_GROUP
: index
= 8; break;
3843 case SHF_TLS
: index
= 9; break;
3850 if (p
!= buff
+ 8 + 4)
3861 size
-= flags
[index
].len
;
3862 p
= stpcpy (p
, flags
[index
].str
);
3864 else if (flag
& SHF_MASKOS
)
3867 sprintf (p
, "OS (%8.8lx)", (unsigned long) flag
);
3870 else if (flag
& SHF_MASKPROC
)
3873 sprintf (p
, "PROC (%8.8lx)", (unsigned long) flag
);
3879 sprintf (p
, "UNKNOWN (%8.8lx)", (unsigned long) flag
);
3887 case SHF_WRITE
: *p
= 'W'; break;
3888 case SHF_ALLOC
: *p
= 'A'; break;
3889 case SHF_EXECINSTR
: *p
= 'X'; break;
3890 case SHF_MERGE
: *p
= 'M'; break;
3891 case SHF_STRINGS
: *p
= 'S'; break;
3892 case SHF_INFO_LINK
: *p
= 'I'; break;
3893 case SHF_LINK_ORDER
: *p
= 'L'; break;
3894 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
3895 case SHF_GROUP
: *p
= 'G'; break;
3896 case SHF_TLS
: *p
= 'T'; break;
3899 if (elf_header
.e_machine
== EM_X86_64
3900 && flag
== SHF_X86_64_LARGE
)
3902 else if (flag
& SHF_MASKOS
)
3905 sh_flags
&= ~ SHF_MASKOS
;
3907 else if (flag
& SHF_MASKPROC
)
3910 sh_flags
&= ~ SHF_MASKPROC
;
3925 process_section_headers (FILE *file
)
3927 Elf_Internal_Shdr
*section
;
3930 section_headers
= NULL
;
3932 if (elf_header
.e_shnum
== 0)
3935 printf (_("\nThere are no sections in this file.\n"));
3940 if (do_sections
&& !do_header
)
3941 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3942 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
3946 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
3949 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
3952 /* Read in the string table, so that we have names to display. */
3953 if (SECTION_HEADER_INDEX (elf_header
.e_shstrndx
) < elf_header
.e_shnum
)
3955 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
3957 if (section
->sh_size
!= 0)
3959 string_table
= get_data (NULL
, file
, section
->sh_offset
,
3960 1, section
->sh_size
, _("string table"));
3962 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
3966 /* Scan the sections for the dynamic symbol table
3967 and dynamic string table and debug sections. */
3968 dynamic_symbols
= NULL
;
3969 dynamic_strings
= NULL
;
3970 dynamic_syminfo
= NULL
;
3971 symtab_shndx_hdr
= NULL
;
3973 eh_addr_size
= is_32bit_elf
? 4 : 8;
3974 switch (elf_header
.e_machine
)
3977 case EM_MIPS_RS3_LE
:
3978 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
3979 FDE addresses. However, the ABI also has a semi-official ILP32
3980 variant for which the normal FDE address size rules apply.
3982 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
3983 section, where XX is the size of longs in bits. Unfortunately,
3984 earlier compilers provided no way of distinguishing ILP32 objects
3985 from LP64 objects, so if there's any doubt, we should assume that
3986 the official LP64 form is being used. */
3987 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
3988 && find_section (".gcc_compiled_long32") == NULL
)
3993 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
3996 size_t expected_entsize \
3997 = is_32bit_elf ? size32 : size64; \
3998 if (section->sh_entsize != expected_entsize) \
3999 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4000 i, (unsigned long int) section->sh_entsize, \
4001 (unsigned long int) expected_entsize); \
4002 section->sh_entsize = expected_entsize; \
4005 #define CHECK_ENTSIZE(section, i, type) \
4006 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4007 sizeof (Elf64_External_##type))
4009 for (i
= 0, section
= section_headers
;
4010 i
< elf_header
.e_shnum
;
4013 char *name
= SECTION_NAME (section
);
4015 if (section
->sh_type
== SHT_DYNSYM
)
4017 if (dynamic_symbols
!= NULL
)
4019 error (_("File contains multiple dynamic symbol tables\n"));
4023 CHECK_ENTSIZE (section
, i
, Sym
);
4024 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
4025 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
4027 else if (section
->sh_type
== SHT_STRTAB
4028 && streq (name
, ".dynstr"))
4030 if (dynamic_strings
!= NULL
)
4032 error (_("File contains multiple dynamic string tables\n"));
4036 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
4037 1, section
->sh_size
, _("dynamic strings"));
4038 dynamic_strings_length
= section
->sh_size
;
4040 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4042 if (symtab_shndx_hdr
!= NULL
)
4044 error (_("File contains multiple symtab shndx tables\n"));
4047 symtab_shndx_hdr
= section
;
4049 else if (section
->sh_type
== SHT_SYMTAB
)
4050 CHECK_ENTSIZE (section
, i
, Sym
);
4051 else if (section
->sh_type
== SHT_GROUP
)
4052 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4053 else if (section
->sh_type
== SHT_REL
)
4054 CHECK_ENTSIZE (section
, i
, Rel
);
4055 else if (section
->sh_type
== SHT_RELA
)
4056 CHECK_ENTSIZE (section
, i
, Rela
);
4057 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4058 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
4059 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
4060 || do_debug_loc
|| do_debug_ranges
)
4061 && strneq (name
, ".debug_", 7))
4066 || (do_debug_info
&& streq (name
, "info"))
4067 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
4068 || (do_debug_lines
&& streq (name
, "line"))
4069 || (do_debug_pubnames
&& streq (name
, "pubnames"))
4070 || (do_debug_aranges
&& streq (name
, "aranges"))
4071 || (do_debug_ranges
&& streq (name
, "ranges"))
4072 || (do_debug_frames
&& streq (name
, "frame"))
4073 || (do_debug_macinfo
&& streq (name
, "macinfo"))
4074 || (do_debug_str
&& streq (name
, "str"))
4075 || (do_debug_loc
&& streq (name
, "loc"))
4077 request_dump (i
, DEBUG_DUMP
);
4079 /* linkonce section to be combined with .debug_info at link time. */
4080 else if ((do_debugging
|| do_debug_info
)
4081 && strneq (name
, ".gnu.linkonce.wi.", 17))
4082 request_dump (i
, DEBUG_DUMP
);
4083 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4084 request_dump (i
, DEBUG_DUMP
);
4090 if (elf_header
.e_shnum
> 1)
4091 printf (_("\nSection Headers:\n"));
4093 printf (_("\nSection Header:\n"));
4097 if (do_section_details
)
4099 printf (_(" [Nr] Name\n"));
4100 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4104 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4108 if (do_section_details
)
4110 printf (_(" [Nr] Name\n"));
4111 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4115 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4119 if (do_section_details
)
4121 printf (_(" [Nr] Name\n"));
4122 printf (_(" Type Address Offset Link\n"));
4123 printf (_(" Size EntSize Info Align\n"));
4127 printf (_(" [Nr] Name Type Address Offset\n"));
4128 printf (_(" Size EntSize Flags Link Info Align\n"));
4132 if (do_section_details
)
4133 printf (_(" Flags\n"));
4135 for (i
= 0, section
= section_headers
;
4136 i
< elf_header
.e_shnum
;
4139 if (do_section_details
)
4141 printf (" [%2u] %s\n",
4142 SECTION_HEADER_NUM (i
),
4143 SECTION_NAME (section
));
4144 if (is_32bit_elf
|| do_wide
)
4145 printf (" %-15.15s ",
4146 get_section_type_name (section
->sh_type
));
4149 printf (" [%2u] %-17.17s %-15.15s ",
4150 SECTION_HEADER_NUM (i
),
4151 SECTION_NAME (section
),
4152 get_section_type_name (section
->sh_type
));
4156 print_vma (section
->sh_addr
, LONG_HEX
);
4158 printf ( " %6.6lx %6.6lx %2.2lx",
4159 (unsigned long) section
->sh_offset
,
4160 (unsigned long) section
->sh_size
,
4161 (unsigned long) section
->sh_entsize
);
4163 if (do_section_details
)
4164 fputs (" ", stdout
);
4166 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4168 printf ("%2ld %3lu %2ld\n",
4169 (unsigned long) section
->sh_link
,
4170 (unsigned long) section
->sh_info
,
4171 (unsigned long) section
->sh_addralign
);
4175 print_vma (section
->sh_addr
, LONG_HEX
);
4177 if ((long) section
->sh_offset
== section
->sh_offset
)
4178 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4182 print_vma (section
->sh_offset
, LONG_HEX
);
4185 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4186 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4190 print_vma (section
->sh_size
, LONG_HEX
);
4193 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4194 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4198 print_vma (section
->sh_entsize
, LONG_HEX
);
4201 if (do_section_details
)
4202 fputs (" ", stdout
);
4204 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4206 printf ("%2ld %3lu ",
4207 (unsigned long) section
->sh_link
,
4208 (unsigned long) section
->sh_info
);
4210 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4211 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
4214 print_vma (section
->sh_addralign
, DEC
);
4218 else if (do_section_details
)
4220 printf (" %-15.15s ",
4221 get_section_type_name (section
->sh_type
));
4222 print_vma (section
->sh_addr
, LONG_HEX
);
4223 if ((long) section
->sh_offset
== section
->sh_offset
)
4224 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4228 print_vma (section
->sh_offset
, LONG_HEX
);
4230 printf (" %ld\n ", (unsigned long) section
->sh_link
);
4231 print_vma (section
->sh_size
, LONG_HEX
);
4233 print_vma (section
->sh_entsize
, LONG_HEX
);
4235 printf (" %-16lu %ld\n",
4236 (unsigned long) section
->sh_info
,
4237 (unsigned long) section
->sh_addralign
);
4242 print_vma (section
->sh_addr
, LONG_HEX
);
4243 if ((long) section
->sh_offset
== section
->sh_offset
)
4244 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4248 print_vma (section
->sh_offset
, LONG_HEX
);
4251 print_vma (section
->sh_size
, LONG_HEX
);
4253 print_vma (section
->sh_entsize
, LONG_HEX
);
4255 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4257 printf (" %2ld %3lu %ld\n",
4258 (unsigned long) section
->sh_link
,
4259 (unsigned long) section
->sh_info
,
4260 (unsigned long) section
->sh_addralign
);
4263 if (do_section_details
)
4264 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
4267 if (!do_section_details
)
4268 printf (_("Key to Flags:\n\
4269 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4270 I (info), L (link order), G (group), x (unknown)\n\
4271 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4277 get_group_flags (unsigned int flags
)
4279 static char buff
[32];
4286 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x]"), flags
);
4293 process_section_groups (FILE *file
)
4295 Elf_Internal_Shdr
*section
;
4297 struct group
*group
;
4298 Elf_Internal_Shdr
*symtab_sec
, *strtab_sec
;
4299 Elf_Internal_Sym
*symtab
;
4303 /* Don't process section groups unless needed. */
4304 if (!do_unwind
&& !do_section_groups
)
4307 if (elf_header
.e_shnum
== 0)
4309 if (do_section_groups
)
4310 printf (_("\nThere are no sections in this file.\n"));
4315 if (section_headers
== NULL
)
4317 error (_("Section headers are not available!\n"));
4321 section_headers_groups
= calloc (elf_header
.e_shnum
,
4322 sizeof (struct group
*));
4324 if (section_headers_groups
== NULL
)
4326 error (_("Out of memory\n"));
4330 /* Scan the sections for the group section. */
4332 for (i
= 0, section
= section_headers
;
4333 i
< elf_header
.e_shnum
;
4335 if (section
->sh_type
== SHT_GROUP
)
4338 if (group_count
== 0)
4340 if (do_section_groups
)
4341 printf (_("\nThere are no section groups in this file.\n"));
4346 section_groups
= calloc (group_count
, sizeof (struct group
));
4348 if (section_groups
== NULL
)
4350 error (_("Out of memory\n"));
4359 for (i
= 0, section
= section_headers
, group
= section_groups
;
4360 i
< elf_header
.e_shnum
;
4363 if (section
->sh_type
== SHT_GROUP
)
4365 char *name
= SECTION_NAME (section
);
4367 unsigned char *start
, *indices
;
4368 unsigned int entry
, j
, size
;
4369 Elf_Internal_Shdr
*sec
;
4370 Elf_Internal_Sym
*sym
;
4372 /* Get the symbol table. */
4373 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
4374 || ((sec
= SECTION_HEADER (section
->sh_link
))->sh_type
4377 error (_("Bad sh_link in group section `%s'\n"), name
);
4381 if (symtab_sec
!= sec
)
4386 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4389 sym
= symtab
+ section
->sh_info
;
4391 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4393 bfd_vma sec_index
= SECTION_HEADER_INDEX (sym
->st_shndx
);
4396 error (_("Bad sh_info in group section `%s'\n"), name
);
4400 group_name
= SECTION_NAME (section_headers
+ sec_index
);
4409 /* Get the string table. */
4410 if (SECTION_HEADER_INDEX (symtab_sec
->sh_link
)
4411 >= elf_header
.e_shnum
)
4420 != (sec
= SECTION_HEADER (symtab_sec
->sh_link
)))
4425 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
4426 1, strtab_sec
->sh_size
,
4428 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
4430 group_name
= sym
->st_name
< strtab_size
4431 ? strtab
+ sym
->st_name
: "<corrupt>";
4434 start
= get_data (NULL
, file
, section
->sh_offset
,
4435 1, section
->sh_size
, _("section data"));
4438 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4439 entry
= byte_get (indices
, 4);
4442 if (do_section_groups
)
4444 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4445 get_group_flags (entry
), i
, name
, group_name
, size
);
4447 printf (_(" [Index] Name\n"));
4450 group
->group_index
= i
;
4452 for (j
= 0; j
< size
; j
++)
4454 struct group_list
*g
;
4456 entry
= byte_get (indices
, 4);
4459 if (SECTION_HEADER_INDEX (entry
) >= elf_header
.e_shnum
)
4461 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4462 entry
, i
, elf_header
.e_shnum
- 1);
4465 else if (entry
>= SHN_LORESERVE
&& entry
<= SHN_HIRESERVE
)
4467 error (_("invalid section [%5u] in group section [%5u]\n"),
4472 if (section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4477 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4479 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4484 /* Intel C/C++ compiler may put section 0 in a
4485 section group. We just warn it the first time
4486 and ignore it afterwards. */
4487 static int warned
= 0;
4490 error (_("section 0 in group section [%5u]\n"),
4491 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4497 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4500 if (do_section_groups
)
4502 sec
= SECTION_HEADER (entry
);
4503 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
4506 g
= xmalloc (sizeof (struct group_list
));
4507 g
->section_index
= entry
;
4508 g
->next
= group
->root
;
4532 } dynamic_relocations
[] =
4534 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4535 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4536 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4539 /* Process the reloc section. */
4542 process_relocs (FILE *file
)
4544 unsigned long rel_size
;
4545 unsigned long rel_offset
;
4551 if (do_using_dynamic
)
4555 int has_dynamic_reloc
;
4558 has_dynamic_reloc
= 0;
4560 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4562 is_rela
= dynamic_relocations
[i
].rela
;
4563 name
= dynamic_relocations
[i
].name
;
4564 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4565 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4567 has_dynamic_reloc
|= rel_size
;
4569 if (is_rela
== UNKNOWN
)
4571 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4572 switch (dynamic_info
[DT_PLTREL
])
4586 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4587 name
, rel_offset
, rel_size
);
4589 dump_relocations (file
,
4590 offset_from_vma (file
, rel_offset
, rel_size
),
4592 dynamic_symbols
, num_dynamic_syms
,
4593 dynamic_strings
, dynamic_strings_length
, is_rela
);
4597 if (! has_dynamic_reloc
)
4598 printf (_("\nThere are no dynamic relocations in this file.\n"));
4602 Elf_Internal_Shdr
*section
;
4606 for (i
= 0, section
= section_headers
;
4607 i
< elf_header
.e_shnum
;
4610 if ( section
->sh_type
!= SHT_RELA
4611 && section
->sh_type
!= SHT_REL
)
4614 rel_offset
= section
->sh_offset
;
4615 rel_size
= section
->sh_size
;
4619 Elf_Internal_Shdr
*strsec
;
4622 printf (_("\nRelocation section "));
4624 if (string_table
== NULL
)
4625 printf ("%d", section
->sh_name
);
4627 printf (_("'%s'"), SECTION_NAME (section
));
4629 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4630 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4632 is_rela
= section
->sh_type
== SHT_RELA
;
4634 if (section
->sh_link
4635 && SECTION_HEADER_INDEX (section
->sh_link
)
4636 < elf_header
.e_shnum
)
4638 Elf_Internal_Shdr
*symsec
;
4639 Elf_Internal_Sym
*symtab
;
4640 unsigned long nsyms
;
4641 unsigned long strtablen
= 0;
4642 char *strtab
= NULL
;
4644 symsec
= SECTION_HEADER (section
->sh_link
);
4645 if (symsec
->sh_type
!= SHT_SYMTAB
4646 && symsec
->sh_type
!= SHT_DYNSYM
)
4649 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4650 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4655 if (SECTION_HEADER_INDEX (symsec
->sh_link
)
4656 < elf_header
.e_shnum
)
4658 strsec
= SECTION_HEADER (symsec
->sh_link
);
4660 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4663 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4666 dump_relocations (file
, rel_offset
, rel_size
,
4667 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4673 dump_relocations (file
, rel_offset
, rel_size
,
4674 NULL
, 0, NULL
, 0, is_rela
);
4681 printf (_("\nThere are no relocations in this file.\n"));
4687 /* Process the unwind section. */
4689 #include "unwind-ia64.h"
4691 /* An absolute address consists of a section and an offset. If the
4692 section is NULL, the offset itself is the address, otherwise, the
4693 address equals to LOAD_ADDRESS(section) + offset. */
4697 unsigned short section
;
4701 struct ia64_unw_aux_info
4703 struct ia64_unw_table_entry
4705 struct absaddr start
;
4707 struct absaddr info
;
4709 *table
; /* Unwind table. */
4710 unsigned long table_len
; /* Length of unwind table. */
4711 unsigned char *info
; /* Unwind info. */
4712 unsigned long info_size
; /* Size of unwind info. */
4713 bfd_vma info_addr
; /* starting address of unwind info. */
4714 bfd_vma seg_base
; /* Starting address of segment. */
4715 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4716 unsigned long nsyms
; /* Number of symbols. */
4717 char *strtab
; /* The string table. */
4718 unsigned long strtab_size
; /* Size of string table. */
4722 find_symbol_for_address (Elf_Internal_Sym
*symtab
,
4723 unsigned long nsyms
,
4725 unsigned long strtab_size
,
4726 struct absaddr addr
,
4727 const char **symname
,
4730 bfd_vma dist
= 0x100000;
4731 Elf_Internal_Sym
*sym
, *best
= NULL
;
4734 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
4736 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4737 && sym
->st_name
!= 0
4738 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4739 && addr
.offset
>= sym
->st_value
4740 && addr
.offset
- sym
->st_value
< dist
)
4743 dist
= addr
.offset
- sym
->st_value
;
4750 *symname
= (best
->st_name
>= strtab_size
4751 ? "<corrupt>" : strtab
+ best
->st_name
);
4756 *offset
= addr
.offset
;
4760 dump_ia64_unwind (struct ia64_unw_aux_info
*aux
)
4762 struct ia64_unw_table_entry
*tp
;
4765 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4769 const unsigned char *dp
;
4770 const unsigned char *head
;
4771 const char *procname
;
4773 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4774 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
4776 fputs ("\n<", stdout
);
4780 fputs (procname
, stdout
);
4783 printf ("+%lx", (unsigned long) offset
);
4786 fputs (">: [", stdout
);
4787 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4788 fputc ('-', stdout
);
4789 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4790 printf ("], info at +0x%lx\n",
4791 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4793 head
= aux
->info
+ (tp
->info
.offset
- aux
->info_addr
);
4794 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
4796 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4797 (unsigned) UNW_VER (stamp
),
4798 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4799 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4800 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4801 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
4803 if (UNW_VER (stamp
) != 1)
4805 printf ("\tUnknown version.\n");
4810 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
4811 dp
= unw_decode (dp
, in_body
, & in_body
);
4816 slurp_ia64_unwind_table (FILE *file
,
4817 struct ia64_unw_aux_info
*aux
,
4818 Elf_Internal_Shdr
*sec
)
4820 unsigned long size
, nrelas
, i
;
4821 Elf_Internal_Phdr
*seg
;
4822 struct ia64_unw_table_entry
*tep
;
4823 Elf_Internal_Shdr
*relsec
;
4824 Elf_Internal_Rela
*rela
, *rp
;
4825 unsigned char *table
, *tp
;
4826 Elf_Internal_Sym
*sym
;
4827 const char *relname
;
4829 /* First, find the starting address of the segment that includes
4832 if (elf_header
.e_phnum
)
4834 if (! get_program_headers (file
))
4837 for (seg
= program_headers
;
4838 seg
< program_headers
+ elf_header
.e_phnum
;
4841 if (seg
->p_type
!= PT_LOAD
)
4844 if (sec
->sh_addr
>= seg
->p_vaddr
4845 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4847 aux
->seg_base
= seg
->p_vaddr
;
4853 /* Second, build the unwind table from the contents of the unwind section: */
4854 size
= sec
->sh_size
;
4855 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
4859 aux
->table
= xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
4861 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * eh_addr_size
, ++tep
)
4863 tep
->start
.section
= SHN_UNDEF
;
4864 tep
->end
.section
= SHN_UNDEF
;
4865 tep
->info
.section
= SHN_UNDEF
;
4868 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4869 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4870 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
4874 tep
->start
.offset
= BYTE_GET ((unsigned char *) tp
+ 0);
4875 tep
->end
.offset
= BYTE_GET ((unsigned char *) tp
+ 8);
4876 tep
->info
.offset
= BYTE_GET ((unsigned char *) tp
+ 16);
4878 tep
->start
.offset
+= aux
->seg_base
;
4879 tep
->end
.offset
+= aux
->seg_base
;
4880 tep
->info
.offset
+= aux
->seg_base
;
4884 /* Third, apply any relocations to the unwind table: */
4886 for (relsec
= section_headers
;
4887 relsec
< section_headers
+ elf_header
.e_shnum
;
4890 if (relsec
->sh_type
!= SHT_RELA
4891 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
4892 || SECTION_HEADER (relsec
->sh_info
) != sec
)
4895 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
4899 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4903 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4904 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4908 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4909 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4912 if (! strneq (relname
, "R_IA64_SEGREL", 13))
4914 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4918 i
= rp
->r_offset
/ (3 * eh_addr_size
);
4920 switch (rp
->r_offset
/eh_addr_size
% 3)
4923 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4924 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
4927 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4928 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
4931 aux
->table
[i
].info
.section
= sym
->st_shndx
;
4932 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
4942 aux
->table_len
= size
/ (3 * eh_addr_size
);
4947 ia64_process_unwind (FILE *file
)
4949 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
4950 unsigned long i
, unwcount
= 0, unwstart
= 0;
4951 struct ia64_unw_aux_info aux
;
4953 memset (& aux
, 0, sizeof (aux
));
4955 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4957 if (sec
->sh_type
== SHT_SYMTAB
4958 && SECTION_HEADER_INDEX (sec
->sh_link
) < elf_header
.e_shnum
)
4960 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
4961 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
4963 strsec
= SECTION_HEADER (sec
->sh_link
);
4964 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4965 1, strsec
->sh_size
, _("string table"));
4966 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
4968 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4973 printf (_("\nThere are no unwind sections in this file.\n"));
4975 while (unwcount
-- > 0)
4980 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
4981 i
< elf_header
.e_shnum
; ++i
, ++sec
)
4982 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4989 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
4991 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
4993 /* We need to find which section group it is in. */
4994 struct group_list
*g
= section_headers_groups
[i
]->root
;
4996 for (; g
!= NULL
; g
= g
->next
)
4998 sec
= SECTION_HEADER (g
->section_index
);
5000 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
5005 i
= elf_header
.e_shnum
;
5007 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
5009 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5010 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
5011 suffix
= SECTION_NAME (unwsec
) + len
;
5012 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5014 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
5015 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5020 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5021 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5022 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
5023 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
5025 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
5026 suffix
= SECTION_NAME (unwsec
) + len
;
5027 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5029 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
5030 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5034 if (i
== elf_header
.e_shnum
)
5036 printf (_("\nCould not find unwind info section for "));
5038 if (string_table
== NULL
)
5039 printf ("%d", unwsec
->sh_name
);
5041 printf (_("'%s'"), SECTION_NAME (unwsec
));
5045 aux
.info_size
= sec
->sh_size
;
5046 aux
.info_addr
= sec
->sh_addr
;
5047 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, 1, aux
.info_size
,
5050 printf (_("\nUnwind section "));
5052 if (string_table
== NULL
)
5053 printf ("%d", unwsec
->sh_name
);
5055 printf (_("'%s'"), SECTION_NAME (unwsec
));
5057 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5058 (unsigned long) unwsec
->sh_offset
,
5059 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
5061 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
5063 if (aux
.table_len
> 0)
5064 dump_ia64_unwind (& aux
);
5067 free ((char *) aux
.table
);
5069 free ((char *) aux
.info
);
5078 free ((char *) aux
.strtab
);
5083 struct hppa_unw_aux_info
5085 struct hppa_unw_table_entry
5087 struct absaddr start
;
5089 unsigned int Cannot_unwind
:1; /* 0 */
5090 unsigned int Millicode
:1; /* 1 */
5091 unsigned int Millicode_save_sr0
:1; /* 2 */
5092 unsigned int Region_description
:2; /* 3..4 */
5093 unsigned int reserved1
:1; /* 5 */
5094 unsigned int Entry_SR
:1; /* 6 */
5095 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
5096 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
5097 unsigned int Args_stored
:1; /* 16 */
5098 unsigned int Variable_Frame
:1; /* 17 */
5099 unsigned int Separate_Package_Body
:1; /* 18 */
5100 unsigned int Frame_Extension_Millicode
:1; /* 19 */
5101 unsigned int Stack_Overflow_Check
:1; /* 20 */
5102 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
5103 unsigned int Ada_Region
:1; /* 22 */
5104 unsigned int cxx_info
:1; /* 23 */
5105 unsigned int cxx_try_catch
:1; /* 24 */
5106 unsigned int sched_entry_seq
:1; /* 25 */
5107 unsigned int reserved2
:1; /* 26 */
5108 unsigned int Save_SP
:1; /* 27 */
5109 unsigned int Save_RP
:1; /* 28 */
5110 unsigned int Save_MRP_in_frame
:1; /* 29 */
5111 unsigned int extn_ptr_defined
:1; /* 30 */
5112 unsigned int Cleanup_defined
:1; /* 31 */
5114 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
5115 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
5116 unsigned int Large_frame
:1; /* 2 */
5117 unsigned int Pseudo_SP_Set
:1; /* 3 */
5118 unsigned int reserved4
:1; /* 4 */
5119 unsigned int Total_frame_size
:27; /* 5..31 */
5121 *table
; /* Unwind table. */
5122 unsigned long table_len
; /* Length of unwind table. */
5123 bfd_vma seg_base
; /* Starting address of segment. */
5124 Elf_Internal_Sym
*symtab
; /* The symbol table. */
5125 unsigned long nsyms
; /* Number of symbols. */
5126 char *strtab
; /* The string table. */
5127 unsigned long strtab_size
; /* Size of string table. */
5131 dump_hppa_unwind (struct hppa_unw_aux_info
*aux
)
5133 struct hppa_unw_table_entry
*tp
;
5135 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5138 const char *procname
;
5140 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5141 aux
->strtab_size
, tp
->start
, &procname
,
5144 fputs ("\n<", stdout
);
5148 fputs (procname
, stdout
);
5151 printf ("+%lx", (unsigned long) offset
);
5154 fputs (">: [", stdout
);
5155 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5156 fputc ('-', stdout
);
5157 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5160 #define PF(_m) if (tp->_m) printf (#_m " ");
5161 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5164 PF(Millicode_save_sr0
);
5165 /* PV(Region_description); */
5171 PF(Separate_Package_Body
);
5172 PF(Frame_Extension_Millicode
);
5173 PF(Stack_Overflow_Check
);
5174 PF(Two_Instruction_SP_Increment
);
5178 PF(sched_entry_seq
);
5181 PF(Save_MRP_in_frame
);
5182 PF(extn_ptr_defined
);
5183 PF(Cleanup_defined
);
5184 PF(MPE_XL_interrupt_marker
);
5185 PF(HP_UX_interrupt_marker
);
5188 PV(Total_frame_size
);
5197 slurp_hppa_unwind_table (FILE *file
,
5198 struct hppa_unw_aux_info
*aux
,
5199 Elf_Internal_Shdr
*sec
)
5201 unsigned long size
, unw_ent_size
, nrelas
, i
;
5202 Elf_Internal_Phdr
*seg
;
5203 struct hppa_unw_table_entry
*tep
;
5204 Elf_Internal_Shdr
*relsec
;
5205 Elf_Internal_Rela
*rela
, *rp
;
5206 unsigned char *table
, *tp
;
5207 Elf_Internal_Sym
*sym
;
5208 const char *relname
;
5210 /* First, find the starting address of the segment that includes
5213 if (elf_header
.e_phnum
)
5215 if (! get_program_headers (file
))
5218 for (seg
= program_headers
;
5219 seg
< program_headers
+ elf_header
.e_phnum
;
5222 if (seg
->p_type
!= PT_LOAD
)
5225 if (sec
->sh_addr
>= seg
->p_vaddr
5226 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5228 aux
->seg_base
= seg
->p_vaddr
;
5234 /* Second, build the unwind table from the contents of the unwind
5236 size
= sec
->sh_size
;
5237 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
5241 unw_ent_size
= 2 * eh_addr_size
+ 8;
5243 tep
= aux
->table
= xcmalloc (size
/ unw_ent_size
, sizeof (aux
->table
[0]));
5245 for (tp
= table
; tp
< table
+ size
; tp
+= (2 * eh_addr_size
+ 8), ++tep
)
5247 unsigned int tmp1
, tmp2
;
5249 tep
->start
.section
= SHN_UNDEF
;
5250 tep
->end
.section
= SHN_UNDEF
;
5254 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5255 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5256 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
5257 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
5261 tep
->start
.offset
= BYTE_GET ((unsigned char *) tp
+ 0);
5262 tep
->end
.offset
= BYTE_GET ((unsigned char *) tp
+ 8);
5263 tmp1
= byte_get ((unsigned char *) tp
+ 16, 4);
5264 tmp2
= byte_get ((unsigned char *) tp
+ 20, 4);
5267 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
5268 tep
->Millicode
= (tmp1
>> 30) & 0x1;
5269 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
5270 tep
->Region_description
= (tmp1
>> 27) & 0x3;
5271 tep
->reserved1
= (tmp1
>> 26) & 0x1;
5272 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
5273 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
5274 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
5275 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
5276 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
5277 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
5278 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
5279 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
5280 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
5281 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
5282 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
5283 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
5284 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
5285 tep
->reserved2
= (tmp1
>> 5) & 0x1;
5286 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
5287 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
5288 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
5289 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
5290 tep
->Cleanup_defined
= tmp1
& 0x1;
5292 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5293 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5294 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5295 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5296 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5297 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5299 tep
->start
.offset
+= aux
->seg_base
;
5300 tep
->end
.offset
+= aux
->seg_base
;
5304 /* Third, apply any relocations to the unwind table. */
5306 for (relsec
= section_headers
;
5307 relsec
< section_headers
+ elf_header
.e_shnum
;
5310 if (relsec
->sh_type
!= SHT_RELA
5311 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
5312 || SECTION_HEADER (relsec
->sh_info
) != sec
)
5315 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5319 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5323 relname
= elf_hppa_reloc_type (ELF32_R_TYPE (rp
->r_info
));
5324 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
5328 relname
= elf_hppa_reloc_type (ELF64_R_TYPE (rp
->r_info
));
5329 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
5332 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5333 if (strncmp (relname
, "R_PARISC_SEGREL", 15) != 0)
5335 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5339 i
= rp
->r_offset
/ unw_ent_size
;
5341 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5344 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5345 aux
->table
[i
].start
.offset
+= sym
->st_value
+ rp
->r_addend
;
5348 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5349 aux
->table
[i
].end
.offset
+= sym
->st_value
+ rp
->r_addend
;
5359 aux
->table_len
= size
/ unw_ent_size
;
5365 hppa_process_unwind (FILE *file
)
5367 struct hppa_unw_aux_info aux
;
5368 Elf_Internal_Shdr
*unwsec
= NULL
;
5369 Elf_Internal_Shdr
*strsec
;
5370 Elf_Internal_Shdr
*sec
;
5373 memset (& aux
, 0, sizeof (aux
));
5375 if (string_table
== NULL
)
5378 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5380 if (sec
->sh_type
== SHT_SYMTAB
5381 && SECTION_HEADER_INDEX (sec
->sh_link
) < elf_header
.e_shnum
)
5383 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5384 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5386 strsec
= SECTION_HEADER (sec
->sh_link
);
5387 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5388 1, strsec
->sh_size
, _("string table"));
5389 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5391 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5396 printf (_("\nThere are no unwind sections in this file.\n"));
5398 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5400 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5402 printf (_("\nUnwind section "));
5403 printf (_("'%s'"), SECTION_NAME (sec
));
5405 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5406 (unsigned long) sec
->sh_offset
,
5407 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5409 slurp_hppa_unwind_table (file
, &aux
, sec
);
5410 if (aux
.table_len
> 0)
5411 dump_hppa_unwind (&aux
);
5414 free ((char *) aux
.table
);
5422 free ((char *) aux
.strtab
);
5428 process_unwind (FILE *file
)
5430 struct unwind_handler
{
5432 int (*handler
)(FILE *file
);
5434 { EM_IA_64
, ia64_process_unwind
},
5435 { EM_PARISC
, hppa_process_unwind
},
5443 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5444 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5445 return handlers
[i
].handler (file
);
5447 printf (_("\nThere are no unwind sections in this file.\n"));
5452 dynamic_section_mips_val (Elf_Internal_Dyn
*entry
)
5454 switch (entry
->d_tag
)
5457 if (entry
->d_un
.d_val
== 0)
5461 static const char * opts
[] =
5463 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5464 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5465 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5466 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5471 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++cnt
)
5472 if (entry
->d_un
.d_val
& (1 << cnt
))
5474 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5481 case DT_MIPS_IVERSION
:
5482 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5483 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5485 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5488 case DT_MIPS_TIME_STAMP
:
5493 time_t time
= entry
->d_un
.d_val
;
5494 tmp
= gmtime (&time
);
5495 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5496 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5497 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5498 printf ("Time Stamp: %s\n", timebuf
);
5502 case DT_MIPS_RLD_VERSION
:
5503 case DT_MIPS_LOCAL_GOTNO
:
5504 case DT_MIPS_CONFLICTNO
:
5505 case DT_MIPS_LIBLISTNO
:
5506 case DT_MIPS_SYMTABNO
:
5507 case DT_MIPS_UNREFEXTNO
:
5508 case DT_MIPS_HIPAGENO
:
5509 case DT_MIPS_DELTA_CLASS_NO
:
5510 case DT_MIPS_DELTA_INSTANCE_NO
:
5511 case DT_MIPS_DELTA_RELOC_NO
:
5512 case DT_MIPS_DELTA_SYM_NO
:
5513 case DT_MIPS_DELTA_CLASSSYM_NO
:
5514 case DT_MIPS_COMPACT_SIZE
:
5515 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5519 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
5525 dynamic_section_parisc_val (Elf_Internal_Dyn
*entry
)
5527 switch (entry
->d_tag
)
5529 case DT_HP_DLD_FLAGS
:
5538 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5539 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5540 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5541 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5542 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5543 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5544 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5545 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5546 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5547 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5548 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
5549 { DT_HP_GST
, "HP_GST" },
5550 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
5551 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
5552 { DT_HP_NODELETE
, "HP_NODELETE" },
5553 { DT_HP_GROUP
, "HP_GROUP" },
5554 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
5558 bfd_vma val
= entry
->d_un
.d_val
;
5560 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
5561 if (val
& flags
[cnt
].bit
)
5565 fputs (flags
[cnt
].str
, stdout
);
5567 val
^= flags
[cnt
].bit
;
5570 if (val
!= 0 || first
)
5574 print_vma (val
, HEX
);
5580 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5587 dynamic_section_ia64_val (Elf_Internal_Dyn
*entry
)
5589 switch (entry
->d_tag
)
5591 case DT_IA_64_PLT_RESERVE
:
5592 /* First 3 slots reserved. */
5593 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5595 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5599 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5606 get_32bit_dynamic_section (FILE *file
)
5608 Elf32_External_Dyn
*edyn
, *ext
;
5609 Elf_Internal_Dyn
*entry
;
5611 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5612 _("dynamic section"));
5616 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5617 might not have the luxury of section headers. Look for the DT_NULL
5618 terminator to determine the number of entries. */
5619 for (ext
= edyn
, dynamic_nent
= 0;
5620 (char *) ext
< (char *) edyn
+ dynamic_size
;
5624 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5628 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5629 if (dynamic_section
== NULL
)
5631 error (_("Out of memory\n"));
5636 for (ext
= edyn
, entry
= dynamic_section
;
5637 entry
< dynamic_section
+ dynamic_nent
;
5640 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5641 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5650 get_64bit_dynamic_section (FILE *file
)
5652 Elf64_External_Dyn
*edyn
, *ext
;
5653 Elf_Internal_Dyn
*entry
;
5655 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5656 _("dynamic section"));
5660 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5661 might not have the luxury of section headers. Look for the DT_NULL
5662 terminator to determine the number of entries. */
5663 for (ext
= edyn
, dynamic_nent
= 0;
5664 (char *) ext
< (char *) edyn
+ dynamic_size
;
5668 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5672 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5673 if (dynamic_section
== NULL
)
5675 error (_("Out of memory\n"));
5680 for (ext
= edyn
, entry
= dynamic_section
;
5681 entry
< dynamic_section
+ dynamic_nent
;
5684 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5685 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5694 print_dynamic_flags (bfd_vma flags
)
5702 flag
= flags
& - flags
;
5712 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
5713 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
5714 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
5715 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
5716 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
5717 default: fputs ("unknown", stdout
); break;
5723 /* Parse and display the contents of the dynamic section. */
5726 process_dynamic_section (FILE *file
)
5728 Elf_Internal_Dyn
*entry
;
5730 if (dynamic_size
== 0)
5733 printf (_("\nThere is no dynamic section in this file.\n"));
5740 if (! get_32bit_dynamic_section (file
))
5743 else if (! get_64bit_dynamic_section (file
))
5746 /* Find the appropriate symbol table. */
5747 if (dynamic_symbols
== NULL
)
5749 for (entry
= dynamic_section
;
5750 entry
< dynamic_section
+ dynamic_nent
;
5753 Elf_Internal_Shdr section
;
5755 if (entry
->d_tag
!= DT_SYMTAB
)
5758 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
5760 /* Since we do not know how big the symbol table is,
5761 we default to reading in the entire file (!) and
5762 processing that. This is overkill, I know, but it
5764 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5766 if (archive_file_offset
!= 0)
5767 section
.sh_size
= archive_file_size
- section
.sh_offset
;
5770 if (fseek (file
, 0, SEEK_END
))
5771 error (_("Unable to seek to end of file!"));
5773 section
.sh_size
= ftell (file
) - section
.sh_offset
;
5777 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
5779 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
5781 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
5782 if (num_dynamic_syms
< 1)
5784 error (_("Unable to determine the number of symbols to load\n"));
5788 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
5792 /* Similarly find a string table. */
5793 if (dynamic_strings
== NULL
)
5795 for (entry
= dynamic_section
;
5796 entry
< dynamic_section
+ dynamic_nent
;
5799 unsigned long offset
;
5802 if (entry
->d_tag
!= DT_STRTAB
)
5805 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
5807 /* Since we do not know how big the string table is,
5808 we default to reading in the entire file (!) and
5809 processing that. This is overkill, I know, but it
5812 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5814 if (archive_file_offset
!= 0)
5815 str_tab_len
= archive_file_size
- offset
;
5818 if (fseek (file
, 0, SEEK_END
))
5819 error (_("Unable to seek to end of file\n"));
5820 str_tab_len
= ftell (file
) - offset
;
5823 if (str_tab_len
< 1)
5826 (_("Unable to determine the length of the dynamic string table\n"));
5830 dynamic_strings
= get_data (NULL
, file
, offset
, 1, str_tab_len
,
5831 _("dynamic string table"));
5832 dynamic_strings_length
= str_tab_len
;
5837 /* And find the syminfo section if available. */
5838 if (dynamic_syminfo
== NULL
)
5840 unsigned long syminsz
= 0;
5842 for (entry
= dynamic_section
;
5843 entry
< dynamic_section
+ dynamic_nent
;
5846 if (entry
->d_tag
== DT_SYMINENT
)
5848 /* Note: these braces are necessary to avoid a syntax
5849 error from the SunOS4 C compiler. */
5850 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
5852 else if (entry
->d_tag
== DT_SYMINSZ
)
5853 syminsz
= entry
->d_un
.d_val
;
5854 else if (entry
->d_tag
== DT_SYMINFO
)
5855 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
5859 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
5861 Elf_External_Syminfo
*extsyminfo
, *extsym
;
5862 Elf_Internal_Syminfo
*syminfo
;
5864 /* There is a syminfo section. Read the data. */
5865 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, 1,
5866 syminsz
, _("symbol information"));
5870 dynamic_syminfo
= malloc (syminsz
);
5871 if (dynamic_syminfo
== NULL
)
5873 error (_("Out of memory\n"));
5877 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
5878 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
5879 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
5880 ++syminfo
, ++extsym
)
5882 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
5883 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
5890 if (do_dynamic
&& dynamic_addr
)
5891 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
5892 dynamic_addr
, dynamic_nent
);
5894 printf (_(" Tag Type Name/Value\n"));
5896 for (entry
= dynamic_section
;
5897 entry
< dynamic_section
+ dynamic_nent
;
5905 print_vma (entry
->d_tag
, FULL_HEX
);
5906 dtype
= get_dynamic_type (entry
->d_tag
);
5907 printf (" (%s)%*s", dtype
,
5908 ((is_32bit_elf
? 27 : 19)
5909 - (int) strlen (dtype
)),
5913 switch (entry
->d_tag
)
5917 print_dynamic_flags (entry
->d_un
.d_val
);
5927 switch (entry
->d_tag
)
5930 printf (_("Auxiliary library"));
5934 printf (_("Filter library"));
5938 printf (_("Configuration file"));
5942 printf (_("Dependency audit library"));
5946 printf (_("Audit library"));
5950 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5951 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5955 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5964 printf (_("Flags:"));
5966 if (entry
->d_un
.d_val
== 0)
5967 printf (_(" None\n"));
5970 unsigned long int val
= entry
->d_un
.d_val
;
5972 if (val
& DTF_1_PARINIT
)
5974 printf (" PARINIT");
5975 val
^= DTF_1_PARINIT
;
5977 if (val
& DTF_1_CONFEXP
)
5979 printf (" CONFEXP");
5980 val
^= DTF_1_CONFEXP
;
5983 printf (" %lx", val
);
5992 printf (_("Flags:"));
5994 if (entry
->d_un
.d_val
== 0)
5995 printf (_(" None\n"));
5998 unsigned long int val
= entry
->d_un
.d_val
;
6000 if (val
& DF_P1_LAZYLOAD
)
6002 printf (" LAZYLOAD");
6003 val
^= DF_P1_LAZYLOAD
;
6005 if (val
& DF_P1_GROUPPERM
)
6007 printf (" GROUPPERM");
6008 val
^= DF_P1_GROUPPERM
;
6011 printf (" %lx", val
);
6020 printf (_("Flags:"));
6021 if (entry
->d_un
.d_val
== 0)
6022 printf (_(" None\n"));
6025 unsigned long int val
= entry
->d_un
.d_val
;
6032 if (val
& DF_1_GLOBAL
)
6037 if (val
& DF_1_GROUP
)
6042 if (val
& DF_1_NODELETE
)
6044 printf (" NODELETE");
6045 val
^= DF_1_NODELETE
;
6047 if (val
& DF_1_LOADFLTR
)
6049 printf (" LOADFLTR");
6050 val
^= DF_1_LOADFLTR
;
6052 if (val
& DF_1_INITFIRST
)
6054 printf (" INITFIRST");
6055 val
^= DF_1_INITFIRST
;
6057 if (val
& DF_1_NOOPEN
)
6062 if (val
& DF_1_ORIGIN
)
6067 if (val
& DF_1_DIRECT
)
6072 if (val
& DF_1_TRANS
)
6077 if (val
& DF_1_INTERPOSE
)
6079 printf (" INTERPOSE");
6080 val
^= DF_1_INTERPOSE
;
6082 if (val
& DF_1_NODEFLIB
)
6084 printf (" NODEFLIB");
6085 val
^= DF_1_NODEFLIB
;
6087 if (val
& DF_1_NODUMP
)
6092 if (val
& DF_1_CONLFAT
)
6094 printf (" CONLFAT");
6095 val
^= DF_1_CONLFAT
;
6098 printf (" %lx", val
);
6105 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6107 puts (get_dynamic_type (entry
->d_un
.d_val
));
6127 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6133 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6134 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6140 switch (entry
->d_tag
)
6143 printf (_("Shared library: [%s]"), name
);
6145 if (streq (name
, program_interpreter
))
6146 printf (_(" program interpreter"));
6150 printf (_("Library soname: [%s]"), name
);
6154 printf (_("Library rpath: [%s]"), name
);
6158 printf (_("Library runpath: [%s]"), name
);
6162 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6167 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6180 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6184 case DT_INIT_ARRAYSZ
:
6185 case DT_FINI_ARRAYSZ
:
6186 case DT_GNU_CONFLICTSZ
:
6187 case DT_GNU_LIBLISTSZ
:
6190 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6191 printf (" (bytes)\n");
6201 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6214 if (entry
->d_tag
== DT_USED
6215 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6217 char *name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6221 printf (_("Not needed object: [%s]\n"), name
);
6226 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6232 /* The value of this entry is ignored. */
6237 case DT_GNU_PRELINKED
:
6241 time_t time
= entry
->d_un
.d_val
;
6243 tmp
= gmtime (&time
);
6244 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6245 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6246 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6252 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
6253 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
6258 switch (elf_header
.e_machine
)
6261 case EM_MIPS_RS3_LE
:
6262 dynamic_section_mips_val (entry
);
6265 dynamic_section_parisc_val (entry
);
6268 dynamic_section_ia64_val (entry
);
6271 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6283 get_ver_flags (unsigned int flags
)
6285 static char buff
[32];
6292 if (flags
& VER_FLG_BASE
)
6293 strcat (buff
, "BASE ");
6295 if (flags
& VER_FLG_WEAK
)
6297 if (flags
& VER_FLG_BASE
)
6298 strcat (buff
, "| ");
6300 strcat (buff
, "WEAK ");
6303 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
6304 strcat (buff
, "| <unknown>");
6309 /* Display the contents of the version sections. */
6311 process_version_sections (FILE *file
)
6313 Elf_Internal_Shdr
*section
;
6320 for (i
= 0, section
= section_headers
;
6321 i
< elf_header
.e_shnum
;
6324 switch (section
->sh_type
)
6326 case SHT_GNU_verdef
:
6328 Elf_External_Verdef
*edefs
;
6335 (_("\nVersion definition section '%s' contains %ld entries:\n"),
6336 SECTION_NAME (section
), section
->sh_info
);
6338 printf (_(" Addr: 0x"));
6339 printf_vma (section
->sh_addr
);
6340 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6341 (unsigned long) section
->sh_offset
, section
->sh_link
,
6342 SECTION_HEADER_INDEX (section
->sh_link
)
6343 < elf_header
.e_shnum
6344 ? SECTION_NAME (SECTION_HEADER (section
->sh_link
))
6347 edefs
= get_data (NULL
, file
, section
->sh_offset
, 1,
6349 _("version definition section"));
6353 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6356 Elf_External_Verdef
*edef
;
6357 Elf_Internal_Verdef ent
;
6358 Elf_External_Verdaux
*eaux
;
6359 Elf_Internal_Verdaux aux
;
6363 vstart
= ((char *) edefs
) + idx
;
6365 edef
= (Elf_External_Verdef
*) vstart
;
6367 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
6368 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
6369 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
6370 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
6371 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
6372 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
6373 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
6375 printf (_(" %#06x: Rev: %d Flags: %s"),
6376 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
6378 printf (_(" Index: %d Cnt: %d "),
6379 ent
.vd_ndx
, ent
.vd_cnt
);
6381 vstart
+= ent
.vd_aux
;
6383 eaux
= (Elf_External_Verdaux
*) vstart
;
6385 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6386 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6388 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6389 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6391 printf (_("Name index: %ld\n"), aux
.vda_name
);
6393 isum
= idx
+ ent
.vd_aux
;
6395 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6397 isum
+= aux
.vda_next
;
6398 vstart
+= aux
.vda_next
;
6400 eaux
= (Elf_External_Verdaux
*) vstart
;
6402 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6403 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6405 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6406 printf (_(" %#06x: Parent %d: %s\n"),
6407 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6409 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6410 isum
, j
, aux
.vda_name
);
6420 case SHT_GNU_verneed
:
6422 Elf_External_Verneed
*eneed
;
6428 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
6429 SECTION_NAME (section
), section
->sh_info
);
6431 printf (_(" Addr: 0x"));
6432 printf_vma (section
->sh_addr
);
6433 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
6434 (unsigned long) section
->sh_offset
, section
->sh_link
,
6435 SECTION_HEADER_INDEX (section
->sh_link
)
6436 < elf_header
.e_shnum
6437 ? SECTION_NAME (SECTION_HEADER (section
->sh_link
))
6440 eneed
= get_data (NULL
, file
, section
->sh_offset
, 1,
6442 _("version need section"));
6446 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6448 Elf_External_Verneed
*entry
;
6449 Elf_Internal_Verneed ent
;
6454 vstart
= ((char *) eneed
) + idx
;
6456 entry
= (Elf_External_Verneed
*) vstart
;
6458 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6459 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6460 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6461 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6462 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6464 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6466 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6467 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6469 printf (_(" File: %lx"), ent
.vn_file
);
6471 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6473 vstart
+= ent
.vn_aux
;
6475 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6477 Elf_External_Vernaux
*eaux
;
6478 Elf_Internal_Vernaux aux
;
6480 eaux
= (Elf_External_Vernaux
*) vstart
;
6482 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6483 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6484 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6485 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6486 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6488 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6489 printf (_(" %#06x: Name: %s"),
6490 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6492 printf (_(" %#06x: Name index: %lx"),
6493 isum
, aux
.vna_name
);
6495 printf (_(" Flags: %s Version: %d\n"),
6496 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6498 isum
+= aux
.vna_next
;
6499 vstart
+= aux
.vna_next
;
6509 case SHT_GNU_versym
:
6511 Elf_Internal_Shdr
*link_section
;
6514 unsigned char *edata
;
6515 unsigned short *data
;
6517 Elf_Internal_Sym
*symbols
;
6518 Elf_Internal_Shdr
*string_sec
;
6521 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
)
6524 link_section
= SECTION_HEADER (section
->sh_link
);
6525 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
6527 if (SECTION_HEADER_INDEX (link_section
->sh_link
)
6528 >= elf_header
.e_shnum
)
6533 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6535 string_sec
= SECTION_HEADER (link_section
->sh_link
);
6537 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
6538 string_sec
->sh_size
, _("version string table"));
6542 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6543 SECTION_NAME (section
), total
);
6545 printf (_(" Addr: "));
6546 printf_vma (section
->sh_addr
);
6547 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6548 (unsigned long) section
->sh_offset
, section
->sh_link
,
6549 SECTION_NAME (link_section
));
6551 off
= offset_from_vma (file
,
6552 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6553 total
* sizeof (short));
6554 edata
= get_data (NULL
, file
, off
, total
, sizeof (short),
6555 _("version symbol data"));
6562 data
= cmalloc (total
, sizeof (short));
6564 for (cnt
= total
; cnt
--;)
6565 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6570 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6573 int check_def
, check_need
;
6576 printf (" %03x:", cnt
);
6578 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6579 switch (data
[cnt
+ j
])
6582 fputs (_(" 0 (*local*) "), stdout
);
6586 fputs (_(" 1 (*global*) "), stdout
);
6590 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
6591 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
6595 if (SECTION_HEADER_INDEX (symbols
[cnt
+ j
].st_shndx
)
6596 >= elf_header
.e_shnum
6597 || SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
6600 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6607 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6609 Elf_Internal_Verneed ivn
;
6610 unsigned long offset
;
6612 offset
= offset_from_vma
6613 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6614 sizeof (Elf_External_Verneed
));
6618 Elf_Internal_Vernaux ivna
;
6619 Elf_External_Verneed evn
;
6620 Elf_External_Vernaux evna
;
6621 unsigned long a_off
;
6623 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
6626 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6627 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6629 a_off
= offset
+ ivn
.vn_aux
;
6633 get_data (&evna
, file
, a_off
, sizeof (evna
),
6634 1, _("version need aux (2)"));
6636 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6637 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6639 a_off
+= ivna
.vna_next
;
6641 while (ivna
.vna_other
!= data
[cnt
+ j
]
6642 && ivna
.vna_next
!= 0);
6644 if (ivna
.vna_other
== data
[cnt
+ j
])
6646 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6648 name
= strtab
+ ivna
.vna_name
;
6649 nn
+= printf ("(%s%-*s",
6651 12 - (int) strlen (name
),
6657 offset
+= ivn
.vn_next
;
6659 while (ivn
.vn_next
);
6662 if (check_def
&& data
[cnt
+ j
] != 0x8001
6663 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6665 Elf_Internal_Verdef ivd
;
6666 Elf_External_Verdef evd
;
6667 unsigned long offset
;
6669 offset
= offset_from_vma
6670 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6675 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
6678 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6679 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6681 offset
+= ivd
.vd_next
;
6683 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
6684 && ivd
.vd_next
!= 0);
6686 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
6688 Elf_External_Verdaux evda
;
6689 Elf_Internal_Verdaux ivda
;
6691 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6693 get_data (&evda
, file
,
6694 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
6696 _("version def aux"));
6698 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6700 name
= strtab
+ ivda
.vda_name
;
6701 nn
+= printf ("(%s%-*s",
6703 12 - (int) strlen (name
),
6709 printf ("%*c", 18 - nn
, ' ');
6727 printf (_("\nNo version information found in this file.\n"));
6733 get_symbol_binding (unsigned int binding
)
6735 static char buff
[32];
6739 case STB_LOCAL
: return "LOCAL";
6740 case STB_GLOBAL
: return "GLOBAL";
6741 case STB_WEAK
: return "WEAK";
6743 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
6744 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
6746 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
6747 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
6749 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
6755 get_symbol_type (unsigned int type
)
6757 static char buff
[32];
6761 case STT_NOTYPE
: return "NOTYPE";
6762 case STT_OBJECT
: return "OBJECT";
6763 case STT_FUNC
: return "FUNC";
6764 case STT_SECTION
: return "SECTION";
6765 case STT_FILE
: return "FILE";
6766 case STT_COMMON
: return "COMMON";
6767 case STT_TLS
: return "TLS";
6769 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
6771 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
6772 return "THUMB_FUNC";
6774 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
6777 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
6778 return "PARISC_MILLI";
6780 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
6782 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
6784 if (elf_header
.e_machine
== EM_PARISC
)
6786 if (type
== STT_HP_OPAQUE
)
6788 if (type
== STT_HP_STUB
)
6792 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
6795 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
6801 get_symbol_visibility (unsigned int visibility
)
6805 case STV_DEFAULT
: return "DEFAULT";
6806 case STV_INTERNAL
: return "INTERNAL";
6807 case STV_HIDDEN
: return "HIDDEN";
6808 case STV_PROTECTED
: return "PROTECTED";
6814 get_symbol_index_type (unsigned int type
)
6816 static char buff
[32];
6820 case SHN_UNDEF
: return "UND";
6821 case SHN_ABS
: return "ABS";
6822 case SHN_COMMON
: return "COM";
6824 if (type
== SHN_IA_64_ANSI_COMMON
6825 && elf_header
.e_machine
== EM_IA_64
6826 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
6828 else if (elf_header
.e_machine
== EM_X86_64
6829 && type
== SHN_X86_64_LCOMMON
)
6831 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
6832 sprintf (buff
, "PRC[0x%04x]", type
);
6833 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
6834 sprintf (buff
, "OS [0x%04x]", type
);
6835 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
6836 sprintf (buff
, "RSV[0x%04x]", type
);
6838 sprintf (buff
, "%3d", type
);
6846 get_dynamic_data (FILE *file
, unsigned int number
, unsigned int ent_size
)
6848 unsigned char *e_data
;
6851 e_data
= cmalloc (number
, ent_size
);
6855 error (_("Out of memory\n"));
6859 if (fread (e_data
, ent_size
, number
, file
) != number
)
6861 error (_("Unable to read in dynamic data\n"));
6865 i_data
= cmalloc (number
, sizeof (*i_data
));
6869 error (_("Out of memory\n"));
6875 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
6882 /* Dump the symbol table. */
6884 process_symbol_table (FILE *file
)
6886 Elf_Internal_Shdr
*section
;
6887 bfd_vma nbuckets
= 0;
6888 bfd_vma nchains
= 0;
6889 bfd_vma
*buckets
= NULL
;
6890 bfd_vma
*chains
= NULL
;
6892 if (! do_syms
&& !do_histogram
)
6895 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
6898 unsigned char nb
[8];
6899 unsigned char nc
[8];
6900 int hash_ent_size
= 4;
6902 if ((elf_header
.e_machine
== EM_ALPHA
6903 || elf_header
.e_machine
== EM_S390
6904 || elf_header
.e_machine
== EM_S390_OLD
)
6905 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
6909 (archive_file_offset
6910 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
6911 sizeof nb
+ sizeof nc
)),
6914 error (_("Unable to seek to start of dynamic information"));
6918 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
6920 error (_("Failed to read in number of buckets\n"));
6924 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
6926 error (_("Failed to read in number of chains\n"));
6930 nbuckets
= byte_get (nb
, hash_ent_size
);
6931 nchains
= byte_get (nc
, hash_ent_size
);
6933 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
6934 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
6936 if (buckets
== NULL
|| chains
== NULL
)
6941 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
6946 printf (_("\nSymbol table for image:\n"));
6948 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6950 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6952 for (hn
= 0; hn
< nbuckets
; hn
++)
6957 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
6959 Elf_Internal_Sym
*psym
;
6962 psym
= dynamic_symbols
+ si
;
6964 n
= print_vma (si
, DEC_5
);
6966 fputs (" " + n
, stdout
);
6967 printf (" %3lu: ", hn
);
6968 print_vma (psym
->st_value
, LONG_HEX
);
6970 print_vma (psym
->st_size
, DEC_5
);
6972 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6973 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6974 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6975 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
6976 if (VALID_DYNAMIC_NAME (psym
->st_name
))
6977 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
6979 printf (" <corrupt: %14ld>", psym
->st_name
);
6984 else if (do_syms
&& !do_using_dynamic
)
6988 for (i
= 0, section
= section_headers
;
6989 i
< elf_header
.e_shnum
;
6993 char *strtab
= NULL
;
6994 unsigned long int strtab_size
= 0;
6995 Elf_Internal_Sym
*symtab
;
6996 Elf_Internal_Sym
*psym
;
6999 if ( section
->sh_type
!= SHT_SYMTAB
7000 && section
->sh_type
!= SHT_DYNSYM
)
7003 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
7004 SECTION_NAME (section
),
7005 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
7007 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7009 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7011 symtab
= GET_ELF_SYMBOLS (file
, section
);
7015 if (section
->sh_link
== elf_header
.e_shstrndx
)
7017 strtab
= string_table
;
7018 strtab_size
= string_table_length
;
7020 else if (SECTION_HEADER_INDEX (section
->sh_link
) < elf_header
.e_shnum
)
7022 Elf_Internal_Shdr
*string_sec
;
7024 string_sec
= SECTION_HEADER (section
->sh_link
);
7026 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
7027 1, string_sec
->sh_size
, _("string table"));
7028 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
7031 for (si
= 0, psym
= symtab
;
7032 si
< section
->sh_size
/ section
->sh_entsize
;
7035 printf ("%6d: ", si
);
7036 print_vma (psym
->st_value
, LONG_HEX
);
7038 print_vma (psym
->st_size
, DEC_5
);
7039 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7040 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7041 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7042 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
7043 print_symbol (25, psym
->st_name
< strtab_size
7044 ? strtab
+ psym
->st_name
: "<corrupt>");
7046 if (section
->sh_type
== SHT_DYNSYM
&&
7047 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
7049 unsigned char data
[2];
7050 unsigned short vers_data
;
7051 unsigned long offset
;
7055 offset
= offset_from_vma
7056 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
7057 sizeof data
+ si
* sizeof (vers_data
));
7059 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
7060 sizeof (data
), 1, _("version data"));
7062 vers_data
= byte_get (data
, 2);
7064 is_nobits
= (SECTION_HEADER_INDEX (psym
->st_shndx
)
7065 < elf_header
.e_shnum
7066 && SECTION_HEADER (psym
->st_shndx
)->sh_type
7069 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
7071 if ((vers_data
& 0x8000) || vers_data
> 1)
7073 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
7074 && (is_nobits
|| ! check_def
))
7076 Elf_External_Verneed evn
;
7077 Elf_Internal_Verneed ivn
;
7078 Elf_Internal_Vernaux ivna
;
7080 /* We must test both. */
7081 offset
= offset_from_vma
7082 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
7087 unsigned long vna_off
;
7089 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
7092 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
7093 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
7095 vna_off
= offset
+ ivn
.vn_aux
;
7099 Elf_External_Vernaux evna
;
7101 get_data (&evna
, file
, vna_off
,
7103 _("version need aux (3)"));
7105 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
7106 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
7107 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
7109 vna_off
+= ivna
.vna_next
;
7111 while (ivna
.vna_other
!= vers_data
7112 && ivna
.vna_next
!= 0);
7114 if (ivna
.vna_other
== vers_data
)
7117 offset
+= ivn
.vn_next
;
7119 while (ivn
.vn_next
!= 0);
7121 if (ivna
.vna_other
== vers_data
)
7124 ivna
.vna_name
< strtab_size
7125 ? strtab
+ ivna
.vna_name
: "<corrupt>",
7129 else if (! is_nobits
)
7130 error (_("bad dynamic symbol"));
7137 if (vers_data
!= 0x8001
7138 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7140 Elf_Internal_Verdef ivd
;
7141 Elf_Internal_Verdaux ivda
;
7142 Elf_External_Verdaux evda
;
7143 unsigned long offset
;
7145 offset
= offset_from_vma
7147 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7148 sizeof (Elf_External_Verdef
));
7152 Elf_External_Verdef evd
;
7154 get_data (&evd
, file
, offset
, sizeof (evd
),
7155 1, _("version def"));
7157 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7158 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7159 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7161 offset
+= ivd
.vd_next
;
7163 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
7164 && ivd
.vd_next
!= 0);
7166 offset
-= ivd
.vd_next
;
7167 offset
+= ivd
.vd_aux
;
7169 get_data (&evda
, file
, offset
, sizeof (evda
),
7170 1, _("version def aux"));
7172 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7174 if (psym
->st_name
!= ivda
.vda_name
)
7175 printf ((vers_data
& 0x8000)
7177 ivda
.vda_name
< strtab_size
7178 ? strtab
+ ivda
.vda_name
: "<corrupt>");
7188 if (strtab
!= string_table
)
7194 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7196 if (do_histogram
&& buckets
!= NULL
)
7198 unsigned long *lengths
;
7199 unsigned long *counts
;
7202 unsigned long maxlength
= 0;
7203 unsigned long nzero_counts
= 0;
7204 unsigned long nsyms
= 0;
7206 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7207 (unsigned long) nbuckets
);
7208 printf (_(" Length Number %% of total Coverage\n"));
7210 lengths
= calloc (nbuckets
, sizeof (*lengths
));
7211 if (lengths
== NULL
)
7213 error (_("Out of memory"));
7216 for (hn
= 0; hn
< nbuckets
; ++hn
)
7218 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
7221 if (maxlength
< ++lengths
[hn
])
7226 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7229 error (_("Out of memory"));
7233 for (hn
= 0; hn
< nbuckets
; ++hn
)
7234 ++counts
[lengths
[hn
]];
7239 printf (" 0 %-10lu (%5.1f%%)\n",
7240 counts
[0], (counts
[0] * 100.0) / nbuckets
);
7241 for (i
= 1; i
<= maxlength
; ++i
)
7243 nzero_counts
+= counts
[i
] * i
;
7244 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7245 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
7246 (nzero_counts
* 100.0) / nsyms
);
7254 if (buckets
!= NULL
)
7264 process_syminfo (FILE *file ATTRIBUTE_UNUSED
)
7268 if (dynamic_syminfo
== NULL
7270 /* No syminfo, this is ok. */
7273 /* There better should be a dynamic symbol section. */
7274 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
7278 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7279 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
7281 printf (_(" Num: Name BoundTo Flags\n"));
7282 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
7284 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
7286 printf ("%4d: ", i
);
7287 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
7288 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
7290 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
7293 switch (dynamic_syminfo
[i
].si_boundto
)
7295 case SYMINFO_BT_SELF
:
7296 fputs ("SELF ", stdout
);
7298 case SYMINFO_BT_PARENT
:
7299 fputs ("PARENT ", stdout
);
7302 if (dynamic_syminfo
[i
].si_boundto
> 0
7303 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
7304 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
7306 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
7310 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
7314 if (flags
& SYMINFO_FLG_DIRECT
)
7316 if (flags
& SYMINFO_FLG_PASSTHRU
)
7317 printf (" PASSTHRU");
7318 if (flags
& SYMINFO_FLG_COPY
)
7320 if (flags
& SYMINFO_FLG_LAZYLOAD
)
7321 printf (" LAZYLOAD");
7329 #ifdef SUPPORT_DISASSEMBLY
7331 disassemble_section (Elf_Internal_Shdr
*section
, FILE *file
)
7333 printf (_("\nAssembly dump of section %s\n"),
7334 SECTION_NAME (section
));
7336 /* XXX -- to be done --- XXX */
7343 dump_section (Elf_Internal_Shdr
*section
, FILE *file
)
7345 bfd_size_type bytes
;
7347 unsigned char *data
;
7348 unsigned char *start
;
7350 bytes
= section
->sh_size
;
7352 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
7354 printf (_("\nSection '%s' has no data to dump.\n"),
7355 SECTION_NAME (section
));
7359 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
7361 addr
= section
->sh_addr
;
7363 start
= get_data (NULL
, file
, section
->sh_offset
, 1, bytes
,
7376 lbytes
= (bytes
> 16 ? 16 : bytes
);
7378 printf (" 0x%8.8lx ", (unsigned long) addr
);
7380 switch (elf_header
.e_ident
[EI_DATA
])
7384 for (j
= 15; j
>= 0; j
--)
7387 printf ("%2.2x", data
[j
]);
7397 for (j
= 0; j
< 16; j
++)
7400 printf ("%2.2x", data
[j
]);
7410 for (j
= 0; j
< lbytes
; j
++)
7413 if (k
>= ' ' && k
< 0x7f)
7432 static unsigned long int
7433 read_leb128 (unsigned char *data
, unsigned int *length_return
, int sign
)
7435 unsigned long int result
= 0;
7436 unsigned int num_read
= 0;
7437 unsigned int shift
= 0;
7445 result
|= ((unsigned long int) (byte
& 0x7f)) << shift
;
7450 while (byte
& 0x80);
7452 if (length_return
!= NULL
)
7453 *length_return
= num_read
;
7455 if (sign
&& (shift
< 8 * sizeof (result
)) && (byte
& 0x40))
7456 result
|= -1L << shift
;
7461 typedef struct State_Machine_Registers
7463 unsigned long address
;
7466 unsigned int column
;
7470 /* This variable hold the number of the last entry seen
7471 in the File Table. */
7472 unsigned int last_file_entry
;
7475 static SMR state_machine_regs
;
7478 reset_state_machine (int is_stmt
)
7480 state_machine_regs
.address
= 0;
7481 state_machine_regs
.file
= 1;
7482 state_machine_regs
.line
= 1;
7483 state_machine_regs
.column
= 0;
7484 state_machine_regs
.is_stmt
= is_stmt
;
7485 state_machine_regs
.basic_block
= 0;
7486 state_machine_regs
.end_sequence
= 0;
7487 state_machine_regs
.last_file_entry
= 0;
7490 /* Handled an extend line op.
7491 Returns the number of bytes read. */
7494 process_extended_line_op (unsigned char *data
, int is_stmt
, int pointer_size
)
7496 unsigned char op_code
;
7497 unsigned int bytes_read
;
7499 unsigned char *name
;
7502 len
= read_leb128 (data
, & bytes_read
, 0);
7507 warn (_("badly formed extended line op encountered!\n"));
7514 printf (_(" Extended opcode %d: "), op_code
);
7518 case DW_LNE_end_sequence
:
7519 printf (_("End of Sequence\n\n"));
7520 reset_state_machine (is_stmt
);
7523 case DW_LNE_set_address
:
7524 adr
= byte_get (data
, pointer_size
);
7525 printf (_("set Address to 0x%lx\n"), adr
);
7526 state_machine_regs
.address
= adr
;
7529 case DW_LNE_define_file
:
7530 printf (_(" define new File Table entry\n"));
7531 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
7533 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
7535 data
+= strlen ((char *) data
) + 1;
7536 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7538 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7540 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7541 printf (_("%s\n\n"), name
);
7545 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
7552 static const char *debug_str_contents
;
7553 static bfd_vma debug_str_size
;
7556 load_debug_str (FILE *file
)
7558 Elf_Internal_Shdr
*sec
;
7560 /* If it is already loaded, do nothing. */
7561 if (debug_str_contents
!= NULL
)
7564 /* Locate the .debug_str section. */
7565 sec
= find_section (".debug_str");
7569 debug_str_size
= sec
->sh_size
;
7571 debug_str_contents
= get_data (NULL
, file
, sec
->sh_offset
, 1, sec
->sh_size
,
7572 _("debug_str section data"));
7576 free_debug_str (void)
7578 if (debug_str_contents
== NULL
)
7581 free ((char *) debug_str_contents
);
7582 debug_str_contents
= NULL
;
7587 fetch_indirect_string (unsigned long offset
)
7589 if (debug_str_contents
== NULL
)
7590 return _("<no .debug_str section>");
7592 if (offset
> debug_str_size
)
7594 warn (_("DW_FORM_strp offset too big: %lx\n"), offset
);
7595 return _("<offset is too big>");
7598 return debug_str_contents
+ offset
;
7601 static const char *debug_loc_contents
;
7602 static bfd_vma debug_loc_size
;
7605 load_debug_loc (FILE *file
)
7607 Elf_Internal_Shdr
*sec
;
7609 /* If it is already loaded, do nothing. */
7610 if (debug_loc_contents
!= NULL
)
7613 /* Locate the .debug_loc section. */
7614 sec
= find_section (".debug_loc");
7618 debug_loc_size
= sec
->sh_size
;
7620 debug_loc_contents
= get_data (NULL
, file
, sec
->sh_offset
, 1, sec
->sh_size
,
7621 _("debug_loc section data"));
7625 free_debug_loc (void)
7627 if (debug_loc_contents
== NULL
)
7630 free ((char *) debug_loc_contents
);
7631 debug_loc_contents
= NULL
;
7635 static const char * debug_range_contents
;
7636 static unsigned long debug_range_size
;
7639 load_debug_range (FILE *file
)
7641 Elf_Internal_Shdr
*sec
;
7643 /* If it is already loaded, do nothing. */
7644 if (debug_range_contents
!= NULL
)
7647 /* Locate the .debug_ranges section. */
7648 sec
= find_section (".debug_ranges");
7652 debug_range_size
= sec
->sh_size
;
7654 debug_range_contents
= get_data (NULL
, file
, sec
->sh_offset
, 1, sec
->sh_size
,
7655 _("debug_range section data"));
7659 free_debug_range (void)
7661 if (debug_range_contents
== NULL
)
7664 free ((char *) debug_range_contents
);
7665 debug_range_contents
= NULL
;
7666 debug_range_size
= 0;
7669 /* Apply addends of RELA relocations. */
7672 debug_apply_rela_addends (FILE *file
,
7673 Elf_Internal_Shdr
*section
,
7675 unsigned char *sec_data
,
7676 unsigned char *start
,
7679 Elf_Internal_Shdr
*relsec
;
7681 if (end
- start
< reloc_size
)
7684 for (relsec
= section_headers
;
7685 relsec
< section_headers
+ elf_header
.e_shnum
;
7688 unsigned long nrelas
;
7689 Elf_Internal_Rela
*rela
, *rp
;
7690 Elf_Internal_Shdr
*symsec
;
7691 Elf_Internal_Sym
*symtab
;
7692 Elf_Internal_Sym
*sym
;
7694 if (relsec
->sh_type
!= SHT_RELA
7695 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
7696 || SECTION_HEADER (relsec
->sh_info
) != section
7697 || relsec
->sh_size
== 0
7698 || SECTION_HEADER_INDEX (relsec
->sh_link
) >= elf_header
.e_shnum
)
7701 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7705 symsec
= SECTION_HEADER (relsec
->sh_link
);
7706 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
7708 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7712 if (rp
->r_offset
>= (bfd_vma
) (start
- sec_data
)
7713 && rp
->r_offset
< (bfd_vma
) (end
- sec_data
) - reloc_size
)
7714 loc
= sec_data
+ rp
->r_offset
;
7720 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
7722 if (ELF32_R_SYM (rp
->r_info
) != 0
7723 && ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
7724 /* Relocations against object symbols can happen,
7725 eg when referencing a global array. For an
7726 example of this see the _clz.o binary in libgcc.a. */
7727 && ELF32_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7729 warn (_("skipping unexpected symbol type %s in relocation in section .rela%s\n"),
7730 get_symbol_type (ELF32_ST_TYPE (sym
->st_info
)),
7731 SECTION_NAME (section
));
7737 /* In MIPS little-endian objects, r_info isn't really a
7738 64-bit little-endian value: it has a 32-bit little-endian
7739 symbol index followed by four individual byte fields.
7740 Reorder INFO accordingly. */
7741 if (elf_header
.e_machine
== EM_MIPS
7742 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
7743 rp
->r_info
= (((rp
->r_info
& 0xffffffff) << 32)
7744 | ((rp
->r_info
>> 56) & 0xff)
7745 | ((rp
->r_info
>> 40) & 0xff00)
7746 | ((rp
->r_info
>> 24) & 0xff0000)
7747 | ((rp
->r_info
>> 8) & 0xff000000));
7749 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
7751 if (ELF64_R_SYM (rp
->r_info
) != 0
7752 && ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
7753 && ELF64_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7755 warn (_("skipping unexpected symbol type %s in relocation in section .rela.%s\n"),
7756 get_symbol_type (ELF64_ST_TYPE (sym
->st_info
)),
7757 SECTION_NAME (section
));
7762 byte_put (loc
, rp
->r_addend
, reloc_size
);
7772 /* FIXME: There are better and more efficient ways to handle
7773 these structures. For now though, I just want something that
7774 is simple to implement. */
7775 typedef struct abbrev_attr
7777 unsigned long attribute
;
7779 struct abbrev_attr
*next
;
7783 typedef struct abbrev_entry
7785 unsigned long entry
;
7788 struct abbrev_attr
*first_attr
;
7789 struct abbrev_attr
*last_attr
;
7790 struct abbrev_entry
*next
;
7794 static abbrev_entry
*first_abbrev
= NULL
;
7795 static abbrev_entry
*last_abbrev
= NULL
;
7800 abbrev_entry
*abbrev
;
7802 for (abbrev
= first_abbrev
; abbrev
;)
7804 abbrev_entry
*next
= abbrev
->next
;
7807 for (attr
= abbrev
->first_attr
; attr
;)
7809 abbrev_attr
*next
= attr
->next
;
7819 last_abbrev
= first_abbrev
= NULL
;
7823 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
7825 abbrev_entry
*entry
;
7827 entry
= malloc (sizeof (*entry
));
7833 entry
->entry
= number
;
7835 entry
->children
= children
;
7836 entry
->first_attr
= NULL
;
7837 entry
->last_attr
= NULL
;
7840 if (first_abbrev
== NULL
)
7841 first_abbrev
= entry
;
7843 last_abbrev
->next
= entry
;
7845 last_abbrev
= entry
;
7849 add_abbrev_attr (unsigned long attribute
, unsigned long form
)
7853 attr
= malloc (sizeof (*attr
));
7859 attr
->attribute
= attribute
;
7863 if (last_abbrev
->first_attr
== NULL
)
7864 last_abbrev
->first_attr
= attr
;
7866 last_abbrev
->last_attr
->next
= attr
;
7868 last_abbrev
->last_attr
= attr
;
7871 /* Processes the (partial) contents of a .debug_abbrev section.
7872 Returns NULL if the end of the section was encountered.
7873 Returns the address after the last byte read if the end of
7874 an abbreviation set was found. */
7876 static unsigned char *
7877 process_abbrev_section (unsigned char *start
, unsigned char *end
)
7879 if (first_abbrev
!= NULL
)
7884 unsigned int bytes_read
;
7885 unsigned long entry
;
7887 unsigned long attribute
;
7890 entry
= read_leb128 (start
, & bytes_read
, 0);
7891 start
+= bytes_read
;
7893 /* A single zero is supposed to end the section according
7894 to the standard. If there's more, then signal that to
7897 return start
== end
? NULL
: start
;
7899 tag
= read_leb128 (start
, & bytes_read
, 0);
7900 start
+= bytes_read
;
7902 children
= *start
++;
7904 add_abbrev (entry
, tag
, children
);
7910 attribute
= read_leb128 (start
, & bytes_read
, 0);
7911 start
+= bytes_read
;
7913 form
= read_leb128 (start
, & bytes_read
, 0);
7914 start
+= bytes_read
;
7917 add_abbrev_attr (attribute
, form
);
7919 while (attribute
!= 0);
7926 get_TAG_name (unsigned long tag
)
7930 case DW_TAG_padding
: return "DW_TAG_padding";
7931 case DW_TAG_array_type
: return "DW_TAG_array_type";
7932 case DW_TAG_class_type
: return "DW_TAG_class_type";
7933 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
7934 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
7935 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
7936 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
7937 case DW_TAG_label
: return "DW_TAG_label";
7938 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
7939 case DW_TAG_member
: return "DW_TAG_member";
7940 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
7941 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
7942 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
7943 case DW_TAG_string_type
: return "DW_TAG_string_type";
7944 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
7945 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
7946 case DW_TAG_typedef
: return "DW_TAG_typedef";
7947 case DW_TAG_union_type
: return "DW_TAG_union_type";
7948 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
7949 case DW_TAG_variant
: return "DW_TAG_variant";
7950 case DW_TAG_common_block
: return "DW_TAG_common_block";
7951 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
7952 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
7953 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
7954 case DW_TAG_module
: return "DW_TAG_module";
7955 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
7956 case DW_TAG_set_type
: return "DW_TAG_set_type";
7957 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
7958 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
7959 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
7960 case DW_TAG_base_type
: return "DW_TAG_base_type";
7961 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
7962 case DW_TAG_const_type
: return "DW_TAG_const_type";
7963 case DW_TAG_constant
: return "DW_TAG_constant";
7964 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
7965 case DW_TAG_file_type
: return "DW_TAG_file_type";
7966 case DW_TAG_friend
: return "DW_TAG_friend";
7967 case DW_TAG_namelist
: return "DW_TAG_namelist";
7968 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
7969 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
7970 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
7971 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
7972 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
7973 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
7974 case DW_TAG_try_block
: return "DW_TAG_try_block";
7975 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
7976 case DW_TAG_variable
: return "DW_TAG_variable";
7977 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
7978 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
7979 case DW_TAG_format_label
: return "DW_TAG_format_label";
7980 case DW_TAG_function_template
: return "DW_TAG_function_template";
7981 case DW_TAG_class_template
: return "DW_TAG_class_template";
7982 /* DWARF 2.1 values. */
7983 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
7984 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
7985 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
7986 case DW_TAG_namespace
: return "DW_TAG_namespace";
7987 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
7988 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
7989 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
7990 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
7992 case DW_TAG_upc_shared_type
: return "DW_TAG_upc_shared_type";
7993 case DW_TAG_upc_strict_type
: return "DW_TAG_upc_strict_type";
7994 case DW_TAG_upc_relaxed_type
: return "DW_TAG_upc_relaxed_type";
7997 static char buffer
[100];
7999 snprintf (buffer
, sizeof (buffer
), _("Unknown TAG value: %lx"), tag
);
8006 get_FORM_name (unsigned long form
)
8010 case DW_FORM_addr
: return "DW_FORM_addr";
8011 case DW_FORM_block2
: return "DW_FORM_block2";
8012 case DW_FORM_block4
: return "DW_FORM_block4";
8013 case DW_FORM_data2
: return "DW_FORM_data2";
8014 case DW_FORM_data4
: return "DW_FORM_data4";
8015 case DW_FORM_data8
: return "DW_FORM_data8";
8016 case DW_FORM_string
: return "DW_FORM_string";
8017 case DW_FORM_block
: return "DW_FORM_block";
8018 case DW_FORM_block1
: return "DW_FORM_block1";
8019 case DW_FORM_data1
: return "DW_FORM_data1";
8020 case DW_FORM_flag
: return "DW_FORM_flag";
8021 case DW_FORM_sdata
: return "DW_FORM_sdata";
8022 case DW_FORM_strp
: return "DW_FORM_strp";
8023 case DW_FORM_udata
: return "DW_FORM_udata";
8024 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
8025 case DW_FORM_ref1
: return "DW_FORM_ref1";
8026 case DW_FORM_ref2
: return "DW_FORM_ref2";
8027 case DW_FORM_ref4
: return "DW_FORM_ref4";
8028 case DW_FORM_ref8
: return "DW_FORM_ref8";
8029 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
8030 case DW_FORM_indirect
: return "DW_FORM_indirect";
8033 static char buffer
[100];
8035 snprintf (buffer
, sizeof (buffer
), _("Unknown FORM value: %lx"), form
);
8041 static unsigned char *
8042 display_block (unsigned char *data
, unsigned long length
)
8044 printf (_(" %lu byte block: "), length
);
8047 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
8053 decode_location_expression (unsigned char * data
,
8054 unsigned int pointer_size
,
8055 unsigned long length
,
8056 unsigned long cu_offset
)
8059 unsigned int bytes_read
;
8060 unsigned long uvalue
;
8061 unsigned char *end
= data
+ length
;
8062 int need_frame_base
= 0;
8071 printf ("DW_OP_addr: %lx",
8072 (unsigned long) byte_get (data
, pointer_size
));
8073 data
+= pointer_size
;
8076 printf ("DW_OP_deref");
8079 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
8082 printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data
++, 1));
8085 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
8089 printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data
, 2));
8093 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
8097 printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data
, 4));
8101 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
8102 (unsigned long) byte_get (data
+ 4, 4));
8106 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
8107 (long) byte_get (data
+ 4, 4));
8111 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
8115 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
8119 printf ("DW_OP_dup");
8122 printf ("DW_OP_drop");
8125 printf ("DW_OP_over");
8128 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
8131 printf ("DW_OP_swap");
8134 printf ("DW_OP_rot");
8137 printf ("DW_OP_xderef");
8140 printf ("DW_OP_abs");
8143 printf ("DW_OP_and");
8146 printf ("DW_OP_div");
8149 printf ("DW_OP_minus");
8152 printf ("DW_OP_mod");
8155 printf ("DW_OP_mul");
8158 printf ("DW_OP_neg");
8161 printf ("DW_OP_not");
8164 printf ("DW_OP_or");
8167 printf ("DW_OP_plus");
8169 case DW_OP_plus_uconst
:
8170 printf ("DW_OP_plus_uconst: %lu",
8171 read_leb128 (data
, &bytes_read
, 0));
8175 printf ("DW_OP_shl");
8178 printf ("DW_OP_shr");
8181 printf ("DW_OP_shra");
8184 printf ("DW_OP_xor");
8187 printf ("DW_OP_bra: %ld", (long) byte_get_signed (data
, 2));
8191 printf ("DW_OP_eq");
8194 printf ("DW_OP_ge");
8197 printf ("DW_OP_gt");
8200 printf ("DW_OP_le");
8203 printf ("DW_OP_lt");
8206 printf ("DW_OP_ne");
8209 printf ("DW_OP_skip: %ld", (long) byte_get_signed (data
, 2));
8245 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
8280 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
8315 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
8316 read_leb128 (data
, &bytes_read
, 1));
8321 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
8325 need_frame_base
= 1;
8326 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
8330 uvalue
= read_leb128 (data
, &bytes_read
, 0);
8332 printf ("DW_OP_bregx: %lu %ld", uvalue
,
8333 read_leb128 (data
, &bytes_read
, 1));
8337 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
8340 case DW_OP_deref_size
:
8341 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
8343 case DW_OP_xderef_size
:
8344 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
8347 printf ("DW_OP_nop");
8350 /* DWARF 3 extensions. */
8351 case DW_OP_push_object_address
:
8352 printf ("DW_OP_push_object_address");
8355 /* XXX: Strictly speaking for 64-bit DWARF3 files
8356 this ought to be an 8-byte wide computation. */
8357 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2) + cu_offset
);
8361 /* XXX: Strictly speaking for 64-bit DWARF3 files
8362 this ought to be an 8-byte wide computation. */
8363 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4) + cu_offset
);
8366 case DW_OP_call_ref
:
8367 printf ("DW_OP_call_ref");
8370 /* GNU extensions. */
8371 case DW_OP_GNU_push_tls_address
:
8372 printf ("DW_OP_GNU_push_tls_address");
8376 if (op
>= DW_OP_lo_user
8377 && op
<= DW_OP_hi_user
)
8378 printf (_("(User defined location op)"));
8380 printf (_("(Unknown location op)"));
8381 /* No way to tell where the next op is, so just bail. */
8382 return need_frame_base
;
8385 /* Separate the ops. */
8390 return need_frame_base
;
8393 /* This structure records the information that
8394 we extract from the.debug_info section. */
8397 unsigned int pointer_size
;
8398 unsigned long cu_offset
;
8399 unsigned long base_address
;
8400 /* This is an array of offsets to the location list table. */
8401 unsigned long *loc_offsets
;
8402 int *have_frame_base
;
8403 unsigned int num_loc_offsets
;
8404 unsigned int max_loc_offsets
;
8405 unsigned long *range_lists
;
8406 unsigned int num_range_lists
;
8407 unsigned int max_range_lists
;
8411 static debug_info
* debug_information
= NULL
;
8412 static unsigned int num_debug_info_entries
= 0;
8413 static unsigned int last_pointer_size
= 0;
8414 static int warned_about_missing_comp_units
= FALSE
;
8416 static unsigned char *
8417 read_and_display_attr_value (unsigned long attribute
,
8419 unsigned char *data
,
8420 unsigned long cu_offset
,
8421 unsigned long pointer_size
,
8422 unsigned long offset_size
,
8424 debug_info
*debug_info_p
,
8427 unsigned long uvalue
= 0;
8428 unsigned char *block_start
= NULL
;
8429 unsigned int bytes_read
;
8436 case DW_FORM_ref_addr
:
8437 if (dwarf_version
== 2)
8439 uvalue
= byte_get (data
, pointer_size
);
8440 data
+= pointer_size
;
8442 else if (dwarf_version
== 3)
8444 uvalue
= byte_get (data
, offset_size
);
8445 data
+= offset_size
;
8449 error (_("Internal error: DWARF version is not 2 or 3.\n"));
8454 uvalue
= byte_get (data
, pointer_size
);
8455 data
+= pointer_size
;
8459 uvalue
= byte_get (data
, offset_size
);
8460 data
+= offset_size
;
8466 uvalue
= byte_get (data
++, 1);
8471 uvalue
= byte_get (data
, 2);
8477 uvalue
= byte_get (data
, 4);
8482 uvalue
= read_leb128 (data
, & bytes_read
, 1);
8486 case DW_FORM_ref_udata
:
8488 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8492 case DW_FORM_indirect
:
8493 form
= read_leb128 (data
, & bytes_read
, 0);
8496 printf (" %s", get_FORM_name (form
));
8497 return read_and_display_attr_value (attribute
, form
, data
,
8498 cu_offset
, pointer_size
,
8499 offset_size
, dwarf_version
,
8500 debug_info_p
, do_loc
);
8505 case DW_FORM_ref_addr
:
8507 printf (" <#%lx>", uvalue
);
8513 case DW_FORM_ref_udata
:
8515 printf (" <%lx>", uvalue
+ cu_offset
);
8521 printf (" %#lx", uvalue
);
8530 printf (" %ld", uvalue
);
8537 uvalue
= byte_get (data
, 4);
8538 printf (" %lx", uvalue
);
8539 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
8541 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8542 && num_debug_info_entries
== 0)
8544 if (sizeof (uvalue
) == 8)
8545 uvalue
= byte_get (data
, 8);
8547 error (_("DW_FORM_data8 is unsupported when sizeof (unsigned long) != 8\n"));
8552 case DW_FORM_string
:
8554 printf (" %s", data
);
8555 data
+= strlen ((char *) data
) + 1;
8559 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8560 block_start
= data
+ bytes_read
;
8562 data
= block_start
+ uvalue
;
8564 data
= display_block (block_start
, uvalue
);
8567 case DW_FORM_block1
:
8568 uvalue
= byte_get (data
, 1);
8569 block_start
= data
+ 1;
8571 data
= block_start
+ uvalue
;
8573 data
= display_block (block_start
, uvalue
);
8576 case DW_FORM_block2
:
8577 uvalue
= byte_get (data
, 2);
8578 block_start
= data
+ 2;
8580 data
= block_start
+ uvalue
;
8582 data
= display_block (block_start
, uvalue
);
8585 case DW_FORM_block4
:
8586 uvalue
= byte_get (data
, 4);
8587 block_start
= data
+ 4;
8589 data
= block_start
+ uvalue
;
8591 data
= display_block (block_start
, uvalue
);
8596 printf (_(" (indirect string, offset: 0x%lx): %s"),
8597 uvalue
, fetch_indirect_string (uvalue
));
8600 case DW_FORM_indirect
:
8601 /* Handled above. */
8605 warn (_("Unrecognized form: %lu\n"), form
);
8609 /* For some attributes we can display further information. */
8610 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8611 && num_debug_info_entries
== 0)
8615 case DW_AT_frame_base
:
8616 have_frame_base
= 1;
8617 case DW_AT_location
:
8618 case DW_AT_data_member_location
:
8619 case DW_AT_vtable_elem_location
:
8620 case DW_AT_allocated
:
8621 case DW_AT_associated
:
8622 case DW_AT_data_location
:
8624 case DW_AT_upper_bound
:
8625 case DW_AT_lower_bound
:
8626 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8628 /* Process location list. */
8629 unsigned int max
= debug_info_p
->max_loc_offsets
;
8630 unsigned int num
= debug_info_p
->num_loc_offsets
;
8632 if (max
== 0 || num
>= max
)
8635 debug_info_p
->loc_offsets
8636 = xcrealloc (debug_info_p
->loc_offsets
,
8637 max
, sizeof (*debug_info_p
->loc_offsets
));
8638 debug_info_p
->have_frame_base
8639 = xcrealloc (debug_info_p
->have_frame_base
,
8640 max
, sizeof (*debug_info_p
->have_frame_base
));
8641 debug_info_p
->max_loc_offsets
= max
;
8643 debug_info_p
->loc_offsets
[num
] = uvalue
;
8644 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
8645 debug_info_p
->num_loc_offsets
++;
8650 if (need_base_address
)
8651 debug_info_p
->base_address
= uvalue
;
8655 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8657 /* Process range list. */
8658 unsigned int max
= debug_info_p
->max_range_lists
;
8659 unsigned int num
= debug_info_p
->num_range_lists
;
8661 if (max
== 0 || num
>= max
)
8664 debug_info_p
->range_lists
8665 = xcrealloc (debug_info_p
->range_lists
,
8666 max
, sizeof (*debug_info_p
->range_lists
));
8667 debug_info_p
->max_range_lists
= max
;
8669 debug_info_p
->range_lists
[num
] = uvalue
;
8670 debug_info_p
->num_range_lists
++;
8689 case DW_INL_not_inlined
:
8690 printf (_("(not inlined)"));
8692 case DW_INL_inlined
:
8693 printf (_("(inlined)"));
8695 case DW_INL_declared_not_inlined
:
8696 printf (_("(declared as inline but ignored)"));
8698 case DW_INL_declared_inlined
:
8699 printf (_("(declared as inline and inlined)"));
8702 printf (_(" (Unknown inline attribute value: %lx)"), uvalue
);
8707 case DW_AT_language
:
8710 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
8711 case DW_LANG_C89
: printf ("(ANSI C)"); break;
8712 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
8713 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
8714 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
8715 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
8716 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
8717 case DW_LANG_Ada83
: printf ("(Ada)"); break;
8718 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
8719 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
8720 /* DWARF 2.1 values. */
8721 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
8722 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
8723 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
8724 /* MIPS extension. */
8725 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
8726 /* UPC extension. */
8727 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
8729 printf ("(Unknown: %lx)", uvalue
);
8734 case DW_AT_encoding
:
8737 case DW_ATE_void
: printf ("(void)"); break;
8738 case DW_ATE_address
: printf ("(machine address)"); break;
8739 case DW_ATE_boolean
: printf ("(boolean)"); break;
8740 case DW_ATE_complex_float
: printf ("(complex float)"); break;
8741 case DW_ATE_float
: printf ("(float)"); break;
8742 case DW_ATE_signed
: printf ("(signed)"); break;
8743 case DW_ATE_signed_char
: printf ("(signed char)"); break;
8744 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
8745 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
8746 /* DWARF 2.1 value. */
8747 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
8748 case DW_ATE_decimal_float
: printf ("(decimal float)"); break;
8750 if (uvalue
>= DW_ATE_lo_user
8751 && uvalue
<= DW_ATE_hi_user
)
8752 printf ("(user defined type)");
8754 printf ("(unknown type)");
8759 case DW_AT_accessibility
:
8762 case DW_ACCESS_public
: printf ("(public)"); break;
8763 case DW_ACCESS_protected
: printf ("(protected)"); break;
8764 case DW_ACCESS_private
: printf ("(private)"); break;
8766 printf ("(unknown accessibility)");
8771 case DW_AT_visibility
:
8774 case DW_VIS_local
: printf ("(local)"); break;
8775 case DW_VIS_exported
: printf ("(exported)"); break;
8776 case DW_VIS_qualified
: printf ("(qualified)"); break;
8777 default: printf ("(unknown visibility)"); break;
8781 case DW_AT_virtuality
:
8784 case DW_VIRTUALITY_none
: printf ("(none)"); break;
8785 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
8786 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
8787 default: printf ("(unknown virtuality)"); break;
8791 case DW_AT_identifier_case
:
8794 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
8795 case DW_ID_up_case
: printf ("(up_case)"); break;
8796 case DW_ID_down_case
: printf ("(down_case)"); break;
8797 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
8798 default: printf ("(unknown case)"); break;
8802 case DW_AT_calling_convention
:
8805 case DW_CC_normal
: printf ("(normal)"); break;
8806 case DW_CC_program
: printf ("(program)"); break;
8807 case DW_CC_nocall
: printf ("(nocall)"); break;
8809 if (uvalue
>= DW_CC_lo_user
8810 && uvalue
<= DW_CC_hi_user
)
8811 printf ("(user defined)");
8813 printf ("(unknown convention)");
8817 case DW_AT_ordering
:
8820 case -1: printf ("(undefined)"); break;
8821 case 0: printf ("(row major)"); break;
8822 case 1: printf ("(column major)"); break;
8826 case DW_AT_frame_base
:
8827 have_frame_base
= 1;
8828 case DW_AT_location
:
8829 case DW_AT_data_member_location
:
8830 case DW_AT_vtable_elem_location
:
8831 case DW_AT_allocated
:
8832 case DW_AT_associated
:
8833 case DW_AT_data_location
:
8835 case DW_AT_upper_bound
:
8836 case DW_AT_lower_bound
:
8839 int need_frame_base
;
8842 need_frame_base
= decode_location_expression (block_start
,
8847 if (need_frame_base
&& !have_frame_base
)
8848 printf (_(" [without DW_AT_frame_base]"));
8850 else if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8851 printf (_("(location list)"));
8863 get_AT_name (unsigned long attribute
)
8867 case DW_AT_sibling
: return "DW_AT_sibling";
8868 case DW_AT_location
: return "DW_AT_location";
8869 case DW_AT_name
: return "DW_AT_name";
8870 case DW_AT_ordering
: return "DW_AT_ordering";
8871 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
8872 case DW_AT_byte_size
: return "DW_AT_byte_size";
8873 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
8874 case DW_AT_bit_size
: return "DW_AT_bit_size";
8875 case DW_AT_element_list
: return "DW_AT_element_list";
8876 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
8877 case DW_AT_low_pc
: return "DW_AT_low_pc";
8878 case DW_AT_high_pc
: return "DW_AT_high_pc";
8879 case DW_AT_language
: return "DW_AT_language";
8880 case DW_AT_member
: return "DW_AT_member";
8881 case DW_AT_discr
: return "DW_AT_discr";
8882 case DW_AT_discr_value
: return "DW_AT_discr_value";
8883 case DW_AT_visibility
: return "DW_AT_visibility";
8884 case DW_AT_import
: return "DW_AT_import";
8885 case DW_AT_string_length
: return "DW_AT_string_length";
8886 case DW_AT_common_reference
: return "DW_AT_common_reference";
8887 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
8888 case DW_AT_const_value
: return "DW_AT_const_value";
8889 case DW_AT_containing_type
: return "DW_AT_containing_type";
8890 case DW_AT_default_value
: return "DW_AT_default_value";
8891 case DW_AT_inline
: return "DW_AT_inline";
8892 case DW_AT_is_optional
: return "DW_AT_is_optional";
8893 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
8894 case DW_AT_producer
: return "DW_AT_producer";
8895 case DW_AT_prototyped
: return "DW_AT_prototyped";
8896 case DW_AT_return_addr
: return "DW_AT_return_addr";
8897 case DW_AT_start_scope
: return "DW_AT_start_scope";
8898 case DW_AT_stride_size
: return "DW_AT_stride_size";
8899 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
8900 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
8901 case DW_AT_accessibility
: return "DW_AT_accessibility";
8902 case DW_AT_address_class
: return "DW_AT_address_class";
8903 case DW_AT_artificial
: return "DW_AT_artificial";
8904 case DW_AT_base_types
: return "DW_AT_base_types";
8905 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
8906 case DW_AT_count
: return "DW_AT_count";
8907 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
8908 case DW_AT_decl_column
: return "DW_AT_decl_column";
8909 case DW_AT_decl_file
: return "DW_AT_decl_file";
8910 case DW_AT_decl_line
: return "DW_AT_decl_line";
8911 case DW_AT_declaration
: return "DW_AT_declaration";
8912 case DW_AT_discr_list
: return "DW_AT_discr_list";
8913 case DW_AT_encoding
: return "DW_AT_encoding";
8914 case DW_AT_external
: return "DW_AT_external";
8915 case DW_AT_frame_base
: return "DW_AT_frame_base";
8916 case DW_AT_friend
: return "DW_AT_friend";
8917 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
8918 case DW_AT_macro_info
: return "DW_AT_macro_info";
8919 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
8920 case DW_AT_priority
: return "DW_AT_priority";
8921 case DW_AT_segment
: return "DW_AT_segment";
8922 case DW_AT_specification
: return "DW_AT_specification";
8923 case DW_AT_static_link
: return "DW_AT_static_link";
8924 case DW_AT_type
: return "DW_AT_type";
8925 case DW_AT_use_location
: return "DW_AT_use_location";
8926 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
8927 case DW_AT_virtuality
: return "DW_AT_virtuality";
8928 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
8929 /* DWARF 2.1 values. */
8930 case DW_AT_allocated
: return "DW_AT_allocated";
8931 case DW_AT_associated
: return "DW_AT_associated";
8932 case DW_AT_data_location
: return "DW_AT_data_location";
8933 case DW_AT_stride
: return "DW_AT_stride";
8934 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
8935 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
8936 case DW_AT_extension
: return "DW_AT_extension";
8937 case DW_AT_ranges
: return "DW_AT_ranges";
8938 case DW_AT_trampoline
: return "DW_AT_trampoline";
8939 case DW_AT_call_column
: return "DW_AT_call_column";
8940 case DW_AT_call_file
: return "DW_AT_call_file";
8941 case DW_AT_call_line
: return "DW_AT_call_line";
8942 /* SGI/MIPS extensions. */
8943 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
8944 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
8945 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
8946 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
8947 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
8948 case DW_AT_MIPS_software_pipeline_depth
:
8949 return "DW_AT_MIPS_software_pipeline_depth";
8950 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
8951 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
8952 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
8953 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
8954 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
8955 /* GNU extensions. */
8956 case DW_AT_sf_names
: return "DW_AT_sf_names";
8957 case DW_AT_src_info
: return "DW_AT_src_info";
8958 case DW_AT_mac_info
: return "DW_AT_mac_info";
8959 case DW_AT_src_coords
: return "DW_AT_src_coords";
8960 case DW_AT_body_begin
: return "DW_AT_body_begin";
8961 case DW_AT_body_end
: return "DW_AT_body_end";
8962 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
8963 /* UPC extension. */
8964 case DW_AT_upc_threads_scaled
: return "DW_AT_upc_threads_scaled";
8967 static char buffer
[100];
8969 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
8976 static unsigned char *
8977 read_and_display_attr (unsigned long attribute
,
8979 unsigned char *data
,
8980 unsigned long cu_offset
,
8981 unsigned long pointer_size
,
8982 unsigned long offset_size
,
8984 debug_info
*debug_info_p
,
8988 printf (" %-18s:", get_AT_name (attribute
));
8989 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
8990 pointer_size
, offset_size
,
8991 dwarf_version
, debug_info_p
,
8999 /* Process the contents of a .debug_info section. If do_loc is non-zero
9000 then we are scanning for location lists and we do not want to display
9001 anything to the user. */
9004 process_debug_info (Elf_Internal_Shdr
*section
, unsigned char *start
,
9005 FILE *file
, int do_loc
)
9007 unsigned char *end
= start
+ section
->sh_size
;
9008 unsigned char *section_begin
;
9010 unsigned int num_units
= 0;
9012 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
9013 && num_debug_info_entries
== 0)
9015 unsigned long length
;
9017 /* First scan the section to get the number of comp units. */
9018 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
9021 /* Read the first 4 bytes. For a 32-bit DWARF section, this
9022 will be the length. For a 64-bit DWARF section, it'll be
9023 the escape code 0xffffffff followed by an 8 byte length. */
9024 length
= byte_get (section_begin
, 4);
9026 if (length
== 0xffffffff)
9028 length
= byte_get (section_begin
+ 4, 8);
9029 section_begin
+= length
+ 12;
9032 section_begin
+= length
+ 4;
9037 error (_("No comp units in .debug_info section ?"));
9041 /* Then allocate an array to hold the information. */
9042 debug_information
= cmalloc (num_units
,
9043 sizeof (* debug_information
));
9044 if (debug_information
== NULL
)
9046 error (_("Not enough memory for a debug info array of %u entries"),
9054 printf (_("The section %s contains:\n\n"),
9055 SECTION_NAME (section
));
9057 load_debug_str (file
);
9058 load_debug_loc (file
);
9059 load_debug_range (file
);
9062 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
9064 DWARF2_Internal_CompUnit compunit
;
9065 unsigned char *hdrptr
;
9066 unsigned char *cu_abbrev_offset_ptr
;
9067 unsigned char *tags
;
9069 unsigned long cu_offset
;
9071 int initial_length_size
;
9075 compunit
.cu_length
= byte_get (hdrptr
, 4);
9078 if (compunit
.cu_length
== 0xffffffff)
9080 compunit
.cu_length
= byte_get (hdrptr
, 8);
9083 initial_length_size
= 12;
9088 initial_length_size
= 4;
9091 compunit
.cu_version
= byte_get (hdrptr
, 2);
9094 cu_offset
= start
- section_begin
;
9095 start
+= compunit
.cu_length
+ initial_length_size
;
9097 if (elf_header
.e_type
== ET_REL
9098 && !debug_apply_rela_addends (file
, section
, offset_size
,
9099 section_begin
, hdrptr
, start
))
9102 cu_abbrev_offset_ptr
= hdrptr
;
9103 compunit
.cu_abbrev_offset
= byte_get (hdrptr
, offset_size
);
9104 hdrptr
+= offset_size
;
9106 compunit
.cu_pointer_size
= byte_get (hdrptr
, 1);
9108 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
9109 && num_debug_info_entries
== 0)
9111 debug_information
[unit
].cu_offset
= cu_offset
;
9112 debug_information
[unit
].pointer_size
9113 = compunit
.cu_pointer_size
;
9114 debug_information
[unit
].base_address
= 0;
9115 debug_information
[unit
].loc_offsets
= NULL
;
9116 debug_information
[unit
].have_frame_base
= NULL
;
9117 debug_information
[unit
].max_loc_offsets
= 0;
9118 debug_information
[unit
].num_loc_offsets
= 0;
9119 debug_information
[unit
].range_lists
= NULL
;
9120 debug_information
[unit
].max_range_lists
= 0;
9121 debug_information
[unit
].num_range_lists
= 0;
9128 printf (_(" Compilation Unit @ offset 0x%lx:\n"), cu_offset
);
9129 printf (_(" Length: %ld\n"), compunit
.cu_length
);
9130 printf (_(" Version: %d\n"), compunit
.cu_version
);
9131 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
9132 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
9135 if (compunit
.cu_version
!= 2 && compunit
.cu_version
!= 3)
9137 warn (_("Only version 2 and 3 DWARF debug information is currently supported.\n"));
9143 /* Read in the abbrevs used by this compilation unit. */
9145 Elf_Internal_Shdr
*sec
;
9146 unsigned char *begin
;
9148 /* Locate the .debug_abbrev section and process it. */
9149 sec
= find_section (".debug_abbrev");
9152 warn (_("Unable to locate .debug_abbrev section!\n"));
9156 begin
= get_data (NULL
, file
, sec
->sh_offset
, 1, sec
->sh_size
,
9157 _("debug_abbrev section data"));
9161 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
9162 begin
+ sec
->sh_size
);
9168 while (tags
< start
)
9170 unsigned int bytes_read
;
9171 unsigned long abbrev_number
;
9172 abbrev_entry
*entry
;
9175 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
9178 /* A null DIE marks the end of a list of children. */
9179 if (abbrev_number
== 0)
9185 /* Scan through the abbreviation list until we reach the
9187 for (entry
= first_abbrev
;
9188 entry
&& entry
->entry
!= abbrev_number
;
9189 entry
= entry
->next
)
9194 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
9200 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
9202 (unsigned long) (tags
- section_begin
9205 get_TAG_name (entry
->tag
));
9210 need_base_address
= 0;
9212 case DW_TAG_compile_unit
:
9213 need_base_address
= 1;
9215 case DW_TAG_entry_point
:
9216 case DW_TAG_inlined_subroutine
:
9217 case DW_TAG_subprogram
:
9218 need_base_address
= 0;
9219 /* Assuming that there is no DW_AT_frame_base. */
9220 have_frame_base
= 0;
9224 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
9225 tags
= read_and_display_attr (attr
->attribute
,
9228 compunit
.cu_pointer_size
,
9230 compunit
.cu_version
,
9231 &debug_information
[unit
],
9234 if (entry
->children
)
9239 /* Set num_debug_info_entries here so that it can be used to check if
9240 we need to process .debug_loc and .debug_ranges sections. */
9241 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
9242 && num_debug_info_entries
== 0)
9243 num_debug_info_entries
= num_units
;
9247 free_debug_range ();
9257 /* Retrieve the pointer size associated with the given compilation unit.
9258 Optionally the offset of this unit into the .debug_info section is
9259 also retutned. If there is no .debug_info section then an error
9260 message is issued and 0 is returned. If the requested comp unit has
9261 not been defined in the .debug_info section then a warning message
9262 is issued and the last know pointer size is returned. This message
9263 is only issued once per section dumped per file dumped. */
9266 get_pointer_size_and_offset_of_comp_unit (unsigned int comp_unit
,
9267 const char * section_name
,
9268 unsigned long * offset_return
)
9270 unsigned long offset
= 0;
9272 if (num_debug_info_entries
== 0)
9273 error (_("%s section needs a populated .debug_info section\n"),
9276 else if (comp_unit
>= num_debug_info_entries
)
9278 if (!warned_about_missing_comp_units
)
9280 warn (_("%s section has more comp units than .debug_info section\n"),
9282 warn (_("assuming that the pointer size is %d, from the last comp unit in .debug_info\n\n"),
9284 warned_about_missing_comp_units
= TRUE
;
9289 last_pointer_size
= debug_information
[comp_unit
].pointer_size
;
9290 offset
= debug_information
[comp_unit
].cu_offset
;
9293 if (offset_return
!= NULL
)
9294 * offset_return
= offset
;
9296 return last_pointer_size
;
9299 /* Locate and scan the .debug_info section in the file and record the pointer
9300 sizes and offsets for the compilation units in it. Usually an executable
9301 will have just one pointer size, but this is not guaranteed, and so we try
9302 not to make any assumptions. Returns zero upon failure, or the number of
9303 compilation units upon success. */
9306 get_debug_info (FILE * file
)
9308 Elf_Internal_Shdr
* section
;
9309 unsigned char * start
;
9312 /* Reset the last pointer size so that we can issue correct error
9313 messages if we are displaying the contents of more than one section. */
9314 last_pointer_size
= 0;
9315 warned_about_missing_comp_units
= FALSE
;
9317 /* If we already have the information there is nothing else to do. */
9318 if (num_debug_info_entries
> 0)
9319 return num_debug_info_entries
;
9321 section
= find_section (".debug_info");
9322 if (section
== NULL
)
9325 start
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
9326 _("extracting information from .debug_info section"));
9330 ret
= process_debug_info (section
, start
, file
, 1);
9333 return ret
? num_debug_info_entries
: 0;
9337 display_debug_lines (Elf_Internal_Shdr
*section
,
9338 unsigned char *start
, FILE *file
)
9340 unsigned char *data
= start
;
9341 unsigned char *end
= start
+ section
->sh_size
;
9342 unsigned int comp_unit
= 0;
9344 printf (_("\nDump of debug contents of section %s:\n\n"),
9345 SECTION_NAME (section
));
9347 get_debug_info (file
);
9351 DWARF2_Internal_LineInfo info
;
9352 unsigned char *standard_opcodes
;
9353 unsigned char *end_of_sequence
;
9354 unsigned char *hdrptr
;
9355 unsigned int pointer_size
;
9356 int initial_length_size
;
9362 /* Check the length of the block. */
9363 info
.li_length
= byte_get (hdrptr
, 4);
9366 if (info
.li_length
== 0xffffffff)
9368 /* This section is 64-bit DWARF 3. */
9369 info
.li_length
= byte_get (hdrptr
, 8);
9372 initial_length_size
= 12;
9377 initial_length_size
= 4;
9380 if (info
.li_length
+ initial_length_size
> section
->sh_size
)
9383 (_("The line info appears to be corrupt - the section is too small\n"));
9387 /* Check its version number. */
9388 info
.li_version
= byte_get (hdrptr
, 2);
9390 if (info
.li_version
!= 2 && info
.li_version
!= 3)
9392 warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
9396 info
.li_prologue_length
= byte_get (hdrptr
, offset_size
);
9397 hdrptr
+= offset_size
;
9398 info
.li_min_insn_length
= byte_get (hdrptr
, 1);
9400 info
.li_default_is_stmt
= byte_get (hdrptr
, 1);
9402 info
.li_line_base
= byte_get (hdrptr
, 1);
9404 info
.li_line_range
= byte_get (hdrptr
, 1);
9406 info
.li_opcode_base
= byte_get (hdrptr
, 1);
9409 /* Sign extend the line base field. */
9410 info
.li_line_base
<<= 24;
9411 info
.li_line_base
>>= 24;
9413 /* Get the pointer size from the comp unit associated
9414 with this block of line number information. */
9415 pointer_size
= get_pointer_size_and_offset_of_comp_unit
9416 (comp_unit
, ".debug_line", NULL
);
9419 printf (_(" Length: %ld\n"), info
.li_length
);
9420 printf (_(" DWARF Version: %d\n"), info
.li_version
);
9421 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
9422 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
9423 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
9424 printf (_(" Line Base: %d\n"), info
.li_line_base
);
9425 printf (_(" Line Range: %d\n"), info
.li_line_range
);
9426 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
9427 printf (_(" (Pointer size: %u)%s\n"),
9429 warned_about_missing_comp_units
? " [assumed]" : "" );
9431 end_of_sequence
= data
+ info
.li_length
+ initial_length_size
;
9433 reset_state_machine (info
.li_default_is_stmt
);
9435 /* Display the contents of the Opcodes table. */
9436 standard_opcodes
= hdrptr
;
9438 printf (_("\n Opcodes:\n"));
9440 for (i
= 1; i
< info
.li_opcode_base
; i
++)
9441 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
9443 /* Display the contents of the Directory table. */
9444 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
9447 printf (_("\n The Directory Table is empty.\n"));
9450 printf (_("\n The Directory Table:\n"));
9454 printf (_(" %s\n"), data
);
9456 data
+= strlen ((char *) data
) + 1;
9460 /* Skip the NUL at the end of the table. */
9463 /* Display the contents of the File Name table. */
9465 printf (_("\n The File Name Table is empty.\n"));
9468 printf (_("\n The File Name Table:\n"));
9469 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
9473 unsigned char *name
;
9474 unsigned int bytes_read
;
9476 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
9479 data
+= strlen ((char *) data
) + 1;
9481 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9483 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9485 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9487 printf (_("%s\n"), name
);
9491 /* Skip the NUL at the end of the table. */
9494 /* Now display the statements. */
9495 printf (_("\n Line Number Statements:\n"));
9497 while (data
< end_of_sequence
)
9499 unsigned char op_code
;
9501 unsigned int bytes_read
;
9505 if (op_code
>= info
.li_opcode_base
)
9507 op_code
-= info
.li_opcode_base
;
9508 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
9509 state_machine_regs
.address
+= adv
;
9510 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
9511 op_code
, adv
, state_machine_regs
.address
);
9512 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
9513 state_machine_regs
.line
+= adv
;
9514 printf (_(" and Line by %d to %d\n"),
9515 adv
, state_machine_regs
.line
);
9517 else switch (op_code
)
9519 case DW_LNS_extended_op
:
9520 if (pointer_size
== 0)
9522 warn (_("Extend line ops need a valid pointer size, guessing at 4\n"));
9526 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
9531 printf (_(" Copy\n"));
9534 case DW_LNS_advance_pc
:
9535 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
9537 state_machine_regs
.address
+= adv
;
9538 printf (_(" Advance PC by %d to %lx\n"), adv
,
9539 state_machine_regs
.address
);
9542 case DW_LNS_advance_line
:
9543 adv
= read_leb128 (data
, & bytes_read
, 1);
9545 state_machine_regs
.line
+= adv
;
9546 printf (_(" Advance Line by %d to %d\n"), adv
,
9547 state_machine_regs
.line
);
9550 case DW_LNS_set_file
:
9551 adv
= read_leb128 (data
, & bytes_read
, 0);
9553 printf (_(" Set File Name to entry %d in the File Name Table\n"),
9555 state_machine_regs
.file
= adv
;
9558 case DW_LNS_set_column
:
9559 adv
= read_leb128 (data
, & bytes_read
, 0);
9561 printf (_(" Set column to %d\n"), adv
);
9562 state_machine_regs
.column
= adv
;
9565 case DW_LNS_negate_stmt
:
9566 adv
= state_machine_regs
.is_stmt
;
9568 printf (_(" Set is_stmt to %d\n"), adv
);
9569 state_machine_regs
.is_stmt
= adv
;
9572 case DW_LNS_set_basic_block
:
9573 printf (_(" Set basic block\n"));
9574 state_machine_regs
.basic_block
= 1;
9577 case DW_LNS_const_add_pc
:
9578 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
9579 * info
.li_min_insn_length
);
9580 state_machine_regs
.address
+= adv
;
9581 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
9582 state_machine_regs
.address
);
9585 case DW_LNS_fixed_advance_pc
:
9586 adv
= byte_get (data
, 2);
9588 state_machine_regs
.address
+= adv
;
9589 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
9590 adv
, state_machine_regs
.address
);
9593 case DW_LNS_set_prologue_end
:
9594 printf (_(" Set prologue_end to true\n"));
9597 case DW_LNS_set_epilogue_begin
:
9598 printf (_(" Set epilogue_begin to true\n"));
9601 case DW_LNS_set_isa
:
9602 adv
= read_leb128 (data
, & bytes_read
, 0);
9604 printf (_(" Set ISA to %d\n"), adv
);
9608 printf (_(" Unknown opcode %d with operands: "), op_code
);
9610 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
9612 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
9613 i
== 1 ? "" : ", ");
9627 display_debug_pubnames (Elf_Internal_Shdr
*section
,
9628 unsigned char *start
,
9629 FILE *file ATTRIBUTE_UNUSED
)
9631 DWARF2_Internal_PubNames pubnames
;
9634 end
= start
+ section
->sh_size
;
9636 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9640 unsigned char *data
;
9641 unsigned long offset
;
9642 int offset_size
, initial_length_size
;
9646 pubnames
.pn_length
= byte_get (data
, 4);
9648 if (pubnames
.pn_length
== 0xffffffff)
9650 pubnames
.pn_length
= byte_get (data
, 8);
9653 initial_length_size
= 12;
9658 initial_length_size
= 4;
9661 pubnames
.pn_version
= byte_get (data
, 2);
9663 pubnames
.pn_offset
= byte_get (data
, offset_size
);
9664 data
+= offset_size
;
9665 pubnames
.pn_size
= byte_get (data
, offset_size
);
9666 data
+= offset_size
;
9668 start
+= pubnames
.pn_length
+ initial_length_size
;
9670 if (pubnames
.pn_version
!= 2 && pubnames
.pn_version
!= 3)
9672 static int warned
= 0;
9676 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
9683 printf (_(" Length: %ld\n"),
9684 pubnames
.pn_length
);
9685 printf (_(" Version: %d\n"),
9686 pubnames
.pn_version
);
9687 printf (_(" Offset into .debug_info section: %ld\n"),
9688 pubnames
.pn_offset
);
9689 printf (_(" Size of area in .debug_info section: %ld\n"),
9692 printf (_("\n Offset\tName\n"));
9696 offset
= byte_get (data
, offset_size
);
9700 data
+= offset_size
;
9701 printf (" %-6ld\t\t%s\n", offset
, data
);
9702 data
+= strlen ((char *) data
) + 1;
9705 while (offset
!= 0);
9713 display_debug_macinfo (Elf_Internal_Shdr
*section
,
9714 unsigned char *start
,
9715 FILE *file ATTRIBUTE_UNUSED
)
9717 unsigned char *end
= start
+ section
->sh_size
;
9718 unsigned char *curr
= start
;
9719 unsigned int bytes_read
;
9720 enum dwarf_macinfo_record_type op
;
9722 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9726 unsigned int lineno
;
9734 case DW_MACINFO_start_file
:
9736 unsigned int filenum
;
9738 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9740 filenum
= read_leb128 (curr
, & bytes_read
, 0);
9743 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
9748 case DW_MACINFO_end_file
:
9749 printf (_(" DW_MACINFO_end_file\n"));
9752 case DW_MACINFO_define
:
9753 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9755 string
= (char *) curr
;
9756 curr
+= strlen (string
) + 1;
9757 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
9761 case DW_MACINFO_undef
:
9762 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9764 string
= (char *) curr
;
9765 curr
+= strlen (string
) + 1;
9766 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
9770 case DW_MACINFO_vendor_ext
:
9772 unsigned int constant
;
9774 constant
= read_leb128 (curr
, & bytes_read
, 0);
9776 string
= (char *) curr
;
9777 curr
+= strlen (string
) + 1;
9778 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
9790 display_debug_abbrev (Elf_Internal_Shdr
*section
,
9791 unsigned char *start
,
9792 FILE *file ATTRIBUTE_UNUSED
)
9794 abbrev_entry
*entry
;
9795 unsigned char *end
= start
+ section
->sh_size
;
9797 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9801 start
= process_abbrev_section (start
, end
);
9803 if (first_abbrev
== NULL
)
9806 printf (_(" Number TAG\n"));
9808 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
9812 printf (_(" %ld %s [%s]\n"),
9814 get_TAG_name (entry
->tag
),
9815 entry
->children
? _("has children") : _("no children"));
9817 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
9818 printf (_(" %-18s %s\n"),
9819 get_AT_name (attr
->attribute
),
9820 get_FORM_name (attr
->form
));
9833 display_debug_loc (Elf_Internal_Shdr
*section
,
9834 unsigned char *start
, FILE *file
)
9836 unsigned char *section_end
;
9837 unsigned long bytes
;
9838 unsigned char *section_begin
= start
;
9839 unsigned int num_loc_list
= 0;
9840 unsigned long last_offset
= 0;
9841 unsigned int first
= 0;
9844 int seen_first_offset
= 0;
9845 int use_debug_info
= 1;
9846 unsigned char *next
;
9848 bytes
= section
->sh_size
;
9849 section_end
= start
+ bytes
;
9853 printf (_("\nThe .debug_loc section is empty.\n"));
9857 get_debug_info (file
);
9859 /* Check the order of location list in .debug_info section. If
9860 offsets of location lists are in the ascending order, we can
9861 use `debug_information' directly. */
9862 for (i
= 0; i
< num_debug_info_entries
; i
++)
9866 num
= debug_information
[i
].num_loc_offsets
;
9867 num_loc_list
+= num
;
9869 /* Check if we can use `debug_information' directly. */
9870 if (use_debug_info
&& num
!= 0)
9872 if (!seen_first_offset
)
9874 /* This is the first location list. */
9875 last_offset
= debug_information
[i
].loc_offsets
[0];
9877 seen_first_offset
= 1;
9883 for (; j
< num
; j
++)
9886 debug_information
[i
].loc_offsets
[j
])
9891 last_offset
= debug_information
[i
].loc_offsets
[j
];
9896 if (!use_debug_info
)
9897 /* FIXME: Should we handle this case? */
9898 error (_("Location lists in .debug_info section aren't in ascending order!\n"));
9900 if (!seen_first_offset
)
9901 error (_("No location lists in .debug_info section!\n"));
9903 if (debug_information
[first
].loc_offsets
[0] != 0)
9904 warn (_("Location lists in .debug_loc section start at 0x%lx\n"),
9905 debug_information
[first
].loc_offsets
[0]);
9907 printf (_("Contents of the .debug_loc section:\n\n"));
9908 printf (_(" Offset Begin End Expression\n"));
9910 seen_first_offset
= 0;
9911 for (i
= first
; i
< num_debug_info_entries
; i
++)
9913 unsigned long begin
;
9915 unsigned short length
;
9916 unsigned long offset
;
9917 unsigned int pointer_size
;
9918 unsigned long cu_offset
;
9919 unsigned long base_address
;
9920 int need_frame_base
;
9923 pointer_size
= debug_information
[i
].pointer_size
;
9924 cu_offset
= debug_information
[i
].cu_offset
;
9926 for (j
= 0; j
< debug_information
[i
].num_loc_offsets
; j
++)
9928 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
9929 offset
= debug_information
[i
].loc_offsets
[j
];
9930 next
= section_begin
+ offset
;
9931 base_address
= debug_information
[i
].base_address
;
9933 if (!seen_first_offset
)
9934 seen_first_offset
= 1;
9938 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
9939 (long)(start
- section_begin
), (long)(next
- section_begin
));
9940 else if (start
> next
)
9941 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
9942 (long)(start
- section_begin
), (long)(next
- section_begin
));
9946 if (offset
>= bytes
)
9948 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
9955 if (start
+ 2 * pointer_size
> section_end
)
9957 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
9962 begin
= byte_get (start
, pointer_size
);
9963 start
+= pointer_size
;
9964 end
= byte_get (start
, pointer_size
);
9965 start
+= pointer_size
;
9967 if (begin
== 0 && end
== 0)
9969 printf (_(" %8.8lx <End of list>\n"), offset
);
9973 /* Check base address specifiers. */
9974 if (begin
== -1UL && end
!= -1UL)
9977 printf (_(" %8.8lx %8.8lx %8.8lx (base address)\n"),
9978 offset
, begin
, end
);
9982 if (start
+ 2 > section_end
)
9984 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
9989 length
= byte_get (start
, 2);
9992 if (start
+ length
> section_end
)
9994 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
9999 printf (" %8.8lx %8.8lx %8.8lx (",
10000 offset
, begin
+ base_address
, end
+ base_address
);
10001 need_frame_base
= decode_location_expression (start
,
10007 if (need_frame_base
&& !has_frame_base
)
10008 printf (_(" [without DW_AT_frame_base]"));
10011 fputs (_(" (start == end)"), stdout
);
10012 else if (begin
> end
)
10013 fputs (_(" (start > end)"), stdout
);
10025 display_debug_str (Elf_Internal_Shdr
*section
,
10026 unsigned char *start
,
10027 FILE *file ATTRIBUTE_UNUSED
)
10029 unsigned long bytes
;
10032 addr
= section
->sh_addr
;
10033 bytes
= section
->sh_size
;
10037 printf (_("\nThe .debug_str section is empty.\n"));
10041 printf (_("Contents of the .debug_str section:\n\n"));
10049 lbytes
= (bytes
> 16 ? 16 : bytes
);
10051 printf (" 0x%8.8lx ", (unsigned long) addr
);
10053 for (j
= 0; j
< 16; j
++)
10056 printf ("%2.2x", start
[j
]);
10064 for (j
= 0; j
< lbytes
; j
++)
10067 if (k
>= ' ' && k
< 0x80)
10087 display_debug_info (Elf_Internal_Shdr
* section
,
10088 unsigned char * start
, FILE * file
)
10090 return process_debug_info (section
, start
, file
, 0);
10095 display_debug_aranges (Elf_Internal_Shdr
*section
,
10096 unsigned char *start
,
10097 FILE *file ATTRIBUTE_UNUSED
)
10099 unsigned char *end
= start
+ section
->sh_size
;
10101 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
10103 while (start
< end
)
10105 unsigned char *hdrptr
;
10106 DWARF2_Internal_ARange arange
;
10107 unsigned char *ranges
;
10108 unsigned long length
;
10109 unsigned long address
;
10112 int initial_length_size
;
10116 arange
.ar_length
= byte_get (hdrptr
, 4);
10119 if (arange
.ar_length
== 0xffffffff)
10121 arange
.ar_length
= byte_get (hdrptr
, 8);
10124 initial_length_size
= 12;
10129 initial_length_size
= 4;
10132 arange
.ar_version
= byte_get (hdrptr
, 2);
10135 arange
.ar_info_offset
= byte_get (hdrptr
, offset_size
);
10136 hdrptr
+= offset_size
;
10138 arange
.ar_pointer_size
= byte_get (hdrptr
, 1);
10141 arange
.ar_segment_size
= byte_get (hdrptr
, 1);
10144 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
10146 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
10150 printf (_(" Length: %ld\n"), arange
.ar_length
);
10151 printf (_(" Version: %d\n"), arange
.ar_version
);
10152 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
10153 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
10154 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
10156 printf (_("\n Address Length\n"));
10160 /* Must pad to an alignment boundary that is twice the pointer size. */
10161 excess
= (hdrptr
- start
) % (2 * arange
.ar_pointer_size
);
10163 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
10167 address
= byte_get (ranges
, arange
.ar_pointer_size
);
10169 ranges
+= arange
.ar_pointer_size
;
10171 length
= byte_get (ranges
, arange
.ar_pointer_size
);
10173 ranges
+= arange
.ar_pointer_size
;
10175 /* A pair of zeros marks the end of the list. */
10176 if (address
== 0 && length
== 0)
10179 printf (" %8.8lx %lu\n", address
, length
);
10182 start
+= arange
.ar_length
+ initial_length_size
;
10191 display_debug_ranges (Elf_Internal_Shdr
*section
,
10192 unsigned char *start
,
10193 FILE *file ATTRIBUTE_UNUSED
)
10195 unsigned char *section_end
;
10196 unsigned long bytes
;
10197 unsigned char *section_begin
= start
;
10198 unsigned int num_range_list
= 0;
10199 unsigned long last_offset
= 0;
10200 unsigned int first
= 0;
10203 int seen_first_offset
= 0;
10204 int use_debug_info
= 1;
10205 unsigned char *next
;
10207 bytes
= section
->sh_size
;
10208 section_end
= start
+ bytes
;
10212 printf (_("\nThe .debug_ranges section is empty.\n"));
10216 get_debug_info (file
);
10218 /* Check the order of range list in .debug_info section. If
10219 offsets of range lists are in the ascending order, we can
10220 use `debug_information' directly. */
10221 for (i
= 0; i
< num_debug_info_entries
; i
++)
10225 num
= debug_information
[i
].num_range_lists
;
10226 num_range_list
+= num
;
10228 /* Check if we can use `debug_information' directly. */
10229 if (use_debug_info
&& num
!= 0)
10231 if (!seen_first_offset
)
10233 /* This is the first range list. */
10234 last_offset
= debug_information
[i
].range_lists
[0];
10236 seen_first_offset
= 1;
10242 for (; j
< num
; j
++)
10245 debug_information
[i
].range_lists
[j
])
10247 use_debug_info
= 0;
10250 last_offset
= debug_information
[i
].range_lists
[j
];
10255 if (!use_debug_info
)
10256 /* FIXME: Should we handle this case? */
10257 error (_("Range lists in .debug_info section aren't in ascending order!\n"));
10259 if (!seen_first_offset
)
10260 error (_("No range lists in .debug_info section!\n"));
10262 if (debug_information
[first
].range_lists
[0] != 0)
10263 warn (_("Range lists in .debug_ranges section start at 0x%lx\n"),
10264 debug_information
[first
].range_lists
[0]);
10266 printf (_("Contents of the .debug_ranges section:\n\n"));
10267 printf (_(" Offset Begin End\n"));
10269 seen_first_offset
= 0;
10270 for (i
= first
; i
< num_debug_info_entries
; i
++)
10272 unsigned long begin
;
10274 unsigned long offset
;
10275 unsigned int pointer_size
;
10276 unsigned long base_address
;
10278 pointer_size
= debug_information
[i
].pointer_size
;
10280 for (j
= 0; j
< debug_information
[i
].num_range_lists
; j
++)
10282 offset
= debug_information
[i
].range_lists
[j
];
10283 next
= section_begin
+ offset
;
10284 base_address
= debug_information
[i
].base_address
;
10286 if (!seen_first_offset
)
10287 seen_first_offset
= 1;
10291 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_ranges section.\n"),
10292 (long)(start
- section_begin
), (long)(next
- section_begin
));
10293 else if (start
> next
)
10294 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_ranges section.\n"),
10295 (long)(start
- section_begin
), (long)(next
- section_begin
));
10301 begin
= byte_get (start
, pointer_size
);
10302 start
+= pointer_size
;
10303 end
= byte_get (start
, pointer_size
);
10304 start
+= pointer_size
;
10306 if (begin
== 0 && end
== 0)
10308 printf (_(" %8.8lx <End of list>\n"), offset
);
10312 /* Check base address specifiers. */
10313 if (begin
== -1UL && end
!= -1UL)
10315 base_address
= end
;
10316 printf (" %8.8lx %8.8lx %8.8lx (base address)\n",
10317 offset
, begin
, end
);
10321 printf (" %8.8lx %8.8lx %8.8lx",
10322 offset
, begin
+ base_address
, end
+ base_address
);
10325 fputs (_(" (start == end)"), stdout
);
10326 else if (begin
> end
)
10327 fputs (_(" (start > end)"), stdout
);
10337 typedef struct Frame_Chunk
10339 struct Frame_Chunk
*next
;
10340 unsigned char *chunk_start
;
10342 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
10343 short int *col_type
;
10345 char *augmentation
;
10346 unsigned int code_factor
;
10348 unsigned long pc_begin
;
10349 unsigned long pc_range
;
10353 unsigned char fde_encoding
;
10354 unsigned char cfa_exp
;
10358 /* A marker for a col_type that means this column was never referenced
10359 in the frame info. */
10360 #define DW_CFA_unreferenced (-1)
10363 frame_need_space (Frame_Chunk
*fc
, int reg
)
10365 int prev
= fc
->ncols
;
10367 if (reg
< fc
->ncols
)
10370 fc
->ncols
= reg
+ 1;
10371 fc
->col_type
= xcrealloc (fc
->col_type
, fc
->ncols
, sizeof (short int));
10372 fc
->col_offset
= xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
10374 while (prev
< fc
->ncols
)
10376 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
10377 fc
->col_offset
[prev
] = 0;
10383 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, int *max_regs
)
10388 if (*max_regs
< fc
->ncols
)
10389 *max_regs
= fc
->ncols
;
10391 if (*need_col_headers
)
10393 *need_col_headers
= 0;
10395 printf (" LOC CFA ");
10397 for (r
= 0; r
< *max_regs
; r
++)
10398 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
10403 printf ("r%-4d", r
);
10409 printf ("%08lx ", fc
->pc_begin
);
10411 strcpy (tmp
, "exp");
10413 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
10414 printf ("%-8s ", tmp
);
10416 for (r
= 0; r
< fc
->ncols
; r
++)
10418 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
10420 switch (fc
->col_type
[r
])
10422 case DW_CFA_undefined
:
10425 case DW_CFA_same_value
:
10428 case DW_CFA_offset
:
10429 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
10431 case DW_CFA_register
:
10432 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
10434 case DW_CFA_expression
:
10435 strcpy (tmp
, "exp");
10438 strcpy (tmp
, "n/a");
10441 printf ("%-5s", tmp
);
10448 size_of_encoded_value (int encoding
)
10450 switch (encoding
& 0x7)
10453 case 0: return eh_addr_size
;
10461 get_encoded_value (unsigned char *data
, int encoding
)
10463 int size
= size_of_encoded_value (encoding
);
10464 if (encoding
& DW_EH_PE_signed
)
10465 return byte_get_signed (data
, size
);
10467 return byte_get (data
, size
);
10470 #define GET(N) byte_get (start, N); start += N
10471 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
10472 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
10475 display_debug_frames (Elf_Internal_Shdr
*section
,
10476 unsigned char *start
,
10477 FILE *file ATTRIBUTE_UNUSED
)
10479 unsigned char *end
= start
+ section
->sh_size
;
10480 unsigned char *section_start
= start
;
10481 Frame_Chunk
*chunks
= 0;
10482 Frame_Chunk
*remembered_state
= 0;
10484 int is_eh
= streq (SECTION_NAME (section
), ".eh_frame");
10485 unsigned int length_return
;
10488 printf (_("The section %s contains:\n"), SECTION_NAME (section
));
10490 while (start
< end
)
10492 unsigned char *saved_start
;
10493 unsigned char *block_end
;
10494 unsigned long length
;
10495 unsigned long cie_id
;
10498 int need_col_headers
= 1;
10499 unsigned char *augmentation_data
= NULL
;
10500 unsigned long augmentation_data_len
= 0;
10501 int encoded_ptr_size
= eh_addr_size
;
10503 int initial_length_size
;
10505 saved_start
= start
;
10506 length
= byte_get (start
, 4); start
+= 4;
10510 printf ("\n%08lx ZERO terminator\n\n",
10511 (unsigned long)(saved_start
- section_start
));
10515 if (length
== 0xffffffff)
10517 length
= byte_get (start
, 8);
10520 initial_length_size
= 12;
10525 initial_length_size
= 4;
10528 block_end
= saved_start
+ length
+ initial_length_size
;
10529 cie_id
= byte_get (start
, offset_size
); start
+= offset_size
;
10531 if (elf_header
.e_type
== ET_REL
10532 && !debug_apply_rela_addends (file
, section
, offset_size
,
10533 section_start
, start
, block_end
))
10536 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
10540 fc
= xmalloc (sizeof (Frame_Chunk
));
10541 memset (fc
, 0, sizeof (Frame_Chunk
));
10545 fc
->chunk_start
= saved_start
;
10547 fc
->col_type
= xmalloc (sizeof (short int));
10548 fc
->col_offset
= xmalloc (sizeof (int));
10549 frame_need_space (fc
, max_regs
-1);
10551 version
= *start
++;
10553 fc
->augmentation
= (char *) start
;
10554 start
= (unsigned char *) strchr ((char *) start
, '\0') + 1;
10556 if (fc
->augmentation
[0] == 'z')
10558 fc
->code_factor
= LEB ();
10559 fc
->data_factor
= SLEB ();
10568 augmentation_data_len
= LEB ();
10569 augmentation_data
= start
;
10570 start
+= augmentation_data_len
;
10572 else if (streq (fc
->augmentation
, "eh"))
10574 start
+= eh_addr_size
;
10575 fc
->code_factor
= LEB ();
10576 fc
->data_factor
= SLEB ();
10588 fc
->code_factor
= LEB ();
10589 fc
->data_factor
= SLEB ();
10601 if (do_debug_frames_interp
)
10602 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
10603 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
10604 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
10608 printf ("\n%08lx %08lx %08lx CIE\n",
10609 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
10610 printf (" Version: %d\n", version
);
10611 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
10612 printf (" Code alignment factor: %u\n", fc
->code_factor
);
10613 printf (" Data alignment factor: %d\n", fc
->data_factor
);
10614 printf (" Return address column: %d\n", fc
->ra
);
10616 if (augmentation_data_len
)
10619 printf (" Augmentation data: ");
10620 for (i
= 0; i
< augmentation_data_len
; ++i
)
10621 printf (" %02x", augmentation_data
[i
]);
10627 if (augmentation_data_len
)
10629 unsigned char *p
, *q
;
10630 p
= (unsigned char *) fc
->augmentation
+ 1;
10631 q
= augmentation_data
;
10637 else if (*p
== 'P')
10638 q
+= 1 + size_of_encoded_value (*q
);
10639 else if (*p
== 'R')
10640 fc
->fde_encoding
= *q
++;
10646 if (fc
->fde_encoding
)
10647 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
10650 frame_need_space (fc
, fc
->ra
);
10654 unsigned char *look_for
;
10655 static Frame_Chunk fde_fc
;
10658 memset (fc
, 0, sizeof (Frame_Chunk
));
10660 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
10662 for (cie
= chunks
; cie
; cie
= cie
->next
)
10663 if (cie
->chunk_start
== look_for
)
10668 warn ("Invalid CIE pointer %08lx in FDE at %p\n",
10669 cie_id
, saved_start
);
10672 fc
->col_type
= xmalloc (sizeof (short int));
10673 fc
->col_offset
= xmalloc (sizeof (int));
10674 frame_need_space (fc
, max_regs
- 1);
10676 fc
->augmentation
= "";
10677 fc
->fde_encoding
= 0;
10681 fc
->ncols
= cie
->ncols
;
10682 fc
->col_type
= xcmalloc (fc
->ncols
, sizeof (short int));
10683 fc
->col_offset
= xcmalloc (fc
->ncols
, sizeof (int));
10684 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
10685 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
10686 fc
->augmentation
= cie
->augmentation
;
10687 fc
->code_factor
= cie
->code_factor
;
10688 fc
->data_factor
= cie
->data_factor
;
10689 fc
->cfa_reg
= cie
->cfa_reg
;
10690 fc
->cfa_offset
= cie
->cfa_offset
;
10692 frame_need_space (fc
, max_regs
-1);
10693 fc
->fde_encoding
= cie
->fde_encoding
;
10696 if (fc
->fde_encoding
)
10697 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
10699 fc
->pc_begin
= get_encoded_value (start
, fc
->fde_encoding
);
10700 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
10701 /* Don't adjust for ET_REL since there's invariably a pcrel
10702 reloc here, which we haven't applied. */
10703 && elf_header
.e_type
!= ET_REL
)
10704 fc
->pc_begin
+= section
->sh_addr
+ (start
- section_start
);
10705 start
+= encoded_ptr_size
;
10706 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
10707 start
+= encoded_ptr_size
;
10709 if (cie
->augmentation
[0] == 'z')
10711 augmentation_data_len
= LEB ();
10712 augmentation_data
= start
;
10713 start
+= augmentation_data_len
;
10716 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
10717 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
10718 (unsigned long)(cie
->chunk_start
- section_start
),
10719 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
10720 if (! do_debug_frames_interp
&& augmentation_data_len
)
10724 printf (" Augmentation data: ");
10725 for (i
= 0; i
< augmentation_data_len
; ++i
)
10726 printf (" %02x", augmentation_data
[i
]);
10732 /* At this point, fc is the current chunk, cie (if any) is set, and
10733 we're about to interpret instructions for the chunk. */
10734 /* ??? At present we need to do this always, since this sizes the
10735 fc->col_type and fc->col_offset arrays, which we write into always.
10736 We should probably split the interpreted and non-interpreted bits
10737 into two different routines, since there's so much that doesn't
10738 really overlap between them. */
10739 if (1 || do_debug_frames_interp
)
10741 /* Start by making a pass over the chunk, allocating storage
10742 and taking note of what registers are used. */
10743 unsigned char *tmp
= start
;
10745 while (start
< block_end
)
10748 unsigned long reg
, tmp
;
10755 /* Warning: if you add any more cases to this switch, be
10756 sure to add them to the corresponding switch below. */
10759 case DW_CFA_advance_loc
:
10761 case DW_CFA_offset
:
10763 frame_need_space (fc
, opa
);
10764 fc
->col_type
[opa
] = DW_CFA_undefined
;
10766 case DW_CFA_restore
:
10767 frame_need_space (fc
, opa
);
10768 fc
->col_type
[opa
] = DW_CFA_undefined
;
10770 case DW_CFA_set_loc
:
10771 start
+= encoded_ptr_size
;
10773 case DW_CFA_advance_loc1
:
10776 case DW_CFA_advance_loc2
:
10779 case DW_CFA_advance_loc4
:
10782 case DW_CFA_offset_extended
:
10783 reg
= LEB (); LEB ();
10784 frame_need_space (fc
, reg
);
10785 fc
->col_type
[reg
] = DW_CFA_undefined
;
10787 case DW_CFA_restore_extended
:
10789 frame_need_space (fc
, reg
);
10790 fc
->col_type
[reg
] = DW_CFA_undefined
;
10792 case DW_CFA_undefined
:
10794 frame_need_space (fc
, reg
);
10795 fc
->col_type
[reg
] = DW_CFA_undefined
;
10797 case DW_CFA_same_value
:
10799 frame_need_space (fc
, reg
);
10800 fc
->col_type
[reg
] = DW_CFA_undefined
;
10802 case DW_CFA_register
:
10803 reg
= LEB (); LEB ();
10804 frame_need_space (fc
, reg
);
10805 fc
->col_type
[reg
] = DW_CFA_undefined
;
10807 case DW_CFA_def_cfa
:
10810 case DW_CFA_def_cfa_register
:
10813 case DW_CFA_def_cfa_offset
:
10816 case DW_CFA_def_cfa_expression
:
10820 case DW_CFA_expression
:
10824 frame_need_space (fc
, reg
);
10825 fc
->col_type
[reg
] = DW_CFA_undefined
;
10827 case DW_CFA_offset_extended_sf
:
10828 reg
= LEB (); SLEB ();
10829 frame_need_space (fc
, reg
);
10830 fc
->col_type
[reg
] = DW_CFA_undefined
;
10832 case DW_CFA_def_cfa_sf
:
10835 case DW_CFA_def_cfa_offset_sf
:
10838 case DW_CFA_MIPS_advance_loc8
:
10841 case DW_CFA_GNU_args_size
:
10844 case DW_CFA_GNU_negative_offset_extended
:
10845 reg
= LEB (); LEB ();
10846 frame_need_space (fc
, reg
);
10847 fc
->col_type
[reg
] = DW_CFA_undefined
;
10856 /* Now we know what registers are used, make a second pass over
10857 the chunk, this time actually printing out the info. */
10859 while (start
< block_end
)
10862 unsigned long ul
, reg
, roffs
;
10871 /* Warning: if you add any more cases to this switch, be
10872 sure to add them to the corresponding switch above. */
10875 case DW_CFA_advance_loc
:
10876 if (do_debug_frames_interp
)
10877 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10879 printf (" DW_CFA_advance_loc: %d to %08lx\n",
10880 opa
* fc
->code_factor
,
10881 fc
->pc_begin
+ opa
* fc
->code_factor
);
10882 fc
->pc_begin
+= opa
* fc
->code_factor
;
10885 case DW_CFA_offset
:
10887 if (! do_debug_frames_interp
)
10888 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
10889 opa
, roffs
* fc
->data_factor
);
10890 fc
->col_type
[opa
] = DW_CFA_offset
;
10891 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
10894 case DW_CFA_restore
:
10895 if (! do_debug_frames_interp
)
10896 printf (" DW_CFA_restore: r%d\n", opa
);
10897 fc
->col_type
[opa
] = cie
->col_type
[opa
];
10898 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
10901 case DW_CFA_set_loc
:
10902 vma
= get_encoded_value (start
, fc
->fde_encoding
);
10903 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
10904 && elf_header
.e_type
!= ET_REL
)
10905 vma
+= section
->sh_addr
+ (start
- section_start
);
10906 start
+= encoded_ptr_size
;
10907 if (do_debug_frames_interp
)
10908 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10910 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
10911 fc
->pc_begin
= vma
;
10914 case DW_CFA_advance_loc1
:
10915 ofs
= byte_get (start
, 1); start
+= 1;
10916 if (do_debug_frames_interp
)
10917 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10919 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
10920 ofs
* fc
->code_factor
,
10921 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10922 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10925 case DW_CFA_advance_loc2
:
10926 ofs
= byte_get (start
, 2); start
+= 2;
10927 if (do_debug_frames_interp
)
10928 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10930 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
10931 ofs
* fc
->code_factor
,
10932 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10933 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10936 case DW_CFA_advance_loc4
:
10937 ofs
= byte_get (start
, 4); start
+= 4;
10938 if (do_debug_frames_interp
)
10939 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10941 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
10942 ofs
* fc
->code_factor
,
10943 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10944 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10947 case DW_CFA_offset_extended
:
10950 if (! do_debug_frames_interp
)
10951 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
10952 reg
, roffs
* fc
->data_factor
);
10953 fc
->col_type
[reg
] = DW_CFA_offset
;
10954 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
10957 case DW_CFA_restore_extended
:
10959 if (! do_debug_frames_interp
)
10960 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
10961 fc
->col_type
[reg
] = cie
->col_type
[reg
];
10962 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
10965 case DW_CFA_undefined
:
10967 if (! do_debug_frames_interp
)
10968 printf (" DW_CFA_undefined: r%ld\n", reg
);
10969 fc
->col_type
[reg
] = DW_CFA_undefined
;
10970 fc
->col_offset
[reg
] = 0;
10973 case DW_CFA_same_value
:
10975 if (! do_debug_frames_interp
)
10976 printf (" DW_CFA_same_value: r%ld\n", reg
);
10977 fc
->col_type
[reg
] = DW_CFA_same_value
;
10978 fc
->col_offset
[reg
] = 0;
10981 case DW_CFA_register
:
10984 if (! do_debug_frames_interp
)
10985 printf (" DW_CFA_register: r%ld in r%ld\n", reg
, roffs
);
10986 fc
->col_type
[reg
] = DW_CFA_register
;
10987 fc
->col_offset
[reg
] = roffs
;
10990 case DW_CFA_remember_state
:
10991 if (! do_debug_frames_interp
)
10992 printf (" DW_CFA_remember_state\n");
10993 rs
= xmalloc (sizeof (Frame_Chunk
));
10994 rs
->ncols
= fc
->ncols
;
10995 rs
->col_type
= xcmalloc (rs
->ncols
, sizeof (short int));
10996 rs
->col_offset
= xcmalloc (rs
->ncols
, sizeof (int));
10997 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
10998 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
10999 rs
->next
= remembered_state
;
11000 remembered_state
= rs
;
11003 case DW_CFA_restore_state
:
11004 if (! do_debug_frames_interp
)
11005 printf (" DW_CFA_restore_state\n");
11006 rs
= remembered_state
;
11009 remembered_state
= rs
->next
;
11010 frame_need_space (fc
, rs
->ncols
-1);
11011 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
11012 memcpy (fc
->col_offset
, rs
->col_offset
,
11013 rs
->ncols
* sizeof (int));
11014 free (rs
->col_type
);
11015 free (rs
->col_offset
);
11018 else if (do_debug_frames_interp
)
11019 printf ("Mismatched DW_CFA_restore_state\n");
11022 case DW_CFA_def_cfa
:
11023 fc
->cfa_reg
= LEB ();
11024 fc
->cfa_offset
= LEB ();
11026 if (! do_debug_frames_interp
)
11027 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
11028 fc
->cfa_reg
, fc
->cfa_offset
);
11031 case DW_CFA_def_cfa_register
:
11032 fc
->cfa_reg
= LEB ();
11034 if (! do_debug_frames_interp
)
11035 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
11038 case DW_CFA_def_cfa_offset
:
11039 fc
->cfa_offset
= LEB ();
11040 if (! do_debug_frames_interp
)
11041 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
11045 if (! do_debug_frames_interp
)
11046 printf (" DW_CFA_nop\n");
11049 case DW_CFA_def_cfa_expression
:
11051 if (! do_debug_frames_interp
)
11053 printf (" DW_CFA_def_cfa_expression (");
11054 decode_location_expression (start
, eh_addr_size
, ul
, 0);
11061 case DW_CFA_expression
:
11064 if (! do_debug_frames_interp
)
11066 printf (" DW_CFA_expression: r%ld (", reg
);
11067 decode_location_expression (start
, eh_addr_size
, ul
, 0);
11070 fc
->col_type
[reg
] = DW_CFA_expression
;
11074 case DW_CFA_offset_extended_sf
:
11077 frame_need_space (fc
, reg
);
11078 if (! do_debug_frames_interp
)
11079 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
11080 reg
, l
* fc
->data_factor
);
11081 fc
->col_type
[reg
] = DW_CFA_offset
;
11082 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
11085 case DW_CFA_def_cfa_sf
:
11086 fc
->cfa_reg
= LEB ();
11087 fc
->cfa_offset
= SLEB ();
11088 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
11090 if (! do_debug_frames_interp
)
11091 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
11092 fc
->cfa_reg
, fc
->cfa_offset
);
11095 case DW_CFA_def_cfa_offset_sf
:
11096 fc
->cfa_offset
= SLEB ();
11097 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
11098 if (! do_debug_frames_interp
)
11099 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
11102 case DW_CFA_MIPS_advance_loc8
:
11103 ofs
= byte_get (start
, 8); start
+= 8;
11104 if (do_debug_frames_interp
)
11105 frame_display_row (fc
, &need_col_headers
, &max_regs
);
11107 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
11108 ofs
* fc
->code_factor
,
11109 fc
->pc_begin
+ ofs
* fc
->code_factor
);
11110 fc
->pc_begin
+= ofs
* fc
->code_factor
;
11113 case DW_CFA_GNU_window_save
:
11114 if (! do_debug_frames_interp
)
11115 printf (" DW_CFA_GNU_window_save\n");
11118 case DW_CFA_GNU_args_size
:
11120 if (! do_debug_frames_interp
)
11121 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
11124 case DW_CFA_GNU_negative_offset_extended
:
11127 frame_need_space (fc
, reg
);
11128 if (! do_debug_frames_interp
)
11129 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
11130 reg
, l
* fc
->data_factor
);
11131 fc
->col_type
[reg
] = DW_CFA_offset
;
11132 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
11136 warn (_("unsupported or unknown DW_CFA_%d\n"), op
);
11141 if (do_debug_frames_interp
)
11142 frame_display_row (fc
, &need_col_headers
, &max_regs
);
11157 display_debug_not_supported (Elf_Internal_Shdr
*section
,
11158 unsigned char *start ATTRIBUTE_UNUSED
,
11159 FILE *file ATTRIBUTE_UNUSED
)
11161 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
11162 SECTION_NAME (section
));
11167 /* A structure containing the name of a debug section
11168 and a pointer to a function that can decode it. */
11171 const char *const name
;
11172 int (*display
) (Elf_Internal_Shdr
*, unsigned char *, FILE *);
11176 { ".debug_abbrev", display_debug_abbrev
},
11177 { ".debug_aranges", display_debug_aranges
},
11178 { ".debug_frame", display_debug_frames
},
11179 { ".debug_info", display_debug_info
},
11180 { ".debug_line", display_debug_lines
},
11181 { ".debug_pubnames", display_debug_pubnames
},
11182 { ".eh_frame", display_debug_frames
},
11183 { ".debug_macinfo", display_debug_macinfo
},
11184 { ".debug_str", display_debug_str
},
11185 { ".debug_loc", display_debug_loc
},
11186 { ".debug_pubtypes", display_debug_pubnames
},
11187 { ".debug_ranges", display_debug_ranges
},
11188 { ".debug_static_func", display_debug_not_supported
},
11189 { ".debug_static_vars", display_debug_not_supported
},
11190 { ".debug_types", display_debug_not_supported
},
11191 { ".debug_weaknames", display_debug_not_supported
}
11195 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
11197 char *name
= SECTION_NAME (section
);
11198 bfd_size_type length
;
11202 length
= section
->sh_size
;
11205 printf (_("\nSection '%s' has no debugging data.\n"), name
);
11209 if (strneq (name
, ".gnu.linkonce.wi.", 17))
11210 name
= ".debug_info";
11212 /* See if we know how to display the contents of this section. */
11213 for (i
= NUM_ELEM (debug_displays
); i
--;)
11214 if (streq (debug_displays
[i
].name
, name
))
11216 unsigned char *start
;
11218 start
= get_data (NULL
, file
, section
->sh_offset
, 1, length
,
11219 _("debug section data"));
11226 result
&= debug_displays
[i
].display (section
, start
, file
);
11229 /* If we loaded in the abbrev section
11230 at some point, we must release it here. */
11238 printf (_("Unrecognized debug section: %s\n"), name
);
11246 process_section_contents (FILE *file
)
11248 Elf_Internal_Shdr
*section
;
11254 for (i
= 0, section
= section_headers
;
11255 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
11258 #ifdef SUPPORT_DISASSEMBLY
11259 if (dump_sects
[i
] & DISASS_DUMP
)
11260 disassemble_section (section
, file
);
11262 if (dump_sects
[i
] & HEX_DUMP
)
11263 dump_section (section
, file
);
11265 if (dump_sects
[i
] & DEBUG_DUMP
)
11266 display_debug_section (section
, file
);
11269 /* Check to see if the user requested a
11270 dump of a section that does not exist. */
11271 while (i
++ < num_dump_sects
)
11273 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
11277 process_mips_fpe_exception (int mask
)
11282 if (mask
& OEX_FPU_INEX
)
11283 fputs ("INEX", stdout
), first
= 0;
11284 if (mask
& OEX_FPU_UFLO
)
11285 printf ("%sUFLO", first
? "" : "|"), first
= 0;
11286 if (mask
& OEX_FPU_OFLO
)
11287 printf ("%sOFLO", first
? "" : "|"), first
= 0;
11288 if (mask
& OEX_FPU_DIV0
)
11289 printf ("%sDIV0", first
? "" : "|"), first
= 0;
11290 if (mask
& OEX_FPU_INVAL
)
11291 printf ("%sINVAL", first
? "" : "|");
11294 fputs ("0", stdout
);
11298 process_mips_specific (FILE *file
)
11300 Elf_Internal_Dyn
*entry
;
11301 size_t liblist_offset
= 0;
11302 size_t liblistno
= 0;
11303 size_t conflictsno
= 0;
11304 size_t options_offset
= 0;
11305 size_t conflicts_offset
= 0;
11307 /* We have a lot of special sections. Thanks SGI! */
11308 if (dynamic_section
== NULL
)
11309 /* No information available. */
11312 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
11313 switch (entry
->d_tag
)
11315 case DT_MIPS_LIBLIST
:
11317 = offset_from_vma (file
, entry
->d_un
.d_val
,
11318 liblistno
* sizeof (Elf32_External_Lib
));
11320 case DT_MIPS_LIBLISTNO
:
11321 liblistno
= entry
->d_un
.d_val
;
11323 case DT_MIPS_OPTIONS
:
11324 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
11326 case DT_MIPS_CONFLICT
:
11328 = offset_from_vma (file
, entry
->d_un
.d_val
,
11329 conflictsno
* sizeof (Elf32_External_Conflict
));
11331 case DT_MIPS_CONFLICTNO
:
11332 conflictsno
= entry
->d_un
.d_val
;
11338 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
11340 Elf32_External_Lib
*elib
;
11343 elib
= get_data (NULL
, file
, liblist_offset
,
11344 liblistno
, sizeof (Elf32_External_Lib
),
11348 printf ("\nSection '.liblist' contains %lu entries:\n",
11349 (unsigned long) liblistno
);
11350 fputs (" Library Time Stamp Checksum Version Flags\n",
11353 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
11360 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
11361 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
11362 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
11363 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
11364 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
11366 tmp
= gmtime (&time
);
11367 snprintf (timebuf
, sizeof (timebuf
),
11368 "%04u-%02u-%02uT%02u:%02u:%02u",
11369 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11370 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11372 printf ("%3lu: ", (unsigned long) cnt
);
11373 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
11374 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
11376 printf ("<corrupt: %9ld>", liblist
.l_name
);
11377 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
11378 liblist
.l_version
);
11380 if (liblist
.l_flags
== 0)
11384 static const struct
11391 { " EXACT_MATCH", LL_EXACT_MATCH
},
11392 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
11393 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
11394 { " EXPORTS", LL_EXPORTS
},
11395 { " DELAY_LOAD", LL_DELAY_LOAD
},
11396 { " DELTA", LL_DELTA
}
11398 int flags
= liblist
.l_flags
;
11402 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
11404 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
11406 fputs (l_flags_vals
[fcnt
].name
, stdout
);
11407 flags
^= l_flags_vals
[fcnt
].bit
;
11410 printf (" %#x", (unsigned int) flags
);
11420 if (options_offset
!= 0)
11422 Elf_External_Options
*eopt
;
11423 Elf_Internal_Shdr
*sect
= section_headers
;
11424 Elf_Internal_Options
*iopt
;
11425 Elf_Internal_Options
*option
;
11429 /* Find the section header so that we get the size. */
11430 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
11433 eopt
= get_data (NULL
, file
, options_offset
, 1, sect
->sh_size
,
11437 iopt
= cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (*iopt
));
11440 error (_("Out of memory"));
11447 while (offset
< sect
->sh_size
)
11449 Elf_External_Options
*eoption
;
11451 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
11453 option
->kind
= BYTE_GET (eoption
->kind
);
11454 option
->size
= BYTE_GET (eoption
->size
);
11455 option
->section
= BYTE_GET (eoption
->section
);
11456 option
->info
= BYTE_GET (eoption
->info
);
11458 offset
+= option
->size
;
11464 printf (_("\nSection '%s' contains %d entries:\n"),
11465 SECTION_NAME (sect
), cnt
);
11473 switch (option
->kind
)
11476 /* This shouldn't happen. */
11477 printf (" NULL %d %lx", option
->section
, option
->info
);
11480 printf (" REGINFO ");
11481 if (elf_header
.e_machine
== EM_MIPS
)
11484 Elf32_External_RegInfo
*ereg
;
11485 Elf32_RegInfo reginfo
;
11487 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
11488 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
11489 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
11490 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
11491 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
11492 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
11493 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
11495 printf ("GPR %08lx GP 0x%lx\n",
11496 reginfo
.ri_gprmask
,
11497 (unsigned long) reginfo
.ri_gp_value
);
11498 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11499 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11500 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11505 Elf64_External_RegInfo
*ereg
;
11506 Elf64_Internal_RegInfo reginfo
;
11508 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
11509 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
11510 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
11511 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
11512 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
11513 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
11514 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
11516 printf ("GPR %08lx GP 0x",
11517 reginfo
.ri_gprmask
);
11518 printf_vma (reginfo
.ri_gp_value
);
11521 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11522 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11523 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11527 case ODK_EXCEPTIONS
:
11528 fputs (" EXCEPTIONS fpe_min(", stdout
);
11529 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
11530 fputs (") fpe_max(", stdout
);
11531 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
11532 fputs (")", stdout
);
11534 if (option
->info
& OEX_PAGE0
)
11535 fputs (" PAGE0", stdout
);
11536 if (option
->info
& OEX_SMM
)
11537 fputs (" SMM", stdout
);
11538 if (option
->info
& OEX_FPDBUG
)
11539 fputs (" FPDBUG", stdout
);
11540 if (option
->info
& OEX_DISMISS
)
11541 fputs (" DISMISS", stdout
);
11544 fputs (" PAD ", stdout
);
11545 if (option
->info
& OPAD_PREFIX
)
11546 fputs (" PREFIX", stdout
);
11547 if (option
->info
& OPAD_POSTFIX
)
11548 fputs (" POSTFIX", stdout
);
11549 if (option
->info
& OPAD_SYMBOL
)
11550 fputs (" SYMBOL", stdout
);
11553 fputs (" HWPATCH ", stdout
);
11554 if (option
->info
& OHW_R4KEOP
)
11555 fputs (" R4KEOP", stdout
);
11556 if (option
->info
& OHW_R8KPFETCH
)
11557 fputs (" R8KPFETCH", stdout
);
11558 if (option
->info
& OHW_R5KEOP
)
11559 fputs (" R5KEOP", stdout
);
11560 if (option
->info
& OHW_R5KCVTL
)
11561 fputs (" R5KCVTL", stdout
);
11564 fputs (" FILL ", stdout
);
11565 /* XXX Print content of info word? */
11568 fputs (" TAGS ", stdout
);
11569 /* XXX Print content of info word? */
11572 fputs (" HWAND ", stdout
);
11573 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11574 fputs (" R4KEOP_CHECKED", stdout
);
11575 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11576 fputs (" R4KEOP_CLEAN", stdout
);
11579 fputs (" HWOR ", stdout
);
11580 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11581 fputs (" R4KEOP_CHECKED", stdout
);
11582 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11583 fputs (" R4KEOP_CLEAN", stdout
);
11586 printf (" GP_GROUP %#06lx self-contained %#06lx",
11587 option
->info
& OGP_GROUP
,
11588 (option
->info
& OGP_SELF
) >> 16);
11591 printf (" IDENT %#06lx self-contained %#06lx",
11592 option
->info
& OGP_GROUP
,
11593 (option
->info
& OGP_SELF
) >> 16);
11596 /* This shouldn't happen. */
11597 printf (" %3d ??? %d %lx",
11598 option
->kind
, option
->section
, option
->info
);
11602 len
= sizeof (*eopt
);
11603 while (len
< option
->size
)
11604 if (((char *) option
)[len
] >= ' '
11605 && ((char *) option
)[len
] < 0x7f)
11606 printf ("%c", ((char *) option
)[len
++]);
11608 printf ("\\%03o", ((char *) option
)[len
++]);
11610 fputs ("\n", stdout
);
11618 if (conflicts_offset
!= 0 && conflictsno
!= 0)
11620 Elf32_Conflict
*iconf
;
11623 if (dynamic_symbols
== NULL
)
11625 error (_("conflict list found without a dynamic symbol table"));
11629 iconf
= cmalloc (conflictsno
, sizeof (*iconf
));
11632 error (_("Out of memory"));
11638 Elf32_External_Conflict
*econf32
;
11640 econf32
= get_data (NULL
, file
, conflicts_offset
,
11641 conflictsno
, sizeof (*econf32
), _("conflict"));
11645 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11646 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
11652 Elf64_External_Conflict
*econf64
;
11654 econf64
= get_data (NULL
, file
, conflicts_offset
,
11655 conflictsno
, sizeof (*econf64
), _("conflict"));
11659 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11660 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
11665 printf (_("\nSection '.conflict' contains %lu entries:\n"),
11666 (unsigned long) conflictsno
);
11667 puts (_(" Num: Index Value Name"));
11669 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11671 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
11673 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
11674 print_vma (psym
->st_value
, FULL_HEX
);
11676 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11677 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11679 printf ("<corrupt: %14ld>", psym
->st_name
);
11690 process_gnu_liblist (FILE *file
)
11692 Elf_Internal_Shdr
*section
, *string_sec
;
11693 Elf32_External_Lib
*elib
;
11695 size_t strtab_size
;
11702 for (i
= 0, section
= section_headers
;
11703 i
< elf_header
.e_shnum
;
11706 switch (section
->sh_type
)
11708 case SHT_GNU_LIBLIST
:
11709 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
)
11712 elib
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
11717 string_sec
= SECTION_HEADER (section
->sh_link
);
11719 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
11720 string_sec
->sh_size
, _("liblist string table"));
11721 strtab_size
= string_sec
->sh_size
;
11724 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
11730 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
11731 SECTION_NAME (section
),
11732 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
11734 puts (" Library Time Stamp Checksum Version Flags");
11736 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
11744 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
11745 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
11746 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
11747 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
11748 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
11750 tmp
= gmtime (&time
);
11751 snprintf (timebuf
, sizeof (timebuf
),
11752 "%04u-%02u-%02uT%02u:%02u:%02u",
11753 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11754 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11756 printf ("%3lu: ", (unsigned long) cnt
);
11758 printf ("%-20s", liblist
.l_name
< strtab_size
11759 ? strtab
+ liblist
.l_name
: "<corrupt>");
11761 printf ("%-20.20s", liblist
.l_name
< strtab_size
11762 ? strtab
+ liblist
.l_name
: "<corrupt>");
11763 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
11764 liblist
.l_version
, liblist
.l_flags
);
11774 static const char *
11775 get_note_type (unsigned e_type
)
11777 static char buff
[64];
11779 if (elf_header
.e_type
== ET_CORE
)
11783 return _("NT_AUXV (auxiliary vector)");
11785 return _("NT_PRSTATUS (prstatus structure)");
11787 return _("NT_FPREGSET (floating point registers)");
11789 return _("NT_PRPSINFO (prpsinfo structure)");
11790 case NT_TASKSTRUCT
:
11791 return _("NT_TASKSTRUCT (task structure)");
11793 return _("NT_PRXFPREG (user_xfpregs structure)");
11795 return _("NT_PSTATUS (pstatus structure)");
11797 return _("NT_FPREGS (floating point registers)");
11799 return _("NT_PSINFO (psinfo structure)");
11801 return _("NT_LWPSTATUS (lwpstatus_t structure)");
11803 return _("NT_LWPSINFO (lwpsinfo_t structure)");
11804 case NT_WIN32PSTATUS
:
11805 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
11813 return _("NT_VERSION (version)");
11815 return _("NT_ARCH (architecture)");
11820 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11824 static const char *
11825 get_netbsd_elfcore_note_type (unsigned e_type
)
11827 static char buff
[64];
11829 if (e_type
== NT_NETBSDCORE_PROCINFO
)
11831 /* NetBSD core "procinfo" structure. */
11832 return _("NetBSD procinfo structure");
11835 /* As of Jan 2002 there are no other machine-independent notes
11836 defined for NetBSD core files. If the note type is less
11837 than the start of the machine-dependent note types, we don't
11840 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
11842 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11846 switch (elf_header
.e_machine
)
11848 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
11849 and PT_GETFPREGS == mach+2. */
11854 case EM_SPARC32PLUS
:
11858 case NT_NETBSDCORE_FIRSTMACH
+0:
11859 return _("PT_GETREGS (reg structure)");
11860 case NT_NETBSDCORE_FIRSTMACH
+2:
11861 return _("PT_GETFPREGS (fpreg structure)");
11867 /* On all other arch's, PT_GETREGS == mach+1 and
11868 PT_GETFPREGS == mach+3. */
11872 case NT_NETBSDCORE_FIRSTMACH
+1:
11873 return _("PT_GETREGS (reg structure)");
11874 case NT_NETBSDCORE_FIRSTMACH
+3:
11875 return _("PT_GETFPREGS (fpreg structure)");
11881 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
11882 e_type
- NT_NETBSDCORE_FIRSTMACH
);
11886 /* Note that by the ELF standard, the name field is already null byte
11887 terminated, and namesz includes the terminating null byte.
11888 I.E. the value of namesz for the name "FSF" is 4.
11890 If the value of namesz is zero, there is no name present. */
11892 process_note (Elf_Internal_Note
*pnote
)
11896 if (pnote
->namesz
== 0)
11897 /* If there is no note name, then use the default set of
11898 note type strings. */
11899 nt
= get_note_type (pnote
->type
);
11901 else if (strneq (pnote
->namedata
, "NetBSD-CORE", 11))
11902 /* NetBSD-specific core file notes. */
11903 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
11906 /* Don't recognize this note name; just use the default set of
11907 note type strings. */
11908 nt
= get_note_type (pnote
->type
);
11910 printf (" %s\t\t0x%08lx\t%s\n",
11911 pnote
->namesz
? pnote
->namedata
: "(NONE)",
11912 pnote
->descsz
, nt
);
11918 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
11920 Elf_External_Note
*pnotes
;
11921 Elf_External_Note
*external
;
11927 pnotes
= get_data (NULL
, file
, offset
, 1, length
, _("notes"));
11933 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
11934 (unsigned long) offset
, (unsigned long) length
);
11935 printf (_(" Owner\t\tData size\tDescription\n"));
11937 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
11939 Elf_External_Note
*next
;
11940 Elf_Internal_Note inote
;
11943 inote
.type
= BYTE_GET (external
->type
);
11944 inote
.namesz
= BYTE_GET (external
->namesz
);
11945 inote
.namedata
= external
->name
;
11946 inote
.descsz
= BYTE_GET (external
->descsz
);
11947 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
11948 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
11950 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
11952 if (((char *) next
) > (((char *) pnotes
) + length
))
11954 warn (_("corrupt note found at offset %lx into core notes\n"),
11955 (long)((char *)external
- (char *)pnotes
));
11956 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
11957 inote
.type
, inote
.namesz
, inote
.descsz
);
11963 /* Verify that name is null terminated. It appears that at least
11964 one version of Linux (RedHat 6.0) generates corefiles that don't
11965 comply with the ELF spec by failing to include the null byte in
11967 if (inote
.namedata
[inote
.namesz
] != '\0')
11969 temp
= malloc (inote
.namesz
+ 1);
11973 error (_("Out of memory\n"));
11978 strncpy (temp
, inote
.namedata
, inote
.namesz
);
11979 temp
[inote
.namesz
] = 0;
11981 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
11982 inote
.namedata
= temp
;
11985 res
&= process_note (& inote
);
12000 process_corefile_note_segments (FILE *file
)
12002 Elf_Internal_Phdr
*segment
;
12006 if (! get_program_headers (file
))
12009 for (i
= 0, segment
= program_headers
;
12010 i
< elf_header
.e_phnum
;
12013 if (segment
->p_type
== PT_NOTE
)
12014 res
&= process_corefile_note_segment (file
,
12015 (bfd_vma
) segment
->p_offset
,
12016 (bfd_vma
) segment
->p_filesz
);
12023 process_note_sections (FILE *file
)
12025 Elf_Internal_Shdr
*section
;
12029 for (i
= 0, section
= section_headers
;
12030 i
< elf_header
.e_shnum
;
12032 if (section
->sh_type
== SHT_NOTE
)
12033 res
&= process_corefile_note_segment (file
,
12034 (bfd_vma
) section
->sh_offset
,
12035 (bfd_vma
) section
->sh_size
);
12041 process_notes (FILE *file
)
12043 /* If we have not been asked to display the notes then do nothing. */
12047 if (elf_header
.e_type
!= ET_CORE
)
12048 return process_note_sections (file
);
12050 /* No program headers means no NOTE segment. */
12051 if (elf_header
.e_phnum
> 0)
12052 return process_corefile_note_segments (file
);
12054 printf (_("No note segments present in the core file.\n"));
12059 process_arch_specific (FILE *file
)
12064 switch (elf_header
.e_machine
)
12067 case EM_MIPS_RS3_LE
:
12068 return process_mips_specific (file
);
12077 get_file_header (FILE *file
)
12079 /* Read in the identity array. */
12080 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
12083 /* Determine how to read the rest of the header. */
12084 switch (elf_header
.e_ident
[EI_DATA
])
12086 default: /* fall through */
12087 case ELFDATANONE
: /* fall through */
12089 byte_get
= byte_get_little_endian
;
12090 byte_put
= byte_put_little_endian
;
12093 byte_get
= byte_get_big_endian
;
12094 byte_put
= byte_put_big_endian
;
12098 /* For now we only support 32 bit and 64 bit ELF files. */
12099 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
12101 /* Read in the rest of the header. */
12104 Elf32_External_Ehdr ehdr32
;
12106 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
12109 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
12110 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
12111 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
12112 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
12113 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
12114 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
12115 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
12116 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
12117 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
12118 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
12119 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
12120 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
12121 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
12125 Elf64_External_Ehdr ehdr64
;
12127 /* If we have been compiled with sizeof (bfd_vma) == 4, then
12128 we will not be able to cope with the 64bit data found in
12129 64 ELF files. Detect this now and abort before we start
12130 overwriting things. */
12131 if (sizeof (bfd_vma
) < 8)
12133 error (_("This instance of readelf has been built without support for a\n\
12134 64 bit data type and so it cannot read 64 bit ELF files.\n"));
12138 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
12141 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
12142 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
12143 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
12144 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
12145 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
12146 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
12147 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
12148 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
12149 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
12150 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
12151 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
12152 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
12153 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
12156 if (elf_header
.e_shoff
)
12158 /* There may be some extensions in the first section header. Don't
12159 bomb if we can't read it. */
12161 get_32bit_section_headers (file
, 1);
12163 get_64bit_section_headers (file
, 1);
12169 /* Process one ELF object file according to the command line options.
12170 This file may actually be stored in an archive. The file is
12171 positioned at the start of the ELF object. */
12174 process_object (char *file_name
, FILE *file
)
12178 if (! get_file_header (file
))
12180 error (_("%s: Failed to read file header\n"), file_name
);
12184 /* Initialise per file variables. */
12185 for (i
= NUM_ELEM (version_info
); i
--;)
12186 version_info
[i
] = 0;
12188 for (i
= NUM_ELEM (dynamic_info
); i
--;)
12189 dynamic_info
[i
] = 0;
12191 /* Process the file. */
12193 printf (_("\nFile: %s\n"), file_name
);
12195 /* Initialise the dump_sects array from the cmdline_dump_sects array.
12196 Note we do this even if cmdline_dump_sects is empty because we
12197 must make sure that the dump_sets array is zeroed out before each
12198 object file is processed. */
12199 if (num_dump_sects
> num_cmdline_dump_sects
)
12200 memset (dump_sects
, 0, num_dump_sects
);
12202 if (num_cmdline_dump_sects
> 0)
12204 if (num_dump_sects
== 0)
12205 /* A sneaky way of allocating the dump_sects array. */
12206 request_dump (num_cmdline_dump_sects
, 0);
12208 assert (num_dump_sects
>= num_cmdline_dump_sects
);
12209 memcpy (dump_sects
, cmdline_dump_sects
, num_cmdline_dump_sects
);
12212 if (! process_file_header ())
12215 if (! process_section_headers (file
))
12217 /* Without loaded section headers we cannot process lots of
12219 do_unwind
= do_version
= do_dump
= do_arch
= 0;
12221 if (! do_using_dynamic
)
12222 do_syms
= do_reloc
= 0;
12225 if (! process_section_groups (file
))
12227 /* Without loaded section groups we cannot process unwind. */
12231 if (process_program_headers (file
))
12232 process_dynamic_section (file
);
12234 process_relocs (file
);
12236 process_unwind (file
);
12238 process_symbol_table (file
);
12240 process_syminfo (file
);
12242 process_version_sections (file
);
12244 process_section_contents (file
);
12246 process_notes (file
);
12248 process_gnu_liblist (file
);
12250 process_arch_specific (file
);
12252 if (program_headers
)
12254 free (program_headers
);
12255 program_headers
= NULL
;
12258 if (section_headers
)
12260 free (section_headers
);
12261 section_headers
= NULL
;
12266 free (string_table
);
12267 string_table
= NULL
;
12268 string_table_length
= 0;
12271 if (dynamic_strings
)
12273 free (dynamic_strings
);
12274 dynamic_strings
= NULL
;
12275 dynamic_strings_length
= 0;
12278 if (dynamic_symbols
)
12280 free (dynamic_symbols
);
12281 dynamic_symbols
= NULL
;
12282 num_dynamic_syms
= 0;
12285 if (dynamic_syminfo
)
12287 free (dynamic_syminfo
);
12288 dynamic_syminfo
= NULL
;
12291 if (section_headers_groups
)
12293 free (section_headers_groups
);
12294 section_headers_groups
= NULL
;
12297 if (section_groups
)
12299 struct group_list
*g
, *next
;
12301 for (i
= 0; i
< group_count
; i
++)
12303 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
12310 free (section_groups
);
12311 section_groups
= NULL
;
12314 if (debug_information
)
12316 for (i
= 0; i
< num_debug_info_entries
; i
++)
12318 if (!debug_information
[i
].max_loc_offsets
)
12320 free (debug_information
[i
].loc_offsets
);
12321 free (debug_information
[i
].have_frame_base
);
12323 if (!debug_information
[i
].max_range_lists
)
12324 free (debug_information
[i
].range_lists
);
12326 free (debug_information
);
12327 debug_information
= NULL
;
12328 num_debug_info_entries
= 0;
12334 /* Process an ELF archive. The file is positioned just after the
12338 process_archive (char *file_name
, FILE *file
)
12340 struct ar_hdr arhdr
;
12342 unsigned long size
;
12343 char *longnames
= NULL
;
12344 unsigned long longnames_size
= 0;
12345 size_t file_name_size
;
12350 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12351 if (got
!= sizeof arhdr
)
12356 error (_("%s: failed to read archive header\n"), file_name
);
12360 if (memcmp (arhdr
.ar_name
, "/ ", 16) == 0)
12362 /* This is the archive symbol table. Skip it.
12363 FIXME: We should have an option to dump it. */
12364 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
12365 if (fseek (file
, size
+ (size
& 1), SEEK_CUR
) != 0)
12367 error (_("%s: failed to skip archive symbol table\n"), file_name
);
12371 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12372 if (got
!= sizeof arhdr
)
12377 error (_("%s: failed to read archive header\n"), file_name
);
12382 if (memcmp (arhdr
.ar_name
, "// ", 16) == 0)
12384 /* This is the archive string table holding long member
12387 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
12389 longnames
= malloc (longnames_size
);
12390 if (longnames
== NULL
)
12392 error (_("Out of memory\n"));
12396 if (fread (longnames
, longnames_size
, 1, file
) != 1)
12399 error (_("%s: failed to read string table\n"), file_name
);
12403 if ((longnames_size
& 1) != 0)
12406 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12407 if (got
!= sizeof arhdr
)
12414 error (_("%s: failed to read archive header\n"), file_name
);
12419 file_name_size
= strlen (file_name
);
12428 if (arhdr
.ar_name
[0] == '/')
12432 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
12433 if (off
>= longnames_size
)
12435 error (_("%s: invalid archive string table offset %lu\n"), file_name
, off
);
12440 name
= longnames
+ off
;
12441 nameend
= memchr (name
, '/', longnames_size
- off
);
12445 name
= arhdr
.ar_name
;
12446 nameend
= memchr (name
, '/', 16);
12449 if (nameend
== NULL
)
12451 error (_("%s: bad archive file name\n"), file_name
);
12456 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
12457 if (namealc
== NULL
)
12459 error (_("Out of memory\n"));
12464 memcpy (namealc
, file_name
, file_name_size
);
12465 namealc
[file_name_size
] = '(';
12466 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
12467 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
12468 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
12470 archive_file_offset
= ftell (file
);
12471 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
12473 ret
|= process_object (namealc
, file
);
12478 (archive_file_offset
12479 + archive_file_size
12480 + (archive_file_size
& 1)),
12483 error (_("%s: failed to seek to next archive header\n"), file_name
);
12488 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12489 if (got
!= sizeof arhdr
)
12494 error (_("%s: failed to read archive header\n"), file_name
);
12500 if (longnames
!= 0)
12507 process_file (char *file_name
)
12510 struct stat statbuf
;
12511 char armag
[SARMAG
];
12514 if (stat (file_name
, &statbuf
) < 0)
12516 if (errno
== ENOENT
)
12517 error (_("'%s': No such file\n"), file_name
);
12519 error (_("Could not locate '%s'. System error message: %s\n"),
12520 file_name
, strerror (errno
));
12524 if (! S_ISREG (statbuf
.st_mode
))
12526 error (_("'%s' is not an ordinary file\n"), file_name
);
12530 file
= fopen (file_name
, "rb");
12533 error (_("Input file '%s' is not readable.\n"), file_name
);
12537 if (fread (armag
, SARMAG
, 1, file
) != 1)
12539 error (_("%s: Failed to read file header\n"), file_name
);
12544 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
12545 ret
= process_archive (file_name
, file
);
12549 archive_file_size
= archive_file_offset
= 0;
12550 ret
= process_object (file_name
, file
);
12558 #ifdef SUPPORT_DISASSEMBLY
12559 /* Needed by the i386 disassembler. For extra credit, someone could
12560 fix this so that we insert symbolic addresses here, esp for GOT/PLT
12564 print_address (unsigned int addr
, FILE *outfile
)
12566 fprintf (outfile
,"0x%8.8x", addr
);
12569 /* Needed by the i386 disassembler. */
12571 db_task_printsym (unsigned int addr
)
12573 print_address (addr
, stderr
);
12578 main (int argc
, char **argv
)
12582 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
12583 setlocale (LC_MESSAGES
, "");
12585 #if defined (HAVE_SETLOCALE)
12586 setlocale (LC_CTYPE
, "");
12588 bindtextdomain (PACKAGE
, LOCALEDIR
);
12589 textdomain (PACKAGE
);
12591 parse_args (argc
, argv
);
12593 if (num_dump_sects
> 0)
12595 /* Make a copy of the dump_sects array. */
12596 cmdline_dump_sects
= malloc (num_dump_sects
);
12597 if (cmdline_dump_sects
== NULL
)
12598 error (_("Out of memory allocating dump request table."));
12601 memcpy (cmdline_dump_sects
, dump_sects
, num_dump_sects
);
12602 num_cmdline_dump_sects
= num_dump_sects
;
12606 if (optind
< (argc
- 1))
12610 while (optind
< argc
)
12611 err
|= process_file (argv
[optind
++]);
12613 if (dump_sects
!= NULL
)
12615 if (cmdline_dump_sects
!= NULL
)
12616 free (cmdline_dump_sects
);