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
, nentries
, 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"));
5242 nentries
= size
/ unw_ent_size
;
5243 size
= unw_ent_size
* nentries
;
5245 tep
= aux
->table
= xcmalloc (nentries
, sizeof (aux
->table
[0]));
5247 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
5249 unsigned int tmp1
, tmp2
;
5251 tep
->start
.section
= SHN_UNDEF
;
5252 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);
5259 tep
->start
.offset
+= aux
->seg_base
;
5260 tep
->end
.offset
+= aux
->seg_base
;
5262 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
5263 tep
->Millicode
= (tmp1
>> 30) & 0x1;
5264 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
5265 tep
->Region_description
= (tmp1
>> 27) & 0x3;
5266 tep
->reserved1
= (tmp1
>> 26) & 0x1;
5267 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
5268 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
5269 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
5270 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
5271 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
5272 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
5273 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
5274 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
5275 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
5276 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
5277 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
5278 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
5279 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
5280 tep
->reserved2
= (tmp1
>> 5) & 0x1;
5281 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
5282 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
5283 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
5284 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
5285 tep
->Cleanup_defined
= tmp1
& 0x1;
5287 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5288 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5289 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5290 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5291 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5292 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5296 /* Third, apply any relocations to the unwind table. */
5298 for (relsec
= section_headers
;
5299 relsec
< section_headers
+ elf_header
.e_shnum
;
5302 if (relsec
->sh_type
!= SHT_RELA
5303 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
5304 || SECTION_HEADER (relsec
->sh_info
) != sec
)
5307 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5311 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5315 relname
= elf_hppa_reloc_type (ELF32_R_TYPE (rp
->r_info
));
5316 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
5320 relname
= elf_hppa_reloc_type (ELF64_R_TYPE (rp
->r_info
));
5321 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
5324 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5325 if (strncmp (relname
, "R_PARISC_SEGREL", 15) != 0)
5327 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5331 i
= rp
->r_offset
/ unw_ent_size
;
5333 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5336 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5337 aux
->table
[i
].start
.offset
+= sym
->st_value
+ rp
->r_addend
;
5340 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5341 aux
->table
[i
].end
.offset
+= sym
->st_value
+ rp
->r_addend
;
5351 aux
->table_len
= nentries
;
5357 hppa_process_unwind (FILE *file
)
5359 struct hppa_unw_aux_info aux
;
5360 Elf_Internal_Shdr
*unwsec
= NULL
;
5361 Elf_Internal_Shdr
*strsec
;
5362 Elf_Internal_Shdr
*sec
;
5365 memset (& aux
, 0, sizeof (aux
));
5367 if (string_table
== NULL
)
5370 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5372 if (sec
->sh_type
== SHT_SYMTAB
5373 && SECTION_HEADER_INDEX (sec
->sh_link
) < elf_header
.e_shnum
)
5375 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5376 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5378 strsec
= SECTION_HEADER (sec
->sh_link
);
5379 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5380 1, strsec
->sh_size
, _("string table"));
5381 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5383 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5388 printf (_("\nThere are no unwind sections in this file.\n"));
5390 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5392 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5394 printf (_("\nUnwind section "));
5395 printf (_("'%s'"), SECTION_NAME (sec
));
5397 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5398 (unsigned long) sec
->sh_offset
,
5399 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5401 slurp_hppa_unwind_table (file
, &aux
, sec
);
5402 if (aux
.table_len
> 0)
5403 dump_hppa_unwind (&aux
);
5406 free ((char *) aux
.table
);
5414 free ((char *) aux
.strtab
);
5420 process_unwind (FILE *file
)
5422 struct unwind_handler
{
5424 int (*handler
)(FILE *file
);
5426 { EM_IA_64
, ia64_process_unwind
},
5427 { EM_PARISC
, hppa_process_unwind
},
5435 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5436 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5437 return handlers
[i
].handler (file
);
5439 printf (_("\nThere are no unwind sections in this file.\n"));
5444 dynamic_section_mips_val (Elf_Internal_Dyn
*entry
)
5446 switch (entry
->d_tag
)
5449 if (entry
->d_un
.d_val
== 0)
5453 static const char * opts
[] =
5455 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5456 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5457 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5458 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5463 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++cnt
)
5464 if (entry
->d_un
.d_val
& (1 << cnt
))
5466 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5473 case DT_MIPS_IVERSION
:
5474 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5475 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5477 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5480 case DT_MIPS_TIME_STAMP
:
5485 time_t time
= entry
->d_un
.d_val
;
5486 tmp
= gmtime (&time
);
5487 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5488 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5489 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5490 printf ("Time Stamp: %s\n", timebuf
);
5494 case DT_MIPS_RLD_VERSION
:
5495 case DT_MIPS_LOCAL_GOTNO
:
5496 case DT_MIPS_CONFLICTNO
:
5497 case DT_MIPS_LIBLISTNO
:
5498 case DT_MIPS_SYMTABNO
:
5499 case DT_MIPS_UNREFEXTNO
:
5500 case DT_MIPS_HIPAGENO
:
5501 case DT_MIPS_DELTA_CLASS_NO
:
5502 case DT_MIPS_DELTA_INSTANCE_NO
:
5503 case DT_MIPS_DELTA_RELOC_NO
:
5504 case DT_MIPS_DELTA_SYM_NO
:
5505 case DT_MIPS_DELTA_CLASSSYM_NO
:
5506 case DT_MIPS_COMPACT_SIZE
:
5507 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5511 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
5517 dynamic_section_parisc_val (Elf_Internal_Dyn
*entry
)
5519 switch (entry
->d_tag
)
5521 case DT_HP_DLD_FLAGS
:
5530 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5531 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5532 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5533 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5534 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5535 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5536 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5537 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5538 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5539 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5540 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
5541 { DT_HP_GST
, "HP_GST" },
5542 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
5543 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
5544 { DT_HP_NODELETE
, "HP_NODELETE" },
5545 { DT_HP_GROUP
, "HP_GROUP" },
5546 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
5550 bfd_vma val
= entry
->d_un
.d_val
;
5552 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
5553 if (val
& flags
[cnt
].bit
)
5557 fputs (flags
[cnt
].str
, stdout
);
5559 val
^= flags
[cnt
].bit
;
5562 if (val
!= 0 || first
)
5566 print_vma (val
, HEX
);
5572 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5579 dynamic_section_ia64_val (Elf_Internal_Dyn
*entry
)
5581 switch (entry
->d_tag
)
5583 case DT_IA_64_PLT_RESERVE
:
5584 /* First 3 slots reserved. */
5585 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5587 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5591 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5598 get_32bit_dynamic_section (FILE *file
)
5600 Elf32_External_Dyn
*edyn
, *ext
;
5601 Elf_Internal_Dyn
*entry
;
5603 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5604 _("dynamic section"));
5608 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5609 might not have the luxury of section headers. Look for the DT_NULL
5610 terminator to determine the number of entries. */
5611 for (ext
= edyn
, dynamic_nent
= 0;
5612 (char *) ext
< (char *) edyn
+ dynamic_size
;
5616 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5620 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5621 if (dynamic_section
== NULL
)
5623 error (_("Out of memory\n"));
5628 for (ext
= edyn
, entry
= dynamic_section
;
5629 entry
< dynamic_section
+ dynamic_nent
;
5632 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5633 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5642 get_64bit_dynamic_section (FILE *file
)
5644 Elf64_External_Dyn
*edyn
, *ext
;
5645 Elf_Internal_Dyn
*entry
;
5647 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5648 _("dynamic section"));
5652 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5653 might not have the luxury of section headers. Look for the DT_NULL
5654 terminator to determine the number of entries. */
5655 for (ext
= edyn
, dynamic_nent
= 0;
5656 (char *) ext
< (char *) edyn
+ dynamic_size
;
5660 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5664 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5665 if (dynamic_section
== NULL
)
5667 error (_("Out of memory\n"));
5672 for (ext
= edyn
, entry
= dynamic_section
;
5673 entry
< dynamic_section
+ dynamic_nent
;
5676 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5677 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5686 print_dynamic_flags (bfd_vma flags
)
5694 flag
= flags
& - flags
;
5704 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
5705 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
5706 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
5707 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
5708 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
5709 default: fputs ("unknown", stdout
); break;
5715 /* Parse and display the contents of the dynamic section. */
5718 process_dynamic_section (FILE *file
)
5720 Elf_Internal_Dyn
*entry
;
5722 if (dynamic_size
== 0)
5725 printf (_("\nThere is no dynamic section in this file.\n"));
5732 if (! get_32bit_dynamic_section (file
))
5735 else if (! get_64bit_dynamic_section (file
))
5738 /* Find the appropriate symbol table. */
5739 if (dynamic_symbols
== NULL
)
5741 for (entry
= dynamic_section
;
5742 entry
< dynamic_section
+ dynamic_nent
;
5745 Elf_Internal_Shdr section
;
5747 if (entry
->d_tag
!= DT_SYMTAB
)
5750 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
5752 /* Since we do not know how big the symbol table is,
5753 we default to reading in the entire file (!) and
5754 processing that. This is overkill, I know, but it
5756 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5758 if (archive_file_offset
!= 0)
5759 section
.sh_size
= archive_file_size
- section
.sh_offset
;
5762 if (fseek (file
, 0, SEEK_END
))
5763 error (_("Unable to seek to end of file!"));
5765 section
.sh_size
= ftell (file
) - section
.sh_offset
;
5769 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
5771 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
5773 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
5774 if (num_dynamic_syms
< 1)
5776 error (_("Unable to determine the number of symbols to load\n"));
5780 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
5784 /* Similarly find a string table. */
5785 if (dynamic_strings
== NULL
)
5787 for (entry
= dynamic_section
;
5788 entry
< dynamic_section
+ dynamic_nent
;
5791 unsigned long offset
;
5794 if (entry
->d_tag
!= DT_STRTAB
)
5797 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
5799 /* Since we do not know how big the string table is,
5800 we default to reading in the entire file (!) and
5801 processing that. This is overkill, I know, but it
5804 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5806 if (archive_file_offset
!= 0)
5807 str_tab_len
= archive_file_size
- offset
;
5810 if (fseek (file
, 0, SEEK_END
))
5811 error (_("Unable to seek to end of file\n"));
5812 str_tab_len
= ftell (file
) - offset
;
5815 if (str_tab_len
< 1)
5818 (_("Unable to determine the length of the dynamic string table\n"));
5822 dynamic_strings
= get_data (NULL
, file
, offset
, 1, str_tab_len
,
5823 _("dynamic string table"));
5824 dynamic_strings_length
= str_tab_len
;
5829 /* And find the syminfo section if available. */
5830 if (dynamic_syminfo
== NULL
)
5832 unsigned long syminsz
= 0;
5834 for (entry
= dynamic_section
;
5835 entry
< dynamic_section
+ dynamic_nent
;
5838 if (entry
->d_tag
== DT_SYMINENT
)
5840 /* Note: these braces are necessary to avoid a syntax
5841 error from the SunOS4 C compiler. */
5842 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
5844 else if (entry
->d_tag
== DT_SYMINSZ
)
5845 syminsz
= entry
->d_un
.d_val
;
5846 else if (entry
->d_tag
== DT_SYMINFO
)
5847 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
5851 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
5853 Elf_External_Syminfo
*extsyminfo
, *extsym
;
5854 Elf_Internal_Syminfo
*syminfo
;
5856 /* There is a syminfo section. Read the data. */
5857 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, 1,
5858 syminsz
, _("symbol information"));
5862 dynamic_syminfo
= malloc (syminsz
);
5863 if (dynamic_syminfo
== NULL
)
5865 error (_("Out of memory\n"));
5869 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
5870 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
5871 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
5872 ++syminfo
, ++extsym
)
5874 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
5875 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
5882 if (do_dynamic
&& dynamic_addr
)
5883 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
5884 dynamic_addr
, dynamic_nent
);
5886 printf (_(" Tag Type Name/Value\n"));
5888 for (entry
= dynamic_section
;
5889 entry
< dynamic_section
+ dynamic_nent
;
5897 print_vma (entry
->d_tag
, FULL_HEX
);
5898 dtype
= get_dynamic_type (entry
->d_tag
);
5899 printf (" (%s)%*s", dtype
,
5900 ((is_32bit_elf
? 27 : 19)
5901 - (int) strlen (dtype
)),
5905 switch (entry
->d_tag
)
5909 print_dynamic_flags (entry
->d_un
.d_val
);
5919 switch (entry
->d_tag
)
5922 printf (_("Auxiliary library"));
5926 printf (_("Filter library"));
5930 printf (_("Configuration file"));
5934 printf (_("Dependency audit library"));
5938 printf (_("Audit library"));
5942 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5943 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5947 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5956 printf (_("Flags:"));
5958 if (entry
->d_un
.d_val
== 0)
5959 printf (_(" None\n"));
5962 unsigned long int val
= entry
->d_un
.d_val
;
5964 if (val
& DTF_1_PARINIT
)
5966 printf (" PARINIT");
5967 val
^= DTF_1_PARINIT
;
5969 if (val
& DTF_1_CONFEXP
)
5971 printf (" CONFEXP");
5972 val
^= DTF_1_CONFEXP
;
5975 printf (" %lx", val
);
5984 printf (_("Flags:"));
5986 if (entry
->d_un
.d_val
== 0)
5987 printf (_(" None\n"));
5990 unsigned long int val
= entry
->d_un
.d_val
;
5992 if (val
& DF_P1_LAZYLOAD
)
5994 printf (" LAZYLOAD");
5995 val
^= DF_P1_LAZYLOAD
;
5997 if (val
& DF_P1_GROUPPERM
)
5999 printf (" GROUPPERM");
6000 val
^= DF_P1_GROUPPERM
;
6003 printf (" %lx", val
);
6012 printf (_("Flags:"));
6013 if (entry
->d_un
.d_val
== 0)
6014 printf (_(" None\n"));
6017 unsigned long int val
= entry
->d_un
.d_val
;
6024 if (val
& DF_1_GLOBAL
)
6029 if (val
& DF_1_GROUP
)
6034 if (val
& DF_1_NODELETE
)
6036 printf (" NODELETE");
6037 val
^= DF_1_NODELETE
;
6039 if (val
& DF_1_LOADFLTR
)
6041 printf (" LOADFLTR");
6042 val
^= DF_1_LOADFLTR
;
6044 if (val
& DF_1_INITFIRST
)
6046 printf (" INITFIRST");
6047 val
^= DF_1_INITFIRST
;
6049 if (val
& DF_1_NOOPEN
)
6054 if (val
& DF_1_ORIGIN
)
6059 if (val
& DF_1_DIRECT
)
6064 if (val
& DF_1_TRANS
)
6069 if (val
& DF_1_INTERPOSE
)
6071 printf (" INTERPOSE");
6072 val
^= DF_1_INTERPOSE
;
6074 if (val
& DF_1_NODEFLIB
)
6076 printf (" NODEFLIB");
6077 val
^= DF_1_NODEFLIB
;
6079 if (val
& DF_1_NODUMP
)
6084 if (val
& DF_1_CONLFAT
)
6086 printf (" CONLFAT");
6087 val
^= DF_1_CONLFAT
;
6090 printf (" %lx", val
);
6097 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6099 puts (get_dynamic_type (entry
->d_un
.d_val
));
6119 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6125 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6126 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6132 switch (entry
->d_tag
)
6135 printf (_("Shared library: [%s]"), name
);
6137 if (streq (name
, program_interpreter
))
6138 printf (_(" program interpreter"));
6142 printf (_("Library soname: [%s]"), name
);
6146 printf (_("Library rpath: [%s]"), name
);
6150 printf (_("Library runpath: [%s]"), name
);
6154 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6159 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6172 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6176 case DT_INIT_ARRAYSZ
:
6177 case DT_FINI_ARRAYSZ
:
6178 case DT_GNU_CONFLICTSZ
:
6179 case DT_GNU_LIBLISTSZ
:
6182 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6183 printf (" (bytes)\n");
6193 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6206 if (entry
->d_tag
== DT_USED
6207 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6209 char *name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6213 printf (_("Not needed object: [%s]\n"), name
);
6218 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6224 /* The value of this entry is ignored. */
6229 case DT_GNU_PRELINKED
:
6233 time_t time
= entry
->d_un
.d_val
;
6235 tmp
= gmtime (&time
);
6236 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6237 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6238 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6244 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
6245 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
6250 switch (elf_header
.e_machine
)
6253 case EM_MIPS_RS3_LE
:
6254 dynamic_section_mips_val (entry
);
6257 dynamic_section_parisc_val (entry
);
6260 dynamic_section_ia64_val (entry
);
6263 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6275 get_ver_flags (unsigned int flags
)
6277 static char buff
[32];
6284 if (flags
& VER_FLG_BASE
)
6285 strcat (buff
, "BASE ");
6287 if (flags
& VER_FLG_WEAK
)
6289 if (flags
& VER_FLG_BASE
)
6290 strcat (buff
, "| ");
6292 strcat (buff
, "WEAK ");
6295 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
6296 strcat (buff
, "| <unknown>");
6301 /* Display the contents of the version sections. */
6303 process_version_sections (FILE *file
)
6305 Elf_Internal_Shdr
*section
;
6312 for (i
= 0, section
= section_headers
;
6313 i
< elf_header
.e_shnum
;
6316 switch (section
->sh_type
)
6318 case SHT_GNU_verdef
:
6320 Elf_External_Verdef
*edefs
;
6327 (_("\nVersion definition section '%s' contains %ld entries:\n"),
6328 SECTION_NAME (section
), section
->sh_info
);
6330 printf (_(" Addr: 0x"));
6331 printf_vma (section
->sh_addr
);
6332 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6333 (unsigned long) section
->sh_offset
, section
->sh_link
,
6334 SECTION_HEADER_INDEX (section
->sh_link
)
6335 < elf_header
.e_shnum
6336 ? SECTION_NAME (SECTION_HEADER (section
->sh_link
))
6339 edefs
= get_data (NULL
, file
, section
->sh_offset
, 1,
6341 _("version definition section"));
6345 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6348 Elf_External_Verdef
*edef
;
6349 Elf_Internal_Verdef ent
;
6350 Elf_External_Verdaux
*eaux
;
6351 Elf_Internal_Verdaux aux
;
6355 vstart
= ((char *) edefs
) + idx
;
6357 edef
= (Elf_External_Verdef
*) vstart
;
6359 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
6360 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
6361 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
6362 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
6363 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
6364 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
6365 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
6367 printf (_(" %#06x: Rev: %d Flags: %s"),
6368 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
6370 printf (_(" Index: %d Cnt: %d "),
6371 ent
.vd_ndx
, ent
.vd_cnt
);
6373 vstart
+= ent
.vd_aux
;
6375 eaux
= (Elf_External_Verdaux
*) vstart
;
6377 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6378 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6380 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6381 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6383 printf (_("Name index: %ld\n"), aux
.vda_name
);
6385 isum
= idx
+ ent
.vd_aux
;
6387 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6389 isum
+= aux
.vda_next
;
6390 vstart
+= aux
.vda_next
;
6392 eaux
= (Elf_External_Verdaux
*) vstart
;
6394 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6395 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6397 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6398 printf (_(" %#06x: Parent %d: %s\n"),
6399 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6401 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6402 isum
, j
, aux
.vda_name
);
6412 case SHT_GNU_verneed
:
6414 Elf_External_Verneed
*eneed
;
6420 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
6421 SECTION_NAME (section
), section
->sh_info
);
6423 printf (_(" Addr: 0x"));
6424 printf_vma (section
->sh_addr
);
6425 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
6426 (unsigned long) section
->sh_offset
, section
->sh_link
,
6427 SECTION_HEADER_INDEX (section
->sh_link
)
6428 < elf_header
.e_shnum
6429 ? SECTION_NAME (SECTION_HEADER (section
->sh_link
))
6432 eneed
= get_data (NULL
, file
, section
->sh_offset
, 1,
6434 _("version need section"));
6438 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6440 Elf_External_Verneed
*entry
;
6441 Elf_Internal_Verneed ent
;
6446 vstart
= ((char *) eneed
) + idx
;
6448 entry
= (Elf_External_Verneed
*) vstart
;
6450 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6451 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6452 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6453 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6454 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6456 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6458 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6459 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6461 printf (_(" File: %lx"), ent
.vn_file
);
6463 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6465 vstart
+= ent
.vn_aux
;
6467 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6469 Elf_External_Vernaux
*eaux
;
6470 Elf_Internal_Vernaux aux
;
6472 eaux
= (Elf_External_Vernaux
*) vstart
;
6474 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6475 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6476 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6477 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6478 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6480 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6481 printf (_(" %#06x: Name: %s"),
6482 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6484 printf (_(" %#06x: Name index: %lx"),
6485 isum
, aux
.vna_name
);
6487 printf (_(" Flags: %s Version: %d\n"),
6488 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6490 isum
+= aux
.vna_next
;
6491 vstart
+= aux
.vna_next
;
6501 case SHT_GNU_versym
:
6503 Elf_Internal_Shdr
*link_section
;
6506 unsigned char *edata
;
6507 unsigned short *data
;
6509 Elf_Internal_Sym
*symbols
;
6510 Elf_Internal_Shdr
*string_sec
;
6513 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
)
6516 link_section
= SECTION_HEADER (section
->sh_link
);
6517 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
6519 if (SECTION_HEADER_INDEX (link_section
->sh_link
)
6520 >= elf_header
.e_shnum
)
6525 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6527 string_sec
= SECTION_HEADER (link_section
->sh_link
);
6529 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
6530 string_sec
->sh_size
, _("version string table"));
6534 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6535 SECTION_NAME (section
), total
);
6537 printf (_(" Addr: "));
6538 printf_vma (section
->sh_addr
);
6539 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6540 (unsigned long) section
->sh_offset
, section
->sh_link
,
6541 SECTION_NAME (link_section
));
6543 off
= offset_from_vma (file
,
6544 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6545 total
* sizeof (short));
6546 edata
= get_data (NULL
, file
, off
, total
, sizeof (short),
6547 _("version symbol data"));
6554 data
= cmalloc (total
, sizeof (short));
6556 for (cnt
= total
; cnt
--;)
6557 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6562 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6565 int check_def
, check_need
;
6568 printf (" %03x:", cnt
);
6570 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6571 switch (data
[cnt
+ j
])
6574 fputs (_(" 0 (*local*) "), stdout
);
6578 fputs (_(" 1 (*global*) "), stdout
);
6582 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
6583 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
6587 if (SECTION_HEADER_INDEX (symbols
[cnt
+ j
].st_shndx
)
6588 >= elf_header
.e_shnum
6589 || SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
6592 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6599 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6601 Elf_Internal_Verneed ivn
;
6602 unsigned long offset
;
6604 offset
= offset_from_vma
6605 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6606 sizeof (Elf_External_Verneed
));
6610 Elf_Internal_Vernaux ivna
;
6611 Elf_External_Verneed evn
;
6612 Elf_External_Vernaux evna
;
6613 unsigned long a_off
;
6615 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
6618 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6619 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6621 a_off
= offset
+ ivn
.vn_aux
;
6625 get_data (&evna
, file
, a_off
, sizeof (evna
),
6626 1, _("version need aux (2)"));
6628 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6629 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6631 a_off
+= ivna
.vna_next
;
6633 while (ivna
.vna_other
!= data
[cnt
+ j
]
6634 && ivna
.vna_next
!= 0);
6636 if (ivna
.vna_other
== data
[cnt
+ j
])
6638 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6640 name
= strtab
+ ivna
.vna_name
;
6641 nn
+= printf ("(%s%-*s",
6643 12 - (int) strlen (name
),
6649 offset
+= ivn
.vn_next
;
6651 while (ivn
.vn_next
);
6654 if (check_def
&& data
[cnt
+ j
] != 0x8001
6655 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6657 Elf_Internal_Verdef ivd
;
6658 Elf_External_Verdef evd
;
6659 unsigned long offset
;
6661 offset
= offset_from_vma
6662 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6667 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
6670 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6671 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6673 offset
+= ivd
.vd_next
;
6675 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
6676 && ivd
.vd_next
!= 0);
6678 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
6680 Elf_External_Verdaux evda
;
6681 Elf_Internal_Verdaux ivda
;
6683 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6685 get_data (&evda
, file
,
6686 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
6688 _("version def aux"));
6690 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6692 name
= strtab
+ ivda
.vda_name
;
6693 nn
+= printf ("(%s%-*s",
6695 12 - (int) strlen (name
),
6701 printf ("%*c", 18 - nn
, ' ');
6719 printf (_("\nNo version information found in this file.\n"));
6725 get_symbol_binding (unsigned int binding
)
6727 static char buff
[32];
6731 case STB_LOCAL
: return "LOCAL";
6732 case STB_GLOBAL
: return "GLOBAL";
6733 case STB_WEAK
: return "WEAK";
6735 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
6736 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
6738 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
6739 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
6741 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
6747 get_symbol_type (unsigned int type
)
6749 static char buff
[32];
6753 case STT_NOTYPE
: return "NOTYPE";
6754 case STT_OBJECT
: return "OBJECT";
6755 case STT_FUNC
: return "FUNC";
6756 case STT_SECTION
: return "SECTION";
6757 case STT_FILE
: return "FILE";
6758 case STT_COMMON
: return "COMMON";
6759 case STT_TLS
: return "TLS";
6761 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
6763 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
6764 return "THUMB_FUNC";
6766 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
6769 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
6770 return "PARISC_MILLI";
6772 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
6774 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
6776 if (elf_header
.e_machine
== EM_PARISC
)
6778 if (type
== STT_HP_OPAQUE
)
6780 if (type
== STT_HP_STUB
)
6784 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
6787 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
6793 get_symbol_visibility (unsigned int visibility
)
6797 case STV_DEFAULT
: return "DEFAULT";
6798 case STV_INTERNAL
: return "INTERNAL";
6799 case STV_HIDDEN
: return "HIDDEN";
6800 case STV_PROTECTED
: return "PROTECTED";
6806 get_symbol_index_type (unsigned int type
)
6808 static char buff
[32];
6812 case SHN_UNDEF
: return "UND";
6813 case SHN_ABS
: return "ABS";
6814 case SHN_COMMON
: return "COM";
6816 if (type
== SHN_IA_64_ANSI_COMMON
6817 && elf_header
.e_machine
== EM_IA_64
6818 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
6820 else if (elf_header
.e_machine
== EM_X86_64
6821 && type
== SHN_X86_64_LCOMMON
)
6823 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
6824 sprintf (buff
, "PRC[0x%04x]", type
);
6825 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
6826 sprintf (buff
, "OS [0x%04x]", type
);
6827 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
6828 sprintf (buff
, "RSV[0x%04x]", type
);
6830 sprintf (buff
, "%3d", type
);
6838 get_dynamic_data (FILE *file
, unsigned int number
, unsigned int ent_size
)
6840 unsigned char *e_data
;
6843 e_data
= cmalloc (number
, ent_size
);
6847 error (_("Out of memory\n"));
6851 if (fread (e_data
, ent_size
, number
, file
) != number
)
6853 error (_("Unable to read in dynamic data\n"));
6857 i_data
= cmalloc (number
, sizeof (*i_data
));
6861 error (_("Out of memory\n"));
6867 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
6874 /* Dump the symbol table. */
6876 process_symbol_table (FILE *file
)
6878 Elf_Internal_Shdr
*section
;
6879 bfd_vma nbuckets
= 0;
6880 bfd_vma nchains
= 0;
6881 bfd_vma
*buckets
= NULL
;
6882 bfd_vma
*chains
= NULL
;
6884 if (! do_syms
&& !do_histogram
)
6887 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
6890 unsigned char nb
[8];
6891 unsigned char nc
[8];
6892 int hash_ent_size
= 4;
6894 if ((elf_header
.e_machine
== EM_ALPHA
6895 || elf_header
.e_machine
== EM_S390
6896 || elf_header
.e_machine
== EM_S390_OLD
)
6897 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
6901 (archive_file_offset
6902 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
6903 sizeof nb
+ sizeof nc
)),
6906 error (_("Unable to seek to start of dynamic information"));
6910 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
6912 error (_("Failed to read in number of buckets\n"));
6916 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
6918 error (_("Failed to read in number of chains\n"));
6922 nbuckets
= byte_get (nb
, hash_ent_size
);
6923 nchains
= byte_get (nc
, hash_ent_size
);
6925 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
6926 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
6928 if (buckets
== NULL
|| chains
== NULL
)
6933 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
6938 printf (_("\nSymbol table for image:\n"));
6940 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6942 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6944 for (hn
= 0; hn
< nbuckets
; hn
++)
6949 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
6951 Elf_Internal_Sym
*psym
;
6954 psym
= dynamic_symbols
+ si
;
6956 n
= print_vma (si
, DEC_5
);
6958 fputs (" " + n
, stdout
);
6959 printf (" %3lu: ", hn
);
6960 print_vma (psym
->st_value
, LONG_HEX
);
6962 print_vma (psym
->st_size
, DEC_5
);
6964 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6965 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6966 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6967 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
6968 if (VALID_DYNAMIC_NAME (psym
->st_name
))
6969 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
6971 printf (" <corrupt: %14ld>", psym
->st_name
);
6976 else if (do_syms
&& !do_using_dynamic
)
6980 for (i
= 0, section
= section_headers
;
6981 i
< elf_header
.e_shnum
;
6985 char *strtab
= NULL
;
6986 unsigned long int strtab_size
= 0;
6987 Elf_Internal_Sym
*symtab
;
6988 Elf_Internal_Sym
*psym
;
6991 if ( section
->sh_type
!= SHT_SYMTAB
6992 && section
->sh_type
!= SHT_DYNSYM
)
6995 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
6996 SECTION_NAME (section
),
6997 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
6999 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7001 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7003 symtab
= GET_ELF_SYMBOLS (file
, section
);
7007 if (section
->sh_link
== elf_header
.e_shstrndx
)
7009 strtab
= string_table
;
7010 strtab_size
= string_table_length
;
7012 else if (SECTION_HEADER_INDEX (section
->sh_link
) < elf_header
.e_shnum
)
7014 Elf_Internal_Shdr
*string_sec
;
7016 string_sec
= SECTION_HEADER (section
->sh_link
);
7018 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
7019 1, string_sec
->sh_size
, _("string table"));
7020 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
7023 for (si
= 0, psym
= symtab
;
7024 si
< section
->sh_size
/ section
->sh_entsize
;
7027 printf ("%6d: ", si
);
7028 print_vma (psym
->st_value
, LONG_HEX
);
7030 print_vma (psym
->st_size
, DEC_5
);
7031 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7032 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7033 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7034 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
7035 print_symbol (25, psym
->st_name
< strtab_size
7036 ? strtab
+ psym
->st_name
: "<corrupt>");
7038 if (section
->sh_type
== SHT_DYNSYM
&&
7039 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
7041 unsigned char data
[2];
7042 unsigned short vers_data
;
7043 unsigned long offset
;
7047 offset
= offset_from_vma
7048 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
7049 sizeof data
+ si
* sizeof (vers_data
));
7051 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
7052 sizeof (data
), 1, _("version data"));
7054 vers_data
= byte_get (data
, 2);
7056 is_nobits
= (SECTION_HEADER_INDEX (psym
->st_shndx
)
7057 < elf_header
.e_shnum
7058 && SECTION_HEADER (psym
->st_shndx
)->sh_type
7061 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
7063 if ((vers_data
& 0x8000) || vers_data
> 1)
7065 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
7066 && (is_nobits
|| ! check_def
))
7068 Elf_External_Verneed evn
;
7069 Elf_Internal_Verneed ivn
;
7070 Elf_Internal_Vernaux ivna
;
7072 /* We must test both. */
7073 offset
= offset_from_vma
7074 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
7079 unsigned long vna_off
;
7081 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
7084 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
7085 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
7087 vna_off
= offset
+ ivn
.vn_aux
;
7091 Elf_External_Vernaux evna
;
7093 get_data (&evna
, file
, vna_off
,
7095 _("version need aux (3)"));
7097 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
7098 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
7099 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
7101 vna_off
+= ivna
.vna_next
;
7103 while (ivna
.vna_other
!= vers_data
7104 && ivna
.vna_next
!= 0);
7106 if (ivna
.vna_other
== vers_data
)
7109 offset
+= ivn
.vn_next
;
7111 while (ivn
.vn_next
!= 0);
7113 if (ivna
.vna_other
== vers_data
)
7116 ivna
.vna_name
< strtab_size
7117 ? strtab
+ ivna
.vna_name
: "<corrupt>",
7121 else if (! is_nobits
)
7122 error (_("bad dynamic symbol"));
7129 if (vers_data
!= 0x8001
7130 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7132 Elf_Internal_Verdef ivd
;
7133 Elf_Internal_Verdaux ivda
;
7134 Elf_External_Verdaux evda
;
7135 unsigned long offset
;
7137 offset
= offset_from_vma
7139 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7140 sizeof (Elf_External_Verdef
));
7144 Elf_External_Verdef evd
;
7146 get_data (&evd
, file
, offset
, sizeof (evd
),
7147 1, _("version def"));
7149 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7150 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7151 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7153 offset
+= ivd
.vd_next
;
7155 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
7156 && ivd
.vd_next
!= 0);
7158 offset
-= ivd
.vd_next
;
7159 offset
+= ivd
.vd_aux
;
7161 get_data (&evda
, file
, offset
, sizeof (evda
),
7162 1, _("version def aux"));
7164 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7166 if (psym
->st_name
!= ivda
.vda_name
)
7167 printf ((vers_data
& 0x8000)
7169 ivda
.vda_name
< strtab_size
7170 ? strtab
+ ivda
.vda_name
: "<corrupt>");
7180 if (strtab
!= string_table
)
7186 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7188 if (do_histogram
&& buckets
!= NULL
)
7190 unsigned long *lengths
;
7191 unsigned long *counts
;
7194 unsigned long maxlength
= 0;
7195 unsigned long nzero_counts
= 0;
7196 unsigned long nsyms
= 0;
7198 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7199 (unsigned long) nbuckets
);
7200 printf (_(" Length Number %% of total Coverage\n"));
7202 lengths
= calloc (nbuckets
, sizeof (*lengths
));
7203 if (lengths
== NULL
)
7205 error (_("Out of memory"));
7208 for (hn
= 0; hn
< nbuckets
; ++hn
)
7210 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
7213 if (maxlength
< ++lengths
[hn
])
7218 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7221 error (_("Out of memory"));
7225 for (hn
= 0; hn
< nbuckets
; ++hn
)
7226 ++counts
[lengths
[hn
]];
7231 printf (" 0 %-10lu (%5.1f%%)\n",
7232 counts
[0], (counts
[0] * 100.0) / nbuckets
);
7233 for (i
= 1; i
<= maxlength
; ++i
)
7235 nzero_counts
+= counts
[i
] * i
;
7236 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7237 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
7238 (nzero_counts
* 100.0) / nsyms
);
7246 if (buckets
!= NULL
)
7256 process_syminfo (FILE *file ATTRIBUTE_UNUSED
)
7260 if (dynamic_syminfo
== NULL
7262 /* No syminfo, this is ok. */
7265 /* There better should be a dynamic symbol section. */
7266 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
7270 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7271 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
7273 printf (_(" Num: Name BoundTo Flags\n"));
7274 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
7276 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
7278 printf ("%4d: ", i
);
7279 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
7280 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
7282 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
7285 switch (dynamic_syminfo
[i
].si_boundto
)
7287 case SYMINFO_BT_SELF
:
7288 fputs ("SELF ", stdout
);
7290 case SYMINFO_BT_PARENT
:
7291 fputs ("PARENT ", stdout
);
7294 if (dynamic_syminfo
[i
].si_boundto
> 0
7295 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
7296 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
7298 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
7302 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
7306 if (flags
& SYMINFO_FLG_DIRECT
)
7308 if (flags
& SYMINFO_FLG_PASSTHRU
)
7309 printf (" PASSTHRU");
7310 if (flags
& SYMINFO_FLG_COPY
)
7312 if (flags
& SYMINFO_FLG_LAZYLOAD
)
7313 printf (" LAZYLOAD");
7321 #ifdef SUPPORT_DISASSEMBLY
7323 disassemble_section (Elf_Internal_Shdr
*section
, FILE *file
)
7325 printf (_("\nAssembly dump of section %s\n"),
7326 SECTION_NAME (section
));
7328 /* XXX -- to be done --- XXX */
7335 dump_section (Elf_Internal_Shdr
*section
, FILE *file
)
7337 bfd_size_type bytes
;
7339 unsigned char *data
;
7340 unsigned char *start
;
7342 bytes
= section
->sh_size
;
7344 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
7346 printf (_("\nSection '%s' has no data to dump.\n"),
7347 SECTION_NAME (section
));
7351 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
7353 addr
= section
->sh_addr
;
7355 start
= get_data (NULL
, file
, section
->sh_offset
, 1, bytes
,
7368 lbytes
= (bytes
> 16 ? 16 : bytes
);
7370 printf (" 0x%8.8lx ", (unsigned long) addr
);
7372 switch (elf_header
.e_ident
[EI_DATA
])
7376 for (j
= 15; j
>= 0; j
--)
7379 printf ("%2.2x", data
[j
]);
7389 for (j
= 0; j
< 16; j
++)
7392 printf ("%2.2x", data
[j
]);
7402 for (j
= 0; j
< lbytes
; j
++)
7405 if (k
>= ' ' && k
< 0x7f)
7424 static unsigned long int
7425 read_leb128 (unsigned char *data
, unsigned int *length_return
, int sign
)
7427 unsigned long int result
= 0;
7428 unsigned int num_read
= 0;
7429 unsigned int shift
= 0;
7437 result
|= ((unsigned long int) (byte
& 0x7f)) << shift
;
7442 while (byte
& 0x80);
7444 if (length_return
!= NULL
)
7445 *length_return
= num_read
;
7447 if (sign
&& (shift
< 8 * sizeof (result
)) && (byte
& 0x40))
7448 result
|= -1L << shift
;
7453 typedef struct State_Machine_Registers
7455 unsigned long address
;
7458 unsigned int column
;
7462 /* This variable hold the number of the last entry seen
7463 in the File Table. */
7464 unsigned int last_file_entry
;
7467 static SMR state_machine_regs
;
7470 reset_state_machine (int is_stmt
)
7472 state_machine_regs
.address
= 0;
7473 state_machine_regs
.file
= 1;
7474 state_machine_regs
.line
= 1;
7475 state_machine_regs
.column
= 0;
7476 state_machine_regs
.is_stmt
= is_stmt
;
7477 state_machine_regs
.basic_block
= 0;
7478 state_machine_regs
.end_sequence
= 0;
7479 state_machine_regs
.last_file_entry
= 0;
7482 /* Handled an extend line op.
7483 Returns the number of bytes read. */
7486 process_extended_line_op (unsigned char *data
, int is_stmt
, int pointer_size
)
7488 unsigned char op_code
;
7489 unsigned int bytes_read
;
7491 unsigned char *name
;
7494 len
= read_leb128 (data
, & bytes_read
, 0);
7499 warn (_("badly formed extended line op encountered!\n"));
7506 printf (_(" Extended opcode %d: "), op_code
);
7510 case DW_LNE_end_sequence
:
7511 printf (_("End of Sequence\n\n"));
7512 reset_state_machine (is_stmt
);
7515 case DW_LNE_set_address
:
7516 adr
= byte_get (data
, pointer_size
);
7517 printf (_("set Address to 0x%lx\n"), adr
);
7518 state_machine_regs
.address
= adr
;
7521 case DW_LNE_define_file
:
7522 printf (_(" define new File Table entry\n"));
7523 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
7525 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
7527 data
+= strlen ((char *) data
) + 1;
7528 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7530 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7532 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7533 printf (_("%s\n\n"), name
);
7537 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
7544 static const char *debug_str_contents
;
7545 static bfd_vma debug_str_size
;
7548 load_debug_str (FILE *file
)
7550 Elf_Internal_Shdr
*sec
;
7552 /* If it is already loaded, do nothing. */
7553 if (debug_str_contents
!= NULL
)
7556 /* Locate the .debug_str section. */
7557 sec
= find_section (".debug_str");
7561 debug_str_size
= sec
->sh_size
;
7563 debug_str_contents
= get_data (NULL
, file
, sec
->sh_offset
, 1, sec
->sh_size
,
7564 _("debug_str section data"));
7568 free_debug_str (void)
7570 if (debug_str_contents
== NULL
)
7573 free ((char *) debug_str_contents
);
7574 debug_str_contents
= NULL
;
7579 fetch_indirect_string (unsigned long offset
)
7581 if (debug_str_contents
== NULL
)
7582 return _("<no .debug_str section>");
7584 if (offset
> debug_str_size
)
7586 warn (_("DW_FORM_strp offset too big: %lx\n"), offset
);
7587 return _("<offset is too big>");
7590 return debug_str_contents
+ offset
;
7593 static const char *debug_loc_contents
;
7594 static bfd_vma debug_loc_size
;
7597 load_debug_loc (FILE *file
)
7599 Elf_Internal_Shdr
*sec
;
7601 /* If it is already loaded, do nothing. */
7602 if (debug_loc_contents
!= NULL
)
7605 /* Locate the .debug_loc section. */
7606 sec
= find_section (".debug_loc");
7610 debug_loc_size
= sec
->sh_size
;
7612 debug_loc_contents
= get_data (NULL
, file
, sec
->sh_offset
, 1, sec
->sh_size
,
7613 _("debug_loc section data"));
7617 free_debug_loc (void)
7619 if (debug_loc_contents
== NULL
)
7622 free ((char *) debug_loc_contents
);
7623 debug_loc_contents
= NULL
;
7627 static const char * debug_range_contents
;
7628 static unsigned long debug_range_size
;
7631 load_debug_range (FILE *file
)
7633 Elf_Internal_Shdr
*sec
;
7635 /* If it is already loaded, do nothing. */
7636 if (debug_range_contents
!= NULL
)
7639 /* Locate the .debug_ranges section. */
7640 sec
= find_section (".debug_ranges");
7644 debug_range_size
= sec
->sh_size
;
7646 debug_range_contents
= get_data (NULL
, file
, sec
->sh_offset
, 1, sec
->sh_size
,
7647 _("debug_range section data"));
7651 free_debug_range (void)
7653 if (debug_range_contents
== NULL
)
7656 free ((char *) debug_range_contents
);
7657 debug_range_contents
= NULL
;
7658 debug_range_size
= 0;
7661 static unsigned char *debug_abbrev_contents
;
7662 static unsigned long debug_abbrev_size
;
7665 load_debug_abbrev (FILE *file
)
7667 Elf_Internal_Shdr
*sec
;
7669 /* If it is already loaded, do nothing. */
7670 if (debug_abbrev_contents
!= NULL
)
7673 /* Locate the .debug_ranges section. */
7674 sec
= find_section (".debug_abbrev");
7678 debug_abbrev_size
= sec
->sh_size
;
7680 debug_abbrev_contents
= get_data (NULL
, file
, sec
->sh_offset
, 1,
7682 _("debug_abbrev section data"));
7686 free_debug_abbrev (void)
7688 if (debug_abbrev_contents
== NULL
)
7691 free ((char *) debug_abbrev_contents
);
7692 debug_abbrev_contents
= NULL
;
7693 debug_abbrev_size
= 0;
7696 /* Apply addends of RELA relocations. */
7699 debug_apply_rela_addends (FILE *file
,
7700 Elf_Internal_Shdr
*section
,
7702 unsigned char *sec_data
,
7703 unsigned char *start
,
7706 Elf_Internal_Shdr
*relsec
;
7708 if (end
- start
< reloc_size
)
7711 for (relsec
= section_headers
;
7712 relsec
< section_headers
+ elf_header
.e_shnum
;
7715 unsigned long nrelas
;
7716 Elf_Internal_Rela
*rela
, *rp
;
7717 Elf_Internal_Shdr
*symsec
;
7718 Elf_Internal_Sym
*symtab
;
7719 Elf_Internal_Sym
*sym
;
7721 if (relsec
->sh_type
!= SHT_RELA
7722 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
7723 || SECTION_HEADER (relsec
->sh_info
) != section
7724 || relsec
->sh_size
== 0
7725 || SECTION_HEADER_INDEX (relsec
->sh_link
) >= elf_header
.e_shnum
)
7728 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7732 symsec
= SECTION_HEADER (relsec
->sh_link
);
7733 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
7735 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7739 if (rp
->r_offset
>= (bfd_vma
) (start
- sec_data
)
7740 && rp
->r_offset
< (bfd_vma
) (end
- sec_data
) - reloc_size
)
7741 loc
= sec_data
+ rp
->r_offset
;
7747 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
7749 if (ELF32_R_SYM (rp
->r_info
) != 0
7750 && ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
7751 /* Relocations against object symbols can happen,
7752 eg when referencing a global array. For an
7753 example of this see the _clz.o binary in libgcc.a. */
7754 && ELF32_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7756 warn (_("skipping unexpected symbol type %s in relocation in section .rela%s\n"),
7757 get_symbol_type (ELF32_ST_TYPE (sym
->st_info
)),
7758 SECTION_NAME (section
));
7764 /* In MIPS little-endian objects, r_info isn't really a
7765 64-bit little-endian value: it has a 32-bit little-endian
7766 symbol index followed by four individual byte fields.
7767 Reorder INFO accordingly. */
7768 if (elf_header
.e_machine
== EM_MIPS
7769 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
7770 rp
->r_info
= (((rp
->r_info
& 0xffffffff) << 32)
7771 | ((rp
->r_info
>> 56) & 0xff)
7772 | ((rp
->r_info
>> 40) & 0xff00)
7773 | ((rp
->r_info
>> 24) & 0xff0000)
7774 | ((rp
->r_info
>> 8) & 0xff000000));
7776 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
7778 if (ELF64_R_SYM (rp
->r_info
) != 0
7779 && ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
7780 && ELF64_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7782 warn (_("skipping unexpected symbol type %s in relocation in section .rela.%s\n"),
7783 get_symbol_type (ELF64_ST_TYPE (sym
->st_info
)),
7784 SECTION_NAME (section
));
7789 byte_put (loc
, rp
->r_addend
, reloc_size
);
7799 /* FIXME: There are better and more efficient ways to handle
7800 these structures. For now though, I just want something that
7801 is simple to implement. */
7802 typedef struct abbrev_attr
7804 unsigned long attribute
;
7806 struct abbrev_attr
*next
;
7810 typedef struct abbrev_entry
7812 unsigned long entry
;
7815 struct abbrev_attr
*first_attr
;
7816 struct abbrev_attr
*last_attr
;
7817 struct abbrev_entry
*next
;
7821 static abbrev_entry
*first_abbrev
= NULL
;
7822 static abbrev_entry
*last_abbrev
= NULL
;
7827 abbrev_entry
*abbrev
;
7829 for (abbrev
= first_abbrev
; abbrev
;)
7831 abbrev_entry
*next
= abbrev
->next
;
7834 for (attr
= abbrev
->first_attr
; attr
;)
7836 abbrev_attr
*next
= attr
->next
;
7846 last_abbrev
= first_abbrev
= NULL
;
7850 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
7852 abbrev_entry
*entry
;
7854 entry
= malloc (sizeof (*entry
));
7860 entry
->entry
= number
;
7862 entry
->children
= children
;
7863 entry
->first_attr
= NULL
;
7864 entry
->last_attr
= NULL
;
7867 if (first_abbrev
== NULL
)
7868 first_abbrev
= entry
;
7870 last_abbrev
->next
= entry
;
7872 last_abbrev
= entry
;
7876 add_abbrev_attr (unsigned long attribute
, unsigned long form
)
7880 attr
= malloc (sizeof (*attr
));
7886 attr
->attribute
= attribute
;
7890 if (last_abbrev
->first_attr
== NULL
)
7891 last_abbrev
->first_attr
= attr
;
7893 last_abbrev
->last_attr
->next
= attr
;
7895 last_abbrev
->last_attr
= attr
;
7898 /* Processes the (partial) contents of a .debug_abbrev section.
7899 Returns NULL if the end of the section was encountered.
7900 Returns the address after the last byte read if the end of
7901 an abbreviation set was found. */
7903 static unsigned char *
7904 process_abbrev_section (unsigned char *start
, unsigned char *end
)
7906 if (first_abbrev
!= NULL
)
7911 unsigned int bytes_read
;
7912 unsigned long entry
;
7914 unsigned long attribute
;
7917 entry
= read_leb128 (start
, & bytes_read
, 0);
7918 start
+= bytes_read
;
7920 /* A single zero is supposed to end the section according
7921 to the standard. If there's more, then signal that to
7924 return start
== end
? NULL
: start
;
7926 tag
= read_leb128 (start
, & bytes_read
, 0);
7927 start
+= bytes_read
;
7929 children
= *start
++;
7931 add_abbrev (entry
, tag
, children
);
7937 attribute
= read_leb128 (start
, & bytes_read
, 0);
7938 start
+= bytes_read
;
7940 form
= read_leb128 (start
, & bytes_read
, 0);
7941 start
+= bytes_read
;
7944 add_abbrev_attr (attribute
, form
);
7946 while (attribute
!= 0);
7953 get_TAG_name (unsigned long tag
)
7957 case DW_TAG_padding
: return "DW_TAG_padding";
7958 case DW_TAG_array_type
: return "DW_TAG_array_type";
7959 case DW_TAG_class_type
: return "DW_TAG_class_type";
7960 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
7961 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
7962 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
7963 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
7964 case DW_TAG_label
: return "DW_TAG_label";
7965 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
7966 case DW_TAG_member
: return "DW_TAG_member";
7967 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
7968 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
7969 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
7970 case DW_TAG_string_type
: return "DW_TAG_string_type";
7971 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
7972 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
7973 case DW_TAG_typedef
: return "DW_TAG_typedef";
7974 case DW_TAG_union_type
: return "DW_TAG_union_type";
7975 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
7976 case DW_TAG_variant
: return "DW_TAG_variant";
7977 case DW_TAG_common_block
: return "DW_TAG_common_block";
7978 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
7979 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
7980 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
7981 case DW_TAG_module
: return "DW_TAG_module";
7982 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
7983 case DW_TAG_set_type
: return "DW_TAG_set_type";
7984 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
7985 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
7986 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
7987 case DW_TAG_base_type
: return "DW_TAG_base_type";
7988 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
7989 case DW_TAG_const_type
: return "DW_TAG_const_type";
7990 case DW_TAG_constant
: return "DW_TAG_constant";
7991 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
7992 case DW_TAG_file_type
: return "DW_TAG_file_type";
7993 case DW_TAG_friend
: return "DW_TAG_friend";
7994 case DW_TAG_namelist
: return "DW_TAG_namelist";
7995 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
7996 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
7997 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
7998 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
7999 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
8000 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
8001 case DW_TAG_try_block
: return "DW_TAG_try_block";
8002 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
8003 case DW_TAG_variable
: return "DW_TAG_variable";
8004 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
8005 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
8006 case DW_TAG_format_label
: return "DW_TAG_format_label";
8007 case DW_TAG_function_template
: return "DW_TAG_function_template";
8008 case DW_TAG_class_template
: return "DW_TAG_class_template";
8009 /* DWARF 2.1 values. */
8010 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
8011 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
8012 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
8013 case DW_TAG_namespace
: return "DW_TAG_namespace";
8014 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
8015 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
8016 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
8017 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
8019 case DW_TAG_upc_shared_type
: return "DW_TAG_upc_shared_type";
8020 case DW_TAG_upc_strict_type
: return "DW_TAG_upc_strict_type";
8021 case DW_TAG_upc_relaxed_type
: return "DW_TAG_upc_relaxed_type";
8024 static char buffer
[100];
8026 snprintf (buffer
, sizeof (buffer
), _("Unknown TAG value: %lx"), tag
);
8033 get_FORM_name (unsigned long form
)
8037 case DW_FORM_addr
: return "DW_FORM_addr";
8038 case DW_FORM_block2
: return "DW_FORM_block2";
8039 case DW_FORM_block4
: return "DW_FORM_block4";
8040 case DW_FORM_data2
: return "DW_FORM_data2";
8041 case DW_FORM_data4
: return "DW_FORM_data4";
8042 case DW_FORM_data8
: return "DW_FORM_data8";
8043 case DW_FORM_string
: return "DW_FORM_string";
8044 case DW_FORM_block
: return "DW_FORM_block";
8045 case DW_FORM_block1
: return "DW_FORM_block1";
8046 case DW_FORM_data1
: return "DW_FORM_data1";
8047 case DW_FORM_flag
: return "DW_FORM_flag";
8048 case DW_FORM_sdata
: return "DW_FORM_sdata";
8049 case DW_FORM_strp
: return "DW_FORM_strp";
8050 case DW_FORM_udata
: return "DW_FORM_udata";
8051 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
8052 case DW_FORM_ref1
: return "DW_FORM_ref1";
8053 case DW_FORM_ref2
: return "DW_FORM_ref2";
8054 case DW_FORM_ref4
: return "DW_FORM_ref4";
8055 case DW_FORM_ref8
: return "DW_FORM_ref8";
8056 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
8057 case DW_FORM_indirect
: return "DW_FORM_indirect";
8060 static char buffer
[100];
8062 snprintf (buffer
, sizeof (buffer
), _("Unknown FORM value: %lx"), form
);
8068 static unsigned char *
8069 display_block (unsigned char *data
, unsigned long length
)
8071 printf (_(" %lu byte block: "), length
);
8074 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
8080 decode_location_expression (unsigned char * data
,
8081 unsigned int pointer_size
,
8082 unsigned long length
,
8083 unsigned long cu_offset
)
8086 unsigned int bytes_read
;
8087 unsigned long uvalue
;
8088 unsigned char *end
= data
+ length
;
8089 int need_frame_base
= 0;
8098 printf ("DW_OP_addr: %lx",
8099 (unsigned long) byte_get (data
, pointer_size
));
8100 data
+= pointer_size
;
8103 printf ("DW_OP_deref");
8106 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
8109 printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data
++, 1));
8112 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
8116 printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data
, 2));
8120 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
8124 printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data
, 4));
8128 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
8129 (unsigned long) byte_get (data
+ 4, 4));
8133 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
8134 (long) byte_get (data
+ 4, 4));
8138 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
8142 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
8146 printf ("DW_OP_dup");
8149 printf ("DW_OP_drop");
8152 printf ("DW_OP_over");
8155 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
8158 printf ("DW_OP_swap");
8161 printf ("DW_OP_rot");
8164 printf ("DW_OP_xderef");
8167 printf ("DW_OP_abs");
8170 printf ("DW_OP_and");
8173 printf ("DW_OP_div");
8176 printf ("DW_OP_minus");
8179 printf ("DW_OP_mod");
8182 printf ("DW_OP_mul");
8185 printf ("DW_OP_neg");
8188 printf ("DW_OP_not");
8191 printf ("DW_OP_or");
8194 printf ("DW_OP_plus");
8196 case DW_OP_plus_uconst
:
8197 printf ("DW_OP_plus_uconst: %lu",
8198 read_leb128 (data
, &bytes_read
, 0));
8202 printf ("DW_OP_shl");
8205 printf ("DW_OP_shr");
8208 printf ("DW_OP_shra");
8211 printf ("DW_OP_xor");
8214 printf ("DW_OP_bra: %ld", (long) byte_get_signed (data
, 2));
8218 printf ("DW_OP_eq");
8221 printf ("DW_OP_ge");
8224 printf ("DW_OP_gt");
8227 printf ("DW_OP_le");
8230 printf ("DW_OP_lt");
8233 printf ("DW_OP_ne");
8236 printf ("DW_OP_skip: %ld", (long) byte_get_signed (data
, 2));
8272 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
8307 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
8342 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
8343 read_leb128 (data
, &bytes_read
, 1));
8348 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
8352 need_frame_base
= 1;
8353 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
8357 uvalue
= read_leb128 (data
, &bytes_read
, 0);
8359 printf ("DW_OP_bregx: %lu %ld", uvalue
,
8360 read_leb128 (data
, &bytes_read
, 1));
8364 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
8367 case DW_OP_deref_size
:
8368 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
8370 case DW_OP_xderef_size
:
8371 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
8374 printf ("DW_OP_nop");
8377 /* DWARF 3 extensions. */
8378 case DW_OP_push_object_address
:
8379 printf ("DW_OP_push_object_address");
8382 /* XXX: Strictly speaking for 64-bit DWARF3 files
8383 this ought to be an 8-byte wide computation. */
8384 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2) + cu_offset
);
8388 /* XXX: Strictly speaking for 64-bit DWARF3 files
8389 this ought to be an 8-byte wide computation. */
8390 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4) + cu_offset
);
8393 case DW_OP_call_ref
:
8394 printf ("DW_OP_call_ref");
8397 /* GNU extensions. */
8398 case DW_OP_GNU_push_tls_address
:
8399 printf ("DW_OP_GNU_push_tls_address");
8403 if (op
>= DW_OP_lo_user
8404 && op
<= DW_OP_hi_user
)
8405 printf (_("(User defined location op)"));
8407 printf (_("(Unknown location op)"));
8408 /* No way to tell where the next op is, so just bail. */
8409 return need_frame_base
;
8412 /* Separate the ops. */
8417 return need_frame_base
;
8420 /* This structure records the information that
8421 we extract from the.debug_info section. */
8424 unsigned int pointer_size
;
8425 unsigned long cu_offset
;
8426 unsigned long base_address
;
8427 /* This is an array of offsets to the location list table. */
8428 unsigned long *loc_offsets
;
8429 int *have_frame_base
;
8430 unsigned int num_loc_offsets
;
8431 unsigned int max_loc_offsets
;
8432 unsigned long *range_lists
;
8433 unsigned int num_range_lists
;
8434 unsigned int max_range_lists
;
8438 static debug_info
* debug_information
= NULL
;
8439 static unsigned int num_debug_info_entries
= 0;
8440 static unsigned int last_pointer_size
= 0;
8441 static int warned_about_missing_comp_units
= FALSE
;
8443 static unsigned char *
8444 read_and_display_attr_value (unsigned long attribute
,
8446 unsigned char *data
,
8447 unsigned long cu_offset
,
8448 unsigned long pointer_size
,
8449 unsigned long offset_size
,
8451 debug_info
*debug_info_p
,
8454 unsigned long uvalue
= 0;
8455 unsigned char *block_start
= NULL
;
8456 unsigned int bytes_read
;
8463 case DW_FORM_ref_addr
:
8464 if (dwarf_version
== 2)
8466 uvalue
= byte_get (data
, pointer_size
);
8467 data
+= pointer_size
;
8469 else if (dwarf_version
== 3)
8471 uvalue
= byte_get (data
, offset_size
);
8472 data
+= offset_size
;
8476 error (_("Internal error: DWARF version is not 2 or 3.\n"));
8481 uvalue
= byte_get (data
, pointer_size
);
8482 data
+= pointer_size
;
8486 uvalue
= byte_get (data
, offset_size
);
8487 data
+= offset_size
;
8493 uvalue
= byte_get (data
++, 1);
8498 uvalue
= byte_get (data
, 2);
8504 uvalue
= byte_get (data
, 4);
8509 uvalue
= read_leb128 (data
, & bytes_read
, 1);
8513 case DW_FORM_ref_udata
:
8515 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8519 case DW_FORM_indirect
:
8520 form
= read_leb128 (data
, & bytes_read
, 0);
8523 printf (" %s", get_FORM_name (form
));
8524 return read_and_display_attr_value (attribute
, form
, data
,
8525 cu_offset
, pointer_size
,
8526 offset_size
, dwarf_version
,
8527 debug_info_p
, do_loc
);
8532 case DW_FORM_ref_addr
:
8534 printf (" <#%lx>", uvalue
);
8540 case DW_FORM_ref_udata
:
8542 printf (" <%lx>", uvalue
+ cu_offset
);
8548 printf (" %#lx", uvalue
);
8557 printf (" %ld", uvalue
);
8564 uvalue
= byte_get (data
, 4);
8565 printf (" %lx", uvalue
);
8566 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
8568 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8569 && num_debug_info_entries
== 0)
8571 if (sizeof (uvalue
) == 8)
8572 uvalue
= byte_get (data
, 8);
8574 error (_("DW_FORM_data8 is unsupported when sizeof (unsigned long) != 8\n"));
8579 case DW_FORM_string
:
8581 printf (" %s", data
);
8582 data
+= strlen ((char *) data
) + 1;
8586 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8587 block_start
= data
+ bytes_read
;
8589 data
= block_start
+ uvalue
;
8591 data
= display_block (block_start
, uvalue
);
8594 case DW_FORM_block1
:
8595 uvalue
= byte_get (data
, 1);
8596 block_start
= data
+ 1;
8598 data
= block_start
+ uvalue
;
8600 data
= display_block (block_start
, uvalue
);
8603 case DW_FORM_block2
:
8604 uvalue
= byte_get (data
, 2);
8605 block_start
= data
+ 2;
8607 data
= block_start
+ uvalue
;
8609 data
= display_block (block_start
, uvalue
);
8612 case DW_FORM_block4
:
8613 uvalue
= byte_get (data
, 4);
8614 block_start
= data
+ 4;
8616 data
= block_start
+ uvalue
;
8618 data
= display_block (block_start
, uvalue
);
8623 printf (_(" (indirect string, offset: 0x%lx): %s"),
8624 uvalue
, fetch_indirect_string (uvalue
));
8627 case DW_FORM_indirect
:
8628 /* Handled above. */
8632 warn (_("Unrecognized form: %lu\n"), form
);
8636 /* For some attributes we can display further information. */
8637 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8638 && num_debug_info_entries
== 0)
8642 case DW_AT_frame_base
:
8643 have_frame_base
= 1;
8644 case DW_AT_location
:
8645 case DW_AT_data_member_location
:
8646 case DW_AT_vtable_elem_location
:
8647 case DW_AT_allocated
:
8648 case DW_AT_associated
:
8649 case DW_AT_data_location
:
8651 case DW_AT_upper_bound
:
8652 case DW_AT_lower_bound
:
8653 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8655 /* Process location list. */
8656 unsigned int max
= debug_info_p
->max_loc_offsets
;
8657 unsigned int num
= debug_info_p
->num_loc_offsets
;
8659 if (max
== 0 || num
>= max
)
8662 debug_info_p
->loc_offsets
8663 = xcrealloc (debug_info_p
->loc_offsets
,
8664 max
, sizeof (*debug_info_p
->loc_offsets
));
8665 debug_info_p
->have_frame_base
8666 = xcrealloc (debug_info_p
->have_frame_base
,
8667 max
, sizeof (*debug_info_p
->have_frame_base
));
8668 debug_info_p
->max_loc_offsets
= max
;
8670 debug_info_p
->loc_offsets
[num
] = uvalue
;
8671 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
8672 debug_info_p
->num_loc_offsets
++;
8677 if (need_base_address
)
8678 debug_info_p
->base_address
= uvalue
;
8682 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8684 /* Process range list. */
8685 unsigned int max
= debug_info_p
->max_range_lists
;
8686 unsigned int num
= debug_info_p
->num_range_lists
;
8688 if (max
== 0 || num
>= max
)
8691 debug_info_p
->range_lists
8692 = xcrealloc (debug_info_p
->range_lists
,
8693 max
, sizeof (*debug_info_p
->range_lists
));
8694 debug_info_p
->max_range_lists
= max
;
8696 debug_info_p
->range_lists
[num
] = uvalue
;
8697 debug_info_p
->num_range_lists
++;
8716 case DW_INL_not_inlined
:
8717 printf (_("(not inlined)"));
8719 case DW_INL_inlined
:
8720 printf (_("(inlined)"));
8722 case DW_INL_declared_not_inlined
:
8723 printf (_("(declared as inline but ignored)"));
8725 case DW_INL_declared_inlined
:
8726 printf (_("(declared as inline and inlined)"));
8729 printf (_(" (Unknown inline attribute value: %lx)"), uvalue
);
8734 case DW_AT_language
:
8737 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
8738 case DW_LANG_C89
: printf ("(ANSI C)"); break;
8739 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
8740 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
8741 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
8742 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
8743 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
8744 case DW_LANG_Ada83
: printf ("(Ada)"); break;
8745 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
8746 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
8747 /* DWARF 2.1 values. */
8748 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
8749 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
8750 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
8751 /* MIPS extension. */
8752 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
8753 /* UPC extension. */
8754 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
8756 printf ("(Unknown: %lx)", uvalue
);
8761 case DW_AT_encoding
:
8764 case DW_ATE_void
: printf ("(void)"); break;
8765 case DW_ATE_address
: printf ("(machine address)"); break;
8766 case DW_ATE_boolean
: printf ("(boolean)"); break;
8767 case DW_ATE_complex_float
: printf ("(complex float)"); break;
8768 case DW_ATE_float
: printf ("(float)"); break;
8769 case DW_ATE_signed
: printf ("(signed)"); break;
8770 case DW_ATE_signed_char
: printf ("(signed char)"); break;
8771 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
8772 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
8773 /* DWARF 2.1 value. */
8774 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
8775 case DW_ATE_decimal_float
: printf ("(decimal float)"); break;
8777 if (uvalue
>= DW_ATE_lo_user
8778 && uvalue
<= DW_ATE_hi_user
)
8779 printf ("(user defined type)");
8781 printf ("(unknown type)");
8786 case DW_AT_accessibility
:
8789 case DW_ACCESS_public
: printf ("(public)"); break;
8790 case DW_ACCESS_protected
: printf ("(protected)"); break;
8791 case DW_ACCESS_private
: printf ("(private)"); break;
8793 printf ("(unknown accessibility)");
8798 case DW_AT_visibility
:
8801 case DW_VIS_local
: printf ("(local)"); break;
8802 case DW_VIS_exported
: printf ("(exported)"); break;
8803 case DW_VIS_qualified
: printf ("(qualified)"); break;
8804 default: printf ("(unknown visibility)"); break;
8808 case DW_AT_virtuality
:
8811 case DW_VIRTUALITY_none
: printf ("(none)"); break;
8812 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
8813 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
8814 default: printf ("(unknown virtuality)"); break;
8818 case DW_AT_identifier_case
:
8821 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
8822 case DW_ID_up_case
: printf ("(up_case)"); break;
8823 case DW_ID_down_case
: printf ("(down_case)"); break;
8824 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
8825 default: printf ("(unknown case)"); break;
8829 case DW_AT_calling_convention
:
8832 case DW_CC_normal
: printf ("(normal)"); break;
8833 case DW_CC_program
: printf ("(program)"); break;
8834 case DW_CC_nocall
: printf ("(nocall)"); break;
8836 if (uvalue
>= DW_CC_lo_user
8837 && uvalue
<= DW_CC_hi_user
)
8838 printf ("(user defined)");
8840 printf ("(unknown convention)");
8844 case DW_AT_ordering
:
8847 case -1: printf ("(undefined)"); break;
8848 case 0: printf ("(row major)"); break;
8849 case 1: printf ("(column major)"); break;
8853 case DW_AT_frame_base
:
8854 have_frame_base
= 1;
8855 case DW_AT_location
:
8856 case DW_AT_data_member_location
:
8857 case DW_AT_vtable_elem_location
:
8858 case DW_AT_allocated
:
8859 case DW_AT_associated
:
8860 case DW_AT_data_location
:
8862 case DW_AT_upper_bound
:
8863 case DW_AT_lower_bound
:
8866 int need_frame_base
;
8869 need_frame_base
= decode_location_expression (block_start
,
8874 if (need_frame_base
&& !have_frame_base
)
8875 printf (_(" [without DW_AT_frame_base]"));
8877 else if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8878 printf (_("(location list)"));
8890 get_AT_name (unsigned long attribute
)
8894 case DW_AT_sibling
: return "DW_AT_sibling";
8895 case DW_AT_location
: return "DW_AT_location";
8896 case DW_AT_name
: return "DW_AT_name";
8897 case DW_AT_ordering
: return "DW_AT_ordering";
8898 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
8899 case DW_AT_byte_size
: return "DW_AT_byte_size";
8900 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
8901 case DW_AT_bit_size
: return "DW_AT_bit_size";
8902 case DW_AT_element_list
: return "DW_AT_element_list";
8903 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
8904 case DW_AT_low_pc
: return "DW_AT_low_pc";
8905 case DW_AT_high_pc
: return "DW_AT_high_pc";
8906 case DW_AT_language
: return "DW_AT_language";
8907 case DW_AT_member
: return "DW_AT_member";
8908 case DW_AT_discr
: return "DW_AT_discr";
8909 case DW_AT_discr_value
: return "DW_AT_discr_value";
8910 case DW_AT_visibility
: return "DW_AT_visibility";
8911 case DW_AT_import
: return "DW_AT_import";
8912 case DW_AT_string_length
: return "DW_AT_string_length";
8913 case DW_AT_common_reference
: return "DW_AT_common_reference";
8914 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
8915 case DW_AT_const_value
: return "DW_AT_const_value";
8916 case DW_AT_containing_type
: return "DW_AT_containing_type";
8917 case DW_AT_default_value
: return "DW_AT_default_value";
8918 case DW_AT_inline
: return "DW_AT_inline";
8919 case DW_AT_is_optional
: return "DW_AT_is_optional";
8920 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
8921 case DW_AT_producer
: return "DW_AT_producer";
8922 case DW_AT_prototyped
: return "DW_AT_prototyped";
8923 case DW_AT_return_addr
: return "DW_AT_return_addr";
8924 case DW_AT_start_scope
: return "DW_AT_start_scope";
8925 case DW_AT_stride_size
: return "DW_AT_stride_size";
8926 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
8927 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
8928 case DW_AT_accessibility
: return "DW_AT_accessibility";
8929 case DW_AT_address_class
: return "DW_AT_address_class";
8930 case DW_AT_artificial
: return "DW_AT_artificial";
8931 case DW_AT_base_types
: return "DW_AT_base_types";
8932 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
8933 case DW_AT_count
: return "DW_AT_count";
8934 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
8935 case DW_AT_decl_column
: return "DW_AT_decl_column";
8936 case DW_AT_decl_file
: return "DW_AT_decl_file";
8937 case DW_AT_decl_line
: return "DW_AT_decl_line";
8938 case DW_AT_declaration
: return "DW_AT_declaration";
8939 case DW_AT_discr_list
: return "DW_AT_discr_list";
8940 case DW_AT_encoding
: return "DW_AT_encoding";
8941 case DW_AT_external
: return "DW_AT_external";
8942 case DW_AT_frame_base
: return "DW_AT_frame_base";
8943 case DW_AT_friend
: return "DW_AT_friend";
8944 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
8945 case DW_AT_macro_info
: return "DW_AT_macro_info";
8946 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
8947 case DW_AT_priority
: return "DW_AT_priority";
8948 case DW_AT_segment
: return "DW_AT_segment";
8949 case DW_AT_specification
: return "DW_AT_specification";
8950 case DW_AT_static_link
: return "DW_AT_static_link";
8951 case DW_AT_type
: return "DW_AT_type";
8952 case DW_AT_use_location
: return "DW_AT_use_location";
8953 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
8954 case DW_AT_virtuality
: return "DW_AT_virtuality";
8955 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
8956 /* DWARF 2.1 values. */
8957 case DW_AT_allocated
: return "DW_AT_allocated";
8958 case DW_AT_associated
: return "DW_AT_associated";
8959 case DW_AT_data_location
: return "DW_AT_data_location";
8960 case DW_AT_stride
: return "DW_AT_stride";
8961 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
8962 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
8963 case DW_AT_extension
: return "DW_AT_extension";
8964 case DW_AT_ranges
: return "DW_AT_ranges";
8965 case DW_AT_trampoline
: return "DW_AT_trampoline";
8966 case DW_AT_call_column
: return "DW_AT_call_column";
8967 case DW_AT_call_file
: return "DW_AT_call_file";
8968 case DW_AT_call_line
: return "DW_AT_call_line";
8969 /* SGI/MIPS extensions. */
8970 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
8971 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
8972 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
8973 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
8974 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
8975 case DW_AT_MIPS_software_pipeline_depth
:
8976 return "DW_AT_MIPS_software_pipeline_depth";
8977 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
8978 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
8979 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
8980 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
8981 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
8982 /* GNU extensions. */
8983 case DW_AT_sf_names
: return "DW_AT_sf_names";
8984 case DW_AT_src_info
: return "DW_AT_src_info";
8985 case DW_AT_mac_info
: return "DW_AT_mac_info";
8986 case DW_AT_src_coords
: return "DW_AT_src_coords";
8987 case DW_AT_body_begin
: return "DW_AT_body_begin";
8988 case DW_AT_body_end
: return "DW_AT_body_end";
8989 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
8990 /* UPC extension. */
8991 case DW_AT_upc_threads_scaled
: return "DW_AT_upc_threads_scaled";
8994 static char buffer
[100];
8996 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
9003 static unsigned char *
9004 read_and_display_attr (unsigned long attribute
,
9006 unsigned char *data
,
9007 unsigned long cu_offset
,
9008 unsigned long pointer_size
,
9009 unsigned long offset_size
,
9011 debug_info
*debug_info_p
,
9015 printf (" %-18s:", get_AT_name (attribute
));
9016 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
9017 pointer_size
, offset_size
,
9018 dwarf_version
, debug_info_p
,
9026 /* Process the contents of a .debug_info section. If do_loc is non-zero
9027 then we are scanning for location lists and we do not want to display
9028 anything to the user. */
9031 process_debug_info (Elf_Internal_Shdr
*section
, unsigned char *start
,
9032 FILE *file
, int do_loc
)
9034 unsigned char *end
= start
+ section
->sh_size
;
9035 unsigned char *section_begin
;
9037 unsigned int num_units
= 0;
9039 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
9040 && num_debug_info_entries
== 0)
9042 unsigned long length
;
9044 /* First scan the section to get the number of comp units. */
9045 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
9048 /* Read the first 4 bytes. For a 32-bit DWARF section, this
9049 will be the length. For a 64-bit DWARF section, it'll be
9050 the escape code 0xffffffff followed by an 8 byte length. */
9051 length
= byte_get (section_begin
, 4);
9053 if (length
== 0xffffffff)
9055 length
= byte_get (section_begin
+ 4, 8);
9056 section_begin
+= length
+ 12;
9059 section_begin
+= length
+ 4;
9064 error (_("No comp units in .debug_info section ?"));
9068 /* Then allocate an array to hold the information. */
9069 debug_information
= cmalloc (num_units
,
9070 sizeof (* debug_information
));
9071 if (debug_information
== NULL
)
9073 error (_("Not enough memory for a debug info array of %u entries"),
9081 printf (_("The section %s contains:\n\n"),
9082 SECTION_NAME (section
));
9084 load_debug_str (file
);
9085 load_debug_loc (file
);
9086 load_debug_range (file
);
9089 load_debug_abbrev (file
);
9090 if (debug_abbrev_contents
== NULL
)
9092 warn (_("Unable to locate .debug_abbrev section!\n"));
9096 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
9098 DWARF2_Internal_CompUnit compunit
;
9099 unsigned char *hdrptr
;
9100 unsigned char *cu_abbrev_offset_ptr
;
9101 unsigned char *tags
;
9103 unsigned long cu_offset
;
9105 int initial_length_size
;
9109 compunit
.cu_length
= byte_get (hdrptr
, 4);
9112 if (compunit
.cu_length
== 0xffffffff)
9114 compunit
.cu_length
= byte_get (hdrptr
, 8);
9117 initial_length_size
= 12;
9122 initial_length_size
= 4;
9125 compunit
.cu_version
= byte_get (hdrptr
, 2);
9128 cu_offset
= start
- section_begin
;
9129 start
+= compunit
.cu_length
+ initial_length_size
;
9131 if (elf_header
.e_type
== ET_REL
9132 && !debug_apply_rela_addends (file
, section
, offset_size
,
9133 section_begin
, hdrptr
, start
))
9136 cu_abbrev_offset_ptr
= hdrptr
;
9137 compunit
.cu_abbrev_offset
= byte_get (hdrptr
, offset_size
);
9138 hdrptr
+= offset_size
;
9140 compunit
.cu_pointer_size
= byte_get (hdrptr
, 1);
9142 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
9143 && num_debug_info_entries
== 0)
9145 debug_information
[unit
].cu_offset
= cu_offset
;
9146 debug_information
[unit
].pointer_size
9147 = compunit
.cu_pointer_size
;
9148 debug_information
[unit
].base_address
= 0;
9149 debug_information
[unit
].loc_offsets
= NULL
;
9150 debug_information
[unit
].have_frame_base
= NULL
;
9151 debug_information
[unit
].max_loc_offsets
= 0;
9152 debug_information
[unit
].num_loc_offsets
= 0;
9153 debug_information
[unit
].range_lists
= NULL
;
9154 debug_information
[unit
].max_range_lists
= 0;
9155 debug_information
[unit
].num_range_lists
= 0;
9162 printf (_(" Compilation Unit @ offset 0x%lx:\n"), cu_offset
);
9163 printf (_(" Length: %ld\n"), compunit
.cu_length
);
9164 printf (_(" Version: %d\n"), compunit
.cu_version
);
9165 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
9166 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
9169 if (compunit
.cu_version
!= 2 && compunit
.cu_version
!= 3)
9171 warn (_("Only version 2 and 3 DWARF debug information is currently supported.\n"));
9177 /* Process the abbrevs used by this compilation unit. */
9178 process_abbrev_section
9179 (debug_abbrev_contents
+ compunit
.cu_abbrev_offset
,
9180 debug_abbrev_contents
+ debug_abbrev_size
);
9183 while (tags
< start
)
9185 unsigned int bytes_read
;
9186 unsigned long abbrev_number
;
9187 abbrev_entry
*entry
;
9190 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
9193 /* A null DIE marks the end of a list of children. */
9194 if (abbrev_number
== 0)
9200 /* Scan through the abbreviation list until we reach the
9202 for (entry
= first_abbrev
;
9203 entry
&& entry
->entry
!= abbrev_number
;
9204 entry
= entry
->next
)
9209 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
9215 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
9217 (unsigned long) (tags
- section_begin
9220 get_TAG_name (entry
->tag
));
9225 need_base_address
= 0;
9227 case DW_TAG_compile_unit
:
9228 need_base_address
= 1;
9230 case DW_TAG_entry_point
:
9231 case DW_TAG_inlined_subroutine
:
9232 case DW_TAG_subprogram
:
9233 need_base_address
= 0;
9234 /* Assuming that there is no DW_AT_frame_base. */
9235 have_frame_base
= 0;
9239 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
9240 tags
= read_and_display_attr (attr
->attribute
,
9243 compunit
.cu_pointer_size
,
9245 compunit
.cu_version
,
9246 &debug_information
[unit
],
9249 if (entry
->children
)
9254 free_debug_abbrev ();
9256 /* Set num_debug_info_entries here so that it can be used to check if
9257 we need to process .debug_loc and .debug_ranges sections. */
9258 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
9259 && num_debug_info_entries
== 0)
9260 num_debug_info_entries
= num_units
;
9264 free_debug_range ();
9274 /* Retrieve the pointer size associated with the given compilation unit.
9275 Optionally the offset of this unit into the .debug_info section is
9276 also retutned. If there is no .debug_info section then an error
9277 message is issued and 0 is returned. If the requested comp unit has
9278 not been defined in the .debug_info section then a warning message
9279 is issued and the last know pointer size is returned. This message
9280 is only issued once per section dumped per file dumped. */
9283 get_pointer_size_and_offset_of_comp_unit (unsigned int comp_unit
,
9284 const char * section_name
,
9285 unsigned long * offset_return
)
9287 unsigned long offset
= 0;
9289 if (num_debug_info_entries
== 0)
9290 error (_("%s section needs a populated .debug_info section\n"),
9293 else if (comp_unit
>= num_debug_info_entries
)
9295 if (!warned_about_missing_comp_units
)
9297 warn (_("%s section has more comp units than .debug_info section\n"),
9299 warn (_("assuming that the pointer size is %d, from the last comp unit in .debug_info\n\n"),
9301 warned_about_missing_comp_units
= TRUE
;
9306 last_pointer_size
= debug_information
[comp_unit
].pointer_size
;
9307 offset
= debug_information
[comp_unit
].cu_offset
;
9310 if (offset_return
!= NULL
)
9311 * offset_return
= offset
;
9313 return last_pointer_size
;
9316 /* Locate and scan the .debug_info section in the file and record the pointer
9317 sizes and offsets for the compilation units in it. Usually an executable
9318 will have just one pointer size, but this is not guaranteed, and so we try
9319 not to make any assumptions. Returns zero upon failure, or the number of
9320 compilation units upon success. */
9323 get_debug_info (FILE * file
)
9325 Elf_Internal_Shdr
* section
;
9326 unsigned char * start
;
9329 /* Reset the last pointer size so that we can issue correct error
9330 messages if we are displaying the contents of more than one section. */
9331 last_pointer_size
= 0;
9332 warned_about_missing_comp_units
= FALSE
;
9334 /* If we already have the information there is nothing else to do. */
9335 if (num_debug_info_entries
> 0)
9336 return num_debug_info_entries
;
9338 section
= find_section (".debug_info");
9339 if (section
== NULL
)
9342 start
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
9343 _("extracting information from .debug_info section"));
9347 ret
= process_debug_info (section
, start
, file
, 1);
9350 return ret
? num_debug_info_entries
: 0;
9354 display_debug_lines (Elf_Internal_Shdr
*section
,
9355 unsigned char *start
, FILE *file
)
9357 unsigned char *data
= start
;
9358 unsigned char *end
= start
+ section
->sh_size
;
9359 unsigned int comp_unit
= 0;
9361 printf (_("\nDump of debug contents of section %s:\n\n"),
9362 SECTION_NAME (section
));
9364 get_debug_info (file
);
9368 DWARF2_Internal_LineInfo info
;
9369 unsigned char *standard_opcodes
;
9370 unsigned char *end_of_sequence
;
9371 unsigned char *hdrptr
;
9372 unsigned int pointer_size
;
9373 int initial_length_size
;
9379 /* Check the length of the block. */
9380 info
.li_length
= byte_get (hdrptr
, 4);
9383 if (info
.li_length
== 0xffffffff)
9385 /* This section is 64-bit DWARF 3. */
9386 info
.li_length
= byte_get (hdrptr
, 8);
9389 initial_length_size
= 12;
9394 initial_length_size
= 4;
9397 if (info
.li_length
+ initial_length_size
> section
->sh_size
)
9400 (_("The line info appears to be corrupt - the section is too small\n"));
9404 /* Check its version number. */
9405 info
.li_version
= byte_get (hdrptr
, 2);
9407 if (info
.li_version
!= 2 && info
.li_version
!= 3)
9409 warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
9413 info
.li_prologue_length
= byte_get (hdrptr
, offset_size
);
9414 hdrptr
+= offset_size
;
9415 info
.li_min_insn_length
= byte_get (hdrptr
, 1);
9417 info
.li_default_is_stmt
= byte_get (hdrptr
, 1);
9419 info
.li_line_base
= byte_get (hdrptr
, 1);
9421 info
.li_line_range
= byte_get (hdrptr
, 1);
9423 info
.li_opcode_base
= byte_get (hdrptr
, 1);
9426 /* Sign extend the line base field. */
9427 info
.li_line_base
<<= 24;
9428 info
.li_line_base
>>= 24;
9430 /* Get the pointer size from the comp unit associated
9431 with this block of line number information. */
9432 pointer_size
= get_pointer_size_and_offset_of_comp_unit
9433 (comp_unit
, ".debug_line", NULL
);
9436 printf (_(" Length: %ld\n"), info
.li_length
);
9437 printf (_(" DWARF Version: %d\n"), info
.li_version
);
9438 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
9439 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
9440 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
9441 printf (_(" Line Base: %d\n"), info
.li_line_base
);
9442 printf (_(" Line Range: %d\n"), info
.li_line_range
);
9443 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
9444 printf (_(" (Pointer size: %u)%s\n"),
9446 warned_about_missing_comp_units
? " [assumed]" : "" );
9448 end_of_sequence
= data
+ info
.li_length
+ initial_length_size
;
9450 reset_state_machine (info
.li_default_is_stmt
);
9452 /* Display the contents of the Opcodes table. */
9453 standard_opcodes
= hdrptr
;
9455 printf (_("\n Opcodes:\n"));
9457 for (i
= 1; i
< info
.li_opcode_base
; i
++)
9458 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
9460 /* Display the contents of the Directory table. */
9461 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
9464 printf (_("\n The Directory Table is empty.\n"));
9467 printf (_("\n The Directory Table:\n"));
9471 printf (_(" %s\n"), data
);
9473 data
+= strlen ((char *) data
) + 1;
9477 /* Skip the NUL at the end of the table. */
9480 /* Display the contents of the File Name table. */
9482 printf (_("\n The File Name Table is empty.\n"));
9485 printf (_("\n The File Name Table:\n"));
9486 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
9490 unsigned char *name
;
9491 unsigned int bytes_read
;
9493 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
9496 data
+= strlen ((char *) data
) + 1;
9498 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9500 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9502 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9504 printf (_("%s\n"), name
);
9508 /* Skip the NUL at the end of the table. */
9511 /* Now display the statements. */
9512 printf (_("\n Line Number Statements:\n"));
9514 while (data
< end_of_sequence
)
9516 unsigned char op_code
;
9518 unsigned int bytes_read
;
9522 if (op_code
>= info
.li_opcode_base
)
9524 op_code
-= info
.li_opcode_base
;
9525 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
9526 state_machine_regs
.address
+= adv
;
9527 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
9528 op_code
, adv
, state_machine_regs
.address
);
9529 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
9530 state_machine_regs
.line
+= adv
;
9531 printf (_(" and Line by %d to %d\n"),
9532 adv
, state_machine_regs
.line
);
9534 else switch (op_code
)
9536 case DW_LNS_extended_op
:
9537 if (pointer_size
== 0)
9539 warn (_("Extend line ops need a valid pointer size, guessing at 4\n"));
9543 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
9548 printf (_(" Copy\n"));
9551 case DW_LNS_advance_pc
:
9552 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
9554 state_machine_regs
.address
+= adv
;
9555 printf (_(" Advance PC by %d to %lx\n"), adv
,
9556 state_machine_regs
.address
);
9559 case DW_LNS_advance_line
:
9560 adv
= read_leb128 (data
, & bytes_read
, 1);
9562 state_machine_regs
.line
+= adv
;
9563 printf (_(" Advance Line by %d to %d\n"), adv
,
9564 state_machine_regs
.line
);
9567 case DW_LNS_set_file
:
9568 adv
= read_leb128 (data
, & bytes_read
, 0);
9570 printf (_(" Set File Name to entry %d in the File Name Table\n"),
9572 state_machine_regs
.file
= adv
;
9575 case DW_LNS_set_column
:
9576 adv
= read_leb128 (data
, & bytes_read
, 0);
9578 printf (_(" Set column to %d\n"), adv
);
9579 state_machine_regs
.column
= adv
;
9582 case DW_LNS_negate_stmt
:
9583 adv
= state_machine_regs
.is_stmt
;
9585 printf (_(" Set is_stmt to %d\n"), adv
);
9586 state_machine_regs
.is_stmt
= adv
;
9589 case DW_LNS_set_basic_block
:
9590 printf (_(" Set basic block\n"));
9591 state_machine_regs
.basic_block
= 1;
9594 case DW_LNS_const_add_pc
:
9595 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
9596 * info
.li_min_insn_length
);
9597 state_machine_regs
.address
+= adv
;
9598 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
9599 state_machine_regs
.address
);
9602 case DW_LNS_fixed_advance_pc
:
9603 adv
= byte_get (data
, 2);
9605 state_machine_regs
.address
+= adv
;
9606 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
9607 adv
, state_machine_regs
.address
);
9610 case DW_LNS_set_prologue_end
:
9611 printf (_(" Set prologue_end to true\n"));
9614 case DW_LNS_set_epilogue_begin
:
9615 printf (_(" Set epilogue_begin to true\n"));
9618 case DW_LNS_set_isa
:
9619 adv
= read_leb128 (data
, & bytes_read
, 0);
9621 printf (_(" Set ISA to %d\n"), adv
);
9625 printf (_(" Unknown opcode %d with operands: "), op_code
);
9627 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
9629 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
9630 i
== 1 ? "" : ", ");
9644 display_debug_pubnames (Elf_Internal_Shdr
*section
,
9645 unsigned char *start
,
9646 FILE *file ATTRIBUTE_UNUSED
)
9648 DWARF2_Internal_PubNames pubnames
;
9651 end
= start
+ section
->sh_size
;
9653 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9657 unsigned char *data
;
9658 unsigned long offset
;
9659 int offset_size
, initial_length_size
;
9663 pubnames
.pn_length
= byte_get (data
, 4);
9665 if (pubnames
.pn_length
== 0xffffffff)
9667 pubnames
.pn_length
= byte_get (data
, 8);
9670 initial_length_size
= 12;
9675 initial_length_size
= 4;
9678 pubnames
.pn_version
= byte_get (data
, 2);
9680 pubnames
.pn_offset
= byte_get (data
, offset_size
);
9681 data
+= offset_size
;
9682 pubnames
.pn_size
= byte_get (data
, offset_size
);
9683 data
+= offset_size
;
9685 start
+= pubnames
.pn_length
+ initial_length_size
;
9687 if (pubnames
.pn_version
!= 2 && pubnames
.pn_version
!= 3)
9689 static int warned
= 0;
9693 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
9700 printf (_(" Length: %ld\n"),
9701 pubnames
.pn_length
);
9702 printf (_(" Version: %d\n"),
9703 pubnames
.pn_version
);
9704 printf (_(" Offset into .debug_info section: %ld\n"),
9705 pubnames
.pn_offset
);
9706 printf (_(" Size of area in .debug_info section: %ld\n"),
9709 printf (_("\n Offset\tName\n"));
9713 offset
= byte_get (data
, offset_size
);
9717 data
+= offset_size
;
9718 printf (" %-6ld\t\t%s\n", offset
, data
);
9719 data
+= strlen ((char *) data
) + 1;
9722 while (offset
!= 0);
9730 display_debug_macinfo (Elf_Internal_Shdr
*section
,
9731 unsigned char *start
,
9732 FILE *file ATTRIBUTE_UNUSED
)
9734 unsigned char *end
= start
+ section
->sh_size
;
9735 unsigned char *curr
= start
;
9736 unsigned int bytes_read
;
9737 enum dwarf_macinfo_record_type op
;
9739 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9743 unsigned int lineno
;
9751 case DW_MACINFO_start_file
:
9753 unsigned int filenum
;
9755 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9757 filenum
= read_leb128 (curr
, & bytes_read
, 0);
9760 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
9765 case DW_MACINFO_end_file
:
9766 printf (_(" DW_MACINFO_end_file\n"));
9769 case DW_MACINFO_define
:
9770 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9772 string
= (char *) curr
;
9773 curr
+= strlen (string
) + 1;
9774 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
9778 case DW_MACINFO_undef
:
9779 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9781 string
= (char *) curr
;
9782 curr
+= strlen (string
) + 1;
9783 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
9787 case DW_MACINFO_vendor_ext
:
9789 unsigned int constant
;
9791 constant
= read_leb128 (curr
, & bytes_read
, 0);
9793 string
= (char *) curr
;
9794 curr
+= strlen (string
) + 1;
9795 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
9807 display_debug_abbrev (Elf_Internal_Shdr
*section
,
9808 unsigned char *start
,
9809 FILE *file ATTRIBUTE_UNUSED
)
9811 abbrev_entry
*entry
;
9812 unsigned char *end
= start
+ section
->sh_size
;
9814 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9818 start
= process_abbrev_section (start
, end
);
9820 if (first_abbrev
== NULL
)
9823 printf (_(" Number TAG\n"));
9825 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
9829 printf (_(" %ld %s [%s]\n"),
9831 get_TAG_name (entry
->tag
),
9832 entry
->children
? _("has children") : _("no children"));
9834 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
9835 printf (_(" %-18s %s\n"),
9836 get_AT_name (attr
->attribute
),
9837 get_FORM_name (attr
->form
));
9850 display_debug_loc (Elf_Internal_Shdr
*section
,
9851 unsigned char *start
, FILE *file
)
9853 unsigned char *section_end
;
9854 unsigned long bytes
;
9855 unsigned char *section_begin
= start
;
9856 unsigned int num_loc_list
= 0;
9857 unsigned long last_offset
= 0;
9858 unsigned int first
= 0;
9861 int seen_first_offset
= 0;
9862 int use_debug_info
= 1;
9863 unsigned char *next
;
9865 bytes
= section
->sh_size
;
9866 section_end
= start
+ bytes
;
9870 printf (_("\nThe .debug_loc section is empty.\n"));
9874 get_debug_info (file
);
9876 /* Check the order of location list in .debug_info section. If
9877 offsets of location lists are in the ascending order, we can
9878 use `debug_information' directly. */
9879 for (i
= 0; i
< num_debug_info_entries
; i
++)
9883 num
= debug_information
[i
].num_loc_offsets
;
9884 num_loc_list
+= num
;
9886 /* Check if we can use `debug_information' directly. */
9887 if (use_debug_info
&& num
!= 0)
9889 if (!seen_first_offset
)
9891 /* This is the first location list. */
9892 last_offset
= debug_information
[i
].loc_offsets
[0];
9894 seen_first_offset
= 1;
9900 for (; j
< num
; j
++)
9903 debug_information
[i
].loc_offsets
[j
])
9908 last_offset
= debug_information
[i
].loc_offsets
[j
];
9913 if (!use_debug_info
)
9914 /* FIXME: Should we handle this case? */
9915 error (_("Location lists in .debug_info section aren't in ascending order!\n"));
9917 if (!seen_first_offset
)
9918 error (_("No location lists in .debug_info section!\n"));
9920 if (debug_information
[first
].loc_offsets
[0] != 0)
9921 warn (_("Location lists in .debug_loc section start at 0x%lx\n"),
9922 debug_information
[first
].loc_offsets
[0]);
9924 printf (_("Contents of the .debug_loc section:\n\n"));
9925 printf (_(" Offset Begin End Expression\n"));
9927 seen_first_offset
= 0;
9928 for (i
= first
; i
< num_debug_info_entries
; i
++)
9930 unsigned long begin
;
9932 unsigned short length
;
9933 unsigned long offset
;
9934 unsigned int pointer_size
;
9935 unsigned long cu_offset
;
9936 unsigned long base_address
;
9937 int need_frame_base
;
9940 pointer_size
= debug_information
[i
].pointer_size
;
9941 cu_offset
= debug_information
[i
].cu_offset
;
9943 for (j
= 0; j
< debug_information
[i
].num_loc_offsets
; j
++)
9945 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
9946 offset
= debug_information
[i
].loc_offsets
[j
];
9947 next
= section_begin
+ offset
;
9948 base_address
= debug_information
[i
].base_address
;
9950 if (!seen_first_offset
)
9951 seen_first_offset
= 1;
9955 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
9956 (long)(start
- section_begin
), (long)(next
- section_begin
));
9957 else if (start
> next
)
9958 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
9959 (long)(start
- section_begin
), (long)(next
- section_begin
));
9963 if (offset
>= bytes
)
9965 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
9972 if (start
+ 2 * pointer_size
> section_end
)
9974 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
9979 begin
= byte_get (start
, pointer_size
);
9980 start
+= pointer_size
;
9981 end
= byte_get (start
, pointer_size
);
9982 start
+= pointer_size
;
9984 if (begin
== 0 && end
== 0)
9986 printf (_(" %8.8lx <End of list>\n"), offset
);
9990 /* Check base address specifiers. */
9991 if (begin
== -1UL && end
!= -1UL)
9994 printf (_(" %8.8lx %8.8lx %8.8lx (base address)\n"),
9995 offset
, begin
, end
);
9999 if (start
+ 2 > section_end
)
10001 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
10006 length
= byte_get (start
, 2);
10009 if (start
+ length
> section_end
)
10011 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
10016 printf (" %8.8lx %8.8lx %8.8lx (",
10017 offset
, begin
+ base_address
, end
+ base_address
);
10018 need_frame_base
= decode_location_expression (start
,
10024 if (need_frame_base
&& !has_frame_base
)
10025 printf (_(" [without DW_AT_frame_base]"));
10028 fputs (_(" (start == end)"), stdout
);
10029 else if (begin
> end
)
10030 fputs (_(" (start > end)"), stdout
);
10042 display_debug_str (Elf_Internal_Shdr
*section
,
10043 unsigned char *start
,
10044 FILE *file ATTRIBUTE_UNUSED
)
10046 unsigned long bytes
;
10049 addr
= section
->sh_addr
;
10050 bytes
= section
->sh_size
;
10054 printf (_("\nThe .debug_str section is empty.\n"));
10058 printf (_("Contents of the .debug_str section:\n\n"));
10066 lbytes
= (bytes
> 16 ? 16 : bytes
);
10068 printf (" 0x%8.8lx ", (unsigned long) addr
);
10070 for (j
= 0; j
< 16; j
++)
10073 printf ("%2.2x", start
[j
]);
10081 for (j
= 0; j
< lbytes
; j
++)
10084 if (k
>= ' ' && k
< 0x80)
10104 display_debug_info (Elf_Internal_Shdr
* section
,
10105 unsigned char * start
, FILE * file
)
10107 return process_debug_info (section
, start
, file
, 0);
10112 display_debug_aranges (Elf_Internal_Shdr
*section
,
10113 unsigned char *start
,
10114 FILE *file ATTRIBUTE_UNUSED
)
10116 unsigned char *end
= start
+ section
->sh_size
;
10118 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
10120 while (start
< end
)
10122 unsigned char *hdrptr
;
10123 DWARF2_Internal_ARange arange
;
10124 unsigned char *ranges
;
10125 unsigned long length
;
10126 unsigned long address
;
10129 int initial_length_size
;
10133 arange
.ar_length
= byte_get (hdrptr
, 4);
10136 if (arange
.ar_length
== 0xffffffff)
10138 arange
.ar_length
= byte_get (hdrptr
, 8);
10141 initial_length_size
= 12;
10146 initial_length_size
= 4;
10149 arange
.ar_version
= byte_get (hdrptr
, 2);
10152 arange
.ar_info_offset
= byte_get (hdrptr
, offset_size
);
10153 hdrptr
+= offset_size
;
10155 arange
.ar_pointer_size
= byte_get (hdrptr
, 1);
10158 arange
.ar_segment_size
= byte_get (hdrptr
, 1);
10161 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
10163 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
10167 printf (_(" Length: %ld\n"), arange
.ar_length
);
10168 printf (_(" Version: %d\n"), arange
.ar_version
);
10169 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
10170 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
10171 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
10173 printf (_("\n Address Length\n"));
10177 /* Must pad to an alignment boundary that is twice the pointer size. */
10178 excess
= (hdrptr
- start
) % (2 * arange
.ar_pointer_size
);
10180 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
10184 address
= byte_get (ranges
, arange
.ar_pointer_size
);
10186 ranges
+= arange
.ar_pointer_size
;
10188 length
= byte_get (ranges
, arange
.ar_pointer_size
);
10190 ranges
+= arange
.ar_pointer_size
;
10192 /* A pair of zeros marks the end of the list. */
10193 if (address
== 0 && length
== 0)
10196 printf (" %8.8lx %lu\n", address
, length
);
10199 start
+= arange
.ar_length
+ initial_length_size
;
10208 display_debug_ranges (Elf_Internal_Shdr
*section
,
10209 unsigned char *start
,
10210 FILE *file ATTRIBUTE_UNUSED
)
10212 unsigned char *section_end
;
10213 unsigned long bytes
;
10214 unsigned char *section_begin
= start
;
10215 unsigned int num_range_list
= 0;
10216 unsigned long last_offset
= 0;
10217 unsigned int first
= 0;
10220 int seen_first_offset
= 0;
10221 int use_debug_info
= 1;
10222 unsigned char *next
;
10224 bytes
= section
->sh_size
;
10225 section_end
= start
+ bytes
;
10229 printf (_("\nThe .debug_ranges section is empty.\n"));
10233 get_debug_info (file
);
10235 /* Check the order of range list in .debug_info section. If
10236 offsets of range lists are in the ascending order, we can
10237 use `debug_information' directly. */
10238 for (i
= 0; i
< num_debug_info_entries
; i
++)
10242 num
= debug_information
[i
].num_range_lists
;
10243 num_range_list
+= num
;
10245 /* Check if we can use `debug_information' directly. */
10246 if (use_debug_info
&& num
!= 0)
10248 if (!seen_first_offset
)
10250 /* This is the first range list. */
10251 last_offset
= debug_information
[i
].range_lists
[0];
10253 seen_first_offset
= 1;
10259 for (; j
< num
; j
++)
10262 debug_information
[i
].range_lists
[j
])
10264 use_debug_info
= 0;
10267 last_offset
= debug_information
[i
].range_lists
[j
];
10272 if (!use_debug_info
)
10273 /* FIXME: Should we handle this case? */
10274 error (_("Range lists in .debug_info section aren't in ascending order!\n"));
10276 if (!seen_first_offset
)
10277 error (_("No range lists in .debug_info section!\n"));
10279 if (debug_information
[first
].range_lists
[0] != 0)
10280 warn (_("Range lists in .debug_ranges section start at 0x%lx\n"),
10281 debug_information
[first
].range_lists
[0]);
10283 printf (_("Contents of the .debug_ranges section:\n\n"));
10284 printf (_(" Offset Begin End\n"));
10286 seen_first_offset
= 0;
10287 for (i
= first
; i
< num_debug_info_entries
; i
++)
10289 unsigned long begin
;
10291 unsigned long offset
;
10292 unsigned int pointer_size
;
10293 unsigned long base_address
;
10295 pointer_size
= debug_information
[i
].pointer_size
;
10297 for (j
= 0; j
< debug_information
[i
].num_range_lists
; j
++)
10299 offset
= debug_information
[i
].range_lists
[j
];
10300 next
= section_begin
+ offset
;
10301 base_address
= debug_information
[i
].base_address
;
10303 if (!seen_first_offset
)
10304 seen_first_offset
= 1;
10308 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_ranges section.\n"),
10309 (long)(start
- section_begin
), (long)(next
- section_begin
));
10310 else if (start
> next
)
10311 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_ranges section.\n"),
10312 (long)(start
- section_begin
), (long)(next
- section_begin
));
10318 begin
= byte_get (start
, pointer_size
);
10319 start
+= pointer_size
;
10320 end
= byte_get (start
, pointer_size
);
10321 start
+= pointer_size
;
10323 if (begin
== 0 && end
== 0)
10325 printf (_(" %8.8lx <End of list>\n"), offset
);
10329 /* Check base address specifiers. */
10330 if (begin
== -1UL && end
!= -1UL)
10332 base_address
= end
;
10333 printf (" %8.8lx %8.8lx %8.8lx (base address)\n",
10334 offset
, begin
, end
);
10338 printf (" %8.8lx %8.8lx %8.8lx",
10339 offset
, begin
+ base_address
, end
+ base_address
);
10342 fputs (_(" (start == end)"), stdout
);
10343 else if (begin
> end
)
10344 fputs (_(" (start > end)"), stdout
);
10354 typedef struct Frame_Chunk
10356 struct Frame_Chunk
*next
;
10357 unsigned char *chunk_start
;
10359 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
10360 short int *col_type
;
10362 char *augmentation
;
10363 unsigned int code_factor
;
10365 unsigned long pc_begin
;
10366 unsigned long pc_range
;
10370 unsigned char fde_encoding
;
10371 unsigned char cfa_exp
;
10375 /* A marker for a col_type that means this column was never referenced
10376 in the frame info. */
10377 #define DW_CFA_unreferenced (-1)
10380 frame_need_space (Frame_Chunk
*fc
, int reg
)
10382 int prev
= fc
->ncols
;
10384 if (reg
< fc
->ncols
)
10387 fc
->ncols
= reg
+ 1;
10388 fc
->col_type
= xcrealloc (fc
->col_type
, fc
->ncols
, sizeof (short int));
10389 fc
->col_offset
= xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
10391 while (prev
< fc
->ncols
)
10393 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
10394 fc
->col_offset
[prev
] = 0;
10400 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, int *max_regs
)
10405 if (*max_regs
< fc
->ncols
)
10406 *max_regs
= fc
->ncols
;
10408 if (*need_col_headers
)
10410 *need_col_headers
= 0;
10412 printf (" LOC CFA ");
10414 for (r
= 0; r
< *max_regs
; r
++)
10415 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
10420 printf ("r%-4d", r
);
10426 printf ("%08lx ", fc
->pc_begin
);
10428 strcpy (tmp
, "exp");
10430 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
10431 printf ("%-8s ", tmp
);
10433 for (r
= 0; r
< fc
->ncols
; r
++)
10435 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
10437 switch (fc
->col_type
[r
])
10439 case DW_CFA_undefined
:
10442 case DW_CFA_same_value
:
10445 case DW_CFA_offset
:
10446 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
10448 case DW_CFA_register
:
10449 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
10451 case DW_CFA_expression
:
10452 strcpy (tmp
, "exp");
10455 strcpy (tmp
, "n/a");
10458 printf ("%-5s", tmp
);
10465 size_of_encoded_value (int encoding
)
10467 switch (encoding
& 0x7)
10470 case 0: return eh_addr_size
;
10478 get_encoded_value (unsigned char *data
, int encoding
)
10480 int size
= size_of_encoded_value (encoding
);
10481 if (encoding
& DW_EH_PE_signed
)
10482 return byte_get_signed (data
, size
);
10484 return byte_get (data
, size
);
10487 #define GET(N) byte_get (start, N); start += N
10488 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
10489 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
10492 display_debug_frames (Elf_Internal_Shdr
*section
,
10493 unsigned char *start
,
10494 FILE *file ATTRIBUTE_UNUSED
)
10496 unsigned char *end
= start
+ section
->sh_size
;
10497 unsigned char *section_start
= start
;
10498 Frame_Chunk
*chunks
= 0;
10499 Frame_Chunk
*remembered_state
= 0;
10501 int is_eh
= streq (SECTION_NAME (section
), ".eh_frame");
10502 unsigned int length_return
;
10505 printf (_("The section %s contains:\n"), SECTION_NAME (section
));
10507 while (start
< end
)
10509 unsigned char *saved_start
;
10510 unsigned char *block_end
;
10511 unsigned long length
;
10512 unsigned long cie_id
;
10515 int need_col_headers
= 1;
10516 unsigned char *augmentation_data
= NULL
;
10517 unsigned long augmentation_data_len
= 0;
10518 int encoded_ptr_size
= eh_addr_size
;
10520 int initial_length_size
;
10522 saved_start
= start
;
10523 length
= byte_get (start
, 4); start
+= 4;
10527 printf ("\n%08lx ZERO terminator\n\n",
10528 (unsigned long)(saved_start
- section_start
));
10532 if (length
== 0xffffffff)
10534 length
= byte_get (start
, 8);
10537 initial_length_size
= 12;
10542 initial_length_size
= 4;
10545 block_end
= saved_start
+ length
+ initial_length_size
;
10546 cie_id
= byte_get (start
, offset_size
); start
+= offset_size
;
10548 if (elf_header
.e_type
== ET_REL
10549 && !debug_apply_rela_addends (file
, section
, offset_size
,
10550 section_start
, start
, block_end
))
10553 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
10557 fc
= xmalloc (sizeof (Frame_Chunk
));
10558 memset (fc
, 0, sizeof (Frame_Chunk
));
10562 fc
->chunk_start
= saved_start
;
10564 fc
->col_type
= xmalloc (sizeof (short int));
10565 fc
->col_offset
= xmalloc (sizeof (int));
10566 frame_need_space (fc
, max_regs
-1);
10568 version
= *start
++;
10570 fc
->augmentation
= (char *) start
;
10571 start
= (unsigned char *) strchr ((char *) start
, '\0') + 1;
10573 if (fc
->augmentation
[0] == 'z')
10575 fc
->code_factor
= LEB ();
10576 fc
->data_factor
= SLEB ();
10585 augmentation_data_len
= LEB ();
10586 augmentation_data
= start
;
10587 start
+= augmentation_data_len
;
10589 else if (streq (fc
->augmentation
, "eh"))
10591 start
+= eh_addr_size
;
10592 fc
->code_factor
= LEB ();
10593 fc
->data_factor
= SLEB ();
10605 fc
->code_factor
= LEB ();
10606 fc
->data_factor
= SLEB ();
10618 if (do_debug_frames_interp
)
10619 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
10620 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
10621 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
10625 printf ("\n%08lx %08lx %08lx CIE\n",
10626 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
10627 printf (" Version: %d\n", version
);
10628 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
10629 printf (" Code alignment factor: %u\n", fc
->code_factor
);
10630 printf (" Data alignment factor: %d\n", fc
->data_factor
);
10631 printf (" Return address column: %d\n", fc
->ra
);
10633 if (augmentation_data_len
)
10636 printf (" Augmentation data: ");
10637 for (i
= 0; i
< augmentation_data_len
; ++i
)
10638 printf (" %02x", augmentation_data
[i
]);
10644 if (augmentation_data_len
)
10646 unsigned char *p
, *q
;
10647 p
= (unsigned char *) fc
->augmentation
+ 1;
10648 q
= augmentation_data
;
10654 else if (*p
== 'P')
10655 q
+= 1 + size_of_encoded_value (*q
);
10656 else if (*p
== 'R')
10657 fc
->fde_encoding
= *q
++;
10663 if (fc
->fde_encoding
)
10664 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
10667 frame_need_space (fc
, fc
->ra
);
10671 unsigned char *look_for
;
10672 static Frame_Chunk fde_fc
;
10675 memset (fc
, 0, sizeof (Frame_Chunk
));
10677 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
10679 for (cie
= chunks
; cie
; cie
= cie
->next
)
10680 if (cie
->chunk_start
== look_for
)
10685 warn ("Invalid CIE pointer %08lx in FDE at %p\n",
10686 cie_id
, saved_start
);
10689 fc
->col_type
= xmalloc (sizeof (short int));
10690 fc
->col_offset
= xmalloc (sizeof (int));
10691 frame_need_space (fc
, max_regs
- 1);
10693 fc
->augmentation
= "";
10694 fc
->fde_encoding
= 0;
10698 fc
->ncols
= cie
->ncols
;
10699 fc
->col_type
= xcmalloc (fc
->ncols
, sizeof (short int));
10700 fc
->col_offset
= xcmalloc (fc
->ncols
, sizeof (int));
10701 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
10702 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
10703 fc
->augmentation
= cie
->augmentation
;
10704 fc
->code_factor
= cie
->code_factor
;
10705 fc
->data_factor
= cie
->data_factor
;
10706 fc
->cfa_reg
= cie
->cfa_reg
;
10707 fc
->cfa_offset
= cie
->cfa_offset
;
10709 frame_need_space (fc
, max_regs
-1);
10710 fc
->fde_encoding
= cie
->fde_encoding
;
10713 if (fc
->fde_encoding
)
10714 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
10716 fc
->pc_begin
= get_encoded_value (start
, fc
->fde_encoding
);
10717 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
10718 /* Don't adjust for ET_REL since there's invariably a pcrel
10719 reloc here, which we haven't applied. */
10720 && elf_header
.e_type
!= ET_REL
)
10721 fc
->pc_begin
+= section
->sh_addr
+ (start
- section_start
);
10722 start
+= encoded_ptr_size
;
10723 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
10724 start
+= encoded_ptr_size
;
10726 if (cie
->augmentation
[0] == 'z')
10728 augmentation_data_len
= LEB ();
10729 augmentation_data
= start
;
10730 start
+= augmentation_data_len
;
10733 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
10734 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
10735 (unsigned long)(cie
->chunk_start
- section_start
),
10736 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
10737 if (! do_debug_frames_interp
&& augmentation_data_len
)
10741 printf (" Augmentation data: ");
10742 for (i
= 0; i
< augmentation_data_len
; ++i
)
10743 printf (" %02x", augmentation_data
[i
]);
10749 /* At this point, fc is the current chunk, cie (if any) is set, and
10750 we're about to interpret instructions for the chunk. */
10751 /* ??? At present we need to do this always, since this sizes the
10752 fc->col_type and fc->col_offset arrays, which we write into always.
10753 We should probably split the interpreted and non-interpreted bits
10754 into two different routines, since there's so much that doesn't
10755 really overlap between them. */
10756 if (1 || do_debug_frames_interp
)
10758 /* Start by making a pass over the chunk, allocating storage
10759 and taking note of what registers are used. */
10760 unsigned char *tmp
= start
;
10762 while (start
< block_end
)
10765 unsigned long reg
, tmp
;
10772 /* Warning: if you add any more cases to this switch, be
10773 sure to add them to the corresponding switch below. */
10776 case DW_CFA_advance_loc
:
10778 case DW_CFA_offset
:
10780 frame_need_space (fc
, opa
);
10781 fc
->col_type
[opa
] = DW_CFA_undefined
;
10783 case DW_CFA_restore
:
10784 frame_need_space (fc
, opa
);
10785 fc
->col_type
[opa
] = DW_CFA_undefined
;
10787 case DW_CFA_set_loc
:
10788 start
+= encoded_ptr_size
;
10790 case DW_CFA_advance_loc1
:
10793 case DW_CFA_advance_loc2
:
10796 case DW_CFA_advance_loc4
:
10799 case DW_CFA_offset_extended
:
10800 reg
= LEB (); LEB ();
10801 frame_need_space (fc
, reg
);
10802 fc
->col_type
[reg
] = DW_CFA_undefined
;
10804 case DW_CFA_restore_extended
:
10806 frame_need_space (fc
, reg
);
10807 fc
->col_type
[reg
] = DW_CFA_undefined
;
10809 case DW_CFA_undefined
:
10811 frame_need_space (fc
, reg
);
10812 fc
->col_type
[reg
] = DW_CFA_undefined
;
10814 case DW_CFA_same_value
:
10816 frame_need_space (fc
, reg
);
10817 fc
->col_type
[reg
] = DW_CFA_undefined
;
10819 case DW_CFA_register
:
10820 reg
= LEB (); LEB ();
10821 frame_need_space (fc
, reg
);
10822 fc
->col_type
[reg
] = DW_CFA_undefined
;
10824 case DW_CFA_def_cfa
:
10827 case DW_CFA_def_cfa_register
:
10830 case DW_CFA_def_cfa_offset
:
10833 case DW_CFA_def_cfa_expression
:
10837 case DW_CFA_expression
:
10841 frame_need_space (fc
, reg
);
10842 fc
->col_type
[reg
] = DW_CFA_undefined
;
10844 case DW_CFA_offset_extended_sf
:
10845 reg
= LEB (); SLEB ();
10846 frame_need_space (fc
, reg
);
10847 fc
->col_type
[reg
] = DW_CFA_undefined
;
10849 case DW_CFA_def_cfa_sf
:
10852 case DW_CFA_def_cfa_offset_sf
:
10855 case DW_CFA_MIPS_advance_loc8
:
10858 case DW_CFA_GNU_args_size
:
10861 case DW_CFA_GNU_negative_offset_extended
:
10862 reg
= LEB (); LEB ();
10863 frame_need_space (fc
, reg
);
10864 fc
->col_type
[reg
] = DW_CFA_undefined
;
10873 /* Now we know what registers are used, make a second pass over
10874 the chunk, this time actually printing out the info. */
10876 while (start
< block_end
)
10879 unsigned long ul
, reg
, roffs
;
10888 /* Warning: if you add any more cases to this switch, be
10889 sure to add them to the corresponding switch above. */
10892 case DW_CFA_advance_loc
:
10893 if (do_debug_frames_interp
)
10894 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10896 printf (" DW_CFA_advance_loc: %d to %08lx\n",
10897 opa
* fc
->code_factor
,
10898 fc
->pc_begin
+ opa
* fc
->code_factor
);
10899 fc
->pc_begin
+= opa
* fc
->code_factor
;
10902 case DW_CFA_offset
:
10904 if (! do_debug_frames_interp
)
10905 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
10906 opa
, roffs
* fc
->data_factor
);
10907 fc
->col_type
[opa
] = DW_CFA_offset
;
10908 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
10911 case DW_CFA_restore
:
10912 if (! do_debug_frames_interp
)
10913 printf (" DW_CFA_restore: r%d\n", opa
);
10914 fc
->col_type
[opa
] = cie
->col_type
[opa
];
10915 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
10918 case DW_CFA_set_loc
:
10919 vma
= get_encoded_value (start
, fc
->fde_encoding
);
10920 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
10921 && elf_header
.e_type
!= ET_REL
)
10922 vma
+= section
->sh_addr
+ (start
- section_start
);
10923 start
+= encoded_ptr_size
;
10924 if (do_debug_frames_interp
)
10925 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10927 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
10928 fc
->pc_begin
= vma
;
10931 case DW_CFA_advance_loc1
:
10932 ofs
= byte_get (start
, 1); start
+= 1;
10933 if (do_debug_frames_interp
)
10934 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10936 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
10937 ofs
* fc
->code_factor
,
10938 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10939 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10942 case DW_CFA_advance_loc2
:
10943 ofs
= byte_get (start
, 2); start
+= 2;
10944 if (do_debug_frames_interp
)
10945 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10947 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
10948 ofs
* fc
->code_factor
,
10949 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10950 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10953 case DW_CFA_advance_loc4
:
10954 ofs
= byte_get (start
, 4); start
+= 4;
10955 if (do_debug_frames_interp
)
10956 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10958 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
10959 ofs
* fc
->code_factor
,
10960 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10961 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10964 case DW_CFA_offset_extended
:
10967 if (! do_debug_frames_interp
)
10968 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
10969 reg
, roffs
* fc
->data_factor
);
10970 fc
->col_type
[reg
] = DW_CFA_offset
;
10971 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
10974 case DW_CFA_restore_extended
:
10976 if (! do_debug_frames_interp
)
10977 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
10978 fc
->col_type
[reg
] = cie
->col_type
[reg
];
10979 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
10982 case DW_CFA_undefined
:
10984 if (! do_debug_frames_interp
)
10985 printf (" DW_CFA_undefined: r%ld\n", reg
);
10986 fc
->col_type
[reg
] = DW_CFA_undefined
;
10987 fc
->col_offset
[reg
] = 0;
10990 case DW_CFA_same_value
:
10992 if (! do_debug_frames_interp
)
10993 printf (" DW_CFA_same_value: r%ld\n", reg
);
10994 fc
->col_type
[reg
] = DW_CFA_same_value
;
10995 fc
->col_offset
[reg
] = 0;
10998 case DW_CFA_register
:
11001 if (! do_debug_frames_interp
)
11002 printf (" DW_CFA_register: r%ld in r%ld\n", reg
, roffs
);
11003 fc
->col_type
[reg
] = DW_CFA_register
;
11004 fc
->col_offset
[reg
] = roffs
;
11007 case DW_CFA_remember_state
:
11008 if (! do_debug_frames_interp
)
11009 printf (" DW_CFA_remember_state\n");
11010 rs
= xmalloc (sizeof (Frame_Chunk
));
11011 rs
->ncols
= fc
->ncols
;
11012 rs
->col_type
= xcmalloc (rs
->ncols
, sizeof (short int));
11013 rs
->col_offset
= xcmalloc (rs
->ncols
, sizeof (int));
11014 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
11015 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
11016 rs
->next
= remembered_state
;
11017 remembered_state
= rs
;
11020 case DW_CFA_restore_state
:
11021 if (! do_debug_frames_interp
)
11022 printf (" DW_CFA_restore_state\n");
11023 rs
= remembered_state
;
11026 remembered_state
= rs
->next
;
11027 frame_need_space (fc
, rs
->ncols
-1);
11028 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
11029 memcpy (fc
->col_offset
, rs
->col_offset
,
11030 rs
->ncols
* sizeof (int));
11031 free (rs
->col_type
);
11032 free (rs
->col_offset
);
11035 else if (do_debug_frames_interp
)
11036 printf ("Mismatched DW_CFA_restore_state\n");
11039 case DW_CFA_def_cfa
:
11040 fc
->cfa_reg
= LEB ();
11041 fc
->cfa_offset
= LEB ();
11043 if (! do_debug_frames_interp
)
11044 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
11045 fc
->cfa_reg
, fc
->cfa_offset
);
11048 case DW_CFA_def_cfa_register
:
11049 fc
->cfa_reg
= LEB ();
11051 if (! do_debug_frames_interp
)
11052 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
11055 case DW_CFA_def_cfa_offset
:
11056 fc
->cfa_offset
= LEB ();
11057 if (! do_debug_frames_interp
)
11058 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
11062 if (! do_debug_frames_interp
)
11063 printf (" DW_CFA_nop\n");
11066 case DW_CFA_def_cfa_expression
:
11068 if (! do_debug_frames_interp
)
11070 printf (" DW_CFA_def_cfa_expression (");
11071 decode_location_expression (start
, eh_addr_size
, ul
, 0);
11078 case DW_CFA_expression
:
11081 if (! do_debug_frames_interp
)
11083 printf (" DW_CFA_expression: r%ld (", reg
);
11084 decode_location_expression (start
, eh_addr_size
, ul
, 0);
11087 fc
->col_type
[reg
] = DW_CFA_expression
;
11091 case DW_CFA_offset_extended_sf
:
11094 frame_need_space (fc
, reg
);
11095 if (! do_debug_frames_interp
)
11096 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
11097 reg
, l
* fc
->data_factor
);
11098 fc
->col_type
[reg
] = DW_CFA_offset
;
11099 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
11102 case DW_CFA_def_cfa_sf
:
11103 fc
->cfa_reg
= LEB ();
11104 fc
->cfa_offset
= SLEB ();
11105 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
11107 if (! do_debug_frames_interp
)
11108 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
11109 fc
->cfa_reg
, fc
->cfa_offset
);
11112 case DW_CFA_def_cfa_offset_sf
:
11113 fc
->cfa_offset
= SLEB ();
11114 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
11115 if (! do_debug_frames_interp
)
11116 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
11119 case DW_CFA_MIPS_advance_loc8
:
11120 ofs
= byte_get (start
, 8); start
+= 8;
11121 if (do_debug_frames_interp
)
11122 frame_display_row (fc
, &need_col_headers
, &max_regs
);
11124 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
11125 ofs
* fc
->code_factor
,
11126 fc
->pc_begin
+ ofs
* fc
->code_factor
);
11127 fc
->pc_begin
+= ofs
* fc
->code_factor
;
11130 case DW_CFA_GNU_window_save
:
11131 if (! do_debug_frames_interp
)
11132 printf (" DW_CFA_GNU_window_save\n");
11135 case DW_CFA_GNU_args_size
:
11137 if (! do_debug_frames_interp
)
11138 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
11141 case DW_CFA_GNU_negative_offset_extended
:
11144 frame_need_space (fc
, reg
);
11145 if (! do_debug_frames_interp
)
11146 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
11147 reg
, l
* fc
->data_factor
);
11148 fc
->col_type
[reg
] = DW_CFA_offset
;
11149 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
11153 warn (_("unsupported or unknown DW_CFA_%d\n"), op
);
11158 if (do_debug_frames_interp
)
11159 frame_display_row (fc
, &need_col_headers
, &max_regs
);
11174 display_debug_not_supported (Elf_Internal_Shdr
*section
,
11175 unsigned char *start ATTRIBUTE_UNUSED
,
11176 FILE *file ATTRIBUTE_UNUSED
)
11178 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
11179 SECTION_NAME (section
));
11184 /* A structure containing the name of a debug section
11185 and a pointer to a function that can decode it. */
11188 const char *const name
;
11189 int (*display
) (Elf_Internal_Shdr
*, unsigned char *, FILE *);
11193 { ".debug_abbrev", display_debug_abbrev
},
11194 { ".debug_aranges", display_debug_aranges
},
11195 { ".debug_frame", display_debug_frames
},
11196 { ".debug_info", display_debug_info
},
11197 { ".debug_line", display_debug_lines
},
11198 { ".debug_pubnames", display_debug_pubnames
},
11199 { ".eh_frame", display_debug_frames
},
11200 { ".debug_macinfo", display_debug_macinfo
},
11201 { ".debug_str", display_debug_str
},
11202 { ".debug_loc", display_debug_loc
},
11203 { ".debug_pubtypes", display_debug_pubnames
},
11204 { ".debug_ranges", display_debug_ranges
},
11205 { ".debug_static_func", display_debug_not_supported
},
11206 { ".debug_static_vars", display_debug_not_supported
},
11207 { ".debug_types", display_debug_not_supported
},
11208 { ".debug_weaknames", display_debug_not_supported
}
11212 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
11214 char *name
= SECTION_NAME (section
);
11215 bfd_size_type length
;
11219 length
= section
->sh_size
;
11222 printf (_("\nSection '%s' has no debugging data.\n"), name
);
11226 if (strneq (name
, ".gnu.linkonce.wi.", 17))
11227 name
= ".debug_info";
11229 /* See if we know how to display the contents of this section. */
11230 for (i
= NUM_ELEM (debug_displays
); i
--;)
11231 if (streq (debug_displays
[i
].name
, name
))
11233 unsigned char *start
;
11235 start
= get_data (NULL
, file
, section
->sh_offset
, 1, length
,
11236 _("debug section data"));
11243 result
&= debug_displays
[i
].display (section
, start
, file
);
11246 /* If we loaded in the abbrev section
11247 at some point, we must release it here. */
11255 printf (_("Unrecognized debug section: %s\n"), name
);
11263 process_section_contents (FILE *file
)
11265 Elf_Internal_Shdr
*section
;
11271 for (i
= 0, section
= section_headers
;
11272 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
11275 #ifdef SUPPORT_DISASSEMBLY
11276 if (dump_sects
[i
] & DISASS_DUMP
)
11277 disassemble_section (section
, file
);
11279 if (dump_sects
[i
] & HEX_DUMP
)
11280 dump_section (section
, file
);
11282 if (dump_sects
[i
] & DEBUG_DUMP
)
11283 display_debug_section (section
, file
);
11286 /* Check to see if the user requested a
11287 dump of a section that does not exist. */
11288 while (i
++ < num_dump_sects
)
11290 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
11294 process_mips_fpe_exception (int mask
)
11299 if (mask
& OEX_FPU_INEX
)
11300 fputs ("INEX", stdout
), first
= 0;
11301 if (mask
& OEX_FPU_UFLO
)
11302 printf ("%sUFLO", first
? "" : "|"), first
= 0;
11303 if (mask
& OEX_FPU_OFLO
)
11304 printf ("%sOFLO", first
? "" : "|"), first
= 0;
11305 if (mask
& OEX_FPU_DIV0
)
11306 printf ("%sDIV0", first
? "" : "|"), first
= 0;
11307 if (mask
& OEX_FPU_INVAL
)
11308 printf ("%sINVAL", first
? "" : "|");
11311 fputs ("0", stdout
);
11315 process_mips_specific (FILE *file
)
11317 Elf_Internal_Dyn
*entry
;
11318 size_t liblist_offset
= 0;
11319 size_t liblistno
= 0;
11320 size_t conflictsno
= 0;
11321 size_t options_offset
= 0;
11322 size_t conflicts_offset
= 0;
11324 /* We have a lot of special sections. Thanks SGI! */
11325 if (dynamic_section
== NULL
)
11326 /* No information available. */
11329 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
11330 switch (entry
->d_tag
)
11332 case DT_MIPS_LIBLIST
:
11334 = offset_from_vma (file
, entry
->d_un
.d_val
,
11335 liblistno
* sizeof (Elf32_External_Lib
));
11337 case DT_MIPS_LIBLISTNO
:
11338 liblistno
= entry
->d_un
.d_val
;
11340 case DT_MIPS_OPTIONS
:
11341 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
11343 case DT_MIPS_CONFLICT
:
11345 = offset_from_vma (file
, entry
->d_un
.d_val
,
11346 conflictsno
* sizeof (Elf32_External_Conflict
));
11348 case DT_MIPS_CONFLICTNO
:
11349 conflictsno
= entry
->d_un
.d_val
;
11355 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
11357 Elf32_External_Lib
*elib
;
11360 elib
= get_data (NULL
, file
, liblist_offset
,
11361 liblistno
, sizeof (Elf32_External_Lib
),
11365 printf ("\nSection '.liblist' contains %lu entries:\n",
11366 (unsigned long) liblistno
);
11367 fputs (" Library Time Stamp Checksum Version Flags\n",
11370 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
11377 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
11378 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
11379 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
11380 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
11381 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
11383 tmp
= gmtime (&time
);
11384 snprintf (timebuf
, sizeof (timebuf
),
11385 "%04u-%02u-%02uT%02u:%02u:%02u",
11386 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11387 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11389 printf ("%3lu: ", (unsigned long) cnt
);
11390 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
11391 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
11393 printf ("<corrupt: %9ld>", liblist
.l_name
);
11394 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
11395 liblist
.l_version
);
11397 if (liblist
.l_flags
== 0)
11401 static const struct
11408 { " EXACT_MATCH", LL_EXACT_MATCH
},
11409 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
11410 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
11411 { " EXPORTS", LL_EXPORTS
},
11412 { " DELAY_LOAD", LL_DELAY_LOAD
},
11413 { " DELTA", LL_DELTA
}
11415 int flags
= liblist
.l_flags
;
11419 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
11421 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
11423 fputs (l_flags_vals
[fcnt
].name
, stdout
);
11424 flags
^= l_flags_vals
[fcnt
].bit
;
11427 printf (" %#x", (unsigned int) flags
);
11437 if (options_offset
!= 0)
11439 Elf_External_Options
*eopt
;
11440 Elf_Internal_Shdr
*sect
= section_headers
;
11441 Elf_Internal_Options
*iopt
;
11442 Elf_Internal_Options
*option
;
11446 /* Find the section header so that we get the size. */
11447 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
11450 eopt
= get_data (NULL
, file
, options_offset
, 1, sect
->sh_size
,
11454 iopt
= cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (*iopt
));
11457 error (_("Out of memory"));
11464 while (offset
< sect
->sh_size
)
11466 Elf_External_Options
*eoption
;
11468 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
11470 option
->kind
= BYTE_GET (eoption
->kind
);
11471 option
->size
= BYTE_GET (eoption
->size
);
11472 option
->section
= BYTE_GET (eoption
->section
);
11473 option
->info
= BYTE_GET (eoption
->info
);
11475 offset
+= option
->size
;
11481 printf (_("\nSection '%s' contains %d entries:\n"),
11482 SECTION_NAME (sect
), cnt
);
11490 switch (option
->kind
)
11493 /* This shouldn't happen. */
11494 printf (" NULL %d %lx", option
->section
, option
->info
);
11497 printf (" REGINFO ");
11498 if (elf_header
.e_machine
== EM_MIPS
)
11501 Elf32_External_RegInfo
*ereg
;
11502 Elf32_RegInfo reginfo
;
11504 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
11505 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
11506 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
11507 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
11508 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
11509 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
11510 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
11512 printf ("GPR %08lx GP 0x%lx\n",
11513 reginfo
.ri_gprmask
,
11514 (unsigned long) reginfo
.ri_gp_value
);
11515 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11516 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11517 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11522 Elf64_External_RegInfo
*ereg
;
11523 Elf64_Internal_RegInfo reginfo
;
11525 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
11526 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
11527 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
11528 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
11529 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
11530 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
11531 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
11533 printf ("GPR %08lx GP 0x",
11534 reginfo
.ri_gprmask
);
11535 printf_vma (reginfo
.ri_gp_value
);
11538 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11539 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11540 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11544 case ODK_EXCEPTIONS
:
11545 fputs (" EXCEPTIONS fpe_min(", stdout
);
11546 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
11547 fputs (") fpe_max(", stdout
);
11548 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
11549 fputs (")", stdout
);
11551 if (option
->info
& OEX_PAGE0
)
11552 fputs (" PAGE0", stdout
);
11553 if (option
->info
& OEX_SMM
)
11554 fputs (" SMM", stdout
);
11555 if (option
->info
& OEX_FPDBUG
)
11556 fputs (" FPDBUG", stdout
);
11557 if (option
->info
& OEX_DISMISS
)
11558 fputs (" DISMISS", stdout
);
11561 fputs (" PAD ", stdout
);
11562 if (option
->info
& OPAD_PREFIX
)
11563 fputs (" PREFIX", stdout
);
11564 if (option
->info
& OPAD_POSTFIX
)
11565 fputs (" POSTFIX", stdout
);
11566 if (option
->info
& OPAD_SYMBOL
)
11567 fputs (" SYMBOL", stdout
);
11570 fputs (" HWPATCH ", stdout
);
11571 if (option
->info
& OHW_R4KEOP
)
11572 fputs (" R4KEOP", stdout
);
11573 if (option
->info
& OHW_R8KPFETCH
)
11574 fputs (" R8KPFETCH", stdout
);
11575 if (option
->info
& OHW_R5KEOP
)
11576 fputs (" R5KEOP", stdout
);
11577 if (option
->info
& OHW_R5KCVTL
)
11578 fputs (" R5KCVTL", stdout
);
11581 fputs (" FILL ", stdout
);
11582 /* XXX Print content of info word? */
11585 fputs (" TAGS ", stdout
);
11586 /* XXX Print content of info word? */
11589 fputs (" HWAND ", stdout
);
11590 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11591 fputs (" R4KEOP_CHECKED", stdout
);
11592 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11593 fputs (" R4KEOP_CLEAN", stdout
);
11596 fputs (" HWOR ", stdout
);
11597 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11598 fputs (" R4KEOP_CHECKED", stdout
);
11599 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11600 fputs (" R4KEOP_CLEAN", stdout
);
11603 printf (" GP_GROUP %#06lx self-contained %#06lx",
11604 option
->info
& OGP_GROUP
,
11605 (option
->info
& OGP_SELF
) >> 16);
11608 printf (" IDENT %#06lx self-contained %#06lx",
11609 option
->info
& OGP_GROUP
,
11610 (option
->info
& OGP_SELF
) >> 16);
11613 /* This shouldn't happen. */
11614 printf (" %3d ??? %d %lx",
11615 option
->kind
, option
->section
, option
->info
);
11619 len
= sizeof (*eopt
);
11620 while (len
< option
->size
)
11621 if (((char *) option
)[len
] >= ' '
11622 && ((char *) option
)[len
] < 0x7f)
11623 printf ("%c", ((char *) option
)[len
++]);
11625 printf ("\\%03o", ((char *) option
)[len
++]);
11627 fputs ("\n", stdout
);
11635 if (conflicts_offset
!= 0 && conflictsno
!= 0)
11637 Elf32_Conflict
*iconf
;
11640 if (dynamic_symbols
== NULL
)
11642 error (_("conflict list found without a dynamic symbol table"));
11646 iconf
= cmalloc (conflictsno
, sizeof (*iconf
));
11649 error (_("Out of memory"));
11655 Elf32_External_Conflict
*econf32
;
11657 econf32
= get_data (NULL
, file
, conflicts_offset
,
11658 conflictsno
, sizeof (*econf32
), _("conflict"));
11662 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11663 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
11669 Elf64_External_Conflict
*econf64
;
11671 econf64
= get_data (NULL
, file
, conflicts_offset
,
11672 conflictsno
, sizeof (*econf64
), _("conflict"));
11676 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11677 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
11682 printf (_("\nSection '.conflict' contains %lu entries:\n"),
11683 (unsigned long) conflictsno
);
11684 puts (_(" Num: Index Value Name"));
11686 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11688 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
11690 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
11691 print_vma (psym
->st_value
, FULL_HEX
);
11693 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11694 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11696 printf ("<corrupt: %14ld>", psym
->st_name
);
11707 process_gnu_liblist (FILE *file
)
11709 Elf_Internal_Shdr
*section
, *string_sec
;
11710 Elf32_External_Lib
*elib
;
11712 size_t strtab_size
;
11719 for (i
= 0, section
= section_headers
;
11720 i
< elf_header
.e_shnum
;
11723 switch (section
->sh_type
)
11725 case SHT_GNU_LIBLIST
:
11726 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
)
11729 elib
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
11734 string_sec
= SECTION_HEADER (section
->sh_link
);
11736 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
11737 string_sec
->sh_size
, _("liblist string table"));
11738 strtab_size
= string_sec
->sh_size
;
11741 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
11747 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
11748 SECTION_NAME (section
),
11749 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
11751 puts (" Library Time Stamp Checksum Version Flags");
11753 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
11761 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
11762 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
11763 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
11764 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
11765 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
11767 tmp
= gmtime (&time
);
11768 snprintf (timebuf
, sizeof (timebuf
),
11769 "%04u-%02u-%02uT%02u:%02u:%02u",
11770 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11771 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11773 printf ("%3lu: ", (unsigned long) cnt
);
11775 printf ("%-20s", liblist
.l_name
< strtab_size
11776 ? strtab
+ liblist
.l_name
: "<corrupt>");
11778 printf ("%-20.20s", liblist
.l_name
< strtab_size
11779 ? strtab
+ liblist
.l_name
: "<corrupt>");
11780 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
11781 liblist
.l_version
, liblist
.l_flags
);
11791 static const char *
11792 get_note_type (unsigned e_type
)
11794 static char buff
[64];
11796 if (elf_header
.e_type
== ET_CORE
)
11800 return _("NT_AUXV (auxiliary vector)");
11802 return _("NT_PRSTATUS (prstatus structure)");
11804 return _("NT_FPREGSET (floating point registers)");
11806 return _("NT_PRPSINFO (prpsinfo structure)");
11807 case NT_TASKSTRUCT
:
11808 return _("NT_TASKSTRUCT (task structure)");
11810 return _("NT_PRXFPREG (user_xfpregs structure)");
11812 return _("NT_PSTATUS (pstatus structure)");
11814 return _("NT_FPREGS (floating point registers)");
11816 return _("NT_PSINFO (psinfo structure)");
11818 return _("NT_LWPSTATUS (lwpstatus_t structure)");
11820 return _("NT_LWPSINFO (lwpsinfo_t structure)");
11821 case NT_WIN32PSTATUS
:
11822 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
11830 return _("NT_VERSION (version)");
11832 return _("NT_ARCH (architecture)");
11837 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11841 static const char *
11842 get_netbsd_elfcore_note_type (unsigned e_type
)
11844 static char buff
[64];
11846 if (e_type
== NT_NETBSDCORE_PROCINFO
)
11848 /* NetBSD core "procinfo" structure. */
11849 return _("NetBSD procinfo structure");
11852 /* As of Jan 2002 there are no other machine-independent notes
11853 defined for NetBSD core files. If the note type is less
11854 than the start of the machine-dependent note types, we don't
11857 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
11859 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11863 switch (elf_header
.e_machine
)
11865 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
11866 and PT_GETFPREGS == mach+2. */
11871 case EM_SPARC32PLUS
:
11875 case NT_NETBSDCORE_FIRSTMACH
+0:
11876 return _("PT_GETREGS (reg structure)");
11877 case NT_NETBSDCORE_FIRSTMACH
+2:
11878 return _("PT_GETFPREGS (fpreg structure)");
11884 /* On all other arch's, PT_GETREGS == mach+1 and
11885 PT_GETFPREGS == mach+3. */
11889 case NT_NETBSDCORE_FIRSTMACH
+1:
11890 return _("PT_GETREGS (reg structure)");
11891 case NT_NETBSDCORE_FIRSTMACH
+3:
11892 return _("PT_GETFPREGS (fpreg structure)");
11898 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
11899 e_type
- NT_NETBSDCORE_FIRSTMACH
);
11903 /* Note that by the ELF standard, the name field is already null byte
11904 terminated, and namesz includes the terminating null byte.
11905 I.E. the value of namesz for the name "FSF" is 4.
11907 If the value of namesz is zero, there is no name present. */
11909 process_note (Elf_Internal_Note
*pnote
)
11913 if (pnote
->namesz
== 0)
11914 /* If there is no note name, then use the default set of
11915 note type strings. */
11916 nt
= get_note_type (pnote
->type
);
11918 else if (strneq (pnote
->namedata
, "NetBSD-CORE", 11))
11919 /* NetBSD-specific core file notes. */
11920 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
11923 /* Don't recognize this note name; just use the default set of
11924 note type strings. */
11925 nt
= get_note_type (pnote
->type
);
11927 printf (" %s\t\t0x%08lx\t%s\n",
11928 pnote
->namesz
? pnote
->namedata
: "(NONE)",
11929 pnote
->descsz
, nt
);
11935 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
11937 Elf_External_Note
*pnotes
;
11938 Elf_External_Note
*external
;
11944 pnotes
= get_data (NULL
, file
, offset
, 1, length
, _("notes"));
11950 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
11951 (unsigned long) offset
, (unsigned long) length
);
11952 printf (_(" Owner\t\tData size\tDescription\n"));
11954 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
11956 Elf_External_Note
*next
;
11957 Elf_Internal_Note inote
;
11960 inote
.type
= BYTE_GET (external
->type
);
11961 inote
.namesz
= BYTE_GET (external
->namesz
);
11962 inote
.namedata
= external
->name
;
11963 inote
.descsz
= BYTE_GET (external
->descsz
);
11964 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
11965 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
11967 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
11969 if (((char *) next
) > (((char *) pnotes
) + length
))
11971 warn (_("corrupt note found at offset %lx into core notes\n"),
11972 (long)((char *)external
- (char *)pnotes
));
11973 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
11974 inote
.type
, inote
.namesz
, inote
.descsz
);
11980 /* Verify that name is null terminated. It appears that at least
11981 one version of Linux (RedHat 6.0) generates corefiles that don't
11982 comply with the ELF spec by failing to include the null byte in
11984 if (inote
.namedata
[inote
.namesz
] != '\0')
11986 temp
= malloc (inote
.namesz
+ 1);
11990 error (_("Out of memory\n"));
11995 strncpy (temp
, inote
.namedata
, inote
.namesz
);
11996 temp
[inote
.namesz
] = 0;
11998 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
11999 inote
.namedata
= temp
;
12002 res
&= process_note (& inote
);
12017 process_corefile_note_segments (FILE *file
)
12019 Elf_Internal_Phdr
*segment
;
12023 if (! get_program_headers (file
))
12026 for (i
= 0, segment
= program_headers
;
12027 i
< elf_header
.e_phnum
;
12030 if (segment
->p_type
== PT_NOTE
)
12031 res
&= process_corefile_note_segment (file
,
12032 (bfd_vma
) segment
->p_offset
,
12033 (bfd_vma
) segment
->p_filesz
);
12040 process_note_sections (FILE *file
)
12042 Elf_Internal_Shdr
*section
;
12046 for (i
= 0, section
= section_headers
;
12047 i
< elf_header
.e_shnum
;
12049 if (section
->sh_type
== SHT_NOTE
)
12050 res
&= process_corefile_note_segment (file
,
12051 (bfd_vma
) section
->sh_offset
,
12052 (bfd_vma
) section
->sh_size
);
12058 process_notes (FILE *file
)
12060 /* If we have not been asked to display the notes then do nothing. */
12064 if (elf_header
.e_type
!= ET_CORE
)
12065 return process_note_sections (file
);
12067 /* No program headers means no NOTE segment. */
12068 if (elf_header
.e_phnum
> 0)
12069 return process_corefile_note_segments (file
);
12071 printf (_("No note segments present in the core file.\n"));
12076 process_arch_specific (FILE *file
)
12081 switch (elf_header
.e_machine
)
12084 case EM_MIPS_RS3_LE
:
12085 return process_mips_specific (file
);
12094 get_file_header (FILE *file
)
12096 /* Read in the identity array. */
12097 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
12100 /* Determine how to read the rest of the header. */
12101 switch (elf_header
.e_ident
[EI_DATA
])
12103 default: /* fall through */
12104 case ELFDATANONE
: /* fall through */
12106 byte_get
= byte_get_little_endian
;
12107 byte_put
= byte_put_little_endian
;
12110 byte_get
= byte_get_big_endian
;
12111 byte_put
= byte_put_big_endian
;
12115 /* For now we only support 32 bit and 64 bit ELF files. */
12116 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
12118 /* Read in the rest of the header. */
12121 Elf32_External_Ehdr ehdr32
;
12123 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
12126 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
12127 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
12128 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
12129 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
12130 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
12131 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
12132 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
12133 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
12134 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
12135 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
12136 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
12137 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
12138 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
12142 Elf64_External_Ehdr ehdr64
;
12144 /* If we have been compiled with sizeof (bfd_vma) == 4, then
12145 we will not be able to cope with the 64bit data found in
12146 64 ELF files. Detect this now and abort before we start
12147 overwriting things. */
12148 if (sizeof (bfd_vma
) < 8)
12150 error (_("This instance of readelf has been built without support for a\n\
12151 64 bit data type and so it cannot read 64 bit ELF files.\n"));
12155 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
12158 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
12159 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
12160 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
12161 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
12162 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
12163 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
12164 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
12165 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
12166 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
12167 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
12168 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
12169 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
12170 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
12173 if (elf_header
.e_shoff
)
12175 /* There may be some extensions in the first section header. Don't
12176 bomb if we can't read it. */
12178 get_32bit_section_headers (file
, 1);
12180 get_64bit_section_headers (file
, 1);
12186 /* Process one ELF object file according to the command line options.
12187 This file may actually be stored in an archive. The file is
12188 positioned at the start of the ELF object. */
12191 process_object (char *file_name
, FILE *file
)
12195 if (! get_file_header (file
))
12197 error (_("%s: Failed to read file header\n"), file_name
);
12201 /* Initialise per file variables. */
12202 for (i
= NUM_ELEM (version_info
); i
--;)
12203 version_info
[i
] = 0;
12205 for (i
= NUM_ELEM (dynamic_info
); i
--;)
12206 dynamic_info
[i
] = 0;
12208 /* Process the file. */
12210 printf (_("\nFile: %s\n"), file_name
);
12212 /* Initialise the dump_sects array from the cmdline_dump_sects array.
12213 Note we do this even if cmdline_dump_sects is empty because we
12214 must make sure that the dump_sets array is zeroed out before each
12215 object file is processed. */
12216 if (num_dump_sects
> num_cmdline_dump_sects
)
12217 memset (dump_sects
, 0, num_dump_sects
);
12219 if (num_cmdline_dump_sects
> 0)
12221 if (num_dump_sects
== 0)
12222 /* A sneaky way of allocating the dump_sects array. */
12223 request_dump (num_cmdline_dump_sects
, 0);
12225 assert (num_dump_sects
>= num_cmdline_dump_sects
);
12226 memcpy (dump_sects
, cmdline_dump_sects
, num_cmdline_dump_sects
);
12229 if (! process_file_header ())
12232 if (! process_section_headers (file
))
12234 /* Without loaded section headers we cannot process lots of
12236 do_unwind
= do_version
= do_dump
= do_arch
= 0;
12238 if (! do_using_dynamic
)
12239 do_syms
= do_reloc
= 0;
12242 if (! process_section_groups (file
))
12244 /* Without loaded section groups we cannot process unwind. */
12248 if (process_program_headers (file
))
12249 process_dynamic_section (file
);
12251 process_relocs (file
);
12253 process_unwind (file
);
12255 process_symbol_table (file
);
12257 process_syminfo (file
);
12259 process_version_sections (file
);
12261 process_section_contents (file
);
12263 process_notes (file
);
12265 process_gnu_liblist (file
);
12267 process_arch_specific (file
);
12269 if (program_headers
)
12271 free (program_headers
);
12272 program_headers
= NULL
;
12275 if (section_headers
)
12277 free (section_headers
);
12278 section_headers
= NULL
;
12283 free (string_table
);
12284 string_table
= NULL
;
12285 string_table_length
= 0;
12288 if (dynamic_strings
)
12290 free (dynamic_strings
);
12291 dynamic_strings
= NULL
;
12292 dynamic_strings_length
= 0;
12295 if (dynamic_symbols
)
12297 free (dynamic_symbols
);
12298 dynamic_symbols
= NULL
;
12299 num_dynamic_syms
= 0;
12302 if (dynamic_syminfo
)
12304 free (dynamic_syminfo
);
12305 dynamic_syminfo
= NULL
;
12308 if (section_headers_groups
)
12310 free (section_headers_groups
);
12311 section_headers_groups
= NULL
;
12314 if (section_groups
)
12316 struct group_list
*g
, *next
;
12318 for (i
= 0; i
< group_count
; i
++)
12320 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
12327 free (section_groups
);
12328 section_groups
= NULL
;
12331 if (debug_information
)
12333 for (i
= 0; i
< num_debug_info_entries
; i
++)
12335 if (!debug_information
[i
].max_loc_offsets
)
12337 free (debug_information
[i
].loc_offsets
);
12338 free (debug_information
[i
].have_frame_base
);
12340 if (!debug_information
[i
].max_range_lists
)
12341 free (debug_information
[i
].range_lists
);
12343 free (debug_information
);
12344 debug_information
= NULL
;
12345 num_debug_info_entries
= 0;
12351 /* Process an ELF archive. The file is positioned just after the
12355 process_archive (char *file_name
, FILE *file
)
12357 struct ar_hdr arhdr
;
12359 unsigned long size
;
12360 char *longnames
= NULL
;
12361 unsigned long longnames_size
= 0;
12362 size_t file_name_size
;
12367 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12368 if (got
!= sizeof arhdr
)
12373 error (_("%s: failed to read archive header\n"), file_name
);
12377 if (memcmp (arhdr
.ar_name
, "/ ", 16) == 0)
12379 /* This is the archive symbol table. Skip it.
12380 FIXME: We should have an option to dump it. */
12381 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
12382 if (fseek (file
, size
+ (size
& 1), SEEK_CUR
) != 0)
12384 error (_("%s: failed to skip archive symbol table\n"), file_name
);
12388 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12389 if (got
!= sizeof arhdr
)
12394 error (_("%s: failed to read archive header\n"), file_name
);
12399 if (memcmp (arhdr
.ar_name
, "// ", 16) == 0)
12401 /* This is the archive string table holding long member
12404 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
12406 longnames
= malloc (longnames_size
);
12407 if (longnames
== NULL
)
12409 error (_("Out of memory\n"));
12413 if (fread (longnames
, longnames_size
, 1, file
) != 1)
12416 error (_("%s: failed to read string table\n"), file_name
);
12420 if ((longnames_size
& 1) != 0)
12423 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12424 if (got
!= sizeof arhdr
)
12431 error (_("%s: failed to read archive header\n"), file_name
);
12436 file_name_size
= strlen (file_name
);
12445 if (arhdr
.ar_name
[0] == '/')
12449 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
12450 if (off
>= longnames_size
)
12452 error (_("%s: invalid archive string table offset %lu\n"), file_name
, off
);
12457 name
= longnames
+ off
;
12458 nameend
= memchr (name
, '/', longnames_size
- off
);
12462 name
= arhdr
.ar_name
;
12463 nameend
= memchr (name
, '/', 16);
12466 if (nameend
== NULL
)
12468 error (_("%s: bad archive file name\n"), file_name
);
12473 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
12474 if (namealc
== NULL
)
12476 error (_("Out of memory\n"));
12481 memcpy (namealc
, file_name
, file_name_size
);
12482 namealc
[file_name_size
] = '(';
12483 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
12484 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
12485 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
12487 archive_file_offset
= ftell (file
);
12488 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
12490 ret
|= process_object (namealc
, file
);
12495 (archive_file_offset
12496 + archive_file_size
12497 + (archive_file_size
& 1)),
12500 error (_("%s: failed to seek to next archive header\n"), file_name
);
12505 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12506 if (got
!= sizeof arhdr
)
12511 error (_("%s: failed to read archive header\n"), file_name
);
12517 if (longnames
!= 0)
12524 process_file (char *file_name
)
12527 struct stat statbuf
;
12528 char armag
[SARMAG
];
12531 if (stat (file_name
, &statbuf
) < 0)
12533 if (errno
== ENOENT
)
12534 error (_("'%s': No such file\n"), file_name
);
12536 error (_("Could not locate '%s'. System error message: %s\n"),
12537 file_name
, strerror (errno
));
12541 if (! S_ISREG (statbuf
.st_mode
))
12543 error (_("'%s' is not an ordinary file\n"), file_name
);
12547 file
= fopen (file_name
, "rb");
12550 error (_("Input file '%s' is not readable.\n"), file_name
);
12554 if (fread (armag
, SARMAG
, 1, file
) != 1)
12556 error (_("%s: Failed to read file header\n"), file_name
);
12561 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
12562 ret
= process_archive (file_name
, file
);
12566 archive_file_size
= archive_file_offset
= 0;
12567 ret
= process_object (file_name
, file
);
12575 #ifdef SUPPORT_DISASSEMBLY
12576 /* Needed by the i386 disassembler. For extra credit, someone could
12577 fix this so that we insert symbolic addresses here, esp for GOT/PLT
12581 print_address (unsigned int addr
, FILE *outfile
)
12583 fprintf (outfile
,"0x%8.8x", addr
);
12586 /* Needed by the i386 disassembler. */
12588 db_task_printsym (unsigned int addr
)
12590 print_address (addr
, stderr
);
12595 main (int argc
, char **argv
)
12599 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
12600 setlocale (LC_MESSAGES
, "");
12602 #if defined (HAVE_SETLOCALE)
12603 setlocale (LC_CTYPE
, "");
12605 bindtextdomain (PACKAGE
, LOCALEDIR
);
12606 textdomain (PACKAGE
);
12608 parse_args (argc
, argv
);
12610 if (num_dump_sects
> 0)
12612 /* Make a copy of the dump_sects array. */
12613 cmdline_dump_sects
= malloc (num_dump_sects
);
12614 if (cmdline_dump_sects
== NULL
)
12615 error (_("Out of memory allocating dump request table."));
12618 memcpy (cmdline_dump_sects
, dump_sects
, num_dump_sects
);
12619 num_cmdline_dump_sects
= num_dump_sects
;
12623 if (optind
< (argc
- 1))
12627 while (optind
< argc
)
12628 err
|= process_file (argv
[optind
++]);
12630 if (dump_sects
!= NULL
)
12632 if (cmdline_dump_sects
!= NULL
)
12633 free (cmdline_dump_sects
);