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_full_section_name
;
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";
1542 get_ia64_dynamic_type (unsigned long type
)
1546 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1553 get_alpha_dynamic_type (unsigned long type
)
1557 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1564 get_dynamic_type (unsigned long type
)
1566 static char buff
[64];
1570 case DT_NULL
: return "NULL";
1571 case DT_NEEDED
: return "NEEDED";
1572 case DT_PLTRELSZ
: return "PLTRELSZ";
1573 case DT_PLTGOT
: return "PLTGOT";
1574 case DT_HASH
: return "HASH";
1575 case DT_STRTAB
: return "STRTAB";
1576 case DT_SYMTAB
: return "SYMTAB";
1577 case DT_RELA
: return "RELA";
1578 case DT_RELASZ
: return "RELASZ";
1579 case DT_RELAENT
: return "RELAENT";
1580 case DT_STRSZ
: return "STRSZ";
1581 case DT_SYMENT
: return "SYMENT";
1582 case DT_INIT
: return "INIT";
1583 case DT_FINI
: return "FINI";
1584 case DT_SONAME
: return "SONAME";
1585 case DT_RPATH
: return "RPATH";
1586 case DT_SYMBOLIC
: return "SYMBOLIC";
1587 case DT_REL
: return "REL";
1588 case DT_RELSZ
: return "RELSZ";
1589 case DT_RELENT
: return "RELENT";
1590 case DT_PLTREL
: return "PLTREL";
1591 case DT_DEBUG
: return "DEBUG";
1592 case DT_TEXTREL
: return "TEXTREL";
1593 case DT_JMPREL
: return "JMPREL";
1594 case DT_BIND_NOW
: return "BIND_NOW";
1595 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1596 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1597 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1598 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1599 case DT_RUNPATH
: return "RUNPATH";
1600 case DT_FLAGS
: return "FLAGS";
1602 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1603 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1605 case DT_CHECKSUM
: return "CHECKSUM";
1606 case DT_PLTPADSZ
: return "PLTPADSZ";
1607 case DT_MOVEENT
: return "MOVEENT";
1608 case DT_MOVESZ
: return "MOVESZ";
1609 case DT_FEATURE
: return "FEATURE";
1610 case DT_POSFLAG_1
: return "POSFLAG_1";
1611 case DT_SYMINSZ
: return "SYMINSZ";
1612 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1614 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1615 case DT_CONFIG
: return "CONFIG";
1616 case DT_DEPAUDIT
: return "DEPAUDIT";
1617 case DT_AUDIT
: return "AUDIT";
1618 case DT_PLTPAD
: return "PLTPAD";
1619 case DT_MOVETAB
: return "MOVETAB";
1620 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1622 case DT_VERSYM
: return "VERSYM";
1624 case DT_RELACOUNT
: return "RELACOUNT";
1625 case DT_RELCOUNT
: return "RELCOUNT";
1626 case DT_FLAGS_1
: return "FLAGS_1";
1627 case DT_VERDEF
: return "VERDEF";
1628 case DT_VERDEFNUM
: return "VERDEFNUM";
1629 case DT_VERNEED
: return "VERNEED";
1630 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1632 case DT_AUXILIARY
: return "AUXILIARY";
1633 case DT_USED
: return "USED";
1634 case DT_FILTER
: return "FILTER";
1636 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1637 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1638 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1639 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1640 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1643 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1647 switch (elf_header
.e_machine
)
1650 case EM_MIPS_RS3_LE
:
1651 result
= get_mips_dynamic_type (type
);
1654 result
= get_sparc64_dynamic_type (type
);
1657 result
= get_ppc_dynamic_type (type
);
1660 result
= get_ppc64_dynamic_type (type
);
1663 result
= get_ia64_dynamic_type (type
);
1666 result
= get_alpha_dynamic_type (type
);
1676 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1678 else if ((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1682 switch (elf_header
.e_machine
)
1685 result
= get_parisc_dynamic_type (type
);
1695 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1699 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1706 get_file_type (unsigned e_type
)
1708 static char buff
[32];
1712 case ET_NONE
: return _("NONE (None)");
1713 case ET_REL
: return _("REL (Relocatable file)");
1714 case ET_EXEC
: return _("EXEC (Executable file)");
1715 case ET_DYN
: return _("DYN (Shared object file)");
1716 case ET_CORE
: return _("CORE (Core file)");
1719 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1720 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1721 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1722 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1724 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1730 get_machine_name (unsigned e_machine
)
1732 static char buff
[64]; /* XXX */
1736 case EM_NONE
: return _("None");
1737 case EM_M32
: return "WE32100";
1738 case EM_SPARC
: return "Sparc";
1739 case EM_386
: return "Intel 80386";
1740 case EM_68K
: return "MC68000";
1741 case EM_88K
: return "MC88000";
1742 case EM_486
: return "Intel 80486";
1743 case EM_860
: return "Intel 80860";
1744 case EM_MIPS
: return "MIPS R3000";
1745 case EM_S370
: return "IBM System/370";
1746 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1747 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1748 case EM_PARISC
: return "HPPA";
1749 case EM_PPC_OLD
: return "Power PC (old)";
1750 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1751 case EM_960
: return "Intel 90860";
1752 case EM_PPC
: return "PowerPC";
1753 case EM_PPC64
: return "PowerPC64";
1754 case EM_V800
: return "NEC V800";
1755 case EM_FR20
: return "Fujitsu FR20";
1756 case EM_RH32
: return "TRW RH32";
1757 case EM_MCORE
: return "MCORE";
1758 case EM_ARM
: return "ARM";
1759 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1760 case EM_SH
: return "Renesas / SuperH SH";
1761 case EM_SPARCV9
: return "Sparc v9";
1762 case EM_TRICORE
: return "Siemens Tricore";
1763 case EM_ARC
: return "ARC";
1764 case EM_H8_300
: return "Renesas H8/300";
1765 case EM_H8_300H
: return "Renesas H8/300H";
1766 case EM_H8S
: return "Renesas H8S";
1767 case EM_H8_500
: return "Renesas H8/500";
1768 case EM_IA_64
: return "Intel IA-64";
1769 case EM_MIPS_X
: return "Stanford MIPS-X";
1770 case EM_COLDFIRE
: return "Motorola Coldfire";
1771 case EM_68HC12
: return "Motorola M68HC12";
1772 case EM_ALPHA
: return "Alpha";
1773 case EM_CYGNUS_D10V
:
1774 case EM_D10V
: return "d10v";
1775 case EM_CYGNUS_D30V
:
1776 case EM_D30V
: return "d30v";
1777 case EM_CYGNUS_M32R
:
1778 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1779 case EM_CYGNUS_V850
:
1780 case EM_V850
: return "NEC v850";
1781 case EM_CYGNUS_MN10300
:
1782 case EM_MN10300
: return "mn10300";
1783 case EM_CYGNUS_MN10200
:
1784 case EM_MN10200
: return "mn10200";
1785 case EM_CYGNUS_FR30
:
1786 case EM_FR30
: return "Fujitsu FR30";
1787 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1789 case EM_PJ
: return "picoJava";
1790 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1791 case EM_PCP
: return "Siemens PCP";
1792 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1793 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1794 case EM_STARCORE
: return "Motorola Star*Core processor";
1795 case EM_ME16
: return "Toyota ME16 processor";
1796 case EM_ST100
: return "STMicroelectronics ST100 processor";
1797 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1798 case EM_FX66
: return "Siemens FX66 microcontroller";
1799 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1800 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1801 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1802 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1803 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1804 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1805 case EM_SVX
: return "Silicon Graphics SVx";
1806 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1807 case EM_VAX
: return "Digital VAX";
1809 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1810 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1811 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1812 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1813 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1814 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1815 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1816 case EM_PRISM
: return "Vitesse Prism";
1817 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1819 case EM_S390
: return "IBM S/390";
1820 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1822 case EM_OR32
: return "OpenRISC";
1823 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1824 case EM_DLX
: return "OpenDLX";
1826 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1827 case EM_IQ2000
: return "Vitesse IQ2000";
1829 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1830 case EM_M32C
: return "Renesas M32c";
1831 case EM_MS1
: return "Morpho Techologies MS1 processor";
1833 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_machine
);
1839 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
1844 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1845 e_flags
&= ~ EF_ARM_EABIMASK
;
1847 /* Handle "generic" ARM flags. */
1848 if (e_flags
& EF_ARM_RELEXEC
)
1850 strcat (buf
, ", relocatable executable");
1851 e_flags
&= ~ EF_ARM_RELEXEC
;
1854 if (e_flags
& EF_ARM_HASENTRY
)
1856 strcat (buf
, ", has entry point");
1857 e_flags
&= ~ EF_ARM_HASENTRY
;
1860 /* Now handle EABI specific flags. */
1864 strcat (buf
, ", <unrecognized EABI>");
1869 case EF_ARM_EABI_VER1
:
1870 strcat (buf
, ", Version1 EABI");
1875 /* Process flags one bit at a time. */
1876 flag
= e_flags
& - e_flags
;
1881 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1882 strcat (buf
, ", sorted symbol tables");
1892 case EF_ARM_EABI_VER2
:
1893 strcat (buf
, ", Version2 EABI");
1898 /* Process flags one bit at a time. */
1899 flag
= e_flags
& - e_flags
;
1904 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1905 strcat (buf
, ", sorted symbol tables");
1908 case EF_ARM_DYNSYMSUSESEGIDX
:
1909 strcat (buf
, ", dynamic symbols use segment index");
1912 case EF_ARM_MAPSYMSFIRST
:
1913 strcat (buf
, ", mapping symbols precede others");
1923 case EF_ARM_EABI_VER3
:
1924 strcat (buf
, ", Version3 EABI");
1927 case EF_ARM_EABI_VER4
:
1928 strcat (buf
, ", Version4 EABI");
1933 /* Process flags one bit at a time. */
1934 flag
= e_flags
& - e_flags
;
1940 strcat (buf
, ", BE8");
1944 strcat (buf
, ", LE8");
1954 case EF_ARM_EABI_UNKNOWN
:
1955 strcat (buf
, ", GNU EABI");
1960 /* Process flags one bit at a time. */
1961 flag
= e_flags
& - e_flags
;
1966 case EF_ARM_INTERWORK
:
1967 strcat (buf
, ", interworking enabled");
1970 case EF_ARM_APCS_26
:
1971 strcat (buf
, ", uses APCS/26");
1974 case EF_ARM_APCS_FLOAT
:
1975 strcat (buf
, ", uses APCS/float");
1979 strcat (buf
, ", position independent");
1983 strcat (buf
, ", 8 bit structure alignment");
1986 case EF_ARM_NEW_ABI
:
1987 strcat (buf
, ", uses new ABI");
1990 case EF_ARM_OLD_ABI
:
1991 strcat (buf
, ", uses old ABI");
1994 case EF_ARM_SOFT_FLOAT
:
1995 strcat (buf
, ", software FP");
1998 case EF_ARM_VFP_FLOAT
:
1999 strcat (buf
, ", VFP");
2002 case EF_ARM_MAVERICK_FLOAT
:
2003 strcat (buf
, ", Maverick FP");
2014 strcat (buf
,", <unknown>");
2018 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2020 static char buf
[1024];
2032 decode_ARM_machine_flags (e_flags
, buf
);
2036 switch (e_flags
& EF_FRV_CPU_MASK
)
2038 case EF_FRV_CPU_GENERIC
:
2042 strcat (buf
, ", fr???");
2045 case EF_FRV_CPU_FR300
:
2046 strcat (buf
, ", fr300");
2049 case EF_FRV_CPU_FR400
:
2050 strcat (buf
, ", fr400");
2052 case EF_FRV_CPU_FR405
:
2053 strcat (buf
, ", fr405");
2056 case EF_FRV_CPU_FR450
:
2057 strcat (buf
, ", fr450");
2060 case EF_FRV_CPU_FR500
:
2061 strcat (buf
, ", fr500");
2063 case EF_FRV_CPU_FR550
:
2064 strcat (buf
, ", fr550");
2067 case EF_FRV_CPU_SIMPLE
:
2068 strcat (buf
, ", simple");
2070 case EF_FRV_CPU_TOMCAT
:
2071 strcat (buf
, ", tomcat");
2077 if (e_flags
& EF_CPU32
)
2078 strcat (buf
, ", cpu32");
2079 if (e_flags
& EF_M68000
)
2080 strcat (buf
, ", m68000");
2084 if (e_flags
& EF_PPC_EMB
)
2085 strcat (buf
, ", emb");
2087 if (e_flags
& EF_PPC_RELOCATABLE
)
2088 strcat (buf
, ", relocatable");
2090 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2091 strcat (buf
, ", relocatable-lib");
2095 case EM_CYGNUS_V850
:
2096 switch (e_flags
& EF_V850_ARCH
)
2099 strcat (buf
, ", v850e1");
2102 strcat (buf
, ", v850e");
2105 strcat (buf
, ", v850");
2108 strcat (buf
, ", unknown v850 architecture variant");
2114 case EM_CYGNUS_M32R
:
2115 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2116 strcat (buf
, ", m32r");
2121 case EM_MIPS_RS3_LE
:
2122 if (e_flags
& EF_MIPS_NOREORDER
)
2123 strcat (buf
, ", noreorder");
2125 if (e_flags
& EF_MIPS_PIC
)
2126 strcat (buf
, ", pic");
2128 if (e_flags
& EF_MIPS_CPIC
)
2129 strcat (buf
, ", cpic");
2131 if (e_flags
& EF_MIPS_UCODE
)
2132 strcat (buf
, ", ugen_reserved");
2134 if (e_flags
& EF_MIPS_ABI2
)
2135 strcat (buf
, ", abi2");
2137 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2138 strcat (buf
, ", odk first");
2140 if (e_flags
& EF_MIPS_32BITMODE
)
2141 strcat (buf
, ", 32bitmode");
2143 switch ((e_flags
& EF_MIPS_MACH
))
2145 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2146 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2147 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2148 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2149 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2150 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2151 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2152 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2153 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2154 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2156 /* We simply ignore the field in this case to avoid confusion:
2157 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2160 default: strcat (buf
, ", unknown CPU"); break;
2163 switch ((e_flags
& EF_MIPS_ABI
))
2165 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2166 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2167 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2168 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2170 /* We simply ignore the field in this case to avoid confusion:
2171 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2172 This means it is likely to be an o32 file, but not for
2175 default: strcat (buf
, ", unknown ABI"); break;
2178 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2179 strcat (buf
, ", mdmx");
2181 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2182 strcat (buf
, ", mips16");
2184 switch ((e_flags
& EF_MIPS_ARCH
))
2186 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2187 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2188 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2189 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2190 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2191 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2192 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2193 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2194 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2195 default: strcat (buf
, ", unknown ISA"); break;
2201 switch ((e_flags
& EF_SH_MACH_MASK
))
2203 case EF_SH1
: strcat (buf
, ", sh1"); break;
2204 case EF_SH2
: strcat (buf
, ", sh2"); break;
2205 case EF_SH3
: strcat (buf
, ", sh3"); break;
2206 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2207 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2208 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2209 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2210 case EF_SH4
: strcat (buf
, ", sh4"); break;
2211 case EF_SH5
: strcat (buf
, ", sh5"); break;
2212 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2213 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2214 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2215 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2216 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2217 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2218 default: strcat (buf
, ", unknown ISA"); break;
2224 if (e_flags
& EF_SPARC_32PLUS
)
2225 strcat (buf
, ", v8+");
2227 if (e_flags
& EF_SPARC_SUN_US1
)
2228 strcat (buf
, ", ultrasparcI");
2230 if (e_flags
& EF_SPARC_SUN_US3
)
2231 strcat (buf
, ", ultrasparcIII");
2233 if (e_flags
& EF_SPARC_HAL_R1
)
2234 strcat (buf
, ", halr1");
2236 if (e_flags
& EF_SPARC_LEDATA
)
2237 strcat (buf
, ", ledata");
2239 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2240 strcat (buf
, ", tso");
2242 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2243 strcat (buf
, ", pso");
2245 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2246 strcat (buf
, ", rmo");
2250 switch (e_flags
& EF_PARISC_ARCH
)
2252 case EFA_PARISC_1_0
:
2253 strcpy (buf
, ", PA-RISC 1.0");
2255 case EFA_PARISC_1_1
:
2256 strcpy (buf
, ", PA-RISC 1.1");
2258 case EFA_PARISC_2_0
:
2259 strcpy (buf
, ", PA-RISC 2.0");
2264 if (e_flags
& EF_PARISC_TRAPNIL
)
2265 strcat (buf
, ", trapnil");
2266 if (e_flags
& EF_PARISC_EXT
)
2267 strcat (buf
, ", ext");
2268 if (e_flags
& EF_PARISC_LSB
)
2269 strcat (buf
, ", lsb");
2270 if (e_flags
& EF_PARISC_WIDE
)
2271 strcat (buf
, ", wide");
2272 if (e_flags
& EF_PARISC_NO_KABP
)
2273 strcat (buf
, ", no kabp");
2274 if (e_flags
& EF_PARISC_LAZYSWAP
)
2275 strcat (buf
, ", lazyswap");
2280 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2281 strcat (buf
, ", new calling convention");
2283 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2284 strcat (buf
, ", gnu calling convention");
2288 if ((e_flags
& EF_IA_64_ABI64
))
2289 strcat (buf
, ", 64-bit");
2291 strcat (buf
, ", 32-bit");
2292 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2293 strcat (buf
, ", reduced fp model");
2294 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2295 strcat (buf
, ", no function descriptors, constant gp");
2296 else if ((e_flags
& EF_IA_64_CONS_GP
))
2297 strcat (buf
, ", constant gp");
2298 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2299 strcat (buf
, ", absolute");
2303 if ((e_flags
& EF_VAX_NONPIC
))
2304 strcat (buf
, ", non-PIC");
2305 if ((e_flags
& EF_VAX_DFLOAT
))
2306 strcat (buf
, ", D-Float");
2307 if ((e_flags
& EF_VAX_GFLOAT
))
2308 strcat (buf
, ", G-Float");
2317 get_osabi_name (unsigned int osabi
)
2319 static char buff
[32];
2323 case ELFOSABI_NONE
: return "UNIX - System V";
2324 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2325 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2326 case ELFOSABI_LINUX
: return "UNIX - Linux";
2327 case ELFOSABI_HURD
: return "GNU/Hurd";
2328 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2329 case ELFOSABI_AIX
: return "UNIX - AIX";
2330 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2331 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2332 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2333 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2334 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2335 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2336 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2337 case ELFOSABI_AROS
: return "Amiga Research OS";
2338 case ELFOSABI_STANDALONE
: return _("Standalone App");
2339 case ELFOSABI_ARM
: return "ARM";
2341 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2347 get_arm_segment_type (unsigned long type
)
2361 get_mips_segment_type (unsigned long type
)
2365 case PT_MIPS_REGINFO
:
2367 case PT_MIPS_RTPROC
:
2369 case PT_MIPS_OPTIONS
:
2379 get_parisc_segment_type (unsigned long type
)
2383 case PT_HP_TLS
: return "HP_TLS";
2384 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2385 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2386 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2387 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2388 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2389 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2390 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2391 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2392 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2393 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2394 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2395 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2396 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2405 get_ia64_segment_type (unsigned long type
)
2409 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2410 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2411 case PT_HP_TLS
: return "HP_TLS";
2412 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2413 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2414 case PT_IA_64_HP_STACK
: return "HP_STACK";
2423 get_segment_type (unsigned long p_type
)
2425 static char buff
[32];
2429 case PT_NULL
: return "NULL";
2430 case PT_LOAD
: return "LOAD";
2431 case PT_DYNAMIC
: return "DYNAMIC";
2432 case PT_INTERP
: return "INTERP";
2433 case PT_NOTE
: return "NOTE";
2434 case PT_SHLIB
: return "SHLIB";
2435 case PT_PHDR
: return "PHDR";
2436 case PT_TLS
: return "TLS";
2438 case PT_GNU_EH_FRAME
:
2439 return "GNU_EH_FRAME";
2440 case PT_GNU_STACK
: return "GNU_STACK";
2441 case PT_GNU_RELRO
: return "GNU_RELRO";
2444 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2448 switch (elf_header
.e_machine
)
2451 result
= get_arm_segment_type (p_type
);
2454 case EM_MIPS_RS3_LE
:
2455 result
= get_mips_segment_type (p_type
);
2458 result
= get_parisc_segment_type (p_type
);
2461 result
= get_ia64_segment_type (p_type
);
2471 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2473 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2477 switch (elf_header
.e_machine
)
2480 result
= get_parisc_segment_type (p_type
);
2483 result
= get_ia64_segment_type (p_type
);
2493 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2496 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2503 get_mips_section_type_name (unsigned int sh_type
)
2507 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2508 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2509 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2510 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2511 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2512 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2513 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2514 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2515 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2516 case SHT_MIPS_RELD
: return "MIPS_RELD";
2517 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2518 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2519 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2520 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2521 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2522 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2523 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2524 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2525 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2526 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2527 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2528 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2529 case SHT_MIPS_LINE
: return "MIPS_LINE";
2530 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2531 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2532 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2533 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2534 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2535 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2536 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2537 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2538 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2539 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2540 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2541 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2542 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2543 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2544 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2545 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2553 get_parisc_section_type_name (unsigned int sh_type
)
2557 case SHT_PARISC_EXT
: return "PARISC_EXT";
2558 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2559 case SHT_PARISC_DOC
: return "PARISC_DOC";
2567 get_ia64_section_type_name (unsigned int sh_type
)
2569 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2570 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2571 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2575 case SHT_IA_64_EXT
: return "IA_64_EXT";
2576 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2577 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2585 get_x86_64_section_type_name (unsigned int sh_type
)
2589 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2597 get_arm_section_type_name (unsigned int sh_type
)
2610 get_section_type_name (unsigned int sh_type
)
2612 static char buff
[32];
2616 case SHT_NULL
: return "NULL";
2617 case SHT_PROGBITS
: return "PROGBITS";
2618 case SHT_SYMTAB
: return "SYMTAB";
2619 case SHT_STRTAB
: return "STRTAB";
2620 case SHT_RELA
: return "RELA";
2621 case SHT_HASH
: return "HASH";
2622 case SHT_DYNAMIC
: return "DYNAMIC";
2623 case SHT_NOTE
: return "NOTE";
2624 case SHT_NOBITS
: return "NOBITS";
2625 case SHT_REL
: return "REL";
2626 case SHT_SHLIB
: return "SHLIB";
2627 case SHT_DYNSYM
: return "DYNSYM";
2628 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2629 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2630 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2631 case SHT_GROUP
: return "GROUP";
2632 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2633 case SHT_GNU_verdef
: return "VERDEF";
2634 case SHT_GNU_verneed
: return "VERNEED";
2635 case SHT_GNU_versym
: return "VERSYM";
2636 case 0x6ffffff0: return "VERSYM";
2637 case 0x6ffffffc: return "VERDEF";
2638 case 0x7ffffffd: return "AUXILIARY";
2639 case 0x7fffffff: return "FILTER";
2640 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2643 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2647 switch (elf_header
.e_machine
)
2650 case EM_MIPS_RS3_LE
:
2651 result
= get_mips_section_type_name (sh_type
);
2654 result
= get_parisc_section_type_name (sh_type
);
2657 result
= get_ia64_section_type_name (sh_type
);
2660 result
= get_x86_64_section_type_name (sh_type
);
2663 result
= get_arm_section_type_name (sh_type
);
2673 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2675 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2676 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2677 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2678 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2680 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
2686 #define OPTION_DEBUG_DUMP 512
2688 static struct option options
[] =
2690 {"all", no_argument
, 0, 'a'},
2691 {"file-header", no_argument
, 0, 'h'},
2692 {"program-headers", no_argument
, 0, 'l'},
2693 {"headers", no_argument
, 0, 'e'},
2694 {"histogram", no_argument
, 0, 'I'},
2695 {"segments", no_argument
, 0, 'l'},
2696 {"sections", no_argument
, 0, 'S'},
2697 {"section-headers", no_argument
, 0, 'S'},
2698 {"section-groups", no_argument
, 0, 'g'},
2699 {"full-section-name",no_argument
, 0, 'N'},
2700 {"symbols", no_argument
, 0, 's'},
2701 {"syms", no_argument
, 0, 's'},
2702 {"relocs", no_argument
, 0, 'r'},
2703 {"notes", no_argument
, 0, 'n'},
2704 {"dynamic", no_argument
, 0, 'd'},
2705 {"arch-specific", no_argument
, 0, 'A'},
2706 {"version-info", no_argument
, 0, 'V'},
2707 {"use-dynamic", no_argument
, 0, 'D'},
2708 {"hex-dump", required_argument
, 0, 'x'},
2709 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2710 {"unwind", no_argument
, 0, 'u'},
2711 #ifdef SUPPORT_DISASSEMBLY
2712 {"instruction-dump", required_argument
, 0, 'i'},
2715 {"version", no_argument
, 0, 'v'},
2716 {"wide", no_argument
, 0, 'W'},
2717 {"help", no_argument
, 0, 'H'},
2718 {0, no_argument
, 0, 0}
2724 fprintf (stdout
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2725 fprintf (stdout
, _(" Display information about the contents of ELF format files\n"));
2726 fprintf (stdout
, _(" Options are:\n\
2727 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2728 -h --file-header Display the ELF file header\n\
2729 -l --program-headers Display the program headers\n\
2730 --segments An alias for --program-headers\n\
2731 -S --section-headers Display the sections' header\n\
2732 --sections An alias for --section-headers\n\
2733 -g --section-groups Display the section groups\n\
2734 -N --full-section-name\n\
2735 Display the full section name\n\
2736 -e --headers Equivalent to: -h -l -S\n\
2737 -s --syms Display the symbol table\n\
2738 --symbols An alias for --syms\n\
2739 -n --notes Display the core notes (if present)\n\
2740 -r --relocs Display the relocations (if present)\n\
2741 -u --unwind Display the unwind info (if present)\n\
2742 -d --dynamic Display the dynamic section (if present)\n\
2743 -V --version-info Display the version sections (if present)\n\
2744 -A --arch-specific Display architecture specific information (if any).\n\
2745 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2746 -x --hex-dump=<number> Dump the contents of section <number>\n\
2747 -w[liaprmfFsoR] or\n\
2748 --debug-dump[=line,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
2749 Display the contents of DWARF2 debug sections\n"));
2750 #ifdef SUPPORT_DISASSEMBLY
2751 fprintf (stdout
, _("\
2752 -i --instruction-dump=<number>\n\
2753 Disassemble the contents of section <number>\n"));
2755 fprintf (stdout
, _("\
2756 -I --histogram Display histogram of bucket list lengths\n\
2757 -W --wide Allow output width to exceed 80 characters\n\
2758 -H --help Display this information\n\
2759 -v --version Display the version number of readelf\n"));
2760 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2765 /* Record the fact that the user wants the contents of section number
2766 SECTION to be displayed using the method(s) encoded as flags bits
2767 in TYPE. Note, TYPE can be zero if we are creating the array for
2771 request_dump (unsigned int section
, int type
)
2773 if (section
>= num_dump_sects
)
2775 char *new_dump_sects
;
2777 new_dump_sects
= calloc (section
+ 1, 1);
2779 if (new_dump_sects
== NULL
)
2780 error (_("Out of memory allocating dump request table."));
2783 /* Copy current flag settings. */
2784 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2788 dump_sects
= new_dump_sects
;
2789 num_dump_sects
= section
+ 1;
2794 dump_sects
[section
] |= type
;
2800 parse_args (int argc
, char **argv
)
2807 while ((c
= getopt_long
2808 (argc
, argv
, "ersuahnldSDAINgw::x:i:vVWH", options
, NULL
)) != EOF
)
2829 do_section_groups
++;
2837 do_section_groups
++;
2840 do_full_section_name
++;
2882 section
= strtoul (optarg
, & cp
, 0);
2883 if (! *cp
&& section
>= 0)
2885 request_dump (section
, HEX_DUMP
);
2895 unsigned int index
= 0;
2899 while (optarg
[index
])
2900 switch (optarg
[index
++])
2909 do_debug_abbrevs
= 1;
2919 do_debug_pubnames
= 1;
2923 do_debug_aranges
= 1;
2927 do_debug_ranges
= 1;
2931 do_debug_frames_interp
= 1;
2933 do_debug_frames
= 1;
2938 do_debug_macinfo
= 1;
2952 warn (_("Unrecognized debug option '%s'\n"), optarg
);
2957 case OPTION_DEBUG_DUMP
:
2965 const char * option
;
2968 debug_dump_long_opts
;
2970 debug_dump_long_opts opts_table
[] =
2972 /* Please keep this table alpha- sorted. */
2973 { "Ranges", & do_debug_ranges
},
2974 { "abbrev", & do_debug_abbrevs
},
2975 { "aranges", & do_debug_aranges
},
2976 { "frames", & do_debug_frames
},
2977 { "frames-interp", & do_debug_frames_interp
},
2978 { "info", & do_debug_info
},
2979 { "line", & do_debug_lines
},
2980 { "loc", & do_debug_loc
},
2981 { "macro", & do_debug_macinfo
},
2982 { "pubnames", & do_debug_pubnames
},
2983 /* This entry is for compatability
2984 with earlier versions of readelf. */
2985 { "ranges", & do_debug_aranges
},
2986 { "str", & do_debug_str
},
2997 debug_dump_long_opts
* entry
;
2999 for (entry
= opts_table
; entry
->option
; entry
++)
3001 size_t len
= strlen (entry
->option
);
3003 if (strneq (p
, entry
->option
, len
)
3004 && (p
[len
] == ',' || p
[len
] == '\0'))
3006 * entry
->variable
= 1;
3008 /* The --debug-dump=frames-interp option also
3009 enables the --debug-dump=frames option. */
3010 if (do_debug_frames_interp
)
3011 do_debug_frames
= 1;
3018 if (entry
->option
== NULL
)
3020 warn (_("Unrecognized debug option '%s'\n"), p
);
3021 p
= strchr (p
, ',');
3031 #ifdef SUPPORT_DISASSEMBLY
3034 section
= strtoul (optarg
, & cp
, 0);
3035 if (! *cp
&& section
>= 0)
3037 request_dump (section
, DISASS_DUMP
);
3043 print_version (program_name
);
3053 /* xgettext:c-format */
3054 error (_("Invalid option '-%c'\n"), c
);
3061 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3062 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3063 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3064 && !do_section_groups
)
3068 warn (_("Nothing to do.\n"));
3074 get_elf_class (unsigned int elf_class
)
3076 static char buff
[32];
3080 case ELFCLASSNONE
: return _("none");
3081 case ELFCLASS32
: return "ELF32";
3082 case ELFCLASS64
: return "ELF64";
3084 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3090 get_data_encoding (unsigned int encoding
)
3092 static char buff
[32];
3096 case ELFDATANONE
: return _("none");
3097 case ELFDATA2LSB
: return _("2's complement, little endian");
3098 case ELFDATA2MSB
: return _("2's complement, big endian");
3100 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3105 /* Decode the data held in 'elf_header'. */
3108 process_file_header (void)
3110 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3111 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3112 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3113 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3116 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3124 printf (_("ELF Header:\n"));
3125 printf (_(" Magic: "));
3126 for (i
= 0; i
< EI_NIDENT
; i
++)
3127 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3129 printf (_(" Class: %s\n"),
3130 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3131 printf (_(" Data: %s\n"),
3132 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3133 printf (_(" Version: %d %s\n"),
3134 elf_header
.e_ident
[EI_VERSION
],
3135 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3137 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3140 printf (_(" OS/ABI: %s\n"),
3141 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3142 printf (_(" ABI Version: %d\n"),
3143 elf_header
.e_ident
[EI_ABIVERSION
]);
3144 printf (_(" Type: %s\n"),
3145 get_file_type (elf_header
.e_type
));
3146 printf (_(" Machine: %s\n"),
3147 get_machine_name (elf_header
.e_machine
));
3148 printf (_(" Version: 0x%lx\n"),
3149 (unsigned long) elf_header
.e_version
);
3151 printf (_(" Entry point address: "));
3152 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3153 printf (_("\n Start of program headers: "));
3154 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3155 printf (_(" (bytes into file)\n Start of section headers: "));
3156 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3157 printf (_(" (bytes into file)\n"));
3159 printf (_(" Flags: 0x%lx%s\n"),
3160 (unsigned long) elf_header
.e_flags
,
3161 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3162 printf (_(" Size of this header: %ld (bytes)\n"),
3163 (long) elf_header
.e_ehsize
);
3164 printf (_(" Size of program headers: %ld (bytes)\n"),
3165 (long) elf_header
.e_phentsize
);
3166 printf (_(" Number of program headers: %ld\n"),
3167 (long) elf_header
.e_phnum
);
3168 printf (_(" Size of section headers: %ld (bytes)\n"),
3169 (long) elf_header
.e_shentsize
);
3170 printf (_(" Number of section headers: %ld"),
3171 (long) elf_header
.e_shnum
);
3172 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
3173 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3174 putc ('\n', stdout
);
3175 printf (_(" Section header string table index: %ld"),
3176 (long) elf_header
.e_shstrndx
);
3177 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
3178 printf (" (%ld)", (long) section_headers
[0].sh_link
);
3179 putc ('\n', stdout
);
3182 if (section_headers
!= NULL
)
3184 if (elf_header
.e_shnum
== 0)
3185 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3186 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
3187 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3188 free (section_headers
);
3189 section_headers
= NULL
;
3197 get_32bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3199 Elf32_External_Phdr
*phdrs
;
3200 Elf32_External_Phdr
*external
;
3201 Elf_Internal_Phdr
*internal
;
3204 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3205 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3206 _("program headers"));
3210 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3211 i
< elf_header
.e_phnum
;
3212 i
++, internal
++, external
++)
3214 internal
->p_type
= BYTE_GET (external
->p_type
);
3215 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3216 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3217 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3218 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3219 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3220 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3221 internal
->p_align
= BYTE_GET (external
->p_align
);
3230 get_64bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3232 Elf64_External_Phdr
*phdrs
;
3233 Elf64_External_Phdr
*external
;
3234 Elf_Internal_Phdr
*internal
;
3237 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3238 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3239 _("program headers"));
3243 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3244 i
< elf_header
.e_phnum
;
3245 i
++, internal
++, external
++)
3247 internal
->p_type
= BYTE_GET (external
->p_type
);
3248 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3249 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3250 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3251 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3252 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3253 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3254 internal
->p_align
= BYTE_GET (external
->p_align
);
3262 /* Returns 1 if the program headers were read into `program_headers'. */
3265 get_program_headers (FILE *file
)
3267 Elf_Internal_Phdr
*phdrs
;
3269 /* Check cache of prior read. */
3270 if (program_headers
!= NULL
)
3273 phdrs
= cmalloc (elf_header
.e_phnum
, sizeof (Elf_Internal_Phdr
));
3277 error (_("Out of memory\n"));
3282 ? get_32bit_program_headers (file
, phdrs
)
3283 : get_64bit_program_headers (file
, phdrs
))
3285 program_headers
= phdrs
;
3293 /* Returns 1 if the program headers were loaded. */
3296 process_program_headers (FILE *file
)
3298 Elf_Internal_Phdr
*segment
;
3301 if (elf_header
.e_phnum
== 0)
3304 printf (_("\nThere are no program headers in this file.\n"));
3308 if (do_segments
&& !do_header
)
3310 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3311 printf (_("Entry point "));
3312 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3313 printf (_("\nThere are %d program headers, starting at offset "),
3314 elf_header
.e_phnum
);
3315 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3319 if (! get_program_headers (file
))
3324 if (elf_header
.e_phnum
> 1)
3325 printf (_("\nProgram Headers:\n"));
3327 printf (_("\nProgram Headers:\n"));
3331 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3334 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3338 (_(" Type Offset VirtAddr PhysAddr\n"));
3340 (_(" FileSiz MemSiz Flags Align\n"));
3347 for (i
= 0, segment
= program_headers
;
3348 i
< elf_header
.e_phnum
;
3353 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3357 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3358 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3359 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3360 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3361 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3363 (segment
->p_flags
& PF_R
? 'R' : ' '),
3364 (segment
->p_flags
& PF_W
? 'W' : ' '),
3365 (segment
->p_flags
& PF_X
? 'E' : ' '));
3366 printf ("%#lx", (unsigned long) segment
->p_align
);
3370 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3371 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3374 print_vma (segment
->p_offset
, FULL_HEX
);
3378 print_vma (segment
->p_vaddr
, FULL_HEX
);
3380 print_vma (segment
->p_paddr
, FULL_HEX
);
3383 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3384 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3387 print_vma (segment
->p_filesz
, FULL_HEX
);
3391 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3392 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3395 print_vma (segment
->p_offset
, FULL_HEX
);
3399 (segment
->p_flags
& PF_R
? 'R' : ' '),
3400 (segment
->p_flags
& PF_W
? 'W' : ' '),
3401 (segment
->p_flags
& PF_X
? 'E' : ' '));
3403 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3404 printf ("%#lx", (unsigned long) segment
->p_align
);
3407 print_vma (segment
->p_align
, PREFIX_HEX
);
3412 print_vma (segment
->p_offset
, FULL_HEX
);
3414 print_vma (segment
->p_vaddr
, FULL_HEX
);
3416 print_vma (segment
->p_paddr
, FULL_HEX
);
3418 print_vma (segment
->p_filesz
, FULL_HEX
);
3420 print_vma (segment
->p_memsz
, FULL_HEX
);
3422 (segment
->p_flags
& PF_R
? 'R' : ' '),
3423 (segment
->p_flags
& PF_W
? 'W' : ' '),
3424 (segment
->p_flags
& PF_X
? 'E' : ' '));
3425 print_vma (segment
->p_align
, HEX
);
3429 switch (segment
->p_type
)
3433 error (_("more than one dynamic segment\n"));
3435 /* Try to locate the .dynamic section. If there is
3436 a section header table, we can easily locate it. */
3437 if (section_headers
!= NULL
)
3439 Elf_Internal_Shdr
*sec
;
3441 sec
= find_section (".dynamic");
3442 if (sec
== NULL
|| sec
->sh_size
== 0)
3444 error (_("no .dynamic section in the dynamic segment"));
3448 dynamic_addr
= sec
->sh_offset
;
3449 dynamic_size
= sec
->sh_size
;
3451 if (dynamic_addr
< segment
->p_offset
3452 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3453 warn (_("the .dynamic section is not contained within the dynamic segment"));
3454 else if (dynamic_addr
> segment
->p_offset
)
3455 warn (_("the .dynamic section is not the first section in the dynamic segment."));
3459 /* Otherwise, we can only assume that the .dynamic
3460 section is the first section in the DYNAMIC segment. */
3461 dynamic_addr
= segment
->p_offset
;
3462 dynamic_size
= segment
->p_filesz
;
3467 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3469 error (_("Unable to find program interpreter name\n"));
3472 program_interpreter
[0] = 0;
3473 fscanf (file
, "%63s", program_interpreter
);
3476 printf (_("\n [Requesting program interpreter: %s]"),
3477 program_interpreter
);
3483 putc ('\n', stdout
);
3486 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3488 printf (_("\n Section to Segment mapping:\n"));
3489 printf (_(" Segment Sections...\n"));
3491 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3494 Elf_Internal_Shdr
*section
;
3496 segment
= program_headers
+ i
;
3497 section
= section_headers
;
3499 printf (" %2.2d ", i
);
3501 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3503 if (section
->sh_size
> 0
3504 /* Compare allocated sections by VMA, unallocated
3505 sections by file offset. */
3506 && (section
->sh_flags
& SHF_ALLOC
3507 ? (section
->sh_addr
>= segment
->p_vaddr
3508 && section
->sh_addr
+ section
->sh_size
3509 <= segment
->p_vaddr
+ segment
->p_memsz
)
3510 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
3511 && (section
->sh_offset
+ section
->sh_size
3512 <= segment
->p_offset
+ segment
->p_filesz
)))
3513 /* .tbss is special. It doesn't contribute memory space
3514 to normal segments. */
3515 && (!((section
->sh_flags
& SHF_TLS
) != 0
3516 && section
->sh_type
== SHT_NOBITS
)
3517 || segment
->p_type
== PT_TLS
))
3518 printf ("%s ", SECTION_NAME (section
));
3529 /* Find the file offset corresponding to VMA by using the program headers. */
3532 offset_from_vma (FILE *file
, bfd_vma vma
, bfd_size_type size
)
3534 Elf_Internal_Phdr
*seg
;
3536 if (! get_program_headers (file
))
3538 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3542 for (seg
= program_headers
;
3543 seg
< program_headers
+ elf_header
.e_phnum
;
3546 if (seg
->p_type
!= PT_LOAD
)
3549 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3550 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3551 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3554 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3561 get_32bit_section_headers (FILE *file
, unsigned int num
)
3563 Elf32_External_Shdr
*shdrs
;
3564 Elf_Internal_Shdr
*internal
;
3567 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3568 elf_header
.e_shentsize
, num
, _("section headers"));
3572 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3574 if (section_headers
== NULL
)
3576 error (_("Out of memory\n"));
3580 for (i
= 0, internal
= section_headers
;
3584 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3585 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3586 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3587 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3588 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3589 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3590 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3591 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3592 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3593 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3602 get_64bit_section_headers (FILE *file
, unsigned int num
)
3604 Elf64_External_Shdr
*shdrs
;
3605 Elf_Internal_Shdr
*internal
;
3608 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3609 elf_header
.e_shentsize
, num
, _("section headers"));
3613 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3615 if (section_headers
== NULL
)
3617 error (_("Out of memory\n"));
3621 for (i
= 0, internal
= section_headers
;
3625 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3626 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3627 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3628 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3629 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3630 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3631 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3632 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3633 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3634 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3642 static Elf_Internal_Sym
*
3643 get_32bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3645 unsigned long number
;
3646 Elf32_External_Sym
*esyms
;
3647 Elf_External_Sym_Shndx
*shndx
;
3648 Elf_Internal_Sym
*isyms
;
3649 Elf_Internal_Sym
*psym
;
3652 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3658 if (symtab_shndx_hdr
!= NULL
3659 && (symtab_shndx_hdr
->sh_link
3660 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3662 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3663 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3671 number
= section
->sh_size
/ section
->sh_entsize
;
3672 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3676 error (_("Out of memory\n"));
3683 for (j
= 0, psym
= isyms
;
3687 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3688 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3689 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3690 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3691 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3693 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3694 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3695 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3705 static Elf_Internal_Sym
*
3706 get_64bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3708 unsigned long number
;
3709 Elf64_External_Sym
*esyms
;
3710 Elf_External_Sym_Shndx
*shndx
;
3711 Elf_Internal_Sym
*isyms
;
3712 Elf_Internal_Sym
*psym
;
3715 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3721 if (symtab_shndx_hdr
!= NULL
3722 && (symtab_shndx_hdr
->sh_link
3723 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3725 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3726 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3734 number
= section
->sh_size
/ section
->sh_entsize
;
3735 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3739 error (_("Out of memory\n"));
3746 for (j
= 0, psym
= isyms
;
3750 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3751 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3752 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3753 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3754 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3756 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3757 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3758 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3769 get_elf_section_flags (bfd_vma sh_flags
)
3771 static char buff
[33];
3778 flag
= sh_flags
& - sh_flags
;
3783 case SHF_WRITE
: *p
= 'W'; break;
3784 case SHF_ALLOC
: *p
= 'A'; break;
3785 case SHF_EXECINSTR
: *p
= 'X'; break;
3786 case SHF_MERGE
: *p
= 'M'; break;
3787 case SHF_STRINGS
: *p
= 'S'; break;
3788 case SHF_INFO_LINK
: *p
= 'I'; break;
3789 case SHF_LINK_ORDER
: *p
= 'L'; break;
3790 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
3791 case SHF_GROUP
: *p
= 'G'; break;
3792 case SHF_TLS
: *p
= 'T'; break;
3795 if (elf_header
.e_machine
== EM_X86_64
3796 && flag
== SHF_X86_64_LARGE
)
3798 else if (flag
& SHF_MASKOS
)
3801 sh_flags
&= ~ SHF_MASKOS
;
3803 else if (flag
& SHF_MASKPROC
)
3806 sh_flags
&= ~ SHF_MASKPROC
;
3820 process_section_headers (FILE *file
)
3822 Elf_Internal_Shdr
*section
;
3825 section_headers
= NULL
;
3827 if (elf_header
.e_shnum
== 0)
3830 printf (_("\nThere are no sections in this file.\n"));
3835 if (do_sections
&& !do_header
)
3836 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3837 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
3841 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
3844 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
3847 /* Read in the string table, so that we have names to display. */
3848 if (SECTION_HEADER_INDEX (elf_header
.e_shstrndx
) < elf_header
.e_shnum
)
3850 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
3852 if (section
->sh_size
!= 0)
3854 string_table
= get_data (NULL
, file
, section
->sh_offset
,
3855 1, section
->sh_size
, _("string table"));
3857 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
3861 /* Scan the sections for the dynamic symbol table
3862 and dynamic string table and debug sections. */
3863 dynamic_symbols
= NULL
;
3864 dynamic_strings
= NULL
;
3865 dynamic_syminfo
= NULL
;
3866 symtab_shndx_hdr
= NULL
;
3868 eh_addr_size
= is_32bit_elf
? 4 : 8;
3869 switch (elf_header
.e_machine
)
3872 case EM_MIPS_RS3_LE
:
3873 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
3874 FDE addresses. However, the ABI also has a semi-official ILP32
3875 variant for which the normal FDE address size rules apply.
3877 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
3878 section, where XX is the size of longs in bits. Unfortunately,
3879 earlier compilers provided no way of distinguishing ILP32 objects
3880 from LP64 objects, so if there's any doubt, we should assume that
3881 the official LP64 form is being used. */
3882 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
3883 && find_section (".gcc_compiled_long32") == NULL
)
3888 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
3891 size_t expected_entsize \
3892 = is_32bit_elf ? size32 : size64; \
3893 if (section->sh_entsize != expected_entsize) \
3894 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
3895 i, (unsigned long int) section->sh_entsize, \
3896 (unsigned long int) expected_entsize); \
3897 section->sh_entsize = expected_entsize; \
3900 #define CHECK_ENTSIZE(section, i, type) \
3901 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
3902 sizeof (Elf64_External_##type))
3904 for (i
= 0, section
= section_headers
;
3905 i
< elf_header
.e_shnum
;
3908 char *name
= SECTION_NAME (section
);
3910 if (section
->sh_type
== SHT_DYNSYM
)
3912 if (dynamic_symbols
!= NULL
)
3914 error (_("File contains multiple dynamic symbol tables\n"));
3918 CHECK_ENTSIZE (section
, i
, Sym
);
3919 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
3920 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
3922 else if (section
->sh_type
== SHT_STRTAB
3923 && streq (name
, ".dynstr"))
3925 if (dynamic_strings
!= NULL
)
3927 error (_("File contains multiple dynamic string tables\n"));
3931 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
3932 1, section
->sh_size
, _("dynamic strings"));
3933 dynamic_strings_length
= section
->sh_size
;
3935 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
3937 if (symtab_shndx_hdr
!= NULL
)
3939 error (_("File contains multiple symtab shndx tables\n"));
3942 symtab_shndx_hdr
= section
;
3944 else if (section
->sh_type
== SHT_SYMTAB
)
3945 CHECK_ENTSIZE (section
, i
, Sym
);
3946 else if (section
->sh_type
== SHT_GROUP
)
3947 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
3948 else if (section
->sh_type
== SHT_REL
)
3949 CHECK_ENTSIZE (section
, i
, Rel
);
3950 else if (section
->sh_type
== SHT_RELA
)
3951 CHECK_ENTSIZE (section
, i
, Rela
);
3952 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
3953 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
3954 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
3955 || do_debug_loc
|| do_debug_ranges
)
3956 && strneq (name
, ".debug_", 7))
3961 || (do_debug_info
&& streq (name
, "info"))
3962 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
3963 || (do_debug_lines
&& streq (name
, "line"))
3964 || (do_debug_pubnames
&& streq (name
, "pubnames"))
3965 || (do_debug_aranges
&& streq (name
, "aranges"))
3966 || (do_debug_ranges
&& streq (name
, "ranges"))
3967 || (do_debug_frames
&& streq (name
, "frame"))
3968 || (do_debug_macinfo
&& streq (name
, "macinfo"))
3969 || (do_debug_str
&& streq (name
, "str"))
3970 || (do_debug_loc
&& streq (name
, "loc"))
3972 request_dump (i
, DEBUG_DUMP
);
3974 /* linkonce section to be combined with .debug_info at link time. */
3975 else if ((do_debugging
|| do_debug_info
)
3976 && strneq (name
, ".gnu.linkonce.wi.", 17))
3977 request_dump (i
, DEBUG_DUMP
);
3978 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
3979 request_dump (i
, DEBUG_DUMP
);
3985 if (elf_header
.e_shnum
> 1)
3986 printf (_("\nSection Headers:\n"));
3988 printf (_("\nSection Header:\n"));
3992 if (do_full_section_name
)
3994 printf (_(" [Nr] Name\n"));
3995 printf (_(" Type Addr Off Size ES Flg Lk Inf Al\n"));
3999 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4003 if (do_full_section_name
)
4005 printf (_(" [Nr] Name\n"));
4006 printf (_(" Type Address Off Size ES Flg Lk Inf Al\n"));
4010 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4014 if (do_full_section_name
)
4016 printf (_(" [Nr] Name\n"));
4017 printf (_(" Flags Type Address Offset\n"));
4018 printf (_(" Size EntSize Link Info Align\n"));
4022 printf (_(" [Nr] Name Type Address Offset\n"));
4023 printf (_(" Size EntSize Flags Link Info Align\n"));
4027 for (i
= 0, section
= section_headers
;
4028 i
< elf_header
.e_shnum
;
4031 if (do_full_section_name
)
4033 printf (" [%2u] %s\n",
4034 SECTION_HEADER_NUM (i
),
4035 SECTION_NAME (section
));
4036 if (is_32bit_elf
|| do_wide
)
4037 printf (" %-15.15s ",
4038 get_section_type_name (section
->sh_type
));
4041 printf (" [%2u] %-17.17s %-15.15s ",
4042 SECTION_HEADER_NUM (i
),
4043 SECTION_NAME (section
),
4044 get_section_type_name (section
->sh_type
));
4048 print_vma (section
->sh_addr
, LONG_HEX
);
4050 printf ( " %6.6lx %6.6lx %2.2lx",
4051 (unsigned long) section
->sh_offset
,
4052 (unsigned long) section
->sh_size
,
4053 (unsigned long) section
->sh_entsize
);
4055 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4057 printf ("%2ld %3lu %2ld\n",
4058 (unsigned long) section
->sh_link
,
4059 (unsigned long) section
->sh_info
,
4060 (unsigned long) section
->sh_addralign
);
4064 print_vma (section
->sh_addr
, LONG_HEX
);
4066 if ((long) section
->sh_offset
== section
->sh_offset
)
4067 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4071 print_vma (section
->sh_offset
, LONG_HEX
);
4074 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4075 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4079 print_vma (section
->sh_size
, LONG_HEX
);
4082 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4083 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4087 print_vma (section
->sh_entsize
, LONG_HEX
);
4090 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4092 printf ("%2ld %3lu ",
4093 (unsigned long) section
->sh_link
,
4094 (unsigned long) section
->sh_info
);
4096 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4097 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
4100 print_vma (section
->sh_addralign
, DEC
);
4104 else if (do_full_section_name
)
4106 printf (" %-15.15s %-15.15s ",
4107 get_elf_section_flags (section
->sh_flags
),
4108 get_section_type_name (section
->sh_type
));
4110 print_vma (section
->sh_addr
, LONG_HEX
);
4111 if ((long) section
->sh_offset
== section
->sh_offset
)
4112 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4116 print_vma (section
->sh_offset
, LONG_HEX
);
4119 print_vma (section
->sh_size
, LONG_HEX
);
4121 print_vma (section
->sh_entsize
, LONG_HEX
);
4123 printf (" %2ld %3lu %ld\n",
4124 (unsigned long) section
->sh_link
,
4125 (unsigned long) section
->sh_info
,
4126 (unsigned long) section
->sh_addralign
);
4131 print_vma (section
->sh_addr
, LONG_HEX
);
4132 if ((long) section
->sh_offset
== section
->sh_offset
)
4133 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4137 print_vma (section
->sh_offset
, LONG_HEX
);
4140 print_vma (section
->sh_size
, LONG_HEX
);
4142 print_vma (section
->sh_entsize
, LONG_HEX
);
4144 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4146 printf (" %2ld %3lu %ld\n",
4147 (unsigned long) section
->sh_link
,
4148 (unsigned long) section
->sh_info
,
4149 (unsigned long) section
->sh_addralign
);
4153 printf (_("Key to Flags:\n\
4154 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4155 I (info), L (link order), G (group), x (unknown)\n\
4156 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4162 get_group_flags (unsigned int flags
)
4164 static char buff
[32];
4171 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x]"), flags
);
4178 process_section_groups (FILE *file
)
4180 Elf_Internal_Shdr
*section
;
4182 struct group
*group
;
4183 Elf_Internal_Shdr
*symtab_sec
, *strtab_sec
;
4184 Elf_Internal_Sym
*symtab
;
4188 /* Don't process section groups unless needed. */
4189 if (!do_unwind
&& !do_section_groups
)
4192 if (elf_header
.e_shnum
== 0)
4194 if (do_section_groups
)
4195 printf (_("\nThere are no sections in this file.\n"));
4200 if (section_headers
== NULL
)
4202 error (_("Section headers are not available!\n"));
4206 section_headers_groups
= calloc (elf_header
.e_shnum
,
4207 sizeof (struct group
*));
4209 if (section_headers_groups
== NULL
)
4211 error (_("Out of memory\n"));
4215 /* Scan the sections for the group section. */
4217 for (i
= 0, section
= section_headers
;
4218 i
< elf_header
.e_shnum
;
4220 if (section
->sh_type
== SHT_GROUP
)
4223 if (group_count
== 0)
4225 if (do_section_groups
)
4226 printf (_("\nThere are no section groups in this file.\n"));
4231 section_groups
= calloc (group_count
, sizeof (struct group
));
4233 if (section_groups
== NULL
)
4235 error (_("Out of memory\n"));
4244 for (i
= 0, section
= section_headers
, group
= section_groups
;
4245 i
< elf_header
.e_shnum
;
4248 if (section
->sh_type
== SHT_GROUP
)
4250 char *name
= SECTION_NAME (section
);
4252 unsigned char *start
, *indices
;
4253 unsigned int entry
, j
, size
;
4254 Elf_Internal_Shdr
*sec
;
4255 Elf_Internal_Sym
*sym
;
4257 /* Get the symbol table. */
4258 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
4259 || ((sec
= SECTION_HEADER (section
->sh_link
))->sh_type
4262 error (_("Bad sh_link in group section `%s'\n"), name
);
4266 if (symtab_sec
!= sec
)
4271 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4274 sym
= symtab
+ section
->sh_info
;
4276 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4278 bfd_vma sec_index
= SECTION_HEADER_INDEX (sym
->st_shndx
);
4281 error (_("Bad sh_info in group section `%s'\n"), name
);
4285 group_name
= SECTION_NAME (section_headers
+ sec_index
);
4294 /* Get the string table. */
4295 if (SECTION_HEADER_INDEX (symtab_sec
->sh_link
)
4296 >= elf_header
.e_shnum
)
4305 != (sec
= SECTION_HEADER (symtab_sec
->sh_link
)))
4310 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
4311 1, strtab_sec
->sh_size
,
4313 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
4315 group_name
= sym
->st_name
< strtab_size
4316 ? strtab
+ sym
->st_name
: "<corrupt>";
4319 start
= get_data (NULL
, file
, section
->sh_offset
,
4320 1, section
->sh_size
, _("section data"));
4323 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4324 entry
= byte_get (indices
, 4);
4327 if (do_section_groups
)
4329 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4330 get_group_flags (entry
), i
, name
, group_name
, size
);
4332 printf (_(" [Index] Name\n"));
4335 group
->group_index
= i
;
4337 for (j
= 0; j
< size
; j
++)
4339 struct group_list
*g
;
4341 entry
= byte_get (indices
, 4);
4344 if (SECTION_HEADER_INDEX (entry
) >= elf_header
.e_shnum
)
4346 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4347 entry
, i
, elf_header
.e_shnum
- 1);
4350 else if (entry
>= SHN_LORESERVE
&& entry
<= SHN_HIRESERVE
)
4352 error (_("invalid section [%5u] in group section [%5u]\n"),
4357 if (section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4362 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4364 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4369 /* Intel C/C++ compiler may put section 0 in a
4370 section group. We just warn it the first time
4371 and ignore it afterwards. */
4372 static int warned
= 0;
4375 error (_("section 0 in group section [%5u]\n"),
4376 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4382 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4385 if (do_section_groups
)
4387 sec
= SECTION_HEADER (entry
);
4388 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
4391 g
= xmalloc (sizeof (struct group_list
));
4392 g
->section_index
= entry
;
4393 g
->next
= group
->root
;
4417 } dynamic_relocations
[] =
4419 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4420 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4421 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4424 /* Process the reloc section. */
4427 process_relocs (FILE *file
)
4429 unsigned long rel_size
;
4430 unsigned long rel_offset
;
4436 if (do_using_dynamic
)
4440 int has_dynamic_reloc
;
4443 has_dynamic_reloc
= 0;
4445 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4447 is_rela
= dynamic_relocations
[i
].rela
;
4448 name
= dynamic_relocations
[i
].name
;
4449 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4450 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4452 has_dynamic_reloc
|= rel_size
;
4454 if (is_rela
== UNKNOWN
)
4456 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4457 switch (dynamic_info
[DT_PLTREL
])
4471 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4472 name
, rel_offset
, rel_size
);
4474 dump_relocations (file
,
4475 offset_from_vma (file
, rel_offset
, rel_size
),
4477 dynamic_symbols
, num_dynamic_syms
,
4478 dynamic_strings
, dynamic_strings_length
, is_rela
);
4482 if (! has_dynamic_reloc
)
4483 printf (_("\nThere are no dynamic relocations in this file.\n"));
4487 Elf_Internal_Shdr
*section
;
4491 for (i
= 0, section
= section_headers
;
4492 i
< elf_header
.e_shnum
;
4495 if ( section
->sh_type
!= SHT_RELA
4496 && section
->sh_type
!= SHT_REL
)
4499 rel_offset
= section
->sh_offset
;
4500 rel_size
= section
->sh_size
;
4504 Elf_Internal_Shdr
*strsec
;
4507 printf (_("\nRelocation section "));
4509 if (string_table
== NULL
)
4510 printf ("%d", section
->sh_name
);
4512 printf (_("'%s'"), SECTION_NAME (section
));
4514 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4515 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4517 is_rela
= section
->sh_type
== SHT_RELA
;
4519 if (section
->sh_link
4520 && SECTION_HEADER_INDEX (section
->sh_link
)
4521 < elf_header
.e_shnum
)
4523 Elf_Internal_Shdr
*symsec
;
4524 Elf_Internal_Sym
*symtab
;
4525 unsigned long nsyms
;
4526 unsigned long strtablen
= 0;
4527 char *strtab
= NULL
;
4529 symsec
= SECTION_HEADER (section
->sh_link
);
4530 if (symsec
->sh_type
!= SHT_SYMTAB
4531 && symsec
->sh_type
!= SHT_DYNSYM
)
4534 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4535 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4540 if (SECTION_HEADER_INDEX (symsec
->sh_link
)
4541 < elf_header
.e_shnum
)
4543 strsec
= SECTION_HEADER (symsec
->sh_link
);
4545 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4548 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4551 dump_relocations (file
, rel_offset
, rel_size
,
4552 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4558 dump_relocations (file
, rel_offset
, rel_size
,
4559 NULL
, 0, NULL
, 0, is_rela
);
4566 printf (_("\nThere are no relocations in this file.\n"));
4572 /* Process the unwind section. */
4574 #include "unwind-ia64.h"
4576 /* An absolute address consists of a section and an offset. If the
4577 section is NULL, the offset itself is the address, otherwise, the
4578 address equals to LOAD_ADDRESS(section) + offset. */
4582 unsigned short section
;
4586 struct ia64_unw_aux_info
4588 struct ia64_unw_table_entry
4590 struct absaddr start
;
4592 struct absaddr info
;
4594 *table
; /* Unwind table. */
4595 unsigned long table_len
; /* Length of unwind table. */
4596 unsigned char *info
; /* Unwind info. */
4597 unsigned long info_size
; /* Size of unwind info. */
4598 bfd_vma info_addr
; /* starting address of unwind info. */
4599 bfd_vma seg_base
; /* Starting address of segment. */
4600 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4601 unsigned long nsyms
; /* Number of symbols. */
4602 char *strtab
; /* The string table. */
4603 unsigned long strtab_size
; /* Size of string table. */
4607 find_symbol_for_address (Elf_Internal_Sym
*symtab
,
4608 unsigned long nsyms
,
4610 unsigned long strtab_size
,
4611 struct absaddr addr
,
4612 const char **symname
,
4615 bfd_vma dist
= 0x100000;
4616 Elf_Internal_Sym
*sym
, *best
= NULL
;
4619 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
4621 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4622 && sym
->st_name
!= 0
4623 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4624 && addr
.offset
>= sym
->st_value
4625 && addr
.offset
- sym
->st_value
< dist
)
4628 dist
= addr
.offset
- sym
->st_value
;
4635 *symname
= (best
->st_name
>= strtab_size
4636 ? "<corrupt>" : strtab
+ best
->st_name
);
4641 *offset
= addr
.offset
;
4645 dump_ia64_unwind (struct ia64_unw_aux_info
*aux
)
4647 struct ia64_unw_table_entry
*tp
;
4650 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4654 const unsigned char *dp
;
4655 const unsigned char *head
;
4656 const char *procname
;
4658 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4659 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
4661 fputs ("\n<", stdout
);
4665 fputs (procname
, stdout
);
4668 printf ("+%lx", (unsigned long) offset
);
4671 fputs (">: [", stdout
);
4672 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4673 fputc ('-', stdout
);
4674 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4675 printf ("], info at +0x%lx\n",
4676 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4678 head
= aux
->info
+ (tp
->info
.offset
- aux
->info_addr
);
4679 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
4681 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4682 (unsigned) UNW_VER (stamp
),
4683 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4684 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4685 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4686 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
4688 if (UNW_VER (stamp
) != 1)
4690 printf ("\tUnknown version.\n");
4695 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
4696 dp
= unw_decode (dp
, in_body
, & in_body
);
4701 slurp_ia64_unwind_table (FILE *file
,
4702 struct ia64_unw_aux_info
*aux
,
4703 Elf_Internal_Shdr
*sec
)
4705 unsigned long size
, nrelas
, i
;
4706 Elf_Internal_Phdr
*seg
;
4707 struct ia64_unw_table_entry
*tep
;
4708 Elf_Internal_Shdr
*relsec
;
4709 Elf_Internal_Rela
*rela
, *rp
;
4710 unsigned char *table
, *tp
;
4711 Elf_Internal_Sym
*sym
;
4712 const char *relname
;
4714 /* First, find the starting address of the segment that includes
4717 if (elf_header
.e_phnum
)
4719 if (! get_program_headers (file
))
4722 for (seg
= program_headers
;
4723 seg
< program_headers
+ elf_header
.e_phnum
;
4726 if (seg
->p_type
!= PT_LOAD
)
4729 if (sec
->sh_addr
>= seg
->p_vaddr
4730 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4732 aux
->seg_base
= seg
->p_vaddr
;
4738 /* Second, build the unwind table from the contents of the unwind section: */
4739 size
= sec
->sh_size
;
4740 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
4744 aux
->table
= xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
4746 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * eh_addr_size
, ++tep
)
4748 tep
->start
.section
= SHN_UNDEF
;
4749 tep
->end
.section
= SHN_UNDEF
;
4750 tep
->info
.section
= SHN_UNDEF
;
4753 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4754 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4755 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
4759 tep
->start
.offset
= BYTE_GET ((unsigned char *) tp
+ 0);
4760 tep
->end
.offset
= BYTE_GET ((unsigned char *) tp
+ 8);
4761 tep
->info
.offset
= BYTE_GET ((unsigned char *) tp
+ 16);
4763 tep
->start
.offset
+= aux
->seg_base
;
4764 tep
->end
.offset
+= aux
->seg_base
;
4765 tep
->info
.offset
+= aux
->seg_base
;
4769 /* Third, apply any relocations to the unwind table: */
4771 for (relsec
= section_headers
;
4772 relsec
< section_headers
+ elf_header
.e_shnum
;
4775 if (relsec
->sh_type
!= SHT_RELA
4776 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
4777 || SECTION_HEADER (relsec
->sh_info
) != sec
)
4780 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
4784 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4788 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4789 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4793 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4794 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4797 if (! strneq (relname
, "R_IA64_SEGREL", 13))
4799 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4803 i
= rp
->r_offset
/ (3 * eh_addr_size
);
4805 switch (rp
->r_offset
/eh_addr_size
% 3)
4808 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4809 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
4812 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4813 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
4816 aux
->table
[i
].info
.section
= sym
->st_shndx
;
4817 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
4827 aux
->table_len
= size
/ (3 * eh_addr_size
);
4832 ia64_process_unwind (FILE *file
)
4834 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
4835 unsigned long i
, unwcount
= 0, unwstart
= 0;
4836 struct ia64_unw_aux_info aux
;
4838 memset (& aux
, 0, sizeof (aux
));
4840 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4842 if (sec
->sh_type
== SHT_SYMTAB
4843 && SECTION_HEADER_INDEX (sec
->sh_link
) < elf_header
.e_shnum
)
4845 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
4846 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
4848 strsec
= SECTION_HEADER (sec
->sh_link
);
4849 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4850 1, strsec
->sh_size
, _("string table"));
4851 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
4853 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4858 printf (_("\nThere are no unwind sections in this file.\n"));
4860 while (unwcount
-- > 0)
4865 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
4866 i
< elf_header
.e_shnum
; ++i
, ++sec
)
4867 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4874 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
4876 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
4878 /* We need to find which section group it is in. */
4879 struct group_list
*g
= section_headers_groups
[i
]->root
;
4881 for (; g
!= NULL
; g
= g
->next
)
4883 sec
= SECTION_HEADER (g
->section_index
);
4885 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
4890 i
= elf_header
.e_shnum
;
4892 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
4894 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
4895 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
4896 suffix
= SECTION_NAME (unwsec
) + len
;
4897 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4899 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
4900 && streq (SECTION_NAME (sec
) + len2
, suffix
))
4905 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
4906 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
4907 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
4908 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
4910 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
4911 suffix
= SECTION_NAME (unwsec
) + len
;
4912 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4914 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
4915 && streq (SECTION_NAME (sec
) + len2
, suffix
))
4919 if (i
== elf_header
.e_shnum
)
4921 printf (_("\nCould not find unwind info section for "));
4923 if (string_table
== NULL
)
4924 printf ("%d", unwsec
->sh_name
);
4926 printf (_("'%s'"), SECTION_NAME (unwsec
));
4930 aux
.info_size
= sec
->sh_size
;
4931 aux
.info_addr
= sec
->sh_addr
;
4932 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, 1, aux
.info_size
,
4935 printf (_("\nUnwind section "));
4937 if (string_table
== NULL
)
4938 printf ("%d", unwsec
->sh_name
);
4940 printf (_("'%s'"), SECTION_NAME (unwsec
));
4942 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4943 (unsigned long) unwsec
->sh_offset
,
4944 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
4946 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
4948 if (aux
.table_len
> 0)
4949 dump_ia64_unwind (& aux
);
4952 free ((char *) aux
.table
);
4954 free ((char *) aux
.info
);
4963 free ((char *) aux
.strtab
);
4968 struct hppa_unw_aux_info
4970 struct hppa_unw_table_entry
4972 struct absaddr start
;
4974 unsigned int Cannot_unwind
:1; /* 0 */
4975 unsigned int Millicode
:1; /* 1 */
4976 unsigned int Millicode_save_sr0
:1; /* 2 */
4977 unsigned int Region_description
:2; /* 3..4 */
4978 unsigned int reserved1
:1; /* 5 */
4979 unsigned int Entry_SR
:1; /* 6 */
4980 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
4981 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
4982 unsigned int Args_stored
:1; /* 16 */
4983 unsigned int Variable_Frame
:1; /* 17 */
4984 unsigned int Separate_Package_Body
:1; /* 18 */
4985 unsigned int Frame_Extension_Millicode
:1; /* 19 */
4986 unsigned int Stack_Overflow_Check
:1; /* 20 */
4987 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
4988 unsigned int Ada_Region
:1; /* 22 */
4989 unsigned int cxx_info
:1; /* 23 */
4990 unsigned int cxx_try_catch
:1; /* 24 */
4991 unsigned int sched_entry_seq
:1; /* 25 */
4992 unsigned int reserved2
:1; /* 26 */
4993 unsigned int Save_SP
:1; /* 27 */
4994 unsigned int Save_RP
:1; /* 28 */
4995 unsigned int Save_MRP_in_frame
:1; /* 29 */
4996 unsigned int extn_ptr_defined
:1; /* 30 */
4997 unsigned int Cleanup_defined
:1; /* 31 */
4999 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
5000 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
5001 unsigned int Large_frame
:1; /* 2 */
5002 unsigned int Pseudo_SP_Set
:1; /* 3 */
5003 unsigned int reserved4
:1; /* 4 */
5004 unsigned int Total_frame_size
:27; /* 5..31 */
5006 *table
; /* Unwind table. */
5007 unsigned long table_len
; /* Length of unwind table. */
5008 bfd_vma seg_base
; /* Starting address of segment. */
5009 Elf_Internal_Sym
*symtab
; /* The symbol table. */
5010 unsigned long nsyms
; /* Number of symbols. */
5011 char *strtab
; /* The string table. */
5012 unsigned long strtab_size
; /* Size of string table. */
5016 dump_hppa_unwind (struct hppa_unw_aux_info
*aux
)
5018 struct hppa_unw_table_entry
*tp
;
5020 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5023 const char *procname
;
5025 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5026 aux
->strtab_size
, tp
->start
, &procname
,
5029 fputs ("\n<", stdout
);
5033 fputs (procname
, stdout
);
5036 printf ("+%lx", (unsigned long) offset
);
5039 fputs (">: [", stdout
);
5040 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5041 fputc ('-', stdout
);
5042 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5045 #define PF(_m) if (tp->_m) printf (#_m " ");
5046 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5049 PF(Millicode_save_sr0
);
5050 /* PV(Region_description); */
5056 PF(Separate_Package_Body
);
5057 PF(Frame_Extension_Millicode
);
5058 PF(Stack_Overflow_Check
);
5059 PF(Two_Instruction_SP_Increment
);
5063 PF(sched_entry_seq
);
5066 PF(Save_MRP_in_frame
);
5067 PF(extn_ptr_defined
);
5068 PF(Cleanup_defined
);
5069 PF(MPE_XL_interrupt_marker
);
5070 PF(HP_UX_interrupt_marker
);
5073 PV(Total_frame_size
);
5082 slurp_hppa_unwind_table (FILE *file
,
5083 struct hppa_unw_aux_info
*aux
,
5084 Elf_Internal_Shdr
*sec
)
5086 unsigned long size
, unw_ent_size
, nrelas
, i
;
5087 Elf_Internal_Phdr
*seg
;
5088 struct hppa_unw_table_entry
*tep
;
5089 Elf_Internal_Shdr
*relsec
;
5090 Elf_Internal_Rela
*rela
, *rp
;
5091 unsigned char *table
, *tp
;
5092 Elf_Internal_Sym
*sym
;
5093 const char *relname
;
5095 /* First, find the starting address of the segment that includes
5098 if (elf_header
.e_phnum
)
5100 if (! get_program_headers (file
))
5103 for (seg
= program_headers
;
5104 seg
< program_headers
+ elf_header
.e_phnum
;
5107 if (seg
->p_type
!= PT_LOAD
)
5110 if (sec
->sh_addr
>= seg
->p_vaddr
5111 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5113 aux
->seg_base
= seg
->p_vaddr
;
5119 /* Second, build the unwind table from the contents of the unwind
5121 size
= sec
->sh_size
;
5122 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
5126 unw_ent_size
= 2 * eh_addr_size
+ 8;
5128 tep
= aux
->table
= xcmalloc (size
/ unw_ent_size
, sizeof (aux
->table
[0]));
5130 for (tp
= table
; tp
< table
+ size
; tp
+= (2 * eh_addr_size
+ 8), ++tep
)
5132 unsigned int tmp1
, tmp2
;
5134 tep
->start
.section
= SHN_UNDEF
;
5135 tep
->end
.section
= SHN_UNDEF
;
5139 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5140 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5141 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
5142 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
5146 tep
->start
.offset
= BYTE_GET ((unsigned char *) tp
+ 0);
5147 tep
->end
.offset
= BYTE_GET ((unsigned char *) tp
+ 8);
5148 tmp1
= byte_get ((unsigned char *) tp
+ 16, 4);
5149 tmp2
= byte_get ((unsigned char *) tp
+ 20, 4);
5152 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
5153 tep
->Millicode
= (tmp1
>> 30) & 0x1;
5154 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
5155 tep
->Region_description
= (tmp1
>> 27) & 0x3;
5156 tep
->reserved1
= (tmp1
>> 26) & 0x1;
5157 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
5158 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
5159 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
5160 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
5161 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
5162 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
5163 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
5164 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
5165 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
5166 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
5167 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
5168 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
5169 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
5170 tep
->reserved2
= (tmp1
>> 5) & 0x1;
5171 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
5172 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
5173 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
5174 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
5175 tep
->Cleanup_defined
= tmp1
& 0x1;
5177 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5178 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5179 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5180 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5181 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5182 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5184 tep
->start
.offset
+= aux
->seg_base
;
5185 tep
->end
.offset
+= aux
->seg_base
;
5189 /* Third, apply any relocations to the unwind table. */
5191 for (relsec
= section_headers
;
5192 relsec
< section_headers
+ elf_header
.e_shnum
;
5195 if (relsec
->sh_type
!= SHT_RELA
5196 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
5197 || SECTION_HEADER (relsec
->sh_info
) != sec
)
5200 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5204 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5208 relname
= elf_hppa_reloc_type (ELF32_R_TYPE (rp
->r_info
));
5209 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
5213 relname
= elf_hppa_reloc_type (ELF64_R_TYPE (rp
->r_info
));
5214 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
5217 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5218 if (strncmp (relname
, "R_PARISC_SEGREL", 15) != 0)
5220 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5224 i
= rp
->r_offset
/ unw_ent_size
;
5226 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5229 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5230 aux
->table
[i
].start
.offset
+= sym
->st_value
+ rp
->r_addend
;
5233 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5234 aux
->table
[i
].end
.offset
+= sym
->st_value
+ rp
->r_addend
;
5244 aux
->table_len
= size
/ unw_ent_size
;
5250 hppa_process_unwind (FILE *file
)
5252 struct hppa_unw_aux_info aux
;
5253 Elf_Internal_Shdr
*unwsec
= NULL
;
5254 Elf_Internal_Shdr
*strsec
;
5255 Elf_Internal_Shdr
*sec
;
5258 memset (& aux
, 0, sizeof (aux
));
5260 if (string_table
== NULL
)
5263 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5265 if (sec
->sh_type
== SHT_SYMTAB
5266 && SECTION_HEADER_INDEX (sec
->sh_link
) < elf_header
.e_shnum
)
5268 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5269 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5271 strsec
= SECTION_HEADER (sec
->sh_link
);
5272 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5273 1, strsec
->sh_size
, _("string table"));
5274 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5276 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5281 printf (_("\nThere are no unwind sections in this file.\n"));
5283 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5285 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5287 printf (_("\nUnwind section "));
5288 printf (_("'%s'"), SECTION_NAME (sec
));
5290 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5291 (unsigned long) sec
->sh_offset
,
5292 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5294 slurp_hppa_unwind_table (file
, &aux
, sec
);
5295 if (aux
.table_len
> 0)
5296 dump_hppa_unwind (&aux
);
5299 free ((char *) aux
.table
);
5307 free ((char *) aux
.strtab
);
5313 process_unwind (FILE *file
)
5315 struct unwind_handler
{
5317 int (*handler
)(FILE *file
);
5319 { EM_IA_64
, ia64_process_unwind
},
5320 { EM_PARISC
, hppa_process_unwind
},
5328 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5329 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5330 return handlers
[i
].handler (file
);
5332 printf (_("\nThere are no unwind sections in this file.\n"));
5337 dynamic_section_mips_val (Elf_Internal_Dyn
*entry
)
5339 switch (entry
->d_tag
)
5342 if (entry
->d_un
.d_val
== 0)
5346 static const char * opts
[] =
5348 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5349 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5350 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5351 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5356 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++cnt
)
5357 if (entry
->d_un
.d_val
& (1 << cnt
))
5359 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5366 case DT_MIPS_IVERSION
:
5367 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5368 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5370 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5373 case DT_MIPS_TIME_STAMP
:
5378 time_t time
= entry
->d_un
.d_val
;
5379 tmp
= gmtime (&time
);
5380 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5381 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5382 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5383 printf ("Time Stamp: %s\n", timebuf
);
5387 case DT_MIPS_RLD_VERSION
:
5388 case DT_MIPS_LOCAL_GOTNO
:
5389 case DT_MIPS_CONFLICTNO
:
5390 case DT_MIPS_LIBLISTNO
:
5391 case DT_MIPS_SYMTABNO
:
5392 case DT_MIPS_UNREFEXTNO
:
5393 case DT_MIPS_HIPAGENO
:
5394 case DT_MIPS_DELTA_CLASS_NO
:
5395 case DT_MIPS_DELTA_INSTANCE_NO
:
5396 case DT_MIPS_DELTA_RELOC_NO
:
5397 case DT_MIPS_DELTA_SYM_NO
:
5398 case DT_MIPS_DELTA_CLASSSYM_NO
:
5399 case DT_MIPS_COMPACT_SIZE
:
5400 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5404 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
5410 dynamic_section_parisc_val (Elf_Internal_Dyn
*entry
)
5412 switch (entry
->d_tag
)
5414 case DT_HP_DLD_FLAGS
:
5423 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5424 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5425 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5426 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5427 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5428 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5429 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5430 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5431 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5432 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5433 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
5437 bfd_vma val
= entry
->d_un
.d_val
;
5439 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
5440 if (val
& flags
[cnt
].bit
)
5444 fputs (flags
[cnt
].str
, stdout
);
5446 val
^= flags
[cnt
].bit
;
5449 if (val
!= 0 || first
)
5453 print_vma (val
, HEX
);
5459 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5466 dynamic_section_ia64_val (Elf_Internal_Dyn
*entry
)
5468 switch (entry
->d_tag
)
5470 case DT_IA_64_PLT_RESERVE
:
5471 /* First 3 slots reserved. */
5472 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5474 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5478 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5485 get_32bit_dynamic_section (FILE *file
)
5487 Elf32_External_Dyn
*edyn
, *ext
;
5488 Elf_Internal_Dyn
*entry
;
5490 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5491 _("dynamic section"));
5495 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5496 might not have the luxury of section headers. Look for the DT_NULL
5497 terminator to determine the number of entries. */
5498 for (ext
= edyn
, dynamic_nent
= 0;
5499 (char *) ext
< (char *) edyn
+ dynamic_size
;
5503 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5507 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5508 if (dynamic_section
== NULL
)
5510 error (_("Out of memory\n"));
5515 for (ext
= edyn
, entry
= dynamic_section
;
5516 entry
< dynamic_section
+ dynamic_nent
;
5519 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5520 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5529 get_64bit_dynamic_section (FILE *file
)
5531 Elf64_External_Dyn
*edyn
, *ext
;
5532 Elf_Internal_Dyn
*entry
;
5534 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5535 _("dynamic section"));
5539 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5540 might not have the luxury of section headers. Look for the DT_NULL
5541 terminator to determine the number of entries. */
5542 for (ext
= edyn
, dynamic_nent
= 0;
5543 (char *) ext
< (char *) edyn
+ dynamic_size
;
5547 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5551 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5552 if (dynamic_section
== NULL
)
5554 error (_("Out of memory\n"));
5559 for (ext
= edyn
, entry
= dynamic_section
;
5560 entry
< dynamic_section
+ dynamic_nent
;
5563 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5564 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5573 print_dynamic_flags (bfd_vma flags
)
5581 flag
= flags
& - flags
;
5591 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
5592 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
5593 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
5594 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
5595 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
5596 default: fputs ("unknown", stdout
); break;
5602 /* Parse and display the contents of the dynamic section. */
5605 process_dynamic_section (FILE *file
)
5607 Elf_Internal_Dyn
*entry
;
5609 if (dynamic_size
== 0)
5612 printf (_("\nThere is no dynamic section in this file.\n"));
5619 if (! get_32bit_dynamic_section (file
))
5622 else if (! get_64bit_dynamic_section (file
))
5625 /* Find the appropriate symbol table. */
5626 if (dynamic_symbols
== NULL
)
5628 for (entry
= dynamic_section
;
5629 entry
< dynamic_section
+ dynamic_nent
;
5632 Elf_Internal_Shdr section
;
5634 if (entry
->d_tag
!= DT_SYMTAB
)
5637 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
5639 /* Since we do not know how big the symbol table is,
5640 we default to reading in the entire file (!) and
5641 processing that. This is overkill, I know, but it
5643 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5645 if (archive_file_offset
!= 0)
5646 section
.sh_size
= archive_file_size
- section
.sh_offset
;
5649 if (fseek (file
, 0, SEEK_END
))
5650 error (_("Unable to seek to end of file!"));
5652 section
.sh_size
= ftell (file
) - section
.sh_offset
;
5656 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
5658 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
5660 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
5661 if (num_dynamic_syms
< 1)
5663 error (_("Unable to determine the number of symbols to load\n"));
5667 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
5671 /* Similarly find a string table. */
5672 if (dynamic_strings
== NULL
)
5674 for (entry
= dynamic_section
;
5675 entry
< dynamic_section
+ dynamic_nent
;
5678 unsigned long offset
;
5681 if (entry
->d_tag
!= DT_STRTAB
)
5684 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
5686 /* Since we do not know how big the string table is,
5687 we default to reading in the entire file (!) and
5688 processing that. This is overkill, I know, but it
5691 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5693 if (archive_file_offset
!= 0)
5694 str_tab_len
= archive_file_size
- offset
;
5697 if (fseek (file
, 0, SEEK_END
))
5698 error (_("Unable to seek to end of file\n"));
5699 str_tab_len
= ftell (file
) - offset
;
5702 if (str_tab_len
< 1)
5705 (_("Unable to determine the length of the dynamic string table\n"));
5709 dynamic_strings
= get_data (NULL
, file
, offset
, 1, str_tab_len
,
5710 _("dynamic string table"));
5711 dynamic_strings_length
= str_tab_len
;
5716 /* And find the syminfo section if available. */
5717 if (dynamic_syminfo
== NULL
)
5719 unsigned long syminsz
= 0;
5721 for (entry
= dynamic_section
;
5722 entry
< dynamic_section
+ dynamic_nent
;
5725 if (entry
->d_tag
== DT_SYMINENT
)
5727 /* Note: these braces are necessary to avoid a syntax
5728 error from the SunOS4 C compiler. */
5729 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
5731 else if (entry
->d_tag
== DT_SYMINSZ
)
5732 syminsz
= entry
->d_un
.d_val
;
5733 else if (entry
->d_tag
== DT_SYMINFO
)
5734 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
5738 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
5740 Elf_External_Syminfo
*extsyminfo
, *extsym
;
5741 Elf_Internal_Syminfo
*syminfo
;
5743 /* There is a syminfo section. Read the data. */
5744 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, 1,
5745 syminsz
, _("symbol information"));
5749 dynamic_syminfo
= malloc (syminsz
);
5750 if (dynamic_syminfo
== NULL
)
5752 error (_("Out of memory\n"));
5756 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
5757 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
5758 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
5759 ++syminfo
, ++extsym
)
5761 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
5762 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
5769 if (do_dynamic
&& dynamic_addr
)
5770 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
5771 dynamic_addr
, dynamic_nent
);
5773 printf (_(" Tag Type Name/Value\n"));
5775 for (entry
= dynamic_section
;
5776 entry
< dynamic_section
+ dynamic_nent
;
5784 print_vma (entry
->d_tag
, FULL_HEX
);
5785 dtype
= get_dynamic_type (entry
->d_tag
);
5786 printf (" (%s)%*s", dtype
,
5787 ((is_32bit_elf
? 27 : 19)
5788 - (int) strlen (dtype
)),
5792 switch (entry
->d_tag
)
5796 print_dynamic_flags (entry
->d_un
.d_val
);
5806 switch (entry
->d_tag
)
5809 printf (_("Auxiliary library"));
5813 printf (_("Filter library"));
5817 printf (_("Configuration file"));
5821 printf (_("Dependency audit library"));
5825 printf (_("Audit library"));
5829 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5830 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5834 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5843 printf (_("Flags:"));
5845 if (entry
->d_un
.d_val
== 0)
5846 printf (_(" None\n"));
5849 unsigned long int val
= entry
->d_un
.d_val
;
5851 if (val
& DTF_1_PARINIT
)
5853 printf (" PARINIT");
5854 val
^= DTF_1_PARINIT
;
5856 if (val
& DTF_1_CONFEXP
)
5858 printf (" CONFEXP");
5859 val
^= DTF_1_CONFEXP
;
5862 printf (" %lx", val
);
5871 printf (_("Flags:"));
5873 if (entry
->d_un
.d_val
== 0)
5874 printf (_(" None\n"));
5877 unsigned long int val
= entry
->d_un
.d_val
;
5879 if (val
& DF_P1_LAZYLOAD
)
5881 printf (" LAZYLOAD");
5882 val
^= DF_P1_LAZYLOAD
;
5884 if (val
& DF_P1_GROUPPERM
)
5886 printf (" GROUPPERM");
5887 val
^= DF_P1_GROUPPERM
;
5890 printf (" %lx", val
);
5899 printf (_("Flags:"));
5900 if (entry
->d_un
.d_val
== 0)
5901 printf (_(" None\n"));
5904 unsigned long int val
= entry
->d_un
.d_val
;
5911 if (val
& DF_1_GLOBAL
)
5916 if (val
& DF_1_GROUP
)
5921 if (val
& DF_1_NODELETE
)
5923 printf (" NODELETE");
5924 val
^= DF_1_NODELETE
;
5926 if (val
& DF_1_LOADFLTR
)
5928 printf (" LOADFLTR");
5929 val
^= DF_1_LOADFLTR
;
5931 if (val
& DF_1_INITFIRST
)
5933 printf (" INITFIRST");
5934 val
^= DF_1_INITFIRST
;
5936 if (val
& DF_1_NOOPEN
)
5941 if (val
& DF_1_ORIGIN
)
5946 if (val
& DF_1_DIRECT
)
5951 if (val
& DF_1_TRANS
)
5956 if (val
& DF_1_INTERPOSE
)
5958 printf (" INTERPOSE");
5959 val
^= DF_1_INTERPOSE
;
5961 if (val
& DF_1_NODEFLIB
)
5963 printf (" NODEFLIB");
5964 val
^= DF_1_NODEFLIB
;
5966 if (val
& DF_1_NODUMP
)
5971 if (val
& DF_1_CONLFAT
)
5973 printf (" CONLFAT");
5974 val
^= DF_1_CONLFAT
;
5977 printf (" %lx", val
);
5984 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5986 puts (get_dynamic_type (entry
->d_un
.d_val
));
6006 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6012 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6013 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6019 switch (entry
->d_tag
)
6022 printf (_("Shared library: [%s]"), name
);
6024 if (streq (name
, program_interpreter
))
6025 printf (_(" program interpreter"));
6029 printf (_("Library soname: [%s]"), name
);
6033 printf (_("Library rpath: [%s]"), name
);
6037 printf (_("Library runpath: [%s]"), name
);
6041 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6046 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6059 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6063 case DT_INIT_ARRAYSZ
:
6064 case DT_FINI_ARRAYSZ
:
6065 case DT_GNU_CONFLICTSZ
:
6066 case DT_GNU_LIBLISTSZ
:
6069 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6070 printf (" (bytes)\n");
6080 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6093 if (entry
->d_tag
== DT_USED
6094 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6096 char *name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6100 printf (_("Not needed object: [%s]\n"), name
);
6105 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6111 /* The value of this entry is ignored. */
6116 case DT_GNU_PRELINKED
:
6120 time_t time
= entry
->d_un
.d_val
;
6122 tmp
= gmtime (&time
);
6123 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6124 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6125 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6131 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
6132 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
6137 switch (elf_header
.e_machine
)
6140 case EM_MIPS_RS3_LE
:
6141 dynamic_section_mips_val (entry
);
6144 dynamic_section_parisc_val (entry
);
6147 dynamic_section_ia64_val (entry
);
6150 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6162 get_ver_flags (unsigned int flags
)
6164 static char buff
[32];
6171 if (flags
& VER_FLG_BASE
)
6172 strcat (buff
, "BASE ");
6174 if (flags
& VER_FLG_WEAK
)
6176 if (flags
& VER_FLG_BASE
)
6177 strcat (buff
, "| ");
6179 strcat (buff
, "WEAK ");
6182 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
6183 strcat (buff
, "| <unknown>");
6188 /* Display the contents of the version sections. */
6190 process_version_sections (FILE *file
)
6192 Elf_Internal_Shdr
*section
;
6199 for (i
= 0, section
= section_headers
;
6200 i
< elf_header
.e_shnum
;
6203 switch (section
->sh_type
)
6205 case SHT_GNU_verdef
:
6207 Elf_External_Verdef
*edefs
;
6214 (_("\nVersion definition section '%s' contains %ld entries:\n"),
6215 SECTION_NAME (section
), section
->sh_info
);
6217 printf (_(" Addr: 0x"));
6218 printf_vma (section
->sh_addr
);
6219 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6220 (unsigned long) section
->sh_offset
, section
->sh_link
,
6221 SECTION_HEADER_INDEX (section
->sh_link
)
6222 < elf_header
.e_shnum
6223 ? SECTION_NAME (SECTION_HEADER (section
->sh_link
))
6226 edefs
= get_data (NULL
, file
, section
->sh_offset
, 1,
6228 _("version definition section"));
6232 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6235 Elf_External_Verdef
*edef
;
6236 Elf_Internal_Verdef ent
;
6237 Elf_External_Verdaux
*eaux
;
6238 Elf_Internal_Verdaux aux
;
6242 vstart
= ((char *) edefs
) + idx
;
6244 edef
= (Elf_External_Verdef
*) vstart
;
6246 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
6247 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
6248 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
6249 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
6250 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
6251 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
6252 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
6254 printf (_(" %#06x: Rev: %d Flags: %s"),
6255 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
6257 printf (_(" Index: %d Cnt: %d "),
6258 ent
.vd_ndx
, ent
.vd_cnt
);
6260 vstart
+= ent
.vd_aux
;
6262 eaux
= (Elf_External_Verdaux
*) vstart
;
6264 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6265 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6267 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6268 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6270 printf (_("Name index: %ld\n"), aux
.vda_name
);
6272 isum
= idx
+ ent
.vd_aux
;
6274 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6276 isum
+= aux
.vda_next
;
6277 vstart
+= aux
.vda_next
;
6279 eaux
= (Elf_External_Verdaux
*) vstart
;
6281 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6282 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6284 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6285 printf (_(" %#06x: Parent %d: %s\n"),
6286 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6288 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6289 isum
, j
, aux
.vda_name
);
6299 case SHT_GNU_verneed
:
6301 Elf_External_Verneed
*eneed
;
6307 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
6308 SECTION_NAME (section
), section
->sh_info
);
6310 printf (_(" Addr: 0x"));
6311 printf_vma (section
->sh_addr
);
6312 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
6313 (unsigned long) section
->sh_offset
, section
->sh_link
,
6314 SECTION_HEADER_INDEX (section
->sh_link
)
6315 < elf_header
.e_shnum
6316 ? SECTION_NAME (SECTION_HEADER (section
->sh_link
))
6319 eneed
= get_data (NULL
, file
, section
->sh_offset
, 1,
6321 _("version need section"));
6325 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6327 Elf_External_Verneed
*entry
;
6328 Elf_Internal_Verneed ent
;
6333 vstart
= ((char *) eneed
) + idx
;
6335 entry
= (Elf_External_Verneed
*) vstart
;
6337 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6338 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6339 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6340 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6341 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6343 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6345 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6346 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6348 printf (_(" File: %lx"), ent
.vn_file
);
6350 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6352 vstart
+= ent
.vn_aux
;
6354 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6356 Elf_External_Vernaux
*eaux
;
6357 Elf_Internal_Vernaux aux
;
6359 eaux
= (Elf_External_Vernaux
*) vstart
;
6361 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6362 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6363 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6364 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6365 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6367 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6368 printf (_(" %#06x: Name: %s"),
6369 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6371 printf (_(" %#06x: Name index: %lx"),
6372 isum
, aux
.vna_name
);
6374 printf (_(" Flags: %s Version: %d\n"),
6375 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6377 isum
+= aux
.vna_next
;
6378 vstart
+= aux
.vna_next
;
6388 case SHT_GNU_versym
:
6390 Elf_Internal_Shdr
*link_section
;
6393 unsigned char *edata
;
6394 unsigned short *data
;
6396 Elf_Internal_Sym
*symbols
;
6397 Elf_Internal_Shdr
*string_sec
;
6400 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
)
6403 link_section
= SECTION_HEADER (section
->sh_link
);
6404 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
6406 if (SECTION_HEADER_INDEX (link_section
->sh_link
)
6407 >= elf_header
.e_shnum
)
6412 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6414 string_sec
= SECTION_HEADER (link_section
->sh_link
);
6416 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
6417 string_sec
->sh_size
, _("version string table"));
6421 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6422 SECTION_NAME (section
), total
);
6424 printf (_(" Addr: "));
6425 printf_vma (section
->sh_addr
);
6426 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6427 (unsigned long) section
->sh_offset
, section
->sh_link
,
6428 SECTION_NAME (link_section
));
6430 off
= offset_from_vma (file
,
6431 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6432 total
* sizeof (short));
6433 edata
= get_data (NULL
, file
, off
, total
, sizeof (short),
6434 _("version symbol data"));
6441 data
= cmalloc (total
, sizeof (short));
6443 for (cnt
= total
; cnt
--;)
6444 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6449 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6452 int check_def
, check_need
;
6455 printf (" %03x:", cnt
);
6457 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6458 switch (data
[cnt
+ j
])
6461 fputs (_(" 0 (*local*) "), stdout
);
6465 fputs (_(" 1 (*global*) "), stdout
);
6469 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
6470 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
6474 if (SECTION_HEADER_INDEX (symbols
[cnt
+ j
].st_shndx
)
6475 >= elf_header
.e_shnum
6476 || SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
6479 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6486 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6488 Elf_Internal_Verneed ivn
;
6489 unsigned long offset
;
6491 offset
= offset_from_vma
6492 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6493 sizeof (Elf_External_Verneed
));
6497 Elf_Internal_Vernaux ivna
;
6498 Elf_External_Verneed evn
;
6499 Elf_External_Vernaux evna
;
6500 unsigned long a_off
;
6502 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
6505 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6506 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6508 a_off
= offset
+ ivn
.vn_aux
;
6512 get_data (&evna
, file
, a_off
, sizeof (evna
),
6513 1, _("version need aux (2)"));
6515 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6516 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6518 a_off
+= ivna
.vna_next
;
6520 while (ivna
.vna_other
!= data
[cnt
+ j
]
6521 && ivna
.vna_next
!= 0);
6523 if (ivna
.vna_other
== data
[cnt
+ j
])
6525 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6527 name
= strtab
+ ivna
.vna_name
;
6528 nn
+= printf ("(%s%-*s",
6530 12 - (int) strlen (name
),
6536 offset
+= ivn
.vn_next
;
6538 while (ivn
.vn_next
);
6541 if (check_def
&& data
[cnt
+ j
] != 0x8001
6542 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6544 Elf_Internal_Verdef ivd
;
6545 Elf_External_Verdef evd
;
6546 unsigned long offset
;
6548 offset
= offset_from_vma
6549 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6554 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
6557 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6558 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6560 offset
+= ivd
.vd_next
;
6562 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
6563 && ivd
.vd_next
!= 0);
6565 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
6567 Elf_External_Verdaux evda
;
6568 Elf_Internal_Verdaux ivda
;
6570 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6572 get_data (&evda
, file
,
6573 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
6575 _("version def aux"));
6577 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6579 name
= strtab
+ ivda
.vda_name
;
6580 nn
+= printf ("(%s%-*s",
6582 12 - (int) strlen (name
),
6588 printf ("%*c", 18 - nn
, ' ');
6606 printf (_("\nNo version information found in this file.\n"));
6612 get_symbol_binding (unsigned int binding
)
6614 static char buff
[32];
6618 case STB_LOCAL
: return "LOCAL";
6619 case STB_GLOBAL
: return "GLOBAL";
6620 case STB_WEAK
: return "WEAK";
6622 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
6623 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
6625 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
6626 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
6628 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
6634 get_symbol_type (unsigned int type
)
6636 static char buff
[32];
6640 case STT_NOTYPE
: return "NOTYPE";
6641 case STT_OBJECT
: return "OBJECT";
6642 case STT_FUNC
: return "FUNC";
6643 case STT_SECTION
: return "SECTION";
6644 case STT_FILE
: return "FILE";
6645 case STT_COMMON
: return "COMMON";
6646 case STT_TLS
: return "TLS";
6648 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
6650 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
6651 return "THUMB_FUNC";
6653 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
6656 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
6657 return "PARISC_MILLI";
6659 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
6661 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
6663 if (elf_header
.e_machine
== EM_PARISC
)
6665 if (type
== STT_HP_OPAQUE
)
6667 if (type
== STT_HP_STUB
)
6671 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
6674 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
6680 get_symbol_visibility (unsigned int visibility
)
6684 case STV_DEFAULT
: return "DEFAULT";
6685 case STV_INTERNAL
: return "INTERNAL";
6686 case STV_HIDDEN
: return "HIDDEN";
6687 case STV_PROTECTED
: return "PROTECTED";
6693 get_symbol_index_type (unsigned int type
)
6695 static char buff
[32];
6699 case SHN_UNDEF
: return "UND";
6700 case SHN_ABS
: return "ABS";
6701 case SHN_COMMON
: return "COM";
6703 if (type
== SHN_IA_64_ANSI_COMMON
6704 && elf_header
.e_machine
== EM_IA_64
6705 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
6707 else if (elf_header
.e_machine
== EM_X86_64
6708 && type
== SHN_X86_64_LCOMMON
)
6710 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
6711 sprintf (buff
, "PRC[0x%04x]", type
);
6712 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
6713 sprintf (buff
, "OS [0x%04x]", type
);
6714 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
6715 sprintf (buff
, "RSV[0x%04x]", type
);
6717 sprintf (buff
, "%3d", type
);
6725 get_dynamic_data (FILE *file
, unsigned int number
, unsigned int ent_size
)
6727 unsigned char *e_data
;
6730 e_data
= cmalloc (number
, ent_size
);
6734 error (_("Out of memory\n"));
6738 if (fread (e_data
, ent_size
, number
, file
) != number
)
6740 error (_("Unable to read in dynamic data\n"));
6744 i_data
= cmalloc (number
, sizeof (*i_data
));
6748 error (_("Out of memory\n"));
6754 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
6761 /* Dump the symbol table. */
6763 process_symbol_table (FILE *file
)
6765 Elf_Internal_Shdr
*section
;
6766 bfd_vma nbuckets
= 0;
6767 bfd_vma nchains
= 0;
6768 bfd_vma
*buckets
= NULL
;
6769 bfd_vma
*chains
= NULL
;
6771 if (! do_syms
&& !do_histogram
)
6774 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
6777 unsigned char nb
[8];
6778 unsigned char nc
[8];
6779 int hash_ent_size
= 4;
6781 if ((elf_header
.e_machine
== EM_ALPHA
6782 || elf_header
.e_machine
== EM_S390
6783 || elf_header
.e_machine
== EM_S390_OLD
)
6784 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
6788 (archive_file_offset
6789 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
6790 sizeof nb
+ sizeof nc
)),
6793 error (_("Unable to seek to start of dynamic information"));
6797 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
6799 error (_("Failed to read in number of buckets\n"));
6803 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
6805 error (_("Failed to read in number of chains\n"));
6809 nbuckets
= byte_get (nb
, hash_ent_size
);
6810 nchains
= byte_get (nc
, hash_ent_size
);
6812 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
6813 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
6815 if (buckets
== NULL
|| chains
== NULL
)
6820 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
6825 printf (_("\nSymbol table for image:\n"));
6827 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6829 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6831 for (hn
= 0; hn
< nbuckets
; hn
++)
6836 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
6838 Elf_Internal_Sym
*psym
;
6841 psym
= dynamic_symbols
+ si
;
6843 n
= print_vma (si
, DEC_5
);
6845 fputs (" " + n
, stdout
);
6846 printf (" %3lu: ", hn
);
6847 print_vma (psym
->st_value
, LONG_HEX
);
6849 print_vma (psym
->st_size
, DEC_5
);
6851 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6852 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6853 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6854 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
6855 if (VALID_DYNAMIC_NAME (psym
->st_name
))
6856 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
6858 printf (" <corrupt: %14ld>", psym
->st_name
);
6863 else if (do_syms
&& !do_using_dynamic
)
6867 for (i
= 0, section
= section_headers
;
6868 i
< elf_header
.e_shnum
;
6872 char *strtab
= NULL
;
6873 unsigned long int strtab_size
= 0;
6874 Elf_Internal_Sym
*symtab
;
6875 Elf_Internal_Sym
*psym
;
6878 if ( section
->sh_type
!= SHT_SYMTAB
6879 && section
->sh_type
!= SHT_DYNSYM
)
6882 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
6883 SECTION_NAME (section
),
6884 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
6886 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6888 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6890 symtab
= GET_ELF_SYMBOLS (file
, section
);
6894 if (section
->sh_link
== elf_header
.e_shstrndx
)
6896 strtab
= string_table
;
6897 strtab_size
= string_table_length
;
6899 else if (SECTION_HEADER_INDEX (section
->sh_link
) < elf_header
.e_shnum
)
6901 Elf_Internal_Shdr
*string_sec
;
6903 string_sec
= SECTION_HEADER (section
->sh_link
);
6905 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
6906 1, string_sec
->sh_size
, _("string table"));
6907 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
6910 for (si
= 0, psym
= symtab
;
6911 si
< section
->sh_size
/ section
->sh_entsize
;
6914 printf ("%6d: ", si
);
6915 print_vma (psym
->st_value
, LONG_HEX
);
6917 print_vma (psym
->st_size
, DEC_5
);
6918 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6919 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6920 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6921 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
6922 print_symbol (25, psym
->st_name
< strtab_size
6923 ? strtab
+ psym
->st_name
: "<corrupt>");
6925 if (section
->sh_type
== SHT_DYNSYM
&&
6926 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
6928 unsigned char data
[2];
6929 unsigned short vers_data
;
6930 unsigned long offset
;
6934 offset
= offset_from_vma
6935 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6936 sizeof data
+ si
* sizeof (vers_data
));
6938 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
6939 sizeof (data
), 1, _("version data"));
6941 vers_data
= byte_get (data
, 2);
6943 is_nobits
= (SECTION_HEADER_INDEX (psym
->st_shndx
)
6944 < elf_header
.e_shnum
6945 && SECTION_HEADER (psym
->st_shndx
)->sh_type
6948 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
6950 if ((vers_data
& 0x8000) || vers_data
> 1)
6952 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
6953 && (is_nobits
|| ! check_def
))
6955 Elf_External_Verneed evn
;
6956 Elf_Internal_Verneed ivn
;
6957 Elf_Internal_Vernaux ivna
;
6959 /* We must test both. */
6960 offset
= offset_from_vma
6961 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6966 unsigned long vna_off
;
6968 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
6971 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6972 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6974 vna_off
= offset
+ ivn
.vn_aux
;
6978 Elf_External_Vernaux evna
;
6980 get_data (&evna
, file
, vna_off
,
6982 _("version need aux (3)"));
6984 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6985 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6986 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6988 vna_off
+= ivna
.vna_next
;
6990 while (ivna
.vna_other
!= vers_data
6991 && ivna
.vna_next
!= 0);
6993 if (ivna
.vna_other
== vers_data
)
6996 offset
+= ivn
.vn_next
;
6998 while (ivn
.vn_next
!= 0);
7000 if (ivna
.vna_other
== vers_data
)
7003 ivna
.vna_name
< strtab_size
7004 ? strtab
+ ivna
.vna_name
: "<corrupt>",
7008 else if (! is_nobits
)
7009 error (_("bad dynamic symbol"));
7016 if (vers_data
!= 0x8001
7017 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7019 Elf_Internal_Verdef ivd
;
7020 Elf_Internal_Verdaux ivda
;
7021 Elf_External_Verdaux evda
;
7022 unsigned long offset
;
7024 offset
= offset_from_vma
7026 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7027 sizeof (Elf_External_Verdef
));
7031 Elf_External_Verdef evd
;
7033 get_data (&evd
, file
, offset
, sizeof (evd
),
7034 1, _("version def"));
7036 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7037 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7038 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7040 offset
+= ivd
.vd_next
;
7042 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
7043 && ivd
.vd_next
!= 0);
7045 offset
-= ivd
.vd_next
;
7046 offset
+= ivd
.vd_aux
;
7048 get_data (&evda
, file
, offset
, sizeof (evda
),
7049 1, _("version def aux"));
7051 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7053 if (psym
->st_name
!= ivda
.vda_name
)
7054 printf ((vers_data
& 0x8000)
7056 ivda
.vda_name
< strtab_size
7057 ? strtab
+ ivda
.vda_name
: "<corrupt>");
7067 if (strtab
!= string_table
)
7073 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7075 if (do_histogram
&& buckets
!= NULL
)
7077 unsigned long *lengths
;
7078 unsigned long *counts
;
7081 unsigned long maxlength
= 0;
7082 unsigned long nzero_counts
= 0;
7083 unsigned long nsyms
= 0;
7085 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7086 (unsigned long) nbuckets
);
7087 printf (_(" Length Number %% of total Coverage\n"));
7089 lengths
= calloc (nbuckets
, sizeof (*lengths
));
7090 if (lengths
== NULL
)
7092 error (_("Out of memory"));
7095 for (hn
= 0; hn
< nbuckets
; ++hn
)
7097 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
7100 if (maxlength
< ++lengths
[hn
])
7105 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7108 error (_("Out of memory"));
7112 for (hn
= 0; hn
< nbuckets
; ++hn
)
7113 ++counts
[lengths
[hn
]];
7118 printf (" 0 %-10lu (%5.1f%%)\n",
7119 counts
[0], (counts
[0] * 100.0) / nbuckets
);
7120 for (i
= 1; i
<= maxlength
; ++i
)
7122 nzero_counts
+= counts
[i
] * i
;
7123 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7124 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
7125 (nzero_counts
* 100.0) / nsyms
);
7133 if (buckets
!= NULL
)
7143 process_syminfo (FILE *file ATTRIBUTE_UNUSED
)
7147 if (dynamic_syminfo
== NULL
7149 /* No syminfo, this is ok. */
7152 /* There better should be a dynamic symbol section. */
7153 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
7157 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7158 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
7160 printf (_(" Num: Name BoundTo Flags\n"));
7161 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
7163 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
7165 printf ("%4d: ", i
);
7166 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
7167 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
7169 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
7172 switch (dynamic_syminfo
[i
].si_boundto
)
7174 case SYMINFO_BT_SELF
:
7175 fputs ("SELF ", stdout
);
7177 case SYMINFO_BT_PARENT
:
7178 fputs ("PARENT ", stdout
);
7181 if (dynamic_syminfo
[i
].si_boundto
> 0
7182 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
7183 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
7185 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
7189 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
7193 if (flags
& SYMINFO_FLG_DIRECT
)
7195 if (flags
& SYMINFO_FLG_PASSTHRU
)
7196 printf (" PASSTHRU");
7197 if (flags
& SYMINFO_FLG_COPY
)
7199 if (flags
& SYMINFO_FLG_LAZYLOAD
)
7200 printf (" LAZYLOAD");
7208 #ifdef SUPPORT_DISASSEMBLY
7210 disassemble_section (Elf_Internal_Shdr
*section
, FILE *file
)
7212 printf (_("\nAssembly dump of section %s\n"),
7213 SECTION_NAME (section
));
7215 /* XXX -- to be done --- XXX */
7222 dump_section (Elf_Internal_Shdr
*section
, FILE *file
)
7224 bfd_size_type bytes
;
7226 unsigned char *data
;
7227 unsigned char *start
;
7229 bytes
= section
->sh_size
;
7231 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
7233 printf (_("\nSection '%s' has no data to dump.\n"),
7234 SECTION_NAME (section
));
7238 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
7240 addr
= section
->sh_addr
;
7242 start
= get_data (NULL
, file
, section
->sh_offset
, 1, bytes
,
7255 lbytes
= (bytes
> 16 ? 16 : bytes
);
7257 printf (" 0x%8.8lx ", (unsigned long) addr
);
7259 switch (elf_header
.e_ident
[EI_DATA
])
7263 for (j
= 15; j
>= 0; j
--)
7266 printf ("%2.2x", data
[j
]);
7276 for (j
= 0; j
< 16; j
++)
7279 printf ("%2.2x", data
[j
]);
7289 for (j
= 0; j
< lbytes
; j
++)
7292 if (k
>= ' ' && k
< 0x7f)
7311 static unsigned long int
7312 read_leb128 (unsigned char *data
, unsigned int *length_return
, int sign
)
7314 unsigned long int result
= 0;
7315 unsigned int num_read
= 0;
7316 unsigned int shift
= 0;
7324 result
|= ((unsigned long int) (byte
& 0x7f)) << shift
;
7329 while (byte
& 0x80);
7331 if (length_return
!= NULL
)
7332 *length_return
= num_read
;
7334 if (sign
&& (shift
< 8 * sizeof (result
)) && (byte
& 0x40))
7335 result
|= -1L << shift
;
7340 typedef struct State_Machine_Registers
7342 unsigned long address
;
7345 unsigned int column
;
7349 /* This variable hold the number of the last entry seen
7350 in the File Table. */
7351 unsigned int last_file_entry
;
7354 static SMR state_machine_regs
;
7357 reset_state_machine (int is_stmt
)
7359 state_machine_regs
.address
= 0;
7360 state_machine_regs
.file
= 1;
7361 state_machine_regs
.line
= 1;
7362 state_machine_regs
.column
= 0;
7363 state_machine_regs
.is_stmt
= is_stmt
;
7364 state_machine_regs
.basic_block
= 0;
7365 state_machine_regs
.end_sequence
= 0;
7366 state_machine_regs
.last_file_entry
= 0;
7369 /* Handled an extend line op.
7370 Returns the number of bytes read. */
7373 process_extended_line_op (unsigned char *data
, int is_stmt
, int pointer_size
)
7375 unsigned char op_code
;
7376 unsigned int bytes_read
;
7378 unsigned char *name
;
7381 len
= read_leb128 (data
, & bytes_read
, 0);
7386 warn (_("badly formed extended line op encountered!\n"));
7393 printf (_(" Extended opcode %d: "), op_code
);
7397 case DW_LNE_end_sequence
:
7398 printf (_("End of Sequence\n\n"));
7399 reset_state_machine (is_stmt
);
7402 case DW_LNE_set_address
:
7403 adr
= byte_get (data
, pointer_size
);
7404 printf (_("set Address to 0x%lx\n"), adr
);
7405 state_machine_regs
.address
= adr
;
7408 case DW_LNE_define_file
:
7409 printf (_(" define new File Table entry\n"));
7410 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
7412 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
7414 data
+= strlen ((char *) data
) + 1;
7415 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7417 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7419 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7420 printf (_("%s\n\n"), name
);
7424 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
7431 static const char *debug_str_contents
;
7432 static bfd_vma debug_str_size
;
7435 load_debug_str (FILE *file
)
7437 Elf_Internal_Shdr
*sec
;
7439 /* If it is already loaded, do nothing. */
7440 if (debug_str_contents
!= NULL
)
7443 /* Locate the .debug_str section. */
7444 sec
= find_section (".debug_str");
7448 debug_str_size
= sec
->sh_size
;
7450 debug_str_contents
= get_data (NULL
, file
, sec
->sh_offset
, 1, sec
->sh_size
,
7451 _("debug_str section data"));
7455 free_debug_str (void)
7457 if (debug_str_contents
== NULL
)
7460 free ((char *) debug_str_contents
);
7461 debug_str_contents
= NULL
;
7466 fetch_indirect_string (unsigned long offset
)
7468 if (debug_str_contents
== NULL
)
7469 return _("<no .debug_str section>");
7471 if (offset
> debug_str_size
)
7473 warn (_("DW_FORM_strp offset too big: %lx\n"), offset
);
7474 return _("<offset is too big>");
7477 return debug_str_contents
+ offset
;
7480 static const char *debug_loc_contents
;
7481 static bfd_vma debug_loc_size
;
7484 load_debug_loc (FILE *file
)
7486 Elf_Internal_Shdr
*sec
;
7488 /* If it is already loaded, do nothing. */
7489 if (debug_loc_contents
!= NULL
)
7492 /* Locate the .debug_loc section. */
7493 sec
= find_section (".debug_loc");
7497 debug_loc_size
= sec
->sh_size
;
7499 debug_loc_contents
= get_data (NULL
, file
, sec
->sh_offset
, 1, sec
->sh_size
,
7500 _("debug_loc section data"));
7504 free_debug_loc (void)
7506 if (debug_loc_contents
== NULL
)
7509 free ((char *) debug_loc_contents
);
7510 debug_loc_contents
= NULL
;
7514 static const char * debug_range_contents
;
7515 static unsigned long debug_range_size
;
7518 load_debug_range (FILE *file
)
7520 Elf_Internal_Shdr
*sec
;
7522 /* If it is already loaded, do nothing. */
7523 if (debug_range_contents
!= NULL
)
7526 /* Locate the .debug_ranges section. */
7527 sec
= find_section (".debug_ranges");
7531 debug_range_size
= sec
->sh_size
;
7533 debug_range_contents
= get_data (NULL
, file
, sec
->sh_offset
, 1, sec
->sh_size
,
7534 _("debug_range section data"));
7538 free_debug_range (void)
7540 if (debug_range_contents
== NULL
)
7543 free ((char *) debug_range_contents
);
7544 debug_range_contents
= NULL
;
7545 debug_range_size
= 0;
7548 /* Apply addends of RELA relocations. */
7551 debug_apply_rela_addends (FILE *file
,
7552 Elf_Internal_Shdr
*section
,
7554 unsigned char *sec_data
,
7555 unsigned char *start
,
7558 Elf_Internal_Shdr
*relsec
;
7560 if (end
- start
< reloc_size
)
7563 for (relsec
= section_headers
;
7564 relsec
< section_headers
+ elf_header
.e_shnum
;
7567 unsigned long nrelas
;
7568 Elf_Internal_Rela
*rela
, *rp
;
7569 Elf_Internal_Shdr
*symsec
;
7570 Elf_Internal_Sym
*symtab
;
7571 Elf_Internal_Sym
*sym
;
7573 if (relsec
->sh_type
!= SHT_RELA
7574 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
7575 || SECTION_HEADER (relsec
->sh_info
) != section
7576 || relsec
->sh_size
== 0
7577 || SECTION_HEADER_INDEX (relsec
->sh_link
) >= elf_header
.e_shnum
)
7580 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7584 symsec
= SECTION_HEADER (relsec
->sh_link
);
7585 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
7587 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7591 if (rp
->r_offset
>= (bfd_vma
) (start
- sec_data
)
7592 && rp
->r_offset
< (bfd_vma
) (end
- sec_data
) - reloc_size
)
7593 loc
= sec_data
+ rp
->r_offset
;
7599 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
7601 if (ELF32_R_SYM (rp
->r_info
) != 0
7602 && ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
7603 /* Relocations against object symbols can happen,
7604 eg when referencing a global array. For an
7605 example of this see the _clz.o binary in libgcc.a. */
7606 && ELF32_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7608 warn (_("skipping unexpected symbol type %s in relocation in section .rela%s\n"),
7609 get_symbol_type (ELF32_ST_TYPE (sym
->st_info
)),
7610 SECTION_NAME (section
));
7616 /* In MIPS little-endian objects, r_info isn't really a
7617 64-bit little-endian value: it has a 32-bit little-endian
7618 symbol index followed by four individual byte fields.
7619 Reorder INFO accordingly. */
7620 if (elf_header
.e_machine
== EM_MIPS
7621 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
7622 rp
->r_info
= (((rp
->r_info
& 0xffffffff) << 32)
7623 | ((rp
->r_info
>> 56) & 0xff)
7624 | ((rp
->r_info
>> 40) & 0xff00)
7625 | ((rp
->r_info
>> 24) & 0xff0000)
7626 | ((rp
->r_info
>> 8) & 0xff000000));
7628 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
7630 if (ELF64_R_SYM (rp
->r_info
) != 0
7631 && ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
7632 && ELF64_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7634 warn (_("skipping unexpected symbol type %s in relocation in section .rela.%s\n"),
7635 get_symbol_type (ELF64_ST_TYPE (sym
->st_info
)),
7636 SECTION_NAME (section
));
7641 byte_put (loc
, rp
->r_addend
, reloc_size
);
7651 /* FIXME: There are better and more efficient ways to handle
7652 these structures. For now though, I just want something that
7653 is simple to implement. */
7654 typedef struct abbrev_attr
7656 unsigned long attribute
;
7658 struct abbrev_attr
*next
;
7662 typedef struct abbrev_entry
7664 unsigned long entry
;
7667 struct abbrev_attr
*first_attr
;
7668 struct abbrev_attr
*last_attr
;
7669 struct abbrev_entry
*next
;
7673 static abbrev_entry
*first_abbrev
= NULL
;
7674 static abbrev_entry
*last_abbrev
= NULL
;
7679 abbrev_entry
*abbrev
;
7681 for (abbrev
= first_abbrev
; abbrev
;)
7683 abbrev_entry
*next
= abbrev
->next
;
7686 for (attr
= abbrev
->first_attr
; attr
;)
7688 abbrev_attr
*next
= attr
->next
;
7698 last_abbrev
= first_abbrev
= NULL
;
7702 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
7704 abbrev_entry
*entry
;
7706 entry
= malloc (sizeof (*entry
));
7712 entry
->entry
= number
;
7714 entry
->children
= children
;
7715 entry
->first_attr
= NULL
;
7716 entry
->last_attr
= NULL
;
7719 if (first_abbrev
== NULL
)
7720 first_abbrev
= entry
;
7722 last_abbrev
->next
= entry
;
7724 last_abbrev
= entry
;
7728 add_abbrev_attr (unsigned long attribute
, unsigned long form
)
7732 attr
= malloc (sizeof (*attr
));
7738 attr
->attribute
= attribute
;
7742 if (last_abbrev
->first_attr
== NULL
)
7743 last_abbrev
->first_attr
= attr
;
7745 last_abbrev
->last_attr
->next
= attr
;
7747 last_abbrev
->last_attr
= attr
;
7750 /* Processes the (partial) contents of a .debug_abbrev section.
7751 Returns NULL if the end of the section was encountered.
7752 Returns the address after the last byte read if the end of
7753 an abbreviation set was found. */
7755 static unsigned char *
7756 process_abbrev_section (unsigned char *start
, unsigned char *end
)
7758 if (first_abbrev
!= NULL
)
7763 unsigned int bytes_read
;
7764 unsigned long entry
;
7766 unsigned long attribute
;
7769 entry
= read_leb128 (start
, & bytes_read
, 0);
7770 start
+= bytes_read
;
7772 /* A single zero is supposed to end the section according
7773 to the standard. If there's more, then signal that to
7776 return start
== end
? NULL
: start
;
7778 tag
= read_leb128 (start
, & bytes_read
, 0);
7779 start
+= bytes_read
;
7781 children
= *start
++;
7783 add_abbrev (entry
, tag
, children
);
7789 attribute
= read_leb128 (start
, & bytes_read
, 0);
7790 start
+= bytes_read
;
7792 form
= read_leb128 (start
, & bytes_read
, 0);
7793 start
+= bytes_read
;
7796 add_abbrev_attr (attribute
, form
);
7798 while (attribute
!= 0);
7805 get_TAG_name (unsigned long tag
)
7809 case DW_TAG_padding
: return "DW_TAG_padding";
7810 case DW_TAG_array_type
: return "DW_TAG_array_type";
7811 case DW_TAG_class_type
: return "DW_TAG_class_type";
7812 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
7813 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
7814 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
7815 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
7816 case DW_TAG_label
: return "DW_TAG_label";
7817 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
7818 case DW_TAG_member
: return "DW_TAG_member";
7819 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
7820 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
7821 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
7822 case DW_TAG_string_type
: return "DW_TAG_string_type";
7823 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
7824 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
7825 case DW_TAG_typedef
: return "DW_TAG_typedef";
7826 case DW_TAG_union_type
: return "DW_TAG_union_type";
7827 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
7828 case DW_TAG_variant
: return "DW_TAG_variant";
7829 case DW_TAG_common_block
: return "DW_TAG_common_block";
7830 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
7831 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
7832 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
7833 case DW_TAG_module
: return "DW_TAG_module";
7834 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
7835 case DW_TAG_set_type
: return "DW_TAG_set_type";
7836 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
7837 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
7838 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
7839 case DW_TAG_base_type
: return "DW_TAG_base_type";
7840 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
7841 case DW_TAG_const_type
: return "DW_TAG_const_type";
7842 case DW_TAG_constant
: return "DW_TAG_constant";
7843 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
7844 case DW_TAG_file_type
: return "DW_TAG_file_type";
7845 case DW_TAG_friend
: return "DW_TAG_friend";
7846 case DW_TAG_namelist
: return "DW_TAG_namelist";
7847 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
7848 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
7849 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
7850 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
7851 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
7852 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
7853 case DW_TAG_try_block
: return "DW_TAG_try_block";
7854 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
7855 case DW_TAG_variable
: return "DW_TAG_variable";
7856 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
7857 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
7858 case DW_TAG_format_label
: return "DW_TAG_format_label";
7859 case DW_TAG_function_template
: return "DW_TAG_function_template";
7860 case DW_TAG_class_template
: return "DW_TAG_class_template";
7861 /* DWARF 2.1 values. */
7862 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
7863 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
7864 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
7865 case DW_TAG_namespace
: return "DW_TAG_namespace";
7866 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
7867 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
7868 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
7869 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
7871 case DW_TAG_upc_shared_type
: return "DW_TAG_upc_shared_type";
7872 case DW_TAG_upc_strict_type
: return "DW_TAG_upc_strict_type";
7873 case DW_TAG_upc_relaxed_type
: return "DW_TAG_upc_relaxed_type";
7876 static char buffer
[100];
7878 snprintf (buffer
, sizeof (buffer
), _("Unknown TAG value: %lx"), tag
);
7885 get_FORM_name (unsigned long form
)
7889 case DW_FORM_addr
: return "DW_FORM_addr";
7890 case DW_FORM_block2
: return "DW_FORM_block2";
7891 case DW_FORM_block4
: return "DW_FORM_block4";
7892 case DW_FORM_data2
: return "DW_FORM_data2";
7893 case DW_FORM_data4
: return "DW_FORM_data4";
7894 case DW_FORM_data8
: return "DW_FORM_data8";
7895 case DW_FORM_string
: return "DW_FORM_string";
7896 case DW_FORM_block
: return "DW_FORM_block";
7897 case DW_FORM_block1
: return "DW_FORM_block1";
7898 case DW_FORM_data1
: return "DW_FORM_data1";
7899 case DW_FORM_flag
: return "DW_FORM_flag";
7900 case DW_FORM_sdata
: return "DW_FORM_sdata";
7901 case DW_FORM_strp
: return "DW_FORM_strp";
7902 case DW_FORM_udata
: return "DW_FORM_udata";
7903 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
7904 case DW_FORM_ref1
: return "DW_FORM_ref1";
7905 case DW_FORM_ref2
: return "DW_FORM_ref2";
7906 case DW_FORM_ref4
: return "DW_FORM_ref4";
7907 case DW_FORM_ref8
: return "DW_FORM_ref8";
7908 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
7909 case DW_FORM_indirect
: return "DW_FORM_indirect";
7912 static char buffer
[100];
7914 snprintf (buffer
, sizeof (buffer
), _("Unknown FORM value: %lx"), form
);
7920 static unsigned char *
7921 display_block (unsigned char *data
, unsigned long length
)
7923 printf (_(" %lu byte block: "), length
);
7926 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
7932 decode_location_expression (unsigned char * data
,
7933 unsigned int pointer_size
,
7934 unsigned long length
,
7935 unsigned long cu_offset
)
7938 unsigned int bytes_read
;
7939 unsigned long uvalue
;
7940 unsigned char *end
= data
+ length
;
7941 int need_frame_base
= 0;
7950 printf ("DW_OP_addr: %lx",
7951 (unsigned long) byte_get (data
, pointer_size
));
7952 data
+= pointer_size
;
7955 printf ("DW_OP_deref");
7958 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
7961 printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data
++, 1));
7964 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
7968 printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data
, 2));
7972 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
7976 printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data
, 4));
7980 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
7981 (unsigned long) byte_get (data
+ 4, 4));
7985 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
7986 (long) byte_get (data
+ 4, 4));
7990 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
7994 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
7998 printf ("DW_OP_dup");
8001 printf ("DW_OP_drop");
8004 printf ("DW_OP_over");
8007 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
8010 printf ("DW_OP_swap");
8013 printf ("DW_OP_rot");
8016 printf ("DW_OP_xderef");
8019 printf ("DW_OP_abs");
8022 printf ("DW_OP_and");
8025 printf ("DW_OP_div");
8028 printf ("DW_OP_minus");
8031 printf ("DW_OP_mod");
8034 printf ("DW_OP_mul");
8037 printf ("DW_OP_neg");
8040 printf ("DW_OP_not");
8043 printf ("DW_OP_or");
8046 printf ("DW_OP_plus");
8048 case DW_OP_plus_uconst
:
8049 printf ("DW_OP_plus_uconst: %lu",
8050 read_leb128 (data
, &bytes_read
, 0));
8054 printf ("DW_OP_shl");
8057 printf ("DW_OP_shr");
8060 printf ("DW_OP_shra");
8063 printf ("DW_OP_xor");
8066 printf ("DW_OP_bra: %ld", (long) byte_get_signed (data
, 2));
8070 printf ("DW_OP_eq");
8073 printf ("DW_OP_ge");
8076 printf ("DW_OP_gt");
8079 printf ("DW_OP_le");
8082 printf ("DW_OP_lt");
8085 printf ("DW_OP_ne");
8088 printf ("DW_OP_skip: %ld", (long) byte_get_signed (data
, 2));
8124 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
8159 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
8194 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
8195 read_leb128 (data
, &bytes_read
, 1));
8200 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
8204 need_frame_base
= 1;
8205 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
8209 uvalue
= read_leb128 (data
, &bytes_read
, 0);
8211 printf ("DW_OP_bregx: %lu %ld", uvalue
,
8212 read_leb128 (data
, &bytes_read
, 1));
8216 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
8219 case DW_OP_deref_size
:
8220 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
8222 case DW_OP_xderef_size
:
8223 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
8226 printf ("DW_OP_nop");
8229 /* DWARF 3 extensions. */
8230 case DW_OP_push_object_address
:
8231 printf ("DW_OP_push_object_address");
8234 /* XXX: Strictly speaking for 64-bit DWARF3 files
8235 this ought to be an 8-byte wide computation. */
8236 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2) + cu_offset
);
8240 /* XXX: Strictly speaking for 64-bit DWARF3 files
8241 this ought to be an 8-byte wide computation. */
8242 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4) + cu_offset
);
8245 case DW_OP_call_ref
:
8246 printf ("DW_OP_call_ref");
8249 /* GNU extensions. */
8250 case DW_OP_GNU_push_tls_address
:
8251 printf ("DW_OP_GNU_push_tls_address");
8255 if (op
>= DW_OP_lo_user
8256 && op
<= DW_OP_hi_user
)
8257 printf (_("(User defined location op)"));
8259 printf (_("(Unknown location op)"));
8260 /* No way to tell where the next op is, so just bail. */
8261 return need_frame_base
;
8264 /* Separate the ops. */
8269 return need_frame_base
;
8272 /* This structure records the information that
8273 we extract from the.debug_info section. */
8276 unsigned int pointer_size
;
8277 unsigned long cu_offset
;
8278 unsigned long base_address
;
8279 /* This is an array of offsets to the location list table. */
8280 unsigned long *loc_offsets
;
8281 int *have_frame_base
;
8282 unsigned int num_loc_offsets
;
8283 unsigned int max_loc_offsets
;
8284 unsigned long *range_lists
;
8285 unsigned int num_range_lists
;
8286 unsigned int max_range_lists
;
8290 static debug_info
* debug_information
= NULL
;
8291 static unsigned int num_debug_info_entries
= 0;
8292 static unsigned int last_pointer_size
= 0;
8293 static int warned_about_missing_comp_units
= FALSE
;
8295 static unsigned char *
8296 read_and_display_attr_value (unsigned long attribute
,
8298 unsigned char *data
,
8299 unsigned long cu_offset
,
8300 unsigned long pointer_size
,
8301 unsigned long offset_size
,
8303 debug_info
*debug_info_p
,
8306 unsigned long uvalue
= 0;
8307 unsigned char *block_start
= NULL
;
8308 unsigned int bytes_read
;
8315 case DW_FORM_ref_addr
:
8316 if (dwarf_version
== 2)
8318 uvalue
= byte_get (data
, pointer_size
);
8319 data
+= pointer_size
;
8321 else if (dwarf_version
== 3)
8323 uvalue
= byte_get (data
, offset_size
);
8324 data
+= offset_size
;
8328 error (_("Internal error: DWARF version is not 2 or 3.\n"));
8333 uvalue
= byte_get (data
, pointer_size
);
8334 data
+= pointer_size
;
8338 uvalue
= byte_get (data
, offset_size
);
8339 data
+= offset_size
;
8345 uvalue
= byte_get (data
++, 1);
8350 uvalue
= byte_get (data
, 2);
8356 uvalue
= byte_get (data
, 4);
8361 uvalue
= read_leb128 (data
, & bytes_read
, 1);
8365 case DW_FORM_ref_udata
:
8367 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8371 case DW_FORM_indirect
:
8372 form
= read_leb128 (data
, & bytes_read
, 0);
8375 printf (" %s", get_FORM_name (form
));
8376 return read_and_display_attr_value (attribute
, form
, data
,
8377 cu_offset
, pointer_size
,
8378 offset_size
, dwarf_version
,
8379 debug_info_p
, do_loc
);
8384 case DW_FORM_ref_addr
:
8386 printf (" <#%lx>", uvalue
);
8392 case DW_FORM_ref_udata
:
8394 printf (" <%lx>", uvalue
+ cu_offset
);
8400 printf (" %#lx", uvalue
);
8409 printf (" %ld", uvalue
);
8416 uvalue
= byte_get (data
, 4);
8417 printf (" %lx", uvalue
);
8418 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
8420 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8421 && num_debug_info_entries
== 0)
8423 if (sizeof (uvalue
) == 8)
8424 uvalue
= byte_get (data
, 8);
8426 error (_("DW_FORM_data8 is unsupported when sizeof (unsigned long) != 8\n"));
8431 case DW_FORM_string
:
8433 printf (" %s", data
);
8434 data
+= strlen ((char *) data
) + 1;
8438 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8439 block_start
= data
+ bytes_read
;
8441 data
= block_start
+ uvalue
;
8443 data
= display_block (block_start
, uvalue
);
8446 case DW_FORM_block1
:
8447 uvalue
= byte_get (data
, 1);
8448 block_start
= data
+ 1;
8450 data
= block_start
+ uvalue
;
8452 data
= display_block (block_start
, uvalue
);
8455 case DW_FORM_block2
:
8456 uvalue
= byte_get (data
, 2);
8457 block_start
= data
+ 2;
8459 data
= block_start
+ uvalue
;
8461 data
= display_block (block_start
, uvalue
);
8464 case DW_FORM_block4
:
8465 uvalue
= byte_get (data
, 4);
8466 block_start
= data
+ 4;
8468 data
= block_start
+ uvalue
;
8470 data
= display_block (block_start
, uvalue
);
8475 printf (_(" (indirect string, offset: 0x%lx): %s"),
8476 uvalue
, fetch_indirect_string (uvalue
));
8479 case DW_FORM_indirect
:
8480 /* Handled above. */
8484 warn (_("Unrecognized form: %lu\n"), form
);
8488 /* For some attributes we can display further information. */
8489 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8490 && num_debug_info_entries
== 0)
8494 case DW_AT_frame_base
:
8495 have_frame_base
= 1;
8496 case DW_AT_location
:
8497 case DW_AT_data_member_location
:
8498 case DW_AT_vtable_elem_location
:
8499 case DW_AT_allocated
:
8500 case DW_AT_associated
:
8501 case DW_AT_data_location
:
8503 case DW_AT_upper_bound
:
8504 case DW_AT_lower_bound
:
8505 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8507 /* Process location list. */
8508 unsigned int max
= debug_info_p
->max_loc_offsets
;
8509 unsigned int num
= debug_info_p
->num_loc_offsets
;
8511 if (max
== 0 || num
>= max
)
8514 debug_info_p
->loc_offsets
8515 = xcrealloc (debug_info_p
->loc_offsets
,
8516 max
, sizeof (*debug_info_p
->loc_offsets
));
8517 debug_info_p
->have_frame_base
8518 = xcrealloc (debug_info_p
->have_frame_base
,
8519 max
, sizeof (*debug_info_p
->have_frame_base
));
8520 debug_info_p
->max_loc_offsets
= max
;
8522 debug_info_p
->loc_offsets
[num
] = uvalue
;
8523 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
8524 debug_info_p
->num_loc_offsets
++;
8529 if (need_base_address
)
8530 debug_info_p
->base_address
= uvalue
;
8534 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8536 /* Process range list. */
8537 unsigned int max
= debug_info_p
->max_range_lists
;
8538 unsigned int num
= debug_info_p
->num_range_lists
;
8540 if (max
== 0 || num
>= max
)
8543 debug_info_p
->range_lists
8544 = xcrealloc (debug_info_p
->range_lists
,
8545 max
, sizeof (*debug_info_p
->range_lists
));
8546 debug_info_p
->max_range_lists
= max
;
8548 debug_info_p
->range_lists
[num
] = uvalue
;
8549 debug_info_p
->num_range_lists
++;
8568 case DW_INL_not_inlined
:
8569 printf (_("(not inlined)"));
8571 case DW_INL_inlined
:
8572 printf (_("(inlined)"));
8574 case DW_INL_declared_not_inlined
:
8575 printf (_("(declared as inline but ignored)"));
8577 case DW_INL_declared_inlined
:
8578 printf (_("(declared as inline and inlined)"));
8581 printf (_(" (Unknown inline attribute value: %lx)"), uvalue
);
8586 case DW_AT_language
:
8589 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
8590 case DW_LANG_C89
: printf ("(ANSI C)"); break;
8591 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
8592 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
8593 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
8594 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
8595 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
8596 case DW_LANG_Ada83
: printf ("(Ada)"); break;
8597 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
8598 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
8599 /* DWARF 2.1 values. */
8600 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
8601 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
8602 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
8603 /* MIPS extension. */
8604 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
8605 /* UPC extension. */
8606 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
8608 printf ("(Unknown: %lx)", uvalue
);
8613 case DW_AT_encoding
:
8616 case DW_ATE_void
: printf ("(void)"); break;
8617 case DW_ATE_address
: printf ("(machine address)"); break;
8618 case DW_ATE_boolean
: printf ("(boolean)"); break;
8619 case DW_ATE_complex_float
: printf ("(complex float)"); break;
8620 case DW_ATE_float
: printf ("(float)"); break;
8621 case DW_ATE_signed
: printf ("(signed)"); break;
8622 case DW_ATE_signed_char
: printf ("(signed char)"); break;
8623 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
8624 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
8625 /* DWARF 2.1 value. */
8626 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
8627 case DW_ATE_decimal_float
: printf ("(decimal float)"); break;
8629 if (uvalue
>= DW_ATE_lo_user
8630 && uvalue
<= DW_ATE_hi_user
)
8631 printf ("(user defined type)");
8633 printf ("(unknown type)");
8638 case DW_AT_accessibility
:
8641 case DW_ACCESS_public
: printf ("(public)"); break;
8642 case DW_ACCESS_protected
: printf ("(protected)"); break;
8643 case DW_ACCESS_private
: printf ("(private)"); break;
8645 printf ("(unknown accessibility)");
8650 case DW_AT_visibility
:
8653 case DW_VIS_local
: printf ("(local)"); break;
8654 case DW_VIS_exported
: printf ("(exported)"); break;
8655 case DW_VIS_qualified
: printf ("(qualified)"); break;
8656 default: printf ("(unknown visibility)"); break;
8660 case DW_AT_virtuality
:
8663 case DW_VIRTUALITY_none
: printf ("(none)"); break;
8664 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
8665 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
8666 default: printf ("(unknown virtuality)"); break;
8670 case DW_AT_identifier_case
:
8673 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
8674 case DW_ID_up_case
: printf ("(up_case)"); break;
8675 case DW_ID_down_case
: printf ("(down_case)"); break;
8676 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
8677 default: printf ("(unknown case)"); break;
8681 case DW_AT_calling_convention
:
8684 case DW_CC_normal
: printf ("(normal)"); break;
8685 case DW_CC_program
: printf ("(program)"); break;
8686 case DW_CC_nocall
: printf ("(nocall)"); break;
8688 if (uvalue
>= DW_CC_lo_user
8689 && uvalue
<= DW_CC_hi_user
)
8690 printf ("(user defined)");
8692 printf ("(unknown convention)");
8696 case DW_AT_ordering
:
8699 case -1: printf ("(undefined)"); break;
8700 case 0: printf ("(row major)"); break;
8701 case 1: printf ("(column major)"); break;
8705 case DW_AT_frame_base
:
8706 have_frame_base
= 1;
8707 case DW_AT_location
:
8708 case DW_AT_data_member_location
:
8709 case DW_AT_vtable_elem_location
:
8710 case DW_AT_allocated
:
8711 case DW_AT_associated
:
8712 case DW_AT_data_location
:
8714 case DW_AT_upper_bound
:
8715 case DW_AT_lower_bound
:
8718 int need_frame_base
;
8721 need_frame_base
= decode_location_expression (block_start
,
8726 if (need_frame_base
&& !have_frame_base
)
8727 printf (_(" [without DW_AT_frame_base]"));
8729 else if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8730 printf (_("(location list)"));
8742 get_AT_name (unsigned long attribute
)
8746 case DW_AT_sibling
: return "DW_AT_sibling";
8747 case DW_AT_location
: return "DW_AT_location";
8748 case DW_AT_name
: return "DW_AT_name";
8749 case DW_AT_ordering
: return "DW_AT_ordering";
8750 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
8751 case DW_AT_byte_size
: return "DW_AT_byte_size";
8752 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
8753 case DW_AT_bit_size
: return "DW_AT_bit_size";
8754 case DW_AT_element_list
: return "DW_AT_element_list";
8755 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
8756 case DW_AT_low_pc
: return "DW_AT_low_pc";
8757 case DW_AT_high_pc
: return "DW_AT_high_pc";
8758 case DW_AT_language
: return "DW_AT_language";
8759 case DW_AT_member
: return "DW_AT_member";
8760 case DW_AT_discr
: return "DW_AT_discr";
8761 case DW_AT_discr_value
: return "DW_AT_discr_value";
8762 case DW_AT_visibility
: return "DW_AT_visibility";
8763 case DW_AT_import
: return "DW_AT_import";
8764 case DW_AT_string_length
: return "DW_AT_string_length";
8765 case DW_AT_common_reference
: return "DW_AT_common_reference";
8766 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
8767 case DW_AT_const_value
: return "DW_AT_const_value";
8768 case DW_AT_containing_type
: return "DW_AT_containing_type";
8769 case DW_AT_default_value
: return "DW_AT_default_value";
8770 case DW_AT_inline
: return "DW_AT_inline";
8771 case DW_AT_is_optional
: return "DW_AT_is_optional";
8772 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
8773 case DW_AT_producer
: return "DW_AT_producer";
8774 case DW_AT_prototyped
: return "DW_AT_prototyped";
8775 case DW_AT_return_addr
: return "DW_AT_return_addr";
8776 case DW_AT_start_scope
: return "DW_AT_start_scope";
8777 case DW_AT_stride_size
: return "DW_AT_stride_size";
8778 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
8779 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
8780 case DW_AT_accessibility
: return "DW_AT_accessibility";
8781 case DW_AT_address_class
: return "DW_AT_address_class";
8782 case DW_AT_artificial
: return "DW_AT_artificial";
8783 case DW_AT_base_types
: return "DW_AT_base_types";
8784 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
8785 case DW_AT_count
: return "DW_AT_count";
8786 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
8787 case DW_AT_decl_column
: return "DW_AT_decl_column";
8788 case DW_AT_decl_file
: return "DW_AT_decl_file";
8789 case DW_AT_decl_line
: return "DW_AT_decl_line";
8790 case DW_AT_declaration
: return "DW_AT_declaration";
8791 case DW_AT_discr_list
: return "DW_AT_discr_list";
8792 case DW_AT_encoding
: return "DW_AT_encoding";
8793 case DW_AT_external
: return "DW_AT_external";
8794 case DW_AT_frame_base
: return "DW_AT_frame_base";
8795 case DW_AT_friend
: return "DW_AT_friend";
8796 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
8797 case DW_AT_macro_info
: return "DW_AT_macro_info";
8798 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
8799 case DW_AT_priority
: return "DW_AT_priority";
8800 case DW_AT_segment
: return "DW_AT_segment";
8801 case DW_AT_specification
: return "DW_AT_specification";
8802 case DW_AT_static_link
: return "DW_AT_static_link";
8803 case DW_AT_type
: return "DW_AT_type";
8804 case DW_AT_use_location
: return "DW_AT_use_location";
8805 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
8806 case DW_AT_virtuality
: return "DW_AT_virtuality";
8807 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
8808 /* DWARF 2.1 values. */
8809 case DW_AT_allocated
: return "DW_AT_allocated";
8810 case DW_AT_associated
: return "DW_AT_associated";
8811 case DW_AT_data_location
: return "DW_AT_data_location";
8812 case DW_AT_stride
: return "DW_AT_stride";
8813 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
8814 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
8815 case DW_AT_extension
: return "DW_AT_extension";
8816 case DW_AT_ranges
: return "DW_AT_ranges";
8817 case DW_AT_trampoline
: return "DW_AT_trampoline";
8818 case DW_AT_call_column
: return "DW_AT_call_column";
8819 case DW_AT_call_file
: return "DW_AT_call_file";
8820 case DW_AT_call_line
: return "DW_AT_call_line";
8821 /* SGI/MIPS extensions. */
8822 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
8823 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
8824 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
8825 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
8826 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
8827 case DW_AT_MIPS_software_pipeline_depth
:
8828 return "DW_AT_MIPS_software_pipeline_depth";
8829 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
8830 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
8831 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
8832 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
8833 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
8834 /* GNU extensions. */
8835 case DW_AT_sf_names
: return "DW_AT_sf_names";
8836 case DW_AT_src_info
: return "DW_AT_src_info";
8837 case DW_AT_mac_info
: return "DW_AT_mac_info";
8838 case DW_AT_src_coords
: return "DW_AT_src_coords";
8839 case DW_AT_body_begin
: return "DW_AT_body_begin";
8840 case DW_AT_body_end
: return "DW_AT_body_end";
8841 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
8842 /* UPC extension. */
8843 case DW_AT_upc_threads_scaled
: return "DW_AT_upc_threads_scaled";
8846 static char buffer
[100];
8848 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
8855 static unsigned char *
8856 read_and_display_attr (unsigned long attribute
,
8858 unsigned char *data
,
8859 unsigned long cu_offset
,
8860 unsigned long pointer_size
,
8861 unsigned long offset_size
,
8863 debug_info
*debug_info_p
,
8867 printf (" %-18s:", get_AT_name (attribute
));
8868 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
8869 pointer_size
, offset_size
,
8870 dwarf_version
, debug_info_p
,
8878 /* Process the contents of a .debug_info section. If do_loc is non-zero
8879 then we are scanning for location lists and we do not want to display
8880 anything to the user. */
8883 process_debug_info (Elf_Internal_Shdr
*section
, unsigned char *start
,
8884 FILE *file
, int do_loc
)
8886 unsigned char *end
= start
+ section
->sh_size
;
8887 unsigned char *section_begin
;
8889 unsigned int num_units
= 0;
8891 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8892 && num_debug_info_entries
== 0)
8894 unsigned long length
;
8896 /* First scan the section to get the number of comp units. */
8897 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
8900 /* Read the first 4 bytes. For a 32-bit DWARF section, this
8901 will be the length. For a 64-bit DWARF section, it'll be
8902 the escape code 0xffffffff followed by an 8 byte length. */
8903 length
= byte_get (section_begin
, 4);
8905 if (length
== 0xffffffff)
8907 length
= byte_get (section_begin
+ 4, 8);
8908 section_begin
+= length
+ 12;
8911 section_begin
+= length
+ 4;
8916 error (_("No comp units in .debug_info section ?"));
8920 /* Then allocate an array to hold the information. */
8921 debug_information
= cmalloc (num_units
,
8922 sizeof (* debug_information
));
8923 if (debug_information
== NULL
)
8925 error (_("Not enough memory for a debug info array of %u entries"),
8933 printf (_("The section %s contains:\n\n"),
8934 SECTION_NAME (section
));
8936 load_debug_str (file
);
8937 load_debug_loc (file
);
8938 load_debug_range (file
);
8941 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
8943 DWARF2_Internal_CompUnit compunit
;
8944 unsigned char *hdrptr
;
8945 unsigned char *cu_abbrev_offset_ptr
;
8946 unsigned char *tags
;
8948 unsigned long cu_offset
;
8950 int initial_length_size
;
8954 compunit
.cu_length
= byte_get (hdrptr
, 4);
8957 if (compunit
.cu_length
== 0xffffffff)
8959 compunit
.cu_length
= byte_get (hdrptr
, 8);
8962 initial_length_size
= 12;
8967 initial_length_size
= 4;
8970 compunit
.cu_version
= byte_get (hdrptr
, 2);
8973 cu_offset
= start
- section_begin
;
8974 start
+= compunit
.cu_length
+ initial_length_size
;
8976 if (elf_header
.e_type
== ET_REL
8977 && !debug_apply_rela_addends (file
, section
, offset_size
,
8978 section_begin
, hdrptr
, start
))
8981 cu_abbrev_offset_ptr
= hdrptr
;
8982 compunit
.cu_abbrev_offset
= byte_get (hdrptr
, offset_size
);
8983 hdrptr
+= offset_size
;
8985 compunit
.cu_pointer_size
= byte_get (hdrptr
, 1);
8987 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8988 && num_debug_info_entries
== 0)
8990 debug_information
[unit
].cu_offset
= cu_offset
;
8991 debug_information
[unit
].pointer_size
8992 = compunit
.cu_pointer_size
;
8993 debug_information
[unit
].base_address
= 0;
8994 debug_information
[unit
].loc_offsets
= NULL
;
8995 debug_information
[unit
].have_frame_base
= NULL
;
8996 debug_information
[unit
].max_loc_offsets
= 0;
8997 debug_information
[unit
].num_loc_offsets
= 0;
8998 debug_information
[unit
].range_lists
= NULL
;
8999 debug_information
[unit
].max_range_lists
= 0;
9000 debug_information
[unit
].num_range_lists
= 0;
9007 printf (_(" Compilation Unit @ offset 0x%lx:\n"), cu_offset
);
9008 printf (_(" Length: %ld\n"), compunit
.cu_length
);
9009 printf (_(" Version: %d\n"), compunit
.cu_version
);
9010 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
9011 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
9014 if (compunit
.cu_version
!= 2 && compunit
.cu_version
!= 3)
9016 warn (_("Only version 2 and 3 DWARF debug information is currently supported.\n"));
9022 /* Read in the abbrevs used by this compilation unit. */
9024 Elf_Internal_Shdr
*sec
;
9025 unsigned char *begin
;
9027 /* Locate the .debug_abbrev section and process it. */
9028 sec
= find_section (".debug_abbrev");
9031 warn (_("Unable to locate .debug_abbrev section!\n"));
9035 begin
= get_data (NULL
, file
, sec
->sh_offset
, 1, sec
->sh_size
,
9036 _("debug_abbrev section data"));
9040 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
9041 begin
+ sec
->sh_size
);
9047 while (tags
< start
)
9049 unsigned int bytes_read
;
9050 unsigned long abbrev_number
;
9051 abbrev_entry
*entry
;
9054 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
9057 /* A null DIE marks the end of a list of children. */
9058 if (abbrev_number
== 0)
9064 /* Scan through the abbreviation list until we reach the
9066 for (entry
= first_abbrev
;
9067 entry
&& entry
->entry
!= abbrev_number
;
9068 entry
= entry
->next
)
9073 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
9079 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
9081 (unsigned long) (tags
- section_begin
9084 get_TAG_name (entry
->tag
));
9089 need_base_address
= 0;
9091 case DW_TAG_compile_unit
:
9092 need_base_address
= 1;
9094 case DW_TAG_entry_point
:
9095 case DW_TAG_inlined_subroutine
:
9096 case DW_TAG_subprogram
:
9097 need_base_address
= 0;
9098 /* Assuming that there is no DW_AT_frame_base. */
9099 have_frame_base
= 0;
9103 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
9104 tags
= read_and_display_attr (attr
->attribute
,
9107 compunit
.cu_pointer_size
,
9109 compunit
.cu_version
,
9110 &debug_information
[unit
],
9113 if (entry
->children
)
9118 /* Set num_debug_info_entries here so that it can be used to check if
9119 we need to process .debug_loc and .debug_ranges sections. */
9120 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
9121 && num_debug_info_entries
== 0)
9122 num_debug_info_entries
= num_units
;
9126 free_debug_range ();
9136 /* Retrieve the pointer size associated with the given compilation unit.
9137 Optionally the offset of this unit into the .debug_info section is
9138 also retutned. If there is no .debug_info section then an error
9139 message is issued and 0 is returned. If the requested comp unit has
9140 not been defined in the .debug_info section then a warning message
9141 is issued and the last know pointer size is returned. This message
9142 is only issued once per section dumped per file dumped. */
9145 get_pointer_size_and_offset_of_comp_unit (unsigned int comp_unit
,
9146 const char * section_name
,
9147 unsigned long * offset_return
)
9149 unsigned long offset
= 0;
9151 if (num_debug_info_entries
== 0)
9152 error (_("%s section needs a populated .debug_info section\n"),
9155 else if (comp_unit
>= num_debug_info_entries
)
9157 if (!warned_about_missing_comp_units
)
9159 warn (_("%s section has more comp units than .debug_info section\n"),
9161 warn (_("assuming that the pointer size is %d, from the last comp unit in .debug_info\n\n"),
9163 warned_about_missing_comp_units
= TRUE
;
9168 last_pointer_size
= debug_information
[comp_unit
].pointer_size
;
9169 offset
= debug_information
[comp_unit
].cu_offset
;
9172 if (offset_return
!= NULL
)
9173 * offset_return
= offset
;
9175 return last_pointer_size
;
9178 /* Locate and scan the .debug_info section in the file and record the pointer
9179 sizes and offsets for the compilation units in it. Usually an executable
9180 will have just one pointer size, but this is not guaranteed, and so we try
9181 not to make any assumptions. Returns zero upon failure, or the number of
9182 compilation units upon success. */
9185 get_debug_info (FILE * file
)
9187 Elf_Internal_Shdr
* section
;
9188 unsigned char * start
;
9191 /* Reset the last pointer size so that we can issue correct error
9192 messages if we are displaying the contents of more than one section. */
9193 last_pointer_size
= 0;
9194 warned_about_missing_comp_units
= FALSE
;
9196 /* If we already have the information there is nothing else to do. */
9197 if (num_debug_info_entries
> 0)
9198 return num_debug_info_entries
;
9200 section
= find_section (".debug_info");
9201 if (section
== NULL
)
9204 start
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
9205 _("extracting information from .debug_info section"));
9209 ret
= process_debug_info (section
, start
, file
, 1);
9212 return ret
? num_debug_info_entries
: 0;
9216 display_debug_lines (Elf_Internal_Shdr
*section
,
9217 unsigned char *start
, FILE *file
)
9219 unsigned char *data
= start
;
9220 unsigned char *end
= start
+ section
->sh_size
;
9221 unsigned int comp_unit
= 0;
9223 printf (_("\nDump of debug contents of section %s:\n\n"),
9224 SECTION_NAME (section
));
9226 get_debug_info (file
);
9230 DWARF2_Internal_LineInfo info
;
9231 unsigned char *standard_opcodes
;
9232 unsigned char *end_of_sequence
;
9233 unsigned char *hdrptr
;
9234 unsigned int pointer_size
;
9235 int initial_length_size
;
9241 /* Check the length of the block. */
9242 info
.li_length
= byte_get (hdrptr
, 4);
9245 if (info
.li_length
== 0xffffffff)
9247 /* This section is 64-bit DWARF 3. */
9248 info
.li_length
= byte_get (hdrptr
, 8);
9251 initial_length_size
= 12;
9256 initial_length_size
= 4;
9259 if (info
.li_length
+ initial_length_size
> section
->sh_size
)
9262 (_("The line info appears to be corrupt - the section is too small\n"));
9266 /* Check its version number. */
9267 info
.li_version
= byte_get (hdrptr
, 2);
9269 if (info
.li_version
!= 2 && info
.li_version
!= 3)
9271 warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
9275 info
.li_prologue_length
= byte_get (hdrptr
, offset_size
);
9276 hdrptr
+= offset_size
;
9277 info
.li_min_insn_length
= byte_get (hdrptr
, 1);
9279 info
.li_default_is_stmt
= byte_get (hdrptr
, 1);
9281 info
.li_line_base
= byte_get (hdrptr
, 1);
9283 info
.li_line_range
= byte_get (hdrptr
, 1);
9285 info
.li_opcode_base
= byte_get (hdrptr
, 1);
9288 /* Sign extend the line base field. */
9289 info
.li_line_base
<<= 24;
9290 info
.li_line_base
>>= 24;
9292 /* Get the pointer size from the comp unit associated
9293 with this block of line number information. */
9294 pointer_size
= get_pointer_size_and_offset_of_comp_unit
9295 (comp_unit
, ".debug_line", NULL
);
9298 printf (_(" Length: %ld\n"), info
.li_length
);
9299 printf (_(" DWARF Version: %d\n"), info
.li_version
);
9300 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
9301 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
9302 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
9303 printf (_(" Line Base: %d\n"), info
.li_line_base
);
9304 printf (_(" Line Range: %d\n"), info
.li_line_range
);
9305 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
9306 printf (_(" (Pointer size: %u)%s\n"),
9308 warned_about_missing_comp_units
? " [assumed]" : "" );
9310 end_of_sequence
= data
+ info
.li_length
+ initial_length_size
;
9312 reset_state_machine (info
.li_default_is_stmt
);
9314 /* Display the contents of the Opcodes table. */
9315 standard_opcodes
= hdrptr
;
9317 printf (_("\n Opcodes:\n"));
9319 for (i
= 1; i
< info
.li_opcode_base
; i
++)
9320 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
9322 /* Display the contents of the Directory table. */
9323 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
9326 printf (_("\n The Directory Table is empty.\n"));
9329 printf (_("\n The Directory Table:\n"));
9333 printf (_(" %s\n"), data
);
9335 data
+= strlen ((char *) data
) + 1;
9339 /* Skip the NUL at the end of the table. */
9342 /* Display the contents of the File Name table. */
9344 printf (_("\n The File Name Table is empty.\n"));
9347 printf (_("\n The File Name Table:\n"));
9348 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
9352 unsigned char *name
;
9353 unsigned int bytes_read
;
9355 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
9358 data
+= strlen ((char *) data
) + 1;
9360 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9362 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9364 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9366 printf (_("%s\n"), name
);
9370 /* Skip the NUL at the end of the table. */
9373 /* Now display the statements. */
9374 printf (_("\n Line Number Statements:\n"));
9376 while (data
< end_of_sequence
)
9378 unsigned char op_code
;
9380 unsigned int bytes_read
;
9384 if (op_code
>= info
.li_opcode_base
)
9386 op_code
-= info
.li_opcode_base
;
9387 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
9388 state_machine_regs
.address
+= adv
;
9389 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
9390 op_code
, adv
, state_machine_regs
.address
);
9391 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
9392 state_machine_regs
.line
+= adv
;
9393 printf (_(" and Line by %d to %d\n"),
9394 adv
, state_machine_regs
.line
);
9396 else switch (op_code
)
9398 case DW_LNS_extended_op
:
9399 if (pointer_size
== 0)
9401 warn (_("Extend line ops need a valid pointer size, guessing at 4\n"));
9405 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
9410 printf (_(" Copy\n"));
9413 case DW_LNS_advance_pc
:
9414 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
9416 state_machine_regs
.address
+= adv
;
9417 printf (_(" Advance PC by %d to %lx\n"), adv
,
9418 state_machine_regs
.address
);
9421 case DW_LNS_advance_line
:
9422 adv
= read_leb128 (data
, & bytes_read
, 1);
9424 state_machine_regs
.line
+= adv
;
9425 printf (_(" Advance Line by %d to %d\n"), adv
,
9426 state_machine_regs
.line
);
9429 case DW_LNS_set_file
:
9430 adv
= read_leb128 (data
, & bytes_read
, 0);
9432 printf (_(" Set File Name to entry %d in the File Name Table\n"),
9434 state_machine_regs
.file
= adv
;
9437 case DW_LNS_set_column
:
9438 adv
= read_leb128 (data
, & bytes_read
, 0);
9440 printf (_(" Set column to %d\n"), adv
);
9441 state_machine_regs
.column
= adv
;
9444 case DW_LNS_negate_stmt
:
9445 adv
= state_machine_regs
.is_stmt
;
9447 printf (_(" Set is_stmt to %d\n"), adv
);
9448 state_machine_regs
.is_stmt
= adv
;
9451 case DW_LNS_set_basic_block
:
9452 printf (_(" Set basic block\n"));
9453 state_machine_regs
.basic_block
= 1;
9456 case DW_LNS_const_add_pc
:
9457 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
9458 * info
.li_min_insn_length
);
9459 state_machine_regs
.address
+= adv
;
9460 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
9461 state_machine_regs
.address
);
9464 case DW_LNS_fixed_advance_pc
:
9465 adv
= byte_get (data
, 2);
9467 state_machine_regs
.address
+= adv
;
9468 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
9469 adv
, state_machine_regs
.address
);
9472 case DW_LNS_set_prologue_end
:
9473 printf (_(" Set prologue_end to true\n"));
9476 case DW_LNS_set_epilogue_begin
:
9477 printf (_(" Set epilogue_begin to true\n"));
9480 case DW_LNS_set_isa
:
9481 adv
= read_leb128 (data
, & bytes_read
, 0);
9483 printf (_(" Set ISA to %d\n"), adv
);
9487 printf (_(" Unknown opcode %d with operands: "), op_code
);
9489 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
9491 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
9492 i
== 1 ? "" : ", ");
9506 display_debug_pubnames (Elf_Internal_Shdr
*section
,
9507 unsigned char *start
,
9508 FILE *file ATTRIBUTE_UNUSED
)
9510 DWARF2_Internal_PubNames pubnames
;
9513 end
= start
+ section
->sh_size
;
9515 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9519 unsigned char *data
;
9520 unsigned long offset
;
9521 int offset_size
, initial_length_size
;
9525 pubnames
.pn_length
= byte_get (data
, 4);
9527 if (pubnames
.pn_length
== 0xffffffff)
9529 pubnames
.pn_length
= byte_get (data
, 8);
9532 initial_length_size
= 12;
9537 initial_length_size
= 4;
9540 pubnames
.pn_version
= byte_get (data
, 2);
9542 pubnames
.pn_offset
= byte_get (data
, offset_size
);
9543 data
+= offset_size
;
9544 pubnames
.pn_size
= byte_get (data
, offset_size
);
9545 data
+= offset_size
;
9547 start
+= pubnames
.pn_length
+ initial_length_size
;
9549 if (pubnames
.pn_version
!= 2 && pubnames
.pn_version
!= 3)
9551 static int warned
= 0;
9555 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
9562 printf (_(" Length: %ld\n"),
9563 pubnames
.pn_length
);
9564 printf (_(" Version: %d\n"),
9565 pubnames
.pn_version
);
9566 printf (_(" Offset into .debug_info section: %ld\n"),
9567 pubnames
.pn_offset
);
9568 printf (_(" Size of area in .debug_info section: %ld\n"),
9571 printf (_("\n Offset\tName\n"));
9575 offset
= byte_get (data
, offset_size
);
9579 data
+= offset_size
;
9580 printf (" %-6ld\t\t%s\n", offset
, data
);
9581 data
+= strlen ((char *) data
) + 1;
9584 while (offset
!= 0);
9592 display_debug_macinfo (Elf_Internal_Shdr
*section
,
9593 unsigned char *start
,
9594 FILE *file ATTRIBUTE_UNUSED
)
9596 unsigned char *end
= start
+ section
->sh_size
;
9597 unsigned char *curr
= start
;
9598 unsigned int bytes_read
;
9599 enum dwarf_macinfo_record_type op
;
9601 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9605 unsigned int lineno
;
9613 case DW_MACINFO_start_file
:
9615 unsigned int filenum
;
9617 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9619 filenum
= read_leb128 (curr
, & bytes_read
, 0);
9622 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
9627 case DW_MACINFO_end_file
:
9628 printf (_(" DW_MACINFO_end_file\n"));
9631 case DW_MACINFO_define
:
9632 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9634 string
= (char *) curr
;
9635 curr
+= strlen (string
) + 1;
9636 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
9640 case DW_MACINFO_undef
:
9641 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9643 string
= (char *) curr
;
9644 curr
+= strlen (string
) + 1;
9645 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
9649 case DW_MACINFO_vendor_ext
:
9651 unsigned int constant
;
9653 constant
= read_leb128 (curr
, & bytes_read
, 0);
9655 string
= (char *) curr
;
9656 curr
+= strlen (string
) + 1;
9657 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
9669 display_debug_abbrev (Elf_Internal_Shdr
*section
,
9670 unsigned char *start
,
9671 FILE *file ATTRIBUTE_UNUSED
)
9673 abbrev_entry
*entry
;
9674 unsigned char *end
= start
+ section
->sh_size
;
9676 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9680 start
= process_abbrev_section (start
, end
);
9682 if (first_abbrev
== NULL
)
9685 printf (_(" Number TAG\n"));
9687 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
9691 printf (_(" %ld %s [%s]\n"),
9693 get_TAG_name (entry
->tag
),
9694 entry
->children
? _("has children") : _("no children"));
9696 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
9697 printf (_(" %-18s %s\n"),
9698 get_AT_name (attr
->attribute
),
9699 get_FORM_name (attr
->form
));
9712 display_debug_loc (Elf_Internal_Shdr
*section
,
9713 unsigned char *start
, FILE *file
)
9715 unsigned char *section_end
;
9716 unsigned long bytes
;
9717 unsigned char *section_begin
= start
;
9718 unsigned int num_loc_list
= 0;
9719 unsigned long last_offset
= 0;
9720 unsigned int first
= 0;
9723 int seen_first_offset
= 0;
9724 int use_debug_info
= 1;
9725 unsigned char *next
;
9727 bytes
= section
->sh_size
;
9728 section_end
= start
+ bytes
;
9732 printf (_("\nThe .debug_loc section is empty.\n"));
9736 get_debug_info (file
);
9738 /* Check the order of location list in .debug_info section. If
9739 offsets of location lists are in the ascending order, we can
9740 use `debug_information' directly. */
9741 for (i
= 0; i
< num_debug_info_entries
; i
++)
9745 num
= debug_information
[i
].num_loc_offsets
;
9746 num_loc_list
+= num
;
9748 /* Check if we can use `debug_information' directly. */
9749 if (use_debug_info
&& num
!= 0)
9751 if (!seen_first_offset
)
9753 /* This is the first location list. */
9754 last_offset
= debug_information
[i
].loc_offsets
[0];
9756 seen_first_offset
= 1;
9762 for (; j
< num
; j
++)
9765 debug_information
[i
].loc_offsets
[j
])
9770 last_offset
= debug_information
[i
].loc_offsets
[j
];
9775 if (!use_debug_info
)
9776 /* FIXME: Should we handle this case? */
9777 error (_("Location lists in .debug_info section aren't in ascending order!\n"));
9779 if (!seen_first_offset
)
9780 error (_("No location lists in .debug_info section!\n"));
9782 if (debug_information
[first
].loc_offsets
[0] != 0)
9783 warn (_("Location lists in .debug_loc section start at 0x%lx\n"),
9784 debug_information
[first
].loc_offsets
[0]);
9786 printf (_("Contents of the .debug_loc section:\n\n"));
9787 printf (_(" Offset Begin End Expression\n"));
9789 seen_first_offset
= 0;
9790 for (i
= first
; i
< num_debug_info_entries
; i
++)
9792 unsigned long begin
;
9794 unsigned short length
;
9795 unsigned long offset
;
9796 unsigned int pointer_size
;
9797 unsigned long cu_offset
;
9798 unsigned long base_address
;
9799 int need_frame_base
;
9802 pointer_size
= debug_information
[i
].pointer_size
;
9803 cu_offset
= debug_information
[i
].cu_offset
;
9805 for (j
= 0; j
< debug_information
[i
].num_loc_offsets
; j
++)
9807 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
9808 offset
= debug_information
[i
].loc_offsets
[j
];
9809 next
= section_begin
+ offset
;
9810 base_address
= debug_information
[i
].base_address
;
9812 if (!seen_first_offset
)
9813 seen_first_offset
= 1;
9817 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
9818 (long)(start
- section_begin
), (long)(next
- section_begin
));
9819 else if (start
> next
)
9820 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
9821 (long)(start
- section_begin
), (long)(next
- section_begin
));
9825 if (offset
>= bytes
)
9827 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
9834 if (start
+ 2 * pointer_size
> section_end
)
9836 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
9841 begin
= byte_get (start
, pointer_size
);
9842 start
+= pointer_size
;
9843 end
= byte_get (start
, pointer_size
);
9844 start
+= pointer_size
;
9846 if (begin
== 0 && end
== 0)
9848 printf (_(" %8.8lx <End of list>\n"), offset
);
9852 /* Check base address specifiers. */
9853 if (begin
== -1UL && end
!= -1UL)
9856 printf (_(" %8.8lx %8.8lx %8.8lx (base address)\n"),
9857 offset
, begin
, end
);
9861 if (start
+ 2 > section_end
)
9863 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
9868 length
= byte_get (start
, 2);
9871 if (start
+ length
> section_end
)
9873 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
9878 printf (" %8.8lx %8.8lx %8.8lx (",
9879 offset
, begin
+ base_address
, end
+ base_address
);
9880 need_frame_base
= decode_location_expression (start
,
9886 if (need_frame_base
&& !has_frame_base
)
9887 printf (_(" [without DW_AT_frame_base]"));
9890 fputs (_(" (start == end)"), stdout
);
9891 else if (begin
> end
)
9892 fputs (_(" (start > end)"), stdout
);
9904 display_debug_str (Elf_Internal_Shdr
*section
,
9905 unsigned char *start
,
9906 FILE *file ATTRIBUTE_UNUSED
)
9908 unsigned long bytes
;
9911 addr
= section
->sh_addr
;
9912 bytes
= section
->sh_size
;
9916 printf (_("\nThe .debug_str section is empty.\n"));
9920 printf (_("Contents of the .debug_str section:\n\n"));
9928 lbytes
= (bytes
> 16 ? 16 : bytes
);
9930 printf (" 0x%8.8lx ", (unsigned long) addr
);
9932 for (j
= 0; j
< 16; j
++)
9935 printf ("%2.2x", start
[j
]);
9943 for (j
= 0; j
< lbytes
; j
++)
9946 if (k
>= ' ' && k
< 0x80)
9966 display_debug_info (Elf_Internal_Shdr
* section
,
9967 unsigned char * start
, FILE * file
)
9969 return process_debug_info (section
, start
, file
, 0);
9974 display_debug_aranges (Elf_Internal_Shdr
*section
,
9975 unsigned char *start
,
9976 FILE *file ATTRIBUTE_UNUSED
)
9978 unsigned char *end
= start
+ section
->sh_size
;
9980 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
9984 unsigned char *hdrptr
;
9985 DWARF2_Internal_ARange arange
;
9986 unsigned char *ranges
;
9987 unsigned long length
;
9988 unsigned long address
;
9991 int initial_length_size
;
9995 arange
.ar_length
= byte_get (hdrptr
, 4);
9998 if (arange
.ar_length
== 0xffffffff)
10000 arange
.ar_length
= byte_get (hdrptr
, 8);
10003 initial_length_size
= 12;
10008 initial_length_size
= 4;
10011 arange
.ar_version
= byte_get (hdrptr
, 2);
10014 arange
.ar_info_offset
= byte_get (hdrptr
, offset_size
);
10015 hdrptr
+= offset_size
;
10017 arange
.ar_pointer_size
= byte_get (hdrptr
, 1);
10020 arange
.ar_segment_size
= byte_get (hdrptr
, 1);
10023 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
10025 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
10029 printf (_(" Length: %ld\n"), arange
.ar_length
);
10030 printf (_(" Version: %d\n"), arange
.ar_version
);
10031 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
10032 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
10033 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
10035 printf (_("\n Address Length\n"));
10039 /* Must pad to an alignment boundary that is twice the pointer size. */
10040 excess
= (hdrptr
- start
) % (2 * arange
.ar_pointer_size
);
10042 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
10046 address
= byte_get (ranges
, arange
.ar_pointer_size
);
10048 ranges
+= arange
.ar_pointer_size
;
10050 length
= byte_get (ranges
, arange
.ar_pointer_size
);
10052 ranges
+= arange
.ar_pointer_size
;
10054 /* A pair of zeros marks the end of the list. */
10055 if (address
== 0 && length
== 0)
10058 printf (" %8.8lx %lu\n", address
, length
);
10061 start
+= arange
.ar_length
+ initial_length_size
;
10070 display_debug_ranges (Elf_Internal_Shdr
*section
,
10071 unsigned char *start
,
10072 FILE *file ATTRIBUTE_UNUSED
)
10074 unsigned char *section_end
;
10075 unsigned long bytes
;
10076 unsigned char *section_begin
= start
;
10077 unsigned int num_range_list
= 0;
10078 unsigned long last_offset
= 0;
10079 unsigned int first
= 0;
10082 int seen_first_offset
= 0;
10083 int use_debug_info
= 1;
10084 unsigned char *next
;
10086 bytes
= section
->sh_size
;
10087 section_end
= start
+ bytes
;
10091 printf (_("\nThe .debug_ranges section is empty.\n"));
10095 get_debug_info (file
);
10097 /* Check the order of range list in .debug_info section. If
10098 offsets of range lists are in the ascending order, we can
10099 use `debug_information' directly. */
10100 for (i
= 0; i
< num_debug_info_entries
; i
++)
10104 num
= debug_information
[i
].num_range_lists
;
10105 num_range_list
+= num
;
10107 /* Check if we can use `debug_information' directly. */
10108 if (use_debug_info
&& num
!= 0)
10110 if (!seen_first_offset
)
10112 /* This is the first range list. */
10113 last_offset
= debug_information
[i
].range_lists
[0];
10115 seen_first_offset
= 1;
10121 for (; j
< num
; j
++)
10124 debug_information
[i
].range_lists
[j
])
10126 use_debug_info
= 0;
10129 last_offset
= debug_information
[i
].range_lists
[j
];
10134 if (!use_debug_info
)
10135 /* FIXME: Should we handle this case? */
10136 error (_("Range lists in .debug_info section aren't in ascending order!\n"));
10138 if (!seen_first_offset
)
10139 error (_("No range lists in .debug_info section!\n"));
10141 if (debug_information
[first
].range_lists
[0] != 0)
10142 warn (_("Range lists in .debug_ranges section start at 0x%lx\n"),
10143 debug_information
[first
].range_lists
[0]);
10145 printf (_("Contents of the .debug_ranges section:\n\n"));
10146 printf (_(" Offset Begin End\n"));
10148 seen_first_offset
= 0;
10149 for (i
= first
; i
< num_debug_info_entries
; i
++)
10151 unsigned long begin
;
10153 unsigned long offset
;
10154 unsigned int pointer_size
;
10155 unsigned long base_address
;
10157 pointer_size
= debug_information
[i
].pointer_size
;
10159 for (j
= 0; j
< debug_information
[i
].num_range_lists
; j
++)
10161 offset
= debug_information
[i
].range_lists
[j
];
10162 next
= section_begin
+ offset
;
10163 base_address
= debug_information
[i
].base_address
;
10165 if (!seen_first_offset
)
10166 seen_first_offset
= 1;
10170 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_ranges section.\n"),
10171 (long)(start
- section_begin
), (long)(next
- section_begin
));
10172 else if (start
> next
)
10173 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_ranges section.\n"),
10174 (long)(start
- section_begin
), (long)(next
- section_begin
));
10180 begin
= byte_get (start
, pointer_size
);
10181 start
+= pointer_size
;
10182 end
= byte_get (start
, pointer_size
);
10183 start
+= pointer_size
;
10185 if (begin
== 0 && end
== 0)
10187 printf (_(" %8.8lx <End of list>\n"), offset
);
10191 /* Check base address specifiers. */
10192 if (begin
== -1UL && end
!= -1UL)
10194 base_address
= end
;
10195 printf (" %8.8lx %8.8lx %8.8lx (base address)\n",
10196 offset
, begin
, end
);
10200 printf (" %8.8lx %8.8lx %8.8lx",
10201 offset
, begin
+ base_address
, end
+ base_address
);
10204 fputs (_(" (start == end)"), stdout
);
10205 else if (begin
> end
)
10206 fputs (_(" (start > end)"), stdout
);
10216 typedef struct Frame_Chunk
10218 struct Frame_Chunk
*next
;
10219 unsigned char *chunk_start
;
10221 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
10222 short int *col_type
;
10224 char *augmentation
;
10225 unsigned int code_factor
;
10227 unsigned long pc_begin
;
10228 unsigned long pc_range
;
10232 unsigned char fde_encoding
;
10233 unsigned char cfa_exp
;
10237 /* A marker for a col_type that means this column was never referenced
10238 in the frame info. */
10239 #define DW_CFA_unreferenced (-1)
10242 frame_need_space (Frame_Chunk
*fc
, int reg
)
10244 int prev
= fc
->ncols
;
10246 if (reg
< fc
->ncols
)
10249 fc
->ncols
= reg
+ 1;
10250 fc
->col_type
= xcrealloc (fc
->col_type
, fc
->ncols
, sizeof (short int));
10251 fc
->col_offset
= xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
10253 while (prev
< fc
->ncols
)
10255 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
10256 fc
->col_offset
[prev
] = 0;
10262 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, int *max_regs
)
10267 if (*max_regs
< fc
->ncols
)
10268 *max_regs
= fc
->ncols
;
10270 if (*need_col_headers
)
10272 *need_col_headers
= 0;
10274 printf (" LOC CFA ");
10276 for (r
= 0; r
< *max_regs
; r
++)
10277 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
10282 printf ("r%-4d", r
);
10288 printf ("%08lx ", fc
->pc_begin
);
10290 strcpy (tmp
, "exp");
10292 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
10293 printf ("%-8s ", tmp
);
10295 for (r
= 0; r
< fc
->ncols
; r
++)
10297 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
10299 switch (fc
->col_type
[r
])
10301 case DW_CFA_undefined
:
10304 case DW_CFA_same_value
:
10307 case DW_CFA_offset
:
10308 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
10310 case DW_CFA_register
:
10311 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
10313 case DW_CFA_expression
:
10314 strcpy (tmp
, "exp");
10317 strcpy (tmp
, "n/a");
10320 printf ("%-5s", tmp
);
10327 size_of_encoded_value (int encoding
)
10329 switch (encoding
& 0x7)
10332 case 0: return eh_addr_size
;
10340 get_encoded_value (unsigned char *data
, int encoding
)
10342 int size
= size_of_encoded_value (encoding
);
10343 if (encoding
& DW_EH_PE_signed
)
10344 return byte_get_signed (data
, size
);
10346 return byte_get (data
, size
);
10349 #define GET(N) byte_get (start, N); start += N
10350 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
10351 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
10354 display_debug_frames (Elf_Internal_Shdr
*section
,
10355 unsigned char *start
,
10356 FILE *file ATTRIBUTE_UNUSED
)
10358 unsigned char *end
= start
+ section
->sh_size
;
10359 unsigned char *section_start
= start
;
10360 Frame_Chunk
*chunks
= 0;
10361 Frame_Chunk
*remembered_state
= 0;
10363 int is_eh
= streq (SECTION_NAME (section
), ".eh_frame");
10364 unsigned int length_return
;
10367 printf (_("The section %s contains:\n"), SECTION_NAME (section
));
10369 while (start
< end
)
10371 unsigned char *saved_start
;
10372 unsigned char *block_end
;
10373 unsigned long length
;
10374 unsigned long cie_id
;
10377 int need_col_headers
= 1;
10378 unsigned char *augmentation_data
= NULL
;
10379 unsigned long augmentation_data_len
= 0;
10380 int encoded_ptr_size
= eh_addr_size
;
10382 int initial_length_size
;
10384 saved_start
= start
;
10385 length
= byte_get (start
, 4); start
+= 4;
10389 printf ("\n%08lx ZERO terminator\n\n",
10390 (unsigned long)(saved_start
- section_start
));
10394 if (length
== 0xffffffff)
10396 length
= byte_get (start
, 8);
10399 initial_length_size
= 12;
10404 initial_length_size
= 4;
10407 block_end
= saved_start
+ length
+ initial_length_size
;
10408 cie_id
= byte_get (start
, offset_size
); start
+= offset_size
;
10410 if (elf_header
.e_type
== ET_REL
10411 && !debug_apply_rela_addends (file
, section
, offset_size
,
10412 section_start
, start
, block_end
))
10415 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
10419 fc
= xmalloc (sizeof (Frame_Chunk
));
10420 memset (fc
, 0, sizeof (Frame_Chunk
));
10424 fc
->chunk_start
= saved_start
;
10426 fc
->col_type
= xmalloc (sizeof (short int));
10427 fc
->col_offset
= xmalloc (sizeof (int));
10428 frame_need_space (fc
, max_regs
-1);
10430 version
= *start
++;
10432 fc
->augmentation
= (char *) start
;
10433 start
= (unsigned char *) strchr ((char *) start
, '\0') + 1;
10435 if (fc
->augmentation
[0] == 'z')
10437 fc
->code_factor
= LEB ();
10438 fc
->data_factor
= SLEB ();
10447 augmentation_data_len
= LEB ();
10448 augmentation_data
= start
;
10449 start
+= augmentation_data_len
;
10451 else if (streq (fc
->augmentation
, "eh"))
10453 start
+= eh_addr_size
;
10454 fc
->code_factor
= LEB ();
10455 fc
->data_factor
= SLEB ();
10467 fc
->code_factor
= LEB ();
10468 fc
->data_factor
= SLEB ();
10480 if (do_debug_frames_interp
)
10481 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
10482 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
10483 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
10487 printf ("\n%08lx %08lx %08lx CIE\n",
10488 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
10489 printf (" Version: %d\n", version
);
10490 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
10491 printf (" Code alignment factor: %u\n", fc
->code_factor
);
10492 printf (" Data alignment factor: %d\n", fc
->data_factor
);
10493 printf (" Return address column: %d\n", fc
->ra
);
10495 if (augmentation_data_len
)
10498 printf (" Augmentation data: ");
10499 for (i
= 0; i
< augmentation_data_len
; ++i
)
10500 printf (" %02x", augmentation_data
[i
]);
10506 if (augmentation_data_len
)
10508 unsigned char *p
, *q
;
10509 p
= (unsigned char *) fc
->augmentation
+ 1;
10510 q
= augmentation_data
;
10516 else if (*p
== 'P')
10517 q
+= 1 + size_of_encoded_value (*q
);
10518 else if (*p
== 'R')
10519 fc
->fde_encoding
= *q
++;
10525 if (fc
->fde_encoding
)
10526 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
10529 frame_need_space (fc
, fc
->ra
);
10533 unsigned char *look_for
;
10534 static Frame_Chunk fde_fc
;
10537 memset (fc
, 0, sizeof (Frame_Chunk
));
10539 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
10541 for (cie
= chunks
; cie
; cie
= cie
->next
)
10542 if (cie
->chunk_start
== look_for
)
10547 warn ("Invalid CIE pointer %08lx in FDE at %p\n",
10548 cie_id
, saved_start
);
10551 fc
->col_type
= xmalloc (sizeof (short int));
10552 fc
->col_offset
= xmalloc (sizeof (int));
10553 frame_need_space (fc
, max_regs
- 1);
10555 fc
->augmentation
= "";
10556 fc
->fde_encoding
= 0;
10560 fc
->ncols
= cie
->ncols
;
10561 fc
->col_type
= xcmalloc (fc
->ncols
, sizeof (short int));
10562 fc
->col_offset
= xcmalloc (fc
->ncols
, sizeof (int));
10563 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
10564 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
10565 fc
->augmentation
= cie
->augmentation
;
10566 fc
->code_factor
= cie
->code_factor
;
10567 fc
->data_factor
= cie
->data_factor
;
10568 fc
->cfa_reg
= cie
->cfa_reg
;
10569 fc
->cfa_offset
= cie
->cfa_offset
;
10571 frame_need_space (fc
, max_regs
-1);
10572 fc
->fde_encoding
= cie
->fde_encoding
;
10575 if (fc
->fde_encoding
)
10576 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
10578 fc
->pc_begin
= get_encoded_value (start
, fc
->fde_encoding
);
10579 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
10580 /* Don't adjust for ET_REL since there's invariably a pcrel
10581 reloc here, which we haven't applied. */
10582 && elf_header
.e_type
!= ET_REL
)
10583 fc
->pc_begin
+= section
->sh_addr
+ (start
- section_start
);
10584 start
+= encoded_ptr_size
;
10585 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
10586 start
+= encoded_ptr_size
;
10588 if (cie
->augmentation
[0] == 'z')
10590 augmentation_data_len
= LEB ();
10591 augmentation_data
= start
;
10592 start
+= augmentation_data_len
;
10595 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
10596 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
10597 (unsigned long)(cie
->chunk_start
- section_start
),
10598 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
10599 if (! do_debug_frames_interp
&& augmentation_data_len
)
10603 printf (" Augmentation data: ");
10604 for (i
= 0; i
< augmentation_data_len
; ++i
)
10605 printf (" %02x", augmentation_data
[i
]);
10611 /* At this point, fc is the current chunk, cie (if any) is set, and
10612 we're about to interpret instructions for the chunk. */
10613 /* ??? At present we need to do this always, since this sizes the
10614 fc->col_type and fc->col_offset arrays, which we write into always.
10615 We should probably split the interpreted and non-interpreted bits
10616 into two different routines, since there's so much that doesn't
10617 really overlap between them. */
10618 if (1 || do_debug_frames_interp
)
10620 /* Start by making a pass over the chunk, allocating storage
10621 and taking note of what registers are used. */
10622 unsigned char *tmp
= start
;
10624 while (start
< block_end
)
10627 unsigned long reg
, tmp
;
10634 /* Warning: if you add any more cases to this switch, be
10635 sure to add them to the corresponding switch below. */
10638 case DW_CFA_advance_loc
:
10640 case DW_CFA_offset
:
10642 frame_need_space (fc
, opa
);
10643 fc
->col_type
[opa
] = DW_CFA_undefined
;
10645 case DW_CFA_restore
:
10646 frame_need_space (fc
, opa
);
10647 fc
->col_type
[opa
] = DW_CFA_undefined
;
10649 case DW_CFA_set_loc
:
10650 start
+= encoded_ptr_size
;
10652 case DW_CFA_advance_loc1
:
10655 case DW_CFA_advance_loc2
:
10658 case DW_CFA_advance_loc4
:
10661 case DW_CFA_offset_extended
:
10662 reg
= LEB (); LEB ();
10663 frame_need_space (fc
, reg
);
10664 fc
->col_type
[reg
] = DW_CFA_undefined
;
10666 case DW_CFA_restore_extended
:
10668 frame_need_space (fc
, reg
);
10669 fc
->col_type
[reg
] = DW_CFA_undefined
;
10671 case DW_CFA_undefined
:
10673 frame_need_space (fc
, reg
);
10674 fc
->col_type
[reg
] = DW_CFA_undefined
;
10676 case DW_CFA_same_value
:
10678 frame_need_space (fc
, reg
);
10679 fc
->col_type
[reg
] = DW_CFA_undefined
;
10681 case DW_CFA_register
:
10682 reg
= LEB (); LEB ();
10683 frame_need_space (fc
, reg
);
10684 fc
->col_type
[reg
] = DW_CFA_undefined
;
10686 case DW_CFA_def_cfa
:
10689 case DW_CFA_def_cfa_register
:
10692 case DW_CFA_def_cfa_offset
:
10695 case DW_CFA_def_cfa_expression
:
10699 case DW_CFA_expression
:
10703 frame_need_space (fc
, reg
);
10704 fc
->col_type
[reg
] = DW_CFA_undefined
;
10706 case DW_CFA_offset_extended_sf
:
10707 reg
= LEB (); SLEB ();
10708 frame_need_space (fc
, reg
);
10709 fc
->col_type
[reg
] = DW_CFA_undefined
;
10711 case DW_CFA_def_cfa_sf
:
10714 case DW_CFA_def_cfa_offset_sf
:
10717 case DW_CFA_MIPS_advance_loc8
:
10720 case DW_CFA_GNU_args_size
:
10723 case DW_CFA_GNU_negative_offset_extended
:
10724 reg
= LEB (); LEB ();
10725 frame_need_space (fc
, reg
);
10726 fc
->col_type
[reg
] = DW_CFA_undefined
;
10735 /* Now we know what registers are used, make a second pass over
10736 the chunk, this time actually printing out the info. */
10738 while (start
< block_end
)
10741 unsigned long ul
, reg
, roffs
;
10750 /* Warning: if you add any more cases to this switch, be
10751 sure to add them to the corresponding switch above. */
10754 case DW_CFA_advance_loc
:
10755 if (do_debug_frames_interp
)
10756 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10758 printf (" DW_CFA_advance_loc: %d to %08lx\n",
10759 opa
* fc
->code_factor
,
10760 fc
->pc_begin
+ opa
* fc
->code_factor
);
10761 fc
->pc_begin
+= opa
* fc
->code_factor
;
10764 case DW_CFA_offset
:
10766 if (! do_debug_frames_interp
)
10767 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
10768 opa
, roffs
* fc
->data_factor
);
10769 fc
->col_type
[opa
] = DW_CFA_offset
;
10770 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
10773 case DW_CFA_restore
:
10774 if (! do_debug_frames_interp
)
10775 printf (" DW_CFA_restore: r%d\n", opa
);
10776 fc
->col_type
[opa
] = cie
->col_type
[opa
];
10777 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
10780 case DW_CFA_set_loc
:
10781 vma
= get_encoded_value (start
, fc
->fde_encoding
);
10782 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
10783 && elf_header
.e_type
!= ET_REL
)
10784 vma
+= section
->sh_addr
+ (start
- section_start
);
10785 start
+= encoded_ptr_size
;
10786 if (do_debug_frames_interp
)
10787 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10789 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
10790 fc
->pc_begin
= vma
;
10793 case DW_CFA_advance_loc1
:
10794 ofs
= byte_get (start
, 1); start
+= 1;
10795 if (do_debug_frames_interp
)
10796 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10798 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
10799 ofs
* fc
->code_factor
,
10800 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10801 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10804 case DW_CFA_advance_loc2
:
10805 ofs
= byte_get (start
, 2); start
+= 2;
10806 if (do_debug_frames_interp
)
10807 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10809 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
10810 ofs
* fc
->code_factor
,
10811 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10812 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10815 case DW_CFA_advance_loc4
:
10816 ofs
= byte_get (start
, 4); start
+= 4;
10817 if (do_debug_frames_interp
)
10818 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10820 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
10821 ofs
* fc
->code_factor
,
10822 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10823 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10826 case DW_CFA_offset_extended
:
10829 if (! do_debug_frames_interp
)
10830 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
10831 reg
, roffs
* fc
->data_factor
);
10832 fc
->col_type
[reg
] = DW_CFA_offset
;
10833 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
10836 case DW_CFA_restore_extended
:
10838 if (! do_debug_frames_interp
)
10839 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
10840 fc
->col_type
[reg
] = cie
->col_type
[reg
];
10841 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
10844 case DW_CFA_undefined
:
10846 if (! do_debug_frames_interp
)
10847 printf (" DW_CFA_undefined: r%ld\n", reg
);
10848 fc
->col_type
[reg
] = DW_CFA_undefined
;
10849 fc
->col_offset
[reg
] = 0;
10852 case DW_CFA_same_value
:
10854 if (! do_debug_frames_interp
)
10855 printf (" DW_CFA_same_value: r%ld\n", reg
);
10856 fc
->col_type
[reg
] = DW_CFA_same_value
;
10857 fc
->col_offset
[reg
] = 0;
10860 case DW_CFA_register
:
10863 if (! do_debug_frames_interp
)
10864 printf (" DW_CFA_register: r%ld in r%ld\n", reg
, roffs
);
10865 fc
->col_type
[reg
] = DW_CFA_register
;
10866 fc
->col_offset
[reg
] = roffs
;
10869 case DW_CFA_remember_state
:
10870 if (! do_debug_frames_interp
)
10871 printf (" DW_CFA_remember_state\n");
10872 rs
= xmalloc (sizeof (Frame_Chunk
));
10873 rs
->ncols
= fc
->ncols
;
10874 rs
->col_type
= xcmalloc (rs
->ncols
, sizeof (short int));
10875 rs
->col_offset
= xcmalloc (rs
->ncols
, sizeof (int));
10876 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
10877 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
10878 rs
->next
= remembered_state
;
10879 remembered_state
= rs
;
10882 case DW_CFA_restore_state
:
10883 if (! do_debug_frames_interp
)
10884 printf (" DW_CFA_restore_state\n");
10885 rs
= remembered_state
;
10888 remembered_state
= rs
->next
;
10889 frame_need_space (fc
, rs
->ncols
-1);
10890 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
10891 memcpy (fc
->col_offset
, rs
->col_offset
,
10892 rs
->ncols
* sizeof (int));
10893 free (rs
->col_type
);
10894 free (rs
->col_offset
);
10897 else if (do_debug_frames_interp
)
10898 printf ("Mismatched DW_CFA_restore_state\n");
10901 case DW_CFA_def_cfa
:
10902 fc
->cfa_reg
= LEB ();
10903 fc
->cfa_offset
= LEB ();
10905 if (! do_debug_frames_interp
)
10906 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
10907 fc
->cfa_reg
, fc
->cfa_offset
);
10910 case DW_CFA_def_cfa_register
:
10911 fc
->cfa_reg
= LEB ();
10913 if (! do_debug_frames_interp
)
10914 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
10917 case DW_CFA_def_cfa_offset
:
10918 fc
->cfa_offset
= LEB ();
10919 if (! do_debug_frames_interp
)
10920 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
10924 if (! do_debug_frames_interp
)
10925 printf (" DW_CFA_nop\n");
10928 case DW_CFA_def_cfa_expression
:
10930 if (! do_debug_frames_interp
)
10932 printf (" DW_CFA_def_cfa_expression (");
10933 decode_location_expression (start
, eh_addr_size
, ul
, 0);
10940 case DW_CFA_expression
:
10943 if (! do_debug_frames_interp
)
10945 printf (" DW_CFA_expression: r%ld (", reg
);
10946 decode_location_expression (start
, eh_addr_size
, ul
, 0);
10949 fc
->col_type
[reg
] = DW_CFA_expression
;
10953 case DW_CFA_offset_extended_sf
:
10956 frame_need_space (fc
, reg
);
10957 if (! do_debug_frames_interp
)
10958 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
10959 reg
, l
* fc
->data_factor
);
10960 fc
->col_type
[reg
] = DW_CFA_offset
;
10961 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
10964 case DW_CFA_def_cfa_sf
:
10965 fc
->cfa_reg
= LEB ();
10966 fc
->cfa_offset
= SLEB ();
10967 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
10969 if (! do_debug_frames_interp
)
10970 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
10971 fc
->cfa_reg
, fc
->cfa_offset
);
10974 case DW_CFA_def_cfa_offset_sf
:
10975 fc
->cfa_offset
= SLEB ();
10976 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
10977 if (! do_debug_frames_interp
)
10978 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
10981 case DW_CFA_MIPS_advance_loc8
:
10982 ofs
= byte_get (start
, 8); start
+= 8;
10983 if (do_debug_frames_interp
)
10984 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10986 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
10987 ofs
* fc
->code_factor
,
10988 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10989 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10992 case DW_CFA_GNU_window_save
:
10993 if (! do_debug_frames_interp
)
10994 printf (" DW_CFA_GNU_window_save\n");
10997 case DW_CFA_GNU_args_size
:
10999 if (! do_debug_frames_interp
)
11000 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
11003 case DW_CFA_GNU_negative_offset_extended
:
11006 frame_need_space (fc
, reg
);
11007 if (! do_debug_frames_interp
)
11008 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
11009 reg
, l
* fc
->data_factor
);
11010 fc
->col_type
[reg
] = DW_CFA_offset
;
11011 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
11015 warn (_("unsupported or unknown DW_CFA_%d\n"), op
);
11020 if (do_debug_frames_interp
)
11021 frame_display_row (fc
, &need_col_headers
, &max_regs
);
11036 display_debug_not_supported (Elf_Internal_Shdr
*section
,
11037 unsigned char *start ATTRIBUTE_UNUSED
,
11038 FILE *file ATTRIBUTE_UNUSED
)
11040 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
11041 SECTION_NAME (section
));
11046 /* A structure containing the name of a debug section
11047 and a pointer to a function that can decode it. */
11050 const char *const name
;
11051 int (*display
) (Elf_Internal_Shdr
*, unsigned char *, FILE *);
11055 { ".debug_abbrev", display_debug_abbrev
},
11056 { ".debug_aranges", display_debug_aranges
},
11057 { ".debug_frame", display_debug_frames
},
11058 { ".debug_info", display_debug_info
},
11059 { ".debug_line", display_debug_lines
},
11060 { ".debug_pubnames", display_debug_pubnames
},
11061 { ".eh_frame", display_debug_frames
},
11062 { ".debug_macinfo", display_debug_macinfo
},
11063 { ".debug_str", display_debug_str
},
11064 { ".debug_loc", display_debug_loc
},
11065 { ".debug_pubtypes", display_debug_pubnames
},
11066 { ".debug_ranges", display_debug_ranges
},
11067 { ".debug_static_func", display_debug_not_supported
},
11068 { ".debug_static_vars", display_debug_not_supported
},
11069 { ".debug_types", display_debug_not_supported
},
11070 { ".debug_weaknames", display_debug_not_supported
}
11074 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
11076 char *name
= SECTION_NAME (section
);
11077 bfd_size_type length
;
11081 length
= section
->sh_size
;
11084 printf (_("\nSection '%s' has no debugging data.\n"), name
);
11088 if (strneq (name
, ".gnu.linkonce.wi.", 17))
11089 name
= ".debug_info";
11091 /* See if we know how to display the contents of this section. */
11092 for (i
= NUM_ELEM (debug_displays
); i
--;)
11093 if (streq (debug_displays
[i
].name
, name
))
11095 unsigned char *start
;
11097 start
= get_data (NULL
, file
, section
->sh_offset
, 1, length
,
11098 _("debug section data"));
11105 result
&= debug_displays
[i
].display (section
, start
, file
);
11108 /* If we loaded in the abbrev section
11109 at some point, we must release it here. */
11117 printf (_("Unrecognized debug section: %s\n"), name
);
11125 process_section_contents (FILE *file
)
11127 Elf_Internal_Shdr
*section
;
11133 for (i
= 0, section
= section_headers
;
11134 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
11137 #ifdef SUPPORT_DISASSEMBLY
11138 if (dump_sects
[i
] & DISASS_DUMP
)
11139 disassemble_section (section
, file
);
11141 if (dump_sects
[i
] & HEX_DUMP
)
11142 dump_section (section
, file
);
11144 if (dump_sects
[i
] & DEBUG_DUMP
)
11145 display_debug_section (section
, file
);
11148 /* Check to see if the user requested a
11149 dump of a section that does not exist. */
11150 while (i
++ < num_dump_sects
)
11152 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
11156 process_mips_fpe_exception (int mask
)
11161 if (mask
& OEX_FPU_INEX
)
11162 fputs ("INEX", stdout
), first
= 0;
11163 if (mask
& OEX_FPU_UFLO
)
11164 printf ("%sUFLO", first
? "" : "|"), first
= 0;
11165 if (mask
& OEX_FPU_OFLO
)
11166 printf ("%sOFLO", first
? "" : "|"), first
= 0;
11167 if (mask
& OEX_FPU_DIV0
)
11168 printf ("%sDIV0", first
? "" : "|"), first
= 0;
11169 if (mask
& OEX_FPU_INVAL
)
11170 printf ("%sINVAL", first
? "" : "|");
11173 fputs ("0", stdout
);
11177 process_mips_specific (FILE *file
)
11179 Elf_Internal_Dyn
*entry
;
11180 size_t liblist_offset
= 0;
11181 size_t liblistno
= 0;
11182 size_t conflictsno
= 0;
11183 size_t options_offset
= 0;
11184 size_t conflicts_offset
= 0;
11186 /* We have a lot of special sections. Thanks SGI! */
11187 if (dynamic_section
== NULL
)
11188 /* No information available. */
11191 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
11192 switch (entry
->d_tag
)
11194 case DT_MIPS_LIBLIST
:
11196 = offset_from_vma (file
, entry
->d_un
.d_val
,
11197 liblistno
* sizeof (Elf32_External_Lib
));
11199 case DT_MIPS_LIBLISTNO
:
11200 liblistno
= entry
->d_un
.d_val
;
11202 case DT_MIPS_OPTIONS
:
11203 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
11205 case DT_MIPS_CONFLICT
:
11207 = offset_from_vma (file
, entry
->d_un
.d_val
,
11208 conflictsno
* sizeof (Elf32_External_Conflict
));
11210 case DT_MIPS_CONFLICTNO
:
11211 conflictsno
= entry
->d_un
.d_val
;
11217 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
11219 Elf32_External_Lib
*elib
;
11222 elib
= get_data (NULL
, file
, liblist_offset
,
11223 liblistno
, sizeof (Elf32_External_Lib
),
11227 printf ("\nSection '.liblist' contains %lu entries:\n",
11228 (unsigned long) liblistno
);
11229 fputs (" Library Time Stamp Checksum Version Flags\n",
11232 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
11239 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
11240 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
11241 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
11242 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
11243 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
11245 tmp
= gmtime (&time
);
11246 snprintf (timebuf
, sizeof (timebuf
),
11247 "%04u-%02u-%02uT%02u:%02u:%02u",
11248 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11249 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11251 printf ("%3lu: ", (unsigned long) cnt
);
11252 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
11253 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
11255 printf ("<corrupt: %9ld>", liblist
.l_name
);
11256 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
11257 liblist
.l_version
);
11259 if (liblist
.l_flags
== 0)
11263 static const struct
11270 { " EXACT_MATCH", LL_EXACT_MATCH
},
11271 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
11272 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
11273 { " EXPORTS", LL_EXPORTS
},
11274 { " DELAY_LOAD", LL_DELAY_LOAD
},
11275 { " DELTA", LL_DELTA
}
11277 int flags
= liblist
.l_flags
;
11281 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
11283 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
11285 fputs (l_flags_vals
[fcnt
].name
, stdout
);
11286 flags
^= l_flags_vals
[fcnt
].bit
;
11289 printf (" %#x", (unsigned int) flags
);
11299 if (options_offset
!= 0)
11301 Elf_External_Options
*eopt
;
11302 Elf_Internal_Shdr
*sect
= section_headers
;
11303 Elf_Internal_Options
*iopt
;
11304 Elf_Internal_Options
*option
;
11308 /* Find the section header so that we get the size. */
11309 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
11312 eopt
= get_data (NULL
, file
, options_offset
, 1, sect
->sh_size
,
11316 iopt
= cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (*iopt
));
11319 error (_("Out of memory"));
11326 while (offset
< sect
->sh_size
)
11328 Elf_External_Options
*eoption
;
11330 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
11332 option
->kind
= BYTE_GET (eoption
->kind
);
11333 option
->size
= BYTE_GET (eoption
->size
);
11334 option
->section
= BYTE_GET (eoption
->section
);
11335 option
->info
= BYTE_GET (eoption
->info
);
11337 offset
+= option
->size
;
11343 printf (_("\nSection '%s' contains %d entries:\n"),
11344 SECTION_NAME (sect
), cnt
);
11352 switch (option
->kind
)
11355 /* This shouldn't happen. */
11356 printf (" NULL %d %lx", option
->section
, option
->info
);
11359 printf (" REGINFO ");
11360 if (elf_header
.e_machine
== EM_MIPS
)
11363 Elf32_External_RegInfo
*ereg
;
11364 Elf32_RegInfo reginfo
;
11366 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
11367 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
11368 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
11369 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
11370 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
11371 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
11372 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
11374 printf ("GPR %08lx GP 0x%lx\n",
11375 reginfo
.ri_gprmask
,
11376 (unsigned long) reginfo
.ri_gp_value
);
11377 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11378 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11379 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11384 Elf64_External_RegInfo
*ereg
;
11385 Elf64_Internal_RegInfo reginfo
;
11387 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
11388 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
11389 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
11390 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
11391 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
11392 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
11393 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
11395 printf ("GPR %08lx GP 0x",
11396 reginfo
.ri_gprmask
);
11397 printf_vma (reginfo
.ri_gp_value
);
11400 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11401 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11402 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11406 case ODK_EXCEPTIONS
:
11407 fputs (" EXCEPTIONS fpe_min(", stdout
);
11408 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
11409 fputs (") fpe_max(", stdout
);
11410 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
11411 fputs (")", stdout
);
11413 if (option
->info
& OEX_PAGE0
)
11414 fputs (" PAGE0", stdout
);
11415 if (option
->info
& OEX_SMM
)
11416 fputs (" SMM", stdout
);
11417 if (option
->info
& OEX_FPDBUG
)
11418 fputs (" FPDBUG", stdout
);
11419 if (option
->info
& OEX_DISMISS
)
11420 fputs (" DISMISS", stdout
);
11423 fputs (" PAD ", stdout
);
11424 if (option
->info
& OPAD_PREFIX
)
11425 fputs (" PREFIX", stdout
);
11426 if (option
->info
& OPAD_POSTFIX
)
11427 fputs (" POSTFIX", stdout
);
11428 if (option
->info
& OPAD_SYMBOL
)
11429 fputs (" SYMBOL", stdout
);
11432 fputs (" HWPATCH ", stdout
);
11433 if (option
->info
& OHW_R4KEOP
)
11434 fputs (" R4KEOP", stdout
);
11435 if (option
->info
& OHW_R8KPFETCH
)
11436 fputs (" R8KPFETCH", stdout
);
11437 if (option
->info
& OHW_R5KEOP
)
11438 fputs (" R5KEOP", stdout
);
11439 if (option
->info
& OHW_R5KCVTL
)
11440 fputs (" R5KCVTL", stdout
);
11443 fputs (" FILL ", stdout
);
11444 /* XXX Print content of info word? */
11447 fputs (" TAGS ", stdout
);
11448 /* XXX Print content of info word? */
11451 fputs (" HWAND ", stdout
);
11452 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11453 fputs (" R4KEOP_CHECKED", stdout
);
11454 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11455 fputs (" R4KEOP_CLEAN", stdout
);
11458 fputs (" HWOR ", stdout
);
11459 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11460 fputs (" R4KEOP_CHECKED", stdout
);
11461 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11462 fputs (" R4KEOP_CLEAN", stdout
);
11465 printf (" GP_GROUP %#06lx self-contained %#06lx",
11466 option
->info
& OGP_GROUP
,
11467 (option
->info
& OGP_SELF
) >> 16);
11470 printf (" IDENT %#06lx self-contained %#06lx",
11471 option
->info
& OGP_GROUP
,
11472 (option
->info
& OGP_SELF
) >> 16);
11475 /* This shouldn't happen. */
11476 printf (" %3d ??? %d %lx",
11477 option
->kind
, option
->section
, option
->info
);
11481 len
= sizeof (*eopt
);
11482 while (len
< option
->size
)
11483 if (((char *) option
)[len
] >= ' '
11484 && ((char *) option
)[len
] < 0x7f)
11485 printf ("%c", ((char *) option
)[len
++]);
11487 printf ("\\%03o", ((char *) option
)[len
++]);
11489 fputs ("\n", stdout
);
11497 if (conflicts_offset
!= 0 && conflictsno
!= 0)
11499 Elf32_Conflict
*iconf
;
11502 if (dynamic_symbols
== NULL
)
11504 error (_("conflict list found without a dynamic symbol table"));
11508 iconf
= cmalloc (conflictsno
, sizeof (*iconf
));
11511 error (_("Out of memory"));
11517 Elf32_External_Conflict
*econf32
;
11519 econf32
= get_data (NULL
, file
, conflicts_offset
,
11520 conflictsno
, sizeof (*econf32
), _("conflict"));
11524 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11525 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
11531 Elf64_External_Conflict
*econf64
;
11533 econf64
= get_data (NULL
, file
, conflicts_offset
,
11534 conflictsno
, sizeof (*econf64
), _("conflict"));
11538 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11539 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
11544 printf (_("\nSection '.conflict' contains %lu entries:\n"),
11545 (unsigned long) conflictsno
);
11546 puts (_(" Num: Index Value Name"));
11548 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11550 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
11552 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
11553 print_vma (psym
->st_value
, FULL_HEX
);
11555 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11556 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11558 printf ("<corrupt: %14ld>", psym
->st_name
);
11569 process_gnu_liblist (FILE *file
)
11571 Elf_Internal_Shdr
*section
, *string_sec
;
11572 Elf32_External_Lib
*elib
;
11574 size_t strtab_size
;
11581 for (i
= 0, section
= section_headers
;
11582 i
< elf_header
.e_shnum
;
11585 switch (section
->sh_type
)
11587 case SHT_GNU_LIBLIST
:
11588 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
)
11591 elib
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
11596 string_sec
= SECTION_HEADER (section
->sh_link
);
11598 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
11599 string_sec
->sh_size
, _("liblist string table"));
11600 strtab_size
= string_sec
->sh_size
;
11603 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
11609 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
11610 SECTION_NAME (section
),
11611 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
11613 puts (" Library Time Stamp Checksum Version Flags");
11615 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
11623 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
11624 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
11625 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
11626 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
11627 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
11629 tmp
= gmtime (&time
);
11630 snprintf (timebuf
, sizeof (timebuf
),
11631 "%04u-%02u-%02uT%02u:%02u:%02u",
11632 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11633 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11635 printf ("%3lu: ", (unsigned long) cnt
);
11637 printf ("%-20s", liblist
.l_name
< strtab_size
11638 ? strtab
+ liblist
.l_name
: "<corrupt>");
11640 printf ("%-20.20s", liblist
.l_name
< strtab_size
11641 ? strtab
+ liblist
.l_name
: "<corrupt>");
11642 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
11643 liblist
.l_version
, liblist
.l_flags
);
11653 static const char *
11654 get_note_type (unsigned e_type
)
11656 static char buff
[64];
11658 if (elf_header
.e_type
== ET_CORE
)
11662 return _("NT_AUXV (auxiliary vector)");
11664 return _("NT_PRSTATUS (prstatus structure)");
11666 return _("NT_FPREGSET (floating point registers)");
11668 return _("NT_PRPSINFO (prpsinfo structure)");
11669 case NT_TASKSTRUCT
:
11670 return _("NT_TASKSTRUCT (task structure)");
11672 return _("NT_PRXFPREG (user_xfpregs structure)");
11674 return _("NT_PSTATUS (pstatus structure)");
11676 return _("NT_FPREGS (floating point registers)");
11678 return _("NT_PSINFO (psinfo structure)");
11680 return _("NT_LWPSTATUS (lwpstatus_t structure)");
11682 return _("NT_LWPSINFO (lwpsinfo_t structure)");
11683 case NT_WIN32PSTATUS
:
11684 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
11692 return _("NT_VERSION (version)");
11694 return _("NT_ARCH (architecture)");
11699 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11703 static const char *
11704 get_netbsd_elfcore_note_type (unsigned e_type
)
11706 static char buff
[64];
11708 if (e_type
== NT_NETBSDCORE_PROCINFO
)
11710 /* NetBSD core "procinfo" structure. */
11711 return _("NetBSD procinfo structure");
11714 /* As of Jan 2002 there are no other machine-independent notes
11715 defined for NetBSD core files. If the note type is less
11716 than the start of the machine-dependent note types, we don't
11719 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
11721 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11725 switch (elf_header
.e_machine
)
11727 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
11728 and PT_GETFPREGS == mach+2. */
11733 case EM_SPARC32PLUS
:
11737 case NT_NETBSDCORE_FIRSTMACH
+0:
11738 return _("PT_GETREGS (reg structure)");
11739 case NT_NETBSDCORE_FIRSTMACH
+2:
11740 return _("PT_GETFPREGS (fpreg structure)");
11746 /* On all other arch's, PT_GETREGS == mach+1 and
11747 PT_GETFPREGS == mach+3. */
11751 case NT_NETBSDCORE_FIRSTMACH
+1:
11752 return _("PT_GETREGS (reg structure)");
11753 case NT_NETBSDCORE_FIRSTMACH
+3:
11754 return _("PT_GETFPREGS (fpreg structure)");
11760 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
11761 e_type
- NT_NETBSDCORE_FIRSTMACH
);
11765 /* Note that by the ELF standard, the name field is already null byte
11766 terminated, and namesz includes the terminating null byte.
11767 I.E. the value of namesz for the name "FSF" is 4.
11769 If the value of namesz is zero, there is no name present. */
11771 process_note (Elf_Internal_Note
*pnote
)
11775 if (pnote
->namesz
== 0)
11776 /* If there is no note name, then use the default set of
11777 note type strings. */
11778 nt
= get_note_type (pnote
->type
);
11780 else if (strneq (pnote
->namedata
, "NetBSD-CORE", 11))
11781 /* NetBSD-specific core file notes. */
11782 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
11785 /* Don't recognize this note name; just use the default set of
11786 note type strings. */
11787 nt
= get_note_type (pnote
->type
);
11789 printf (" %s\t\t0x%08lx\t%s\n",
11790 pnote
->namesz
? pnote
->namedata
: "(NONE)",
11791 pnote
->descsz
, nt
);
11797 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
11799 Elf_External_Note
*pnotes
;
11800 Elf_External_Note
*external
;
11806 pnotes
= get_data (NULL
, file
, offset
, 1, length
, _("notes"));
11812 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
11813 (unsigned long) offset
, (unsigned long) length
);
11814 printf (_(" Owner\t\tData size\tDescription\n"));
11816 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
11818 Elf_External_Note
*next
;
11819 Elf_Internal_Note inote
;
11822 inote
.type
= BYTE_GET (external
->type
);
11823 inote
.namesz
= BYTE_GET (external
->namesz
);
11824 inote
.namedata
= external
->name
;
11825 inote
.descsz
= BYTE_GET (external
->descsz
);
11826 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
11827 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
11829 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
11831 if (((char *) next
) > (((char *) pnotes
) + length
))
11833 warn (_("corrupt note found at offset %lx into core notes\n"),
11834 (long)((char *)external
- (char *)pnotes
));
11835 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
11836 inote
.type
, inote
.namesz
, inote
.descsz
);
11842 /* Verify that name is null terminated. It appears that at least
11843 one version of Linux (RedHat 6.0) generates corefiles that don't
11844 comply with the ELF spec by failing to include the null byte in
11846 if (inote
.namedata
[inote
.namesz
] != '\0')
11848 temp
= malloc (inote
.namesz
+ 1);
11852 error (_("Out of memory\n"));
11857 strncpy (temp
, inote
.namedata
, inote
.namesz
);
11858 temp
[inote
.namesz
] = 0;
11860 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
11861 inote
.namedata
= temp
;
11864 res
&= process_note (& inote
);
11879 process_corefile_note_segments (FILE *file
)
11881 Elf_Internal_Phdr
*segment
;
11885 if (! get_program_headers (file
))
11888 for (i
= 0, segment
= program_headers
;
11889 i
< elf_header
.e_phnum
;
11892 if (segment
->p_type
== PT_NOTE
)
11893 res
&= process_corefile_note_segment (file
,
11894 (bfd_vma
) segment
->p_offset
,
11895 (bfd_vma
) segment
->p_filesz
);
11902 process_note_sections (FILE *file
)
11904 Elf_Internal_Shdr
*section
;
11908 for (i
= 0, section
= section_headers
;
11909 i
< elf_header
.e_shnum
;
11911 if (section
->sh_type
== SHT_NOTE
)
11912 res
&= process_corefile_note_segment (file
,
11913 (bfd_vma
) section
->sh_offset
,
11914 (bfd_vma
) section
->sh_size
);
11920 process_notes (FILE *file
)
11922 /* If we have not been asked to display the notes then do nothing. */
11926 if (elf_header
.e_type
!= ET_CORE
)
11927 return process_note_sections (file
);
11929 /* No program headers means no NOTE segment. */
11930 if (elf_header
.e_phnum
> 0)
11931 return process_corefile_note_segments (file
);
11933 printf (_("No note segments present in the core file.\n"));
11938 process_arch_specific (FILE *file
)
11943 switch (elf_header
.e_machine
)
11946 case EM_MIPS_RS3_LE
:
11947 return process_mips_specific (file
);
11956 get_file_header (FILE *file
)
11958 /* Read in the identity array. */
11959 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
11962 /* Determine how to read the rest of the header. */
11963 switch (elf_header
.e_ident
[EI_DATA
])
11965 default: /* fall through */
11966 case ELFDATANONE
: /* fall through */
11968 byte_get
= byte_get_little_endian
;
11969 byte_put
= byte_put_little_endian
;
11972 byte_get
= byte_get_big_endian
;
11973 byte_put
= byte_put_big_endian
;
11977 /* For now we only support 32 bit and 64 bit ELF files. */
11978 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
11980 /* Read in the rest of the header. */
11983 Elf32_External_Ehdr ehdr32
;
11985 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
11988 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
11989 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
11990 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
11991 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
11992 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
11993 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
11994 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
11995 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
11996 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
11997 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
11998 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
11999 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
12000 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
12004 Elf64_External_Ehdr ehdr64
;
12006 /* If we have been compiled with sizeof (bfd_vma) == 4, then
12007 we will not be able to cope with the 64bit data found in
12008 64 ELF files. Detect this now and abort before we start
12009 overwriting things. */
12010 if (sizeof (bfd_vma
) < 8)
12012 error (_("This instance of readelf has been built without support for a\n\
12013 64 bit data type and so it cannot read 64 bit ELF files.\n"));
12017 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
12020 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
12021 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
12022 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
12023 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
12024 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
12025 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
12026 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
12027 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
12028 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
12029 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
12030 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
12031 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
12032 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
12035 if (elf_header
.e_shoff
)
12037 /* There may be some extensions in the first section header. Don't
12038 bomb if we can't read it. */
12040 get_32bit_section_headers (file
, 1);
12042 get_64bit_section_headers (file
, 1);
12048 /* Process one ELF object file according to the command line options.
12049 This file may actually be stored in an archive. The file is
12050 positioned at the start of the ELF object. */
12053 process_object (char *file_name
, FILE *file
)
12057 if (! get_file_header (file
))
12059 error (_("%s: Failed to read file header\n"), file_name
);
12063 /* Initialise per file variables. */
12064 for (i
= NUM_ELEM (version_info
); i
--;)
12065 version_info
[i
] = 0;
12067 for (i
= NUM_ELEM (dynamic_info
); i
--;)
12068 dynamic_info
[i
] = 0;
12070 /* Process the file. */
12072 printf (_("\nFile: %s\n"), file_name
);
12074 /* Initialise the dump_sects array from the cmdline_dump_sects array.
12075 Note we do this even if cmdline_dump_sects is empty because we
12076 must make sure that the dump_sets array is zeroed out before each
12077 object file is processed. */
12078 if (num_dump_sects
> num_cmdline_dump_sects
)
12079 memset (dump_sects
, 0, num_dump_sects
);
12081 if (num_cmdline_dump_sects
> 0)
12083 if (num_dump_sects
== 0)
12084 /* A sneaky way of allocating the dump_sects array. */
12085 request_dump (num_cmdline_dump_sects
, 0);
12087 assert (num_dump_sects
>= num_cmdline_dump_sects
);
12088 memcpy (dump_sects
, cmdline_dump_sects
, num_cmdline_dump_sects
);
12091 if (! process_file_header ())
12094 if (! process_section_headers (file
))
12096 /* Without loaded section headers we cannot process lots of
12098 do_unwind
= do_version
= do_dump
= do_arch
= 0;
12100 if (! do_using_dynamic
)
12101 do_syms
= do_reloc
= 0;
12104 if (! process_section_groups (file
))
12106 /* Without loaded section groups we cannot process unwind. */
12110 if (process_program_headers (file
))
12111 process_dynamic_section (file
);
12113 process_relocs (file
);
12115 process_unwind (file
);
12117 process_symbol_table (file
);
12119 process_syminfo (file
);
12121 process_version_sections (file
);
12123 process_section_contents (file
);
12125 process_notes (file
);
12127 process_gnu_liblist (file
);
12129 process_arch_specific (file
);
12131 if (program_headers
)
12133 free (program_headers
);
12134 program_headers
= NULL
;
12137 if (section_headers
)
12139 free (section_headers
);
12140 section_headers
= NULL
;
12145 free (string_table
);
12146 string_table
= NULL
;
12147 string_table_length
= 0;
12150 if (dynamic_strings
)
12152 free (dynamic_strings
);
12153 dynamic_strings
= NULL
;
12154 dynamic_strings_length
= 0;
12157 if (dynamic_symbols
)
12159 free (dynamic_symbols
);
12160 dynamic_symbols
= NULL
;
12161 num_dynamic_syms
= 0;
12164 if (dynamic_syminfo
)
12166 free (dynamic_syminfo
);
12167 dynamic_syminfo
= NULL
;
12170 if (section_headers_groups
)
12172 free (section_headers_groups
);
12173 section_headers_groups
= NULL
;
12176 if (section_groups
)
12178 struct group_list
*g
, *next
;
12180 for (i
= 0; i
< group_count
; i
++)
12182 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
12189 free (section_groups
);
12190 section_groups
= NULL
;
12193 if (debug_information
)
12195 for (i
= 0; i
< num_debug_info_entries
; i
++)
12197 if (!debug_information
[i
].max_loc_offsets
)
12199 free (debug_information
[i
].loc_offsets
);
12200 free (debug_information
[i
].have_frame_base
);
12202 if (!debug_information
[i
].max_range_lists
)
12203 free (debug_information
[i
].range_lists
);
12205 free (debug_information
);
12206 debug_information
= NULL
;
12207 num_debug_info_entries
= 0;
12213 /* Process an ELF archive. The file is positioned just after the
12217 process_archive (char *file_name
, FILE *file
)
12219 struct ar_hdr arhdr
;
12221 unsigned long size
;
12222 char *longnames
= NULL
;
12223 unsigned long longnames_size
= 0;
12224 size_t file_name_size
;
12229 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12230 if (got
!= sizeof arhdr
)
12235 error (_("%s: failed to read archive header\n"), file_name
);
12239 if (memcmp (arhdr
.ar_name
, "/ ", 16) == 0)
12241 /* This is the archive symbol table. Skip it.
12242 FIXME: We should have an option to dump it. */
12243 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
12244 if (fseek (file
, size
+ (size
& 1), SEEK_CUR
) != 0)
12246 error (_("%s: failed to skip archive symbol table\n"), file_name
);
12250 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12251 if (got
!= sizeof arhdr
)
12256 error (_("%s: failed to read archive header\n"), file_name
);
12261 if (memcmp (arhdr
.ar_name
, "// ", 16) == 0)
12263 /* This is the archive string table holding long member
12266 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
12268 longnames
= malloc (longnames_size
);
12269 if (longnames
== NULL
)
12271 error (_("Out of memory\n"));
12275 if (fread (longnames
, longnames_size
, 1, file
) != 1)
12278 error (_("%s: failed to read string table\n"), file_name
);
12282 if ((longnames_size
& 1) != 0)
12285 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12286 if (got
!= sizeof arhdr
)
12293 error (_("%s: failed to read archive header\n"), file_name
);
12298 file_name_size
= strlen (file_name
);
12307 if (arhdr
.ar_name
[0] == '/')
12311 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
12312 if (off
>= longnames_size
)
12314 error (_("%s: invalid archive string table offset %lu\n"), file_name
, off
);
12319 name
= longnames
+ off
;
12320 nameend
= memchr (name
, '/', longnames_size
- off
);
12324 name
= arhdr
.ar_name
;
12325 nameend
= memchr (name
, '/', 16);
12328 if (nameend
== NULL
)
12330 error (_("%s: bad archive file name\n"), file_name
);
12335 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
12336 if (namealc
== NULL
)
12338 error (_("Out of memory\n"));
12343 memcpy (namealc
, file_name
, file_name_size
);
12344 namealc
[file_name_size
] = '(';
12345 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
12346 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
12347 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
12349 archive_file_offset
= ftell (file
);
12350 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
12352 ret
|= process_object (namealc
, file
);
12357 (archive_file_offset
12358 + archive_file_size
12359 + (archive_file_size
& 1)),
12362 error (_("%s: failed to seek to next archive header\n"), file_name
);
12367 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12368 if (got
!= sizeof arhdr
)
12373 error (_("%s: failed to read archive header\n"), file_name
);
12379 if (longnames
!= 0)
12386 process_file (char *file_name
)
12389 struct stat statbuf
;
12390 char armag
[SARMAG
];
12393 if (stat (file_name
, &statbuf
) < 0)
12395 if (errno
== ENOENT
)
12396 error (_("'%s': No such file\n"), file_name
);
12398 error (_("Could not locate '%s'. System error message: %s\n"),
12399 file_name
, strerror (errno
));
12403 if (! S_ISREG (statbuf
.st_mode
))
12405 error (_("'%s' is not an ordinary file\n"), file_name
);
12409 file
= fopen (file_name
, "rb");
12412 error (_("Input file '%s' is not readable.\n"), file_name
);
12416 if (fread (armag
, SARMAG
, 1, file
) != 1)
12418 error (_("%s: Failed to read file header\n"), file_name
);
12423 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
12424 ret
= process_archive (file_name
, file
);
12428 archive_file_size
= archive_file_offset
= 0;
12429 ret
= process_object (file_name
, file
);
12437 #ifdef SUPPORT_DISASSEMBLY
12438 /* Needed by the i386 disassembler. For extra credit, someone could
12439 fix this so that we insert symbolic addresses here, esp for GOT/PLT
12443 print_address (unsigned int addr
, FILE *outfile
)
12445 fprintf (outfile
,"0x%8.8x", addr
);
12448 /* Needed by the i386 disassembler. */
12450 db_task_printsym (unsigned int addr
)
12452 print_address (addr
, stderr
);
12457 main (int argc
, char **argv
)
12461 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
12462 setlocale (LC_MESSAGES
, "");
12464 #if defined (HAVE_SETLOCALE)
12465 setlocale (LC_CTYPE
, "");
12467 bindtextdomain (PACKAGE
, LOCALEDIR
);
12468 textdomain (PACKAGE
);
12470 parse_args (argc
, argv
);
12472 if (num_dump_sects
> 0)
12474 /* Make a copy of the dump_sects array. */
12475 cmdline_dump_sects
= malloc (num_dump_sects
);
12476 if (cmdline_dump_sects
== NULL
)
12477 error (_("Out of memory allocating dump request table."));
12480 memcpy (cmdline_dump_sects
, dump_sects
, num_dump_sects
);
12481 num_cmdline_dump_sects
= num_dump_sects
;
12485 if (optind
< (argc
- 1))
12489 while (optind
< argc
)
12490 err
|= process_file (argv
[optind
++]);
12492 if (dump_sects
!= NULL
)
12494 if (cmdline_dump_sects
!= NULL
)
12495 free (cmdline_dump_sects
);