1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
3 Free Software Foundation, Inc.
5 Originally developed by Eric Youngdale <eric@andante.jic.com>
6 Modifications by Nick Clifton <nickc@redhat.com>
8 This file is part of GNU Binutils.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
25 /* The difference between readelf and objdump:
27 Both programs are capable of displaying the contents of ELF format files,
28 so why does the binutils project have two file dumpers ?
30 The reason is that objdump sees an ELF file through a BFD filter of the
31 world; if BFD has a bug where, say, it disagrees about a machine constant
32 in e_flags, then the odds are good that it will remain internally
33 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
34 GAS sees it the BFD way. There was need for a tool to go find out what
35 the file actually says.
37 This is why the readelf program does not link against the BFD library - it
38 exists as an independent program to help verify the correct working of BFD.
40 There is also the case that readelf can provide more information about an
41 ELF file than is provided by objdump. In particular it can display DWARF
42 debugging information which (at the moment) objdump cannot. */
45 #include <sys/types.h>
51 /* Define BFD64 here, even if our default architecture is 32 bit ELF
52 as this will allow us to read in and parse 64bit and 32bit ELF files.
53 Only do this if we believe that the compiler can support a 64 bit
54 data type. For now we only rely on GCC being able to do this. */
60 #include "elf/common.h"
61 #include "elf/external.h"
62 #include "elf/internal.h"
63 #include "elf/dwarf2.h"
65 /* The following headers use the elf/reloc-macros.h file to
66 automatically generate relocation recognition functions
67 such as elf_mips_reloc_type() */
69 #define RELOC_MACROS_GEN_FUNC
71 #include "elf/alpha.h"
92 #include "elf/m68hc11.h"
93 #include "elf/mcore.h"
96 #include "elf/mn10200.h"
97 #include "elf/mn10300.h"
99 #include "elf/msp430.h"
100 #include "elf/or32.h"
103 #include "elf/ppc64.h"
104 #include "elf/s390.h"
106 #include "elf/sparc.h"
107 #include "elf/v850.h"
109 #include "elf/x86-64.h"
110 #include "elf/xstormy16.h"
112 #include "elf/iq2000.h"
113 #include "elf/xtensa.h"
119 #include "libiberty.h"
121 char *program_name
= "readelf";
122 static long archive_file_offset
;
123 static unsigned long archive_file_size
;
124 static unsigned long dynamic_addr
;
125 static bfd_size_type dynamic_size
;
126 static unsigned int dynamic_nent
;
127 static char *dynamic_strings
;
128 static unsigned long dynamic_strings_length
;
129 static char *string_table
;
130 static unsigned long string_table_length
;
131 static unsigned long num_dynamic_syms
;
132 static Elf_Internal_Sym
*dynamic_symbols
;
133 static Elf_Internal_Syminfo
*dynamic_syminfo
;
134 static unsigned long dynamic_syminfo_offset
;
135 static unsigned int dynamic_syminfo_nent
;
136 static char program_interpreter
[64];
137 static bfd_vma dynamic_info
[DT_JMPREL
+ 1];
138 static bfd_vma version_info
[16];
139 static Elf_Internal_Ehdr elf_header
;
140 static Elf_Internal_Shdr
*section_headers
;
141 static Elf_Internal_Phdr
*program_headers
;
142 static Elf_Internal_Dyn
*dynamic_section
;
143 static Elf_Internal_Shdr
*symtab_shndx_hdr
;
144 static int show_name
;
145 static int do_dynamic
;
148 static int do_sections
;
149 static int do_section_groups
;
150 static int do_section_details
;
151 static int do_segments
;
152 static int do_unwind
;
153 static int do_using_dynamic
;
154 static int do_header
;
156 static int do_version
;
158 static int do_histogram
;
159 static int do_debugging
;
160 static int do_debug_info
;
161 static int do_debug_abbrevs
;
162 static int do_debug_lines
;
163 static int do_debug_pubnames
;
164 static int do_debug_aranges
;
165 static int do_debug_ranges
;
166 static int do_debug_frames
;
167 static int do_debug_frames_interp
;
168 static int do_debug_macinfo
;
169 static int do_debug_str
;
170 static int do_debug_loc
;
173 static int is_32bit_elf
;
174 static int is_relocatable
;
175 static int have_frame_base
;
176 static int need_base_address
;
177 static bfd_vma eh_addr_size
;
181 struct group_list
*next
;
182 unsigned int section_index
;
187 struct group_list
*root
;
188 unsigned int group_index
;
191 static size_t group_count
;
192 static struct group
*section_groups
;
193 static struct group
**section_headers_groups
;
195 /* A dynamic array of flags indicating for which sections a hex dump
196 has been requested (via the -x switch) and/or a disassembly dump
197 (via the -i switch). */
198 char *cmdline_dump_sects
= NULL
;
199 unsigned num_cmdline_dump_sects
= 0;
201 /* A dynamic array of flags indicating for which sections a dump of
202 some kind has been requested. It is reset on a per-object file
203 basis and then initialised from the cmdline_dump_sects array and
204 the results of interpreting the -w switch. */
205 char *dump_sects
= NULL
;
206 unsigned int num_dump_sects
= 0;
208 #define HEX_DUMP (1 << 0)
209 #define DISASS_DUMP (1 << 1)
210 #define DEBUG_DUMP (1 << 2)
212 /* How to print a vma value. */
213 typedef enum print_mode
225 static bfd_vma (*byte_get
) (unsigned char *, int);
226 static void (*byte_put
) (unsigned char *, bfd_vma
, int);
230 #define SECTION_NAME(X) ((X) == NULL ? "<none>" : \
231 ((X)->sh_name >= string_table_length \
232 ? "<corrupt>" : string_table + (X)->sh_name))
234 /* Given st_shndx I, map to section_headers index. */
235 #define SECTION_HEADER_INDEX(I) \
236 ((I) < SHN_LORESERVE \
238 : ((I) <= SHN_HIRESERVE \
240 : (I) - (SHN_HIRESERVE + 1 - SHN_LORESERVE)))
242 /* Reverse of the above. */
243 #define SECTION_HEADER_NUM(N) \
244 ((N) < SHN_LORESERVE \
246 : (N) + (SHN_HIRESERVE + 1 - SHN_LORESERVE))
248 #define SECTION_HEADER(I) (section_headers + SECTION_HEADER_INDEX (I))
250 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
252 #define BYTE_GET(field) byte_get (field, sizeof (field))
254 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
256 #define GET_ELF_SYMBOLS(file, section) \
257 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
258 : get_64bit_elf_symbols (file, section))
260 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
261 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
262 already been called and verified that the string exists. */
263 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
265 /* This is just a bit of syntatic sugar. */
266 #define streq(a,b) (strcmp ((a), (b)) == 0)
267 #define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
269 static void ATTRIBUTE_PRINTF_1
270 error (const char *message
, ...)
274 va_start (args
, message
);
275 fprintf (stderr
, _("%s: Error: "), program_name
);
276 vfprintf (stderr
, message
, args
);
280 static void ATTRIBUTE_PRINTF_1
281 warn (const char *message
, ...)
285 va_start (args
, message
);
286 fprintf (stderr
, _("%s: Warning: "), program_name
);
287 vfprintf (stderr
, message
, args
);
292 cmalloc (size_t nmemb
, size_t size
)
294 /* Check for overflow. */
295 if (nmemb
>= ~(size_t) 0 / size
)
298 return malloc (nmemb
* size
);
302 xcmalloc (size_t nmemb
, size_t size
)
304 /* Check for overflow. */
305 if (nmemb
>= ~(size_t) 0 / size
)
308 return xmalloc (nmemb
* size
);
312 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
314 /* Check for overflow. */
315 if (nmemb
>= ~(size_t) 0 / size
)
318 return xrealloc (ptr
, nmemb
* size
);
322 get_data (void *var
, FILE *file
, long offset
, size_t size
, size_t nmemb
,
327 if (size
== 0 || nmemb
== 0)
330 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
332 error (_("Unable to seek to 0x%lx for %s\n"),
333 archive_file_offset
+ offset
, reason
);
340 /* Check for overflow. */
341 if (nmemb
< (~(size_t) 0 - 1) / size
)
342 /* + 1 so that we can '\0' terminate invalid string table sections. */
343 mvar
= malloc (size
* nmemb
+ 1);
347 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
348 (unsigned long)(size
* nmemb
), reason
);
352 ((char *) mvar
)[size
* nmemb
] = '\0';
355 if (fread (mvar
, size
, nmemb
, file
) != nmemb
)
357 error (_("Unable to read in 0x%lx bytes of %s\n"),
358 (unsigned long)(size
* nmemb
), reason
);
368 byte_put_little_endian (unsigned char *field
, bfd_vma value
, int size
)
373 field
[7] = (((value
>> 24) >> 24) >> 8) & 0xff;
374 field
[6] = ((value
>> 24) >> 24) & 0xff;
375 field
[5] = ((value
>> 24) >> 16) & 0xff;
376 field
[4] = ((value
>> 24) >> 8) & 0xff;
379 field
[3] = (value
>> 24) & 0xff;
380 field
[2] = (value
>> 16) & 0xff;
383 field
[1] = (value
>> 8) & 0xff;
386 field
[0] = value
& 0xff;
390 error (_("Unhandled data length: %d\n"), size
);
395 #if defined BFD64 && !BFD_HOST_64BIT_LONG
397 print_dec_vma (bfd_vma vma
, int is_signed
)
403 if (is_signed
&& (bfd_signed_vma
) vma
< 0)
412 *bufp
++ = '0' + vma
% 10;
424 print_hex_vma (bfd_vma vma
)
432 char digit
= '0' + (vma
& 0x0f);
434 digit
+= 'a' - '0' - 10;
447 /* Print a VMA value. */
449 print_vma (bfd_vma vma
, print_mode mode
)
458 return printf ("0x%8.8lx", (unsigned long) vma
);
461 return printf ("%8.8lx", (unsigned long) vma
);
465 return printf ("%5ld", (long) vma
);
469 return printf ("0x%lx", (unsigned long) vma
);
472 return printf ("%lx", (unsigned long) vma
);
475 return printf ("%ld", (unsigned long) vma
);
478 return printf ("%lu", (unsigned long) vma
);
501 #if BFD_HOST_64BIT_LONG
502 return nc
+ printf ("%lx", vma
);
504 return nc
+ print_hex_vma (vma
);
508 #if BFD_HOST_64BIT_LONG
509 return printf ("%ld", vma
);
511 return print_dec_vma (vma
, 1);
515 #if BFD_HOST_64BIT_LONG
517 return printf ("%5ld", vma
);
519 return printf ("%#lx", vma
);
522 return printf ("%5ld", _bfd_int64_low (vma
));
524 return print_hex_vma (vma
);
528 #if BFD_HOST_64BIT_LONG
529 return printf ("%lu", vma
);
531 return print_dec_vma (vma
, 0);
539 /* Display a symbol on stdout. If do_wide is not true then
540 format the symbol to be at most WIDTH characters,
541 truncating as necessary. If WIDTH is negative then
542 format the string to be exactly - WIDTH characters,
543 truncating or padding as necessary. */
546 print_symbol (int width
, const char *symbol
)
549 printf ("%s", symbol
);
551 printf ("%-*.*s", width
, width
, symbol
);
553 printf ("%-.*s", width
, symbol
);
557 byte_put_big_endian (unsigned char *field
, bfd_vma value
, int size
)
562 field
[7] = value
& 0xff;
563 field
[6] = (value
>> 8) & 0xff;
564 field
[5] = (value
>> 16) & 0xff;
565 field
[4] = (value
>> 24) & 0xff;
570 field
[3] = value
& 0xff;
571 field
[2] = (value
>> 8) & 0xff;
575 field
[1] = value
& 0xff;
579 field
[0] = value
& 0xff;
583 error (_("Unhandled data length: %d\n"), size
);
588 /* Return a pointer to section NAME, or NULL if no such section exists. */
590 static Elf_Internal_Shdr
*
591 find_section (const char *name
)
595 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
596 if (streq (SECTION_NAME (section_headers
+ i
), name
))
597 return section_headers
+ i
;
602 /* Guess the relocation size commonly used by the specific machines. */
605 guess_is_rela (unsigned long e_machine
)
609 /* Targets that use REL relocations. */
624 /* Targets that use RELA relocations. */
639 case EM_CYGNUS_MN10200
:
641 case EM_CYGNUS_MN10300
:
690 warn (_("Don't know about relocations on this machine architecture\n"));
696 slurp_rela_relocs (FILE *file
,
697 unsigned long rel_offset
,
698 unsigned long rel_size
,
699 Elf_Internal_Rela
**relasp
,
700 unsigned long *nrelasp
)
702 Elf_Internal_Rela
*relas
;
703 unsigned long nrelas
;
708 Elf32_External_Rela
*erelas
;
710 erelas
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
714 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
716 relas
= cmalloc (nrelas
, sizeof (Elf_Internal_Rela
));
721 error (_("out of memory parsing relocs"));
725 for (i
= 0; i
< nrelas
; i
++)
727 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
728 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
729 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
736 Elf64_External_Rela
*erelas
;
738 erelas
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
742 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
744 relas
= cmalloc (nrelas
, sizeof (Elf_Internal_Rela
));
749 error (_("out of memory parsing relocs"));
753 for (i
= 0; i
< nrelas
; i
++)
755 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
756 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
757 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
768 slurp_rel_relocs (FILE *file
,
769 unsigned long rel_offset
,
770 unsigned long rel_size
,
771 Elf_Internal_Rela
**relsp
,
772 unsigned long *nrelsp
)
774 Elf_Internal_Rela
*rels
;
780 Elf32_External_Rel
*erels
;
782 erels
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
786 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
788 rels
= cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
793 error (_("out of memory parsing relocs"));
797 for (i
= 0; i
< nrels
; i
++)
799 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
800 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
801 rels
[i
].r_addend
= 0;
808 Elf64_External_Rel
*erels
;
810 erels
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
814 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
816 rels
= cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
821 error (_("out of memory parsing relocs"));
825 for (i
= 0; i
< nrels
; i
++)
827 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
828 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
829 rels
[i
].r_addend
= 0;
839 /* Display the contents of the relocation data found at the specified
843 dump_relocations (FILE *file
,
844 unsigned long rel_offset
,
845 unsigned long rel_size
,
846 Elf_Internal_Sym
*symtab
,
849 unsigned long strtablen
,
853 Elf_Internal_Rela
*rels
;
856 if (is_rela
== UNKNOWN
)
857 is_rela
= guess_is_rela (elf_header
.e_machine
);
861 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
866 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
875 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
877 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
882 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
884 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
892 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
894 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
899 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
901 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
905 for (i
= 0; i
< rel_size
; i
++)
908 const char *rtype2
= NULL
;
909 const char *rtype3
= NULL
;
912 bfd_vma symtab_index
;
917 offset
= rels
[i
].r_offset
;
918 info
= rels
[i
].r_info
;
922 type
= ELF32_R_TYPE (info
);
923 symtab_index
= ELF32_R_SYM (info
);
927 /* The #ifdef BFD64 below is to prevent a compile time warning.
928 We know that if we do not have a 64 bit data type that we
929 will never execute this code anyway. */
931 if (elf_header
.e_machine
== EM_MIPS
)
933 /* In little-endian objects, r_info isn't really a 64-bit
934 little-endian value: it has a 32-bit little-endian
935 symbol index followed by four individual byte fields.
936 Reorder INFO accordingly. */
937 if (elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
938 info
= (((info
& 0xffffffff) << 32)
939 | ((info
>> 56) & 0xff)
940 | ((info
>> 40) & 0xff00)
941 | ((info
>> 24) & 0xff0000)
942 | ((info
>> 8) & 0xff000000));
943 type
= ELF64_MIPS_R_TYPE (info
);
944 type2
= ELF64_MIPS_R_TYPE2 (info
);
945 type3
= ELF64_MIPS_R_TYPE3 (info
);
947 else if (elf_header
.e_machine
== EM_SPARCV9
)
948 type
= ELF64_R_TYPE_ID (info
);
950 type
= ELF64_R_TYPE (info
);
952 symtab_index
= ELF64_R_SYM (info
);
958 #ifdef _bfd_int64_low
959 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset
), _bfd_int64_low (info
));
961 printf ("%8.8lx %8.8lx ", offset
, info
);
966 #ifdef _bfd_int64_low
968 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
969 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
970 _bfd_int64_high (offset
),
971 _bfd_int64_low (offset
),
972 _bfd_int64_high (info
),
973 _bfd_int64_low (info
));
976 ? "%16.16lx %16.16lx "
977 : "%12.12lx %12.12lx ",
982 switch (elf_header
.e_machine
)
990 rtype
= elf_m32r_reloc_type (type
);
995 rtype
= elf_i386_reloc_type (type
);
1000 rtype
= elf_m68hc11_reloc_type (type
);
1004 rtype
= elf_m68k_reloc_type (type
);
1008 rtype
= elf_i960_reloc_type (type
);
1013 rtype
= elf_avr_reloc_type (type
);
1016 case EM_OLD_SPARCV9
:
1017 case EM_SPARC32PLUS
:
1020 rtype
= elf_sparc_reloc_type (type
);
1024 case EM_CYGNUS_V850
:
1025 rtype
= v850_reloc_type (type
);
1029 case EM_CYGNUS_D10V
:
1030 rtype
= elf_d10v_reloc_type (type
);
1034 case EM_CYGNUS_D30V
:
1035 rtype
= elf_d30v_reloc_type (type
);
1039 rtype
= elf_dlx_reloc_type (type
);
1043 rtype
= elf_sh_reloc_type (type
);
1047 case EM_CYGNUS_MN10300
:
1048 rtype
= elf_mn10300_reloc_type (type
);
1052 case EM_CYGNUS_MN10200
:
1053 rtype
= elf_mn10200_reloc_type (type
);
1057 case EM_CYGNUS_FR30
:
1058 rtype
= elf_fr30_reloc_type (type
);
1062 rtype
= elf_frv_reloc_type (type
);
1066 rtype
= elf_mcore_reloc_type (type
);
1070 rtype
= elf_mmix_reloc_type (type
);
1075 rtype
= elf_msp430_reloc_type (type
);
1079 rtype
= elf_ppc_reloc_type (type
);
1083 rtype
= elf_ppc64_reloc_type (type
);
1087 case EM_MIPS_RS3_LE
:
1088 rtype
= elf_mips_reloc_type (type
);
1091 rtype2
= elf_mips_reloc_type (type2
);
1092 rtype3
= elf_mips_reloc_type (type3
);
1097 rtype
= elf_alpha_reloc_type (type
);
1101 rtype
= elf_arm_reloc_type (type
);
1105 rtype
= elf_arc_reloc_type (type
);
1109 rtype
= elf_hppa_reloc_type (type
);
1115 rtype
= elf_h8_reloc_type (type
);
1120 rtype
= elf_or32_reloc_type (type
);
1125 rtype
= elf_pj_reloc_type (type
);
1128 rtype
= elf_ia64_reloc_type (type
);
1132 rtype
= elf_cris_reloc_type (type
);
1136 rtype
= elf_i860_reloc_type (type
);
1140 rtype
= elf_x86_64_reloc_type (type
);
1144 rtype
= i370_reloc_type (type
);
1149 rtype
= elf_s390_reloc_type (type
);
1153 rtype
= elf_xstormy16_reloc_type (type
);
1157 rtype
= elf_crx_reloc_type (type
);
1161 rtype
= elf_vax_reloc_type (type
);
1166 rtype
= elf_ip2k_reloc_type (type
);
1170 rtype
= elf_iq2000_reloc_type (type
);
1175 rtype
= elf_xtensa_reloc_type (type
);
1179 rtype
= elf_m32c_reloc_type (type
);
1183 rtype
= elf_ms1_reloc_type (type
);
1188 #ifdef _bfd_int64_low
1189 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type
));
1191 printf (_("unrecognized: %-7lx"), type
);
1194 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1196 if (elf_header
.e_machine
== EM_ALPHA
1197 && streq (rtype
, "R_ALPHA_LITUSE")
1200 switch (rels
[i
].r_addend
)
1202 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1203 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1204 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1205 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1206 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1207 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1208 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1209 default: rtype
= NULL
;
1212 printf (" (%s)", rtype
);
1216 printf (_("<unknown addend: %lx>"),
1217 (unsigned long) rels
[i
].r_addend
);
1220 else if (symtab_index
)
1222 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1223 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1226 Elf_Internal_Sym
*psym
;
1228 psym
= symtab
+ symtab_index
;
1231 print_vma (psym
->st_value
, LONG_HEX
);
1232 printf (is_32bit_elf
? " " : " ");
1234 if (psym
->st_name
== 0)
1236 const char *sec_name
= "<null>";
1239 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1241 bfd_vma sec_index
= (bfd_vma
) -1;
1243 if (psym
->st_shndx
< SHN_LORESERVE
)
1244 sec_index
= psym
->st_shndx
;
1245 else if (psym
->st_shndx
> SHN_HIRESERVE
)
1246 sec_index
= psym
->st_shndx
- (SHN_HIRESERVE
+ 1
1249 if (sec_index
!= (bfd_vma
) -1)
1250 sec_name
= SECTION_NAME (section_headers
+ sec_index
);
1251 else if (psym
->st_shndx
== SHN_ABS
)
1253 else if (psym
->st_shndx
== SHN_COMMON
)
1254 sec_name
= "COMMON";
1255 else if (elf_header
.e_machine
== EM_X86_64
1256 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1257 sec_name
= "LARGE_COMMON";
1258 else if (elf_header
.e_machine
== EM_IA_64
1259 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1260 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1261 sec_name
= "ANSI_COM";
1264 sprintf (name_buf
, "<section 0x%x>",
1265 (unsigned int) psym
->st_shndx
);
1266 sec_name
= name_buf
;
1269 print_symbol (22, sec_name
);
1271 else if (strtab
== NULL
)
1272 printf (_("<string table index: %3ld>"), psym
->st_name
);
1273 else if (psym
->st_name
>= strtablen
)
1274 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1276 print_symbol (22, strtab
+ psym
->st_name
);
1279 printf (" + %lx", (unsigned long) rels
[i
].r_addend
);
1284 printf ("%*c", is_32bit_elf
?
1285 (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1286 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1289 if (elf_header
.e_machine
== EM_SPARCV9
&& streq (rtype
, "R_SPARC_OLO10"))
1290 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1294 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1296 printf (" Type2: ");
1299 #ifdef _bfd_int64_low
1300 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2
));
1302 printf (_("unrecognized: %-7lx"), type2
);
1305 printf ("%-17.17s", rtype2
);
1307 printf ("\n Type3: ");
1310 #ifdef _bfd_int64_low
1311 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3
));
1313 printf (_("unrecognized: %-7lx"), type3
);
1316 printf ("%-17.17s", rtype3
);
1328 get_mips_dynamic_type (unsigned long type
)
1332 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1333 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1334 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1335 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1336 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1337 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1338 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1339 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1340 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1341 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1342 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1343 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1344 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1345 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1346 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1347 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1348 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1349 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1350 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1351 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1352 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1353 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1354 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1355 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1356 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1357 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1358 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1359 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1360 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1361 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1362 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1363 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1364 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1365 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1366 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1367 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1368 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1369 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1370 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1371 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1372 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1373 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1374 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1381 get_sparc64_dynamic_type (unsigned long type
)
1385 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1392 get_ppc_dynamic_type (unsigned long type
)
1396 case DT_PPC_GOT
: return "PPC_GOT";
1403 get_ppc64_dynamic_type (unsigned long type
)
1407 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1408 case DT_PPC64_OPD
: return "PPC64_OPD";
1409 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1416 get_parisc_dynamic_type (unsigned long type
)
1420 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1421 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1422 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1423 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1424 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1425 case DT_HP_PREINIT
: return "HP_PREINIT";
1426 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1427 case DT_HP_NEEDED
: return "HP_NEEDED";
1428 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1429 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1430 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1431 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1432 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1433 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1434 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1435 case DT_HP_FILTERED
: return "HP_FILTERED";
1436 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1437 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1438 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1439 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1440 case DT_PLT
: return "PLT";
1441 case DT_PLT_SIZE
: return "PLT_SIZE";
1442 case DT_DLT
: return "DLT";
1443 case DT_DLT_SIZE
: return "DLT_SIZE";
1450 get_ia64_dynamic_type (unsigned long type
)
1454 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1461 get_alpha_dynamic_type (unsigned long type
)
1465 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1472 get_dynamic_type (unsigned long type
)
1474 static char buff
[64];
1478 case DT_NULL
: return "NULL";
1479 case DT_NEEDED
: return "NEEDED";
1480 case DT_PLTRELSZ
: return "PLTRELSZ";
1481 case DT_PLTGOT
: return "PLTGOT";
1482 case DT_HASH
: return "HASH";
1483 case DT_STRTAB
: return "STRTAB";
1484 case DT_SYMTAB
: return "SYMTAB";
1485 case DT_RELA
: return "RELA";
1486 case DT_RELASZ
: return "RELASZ";
1487 case DT_RELAENT
: return "RELAENT";
1488 case DT_STRSZ
: return "STRSZ";
1489 case DT_SYMENT
: return "SYMENT";
1490 case DT_INIT
: return "INIT";
1491 case DT_FINI
: return "FINI";
1492 case DT_SONAME
: return "SONAME";
1493 case DT_RPATH
: return "RPATH";
1494 case DT_SYMBOLIC
: return "SYMBOLIC";
1495 case DT_REL
: return "REL";
1496 case DT_RELSZ
: return "RELSZ";
1497 case DT_RELENT
: return "RELENT";
1498 case DT_PLTREL
: return "PLTREL";
1499 case DT_DEBUG
: return "DEBUG";
1500 case DT_TEXTREL
: return "TEXTREL";
1501 case DT_JMPREL
: return "JMPREL";
1502 case DT_BIND_NOW
: return "BIND_NOW";
1503 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1504 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1505 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1506 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1507 case DT_RUNPATH
: return "RUNPATH";
1508 case DT_FLAGS
: return "FLAGS";
1510 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1511 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1513 case DT_CHECKSUM
: return "CHECKSUM";
1514 case DT_PLTPADSZ
: return "PLTPADSZ";
1515 case DT_MOVEENT
: return "MOVEENT";
1516 case DT_MOVESZ
: return "MOVESZ";
1517 case DT_FEATURE
: return "FEATURE";
1518 case DT_POSFLAG_1
: return "POSFLAG_1";
1519 case DT_SYMINSZ
: return "SYMINSZ";
1520 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1522 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1523 case DT_CONFIG
: return "CONFIG";
1524 case DT_DEPAUDIT
: return "DEPAUDIT";
1525 case DT_AUDIT
: return "AUDIT";
1526 case DT_PLTPAD
: return "PLTPAD";
1527 case DT_MOVETAB
: return "MOVETAB";
1528 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1530 case DT_VERSYM
: return "VERSYM";
1532 case DT_RELACOUNT
: return "RELACOUNT";
1533 case DT_RELCOUNT
: return "RELCOUNT";
1534 case DT_FLAGS_1
: return "FLAGS_1";
1535 case DT_VERDEF
: return "VERDEF";
1536 case DT_VERDEFNUM
: return "VERDEFNUM";
1537 case DT_VERNEED
: return "VERNEED";
1538 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1540 case DT_AUXILIARY
: return "AUXILIARY";
1541 case DT_USED
: return "USED";
1542 case DT_FILTER
: return "FILTER";
1544 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1545 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1546 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1547 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1548 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1551 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1555 switch (elf_header
.e_machine
)
1558 case EM_MIPS_RS3_LE
:
1559 result
= get_mips_dynamic_type (type
);
1562 result
= get_sparc64_dynamic_type (type
);
1565 result
= get_ppc_dynamic_type (type
);
1568 result
= get_ppc64_dynamic_type (type
);
1571 result
= get_ia64_dynamic_type (type
);
1574 result
= get_alpha_dynamic_type (type
);
1584 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1586 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1587 || (elf_header
.e_machine
== EM_PARISC
1588 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1592 switch (elf_header
.e_machine
)
1595 result
= get_parisc_dynamic_type (type
);
1605 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1609 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1616 get_file_type (unsigned e_type
)
1618 static char buff
[32];
1622 case ET_NONE
: return _("NONE (None)");
1623 case ET_REL
: return _("REL (Relocatable file)");
1624 case ET_EXEC
: return _("EXEC (Executable file)");
1625 case ET_DYN
: return _("DYN (Shared object file)");
1626 case ET_CORE
: return _("CORE (Core file)");
1629 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1630 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1631 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1632 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1634 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1640 get_machine_name (unsigned e_machine
)
1642 static char buff
[64]; /* XXX */
1646 case EM_NONE
: return _("None");
1647 case EM_M32
: return "WE32100";
1648 case EM_SPARC
: return "Sparc";
1649 case EM_386
: return "Intel 80386";
1650 case EM_68K
: return "MC68000";
1651 case EM_88K
: return "MC88000";
1652 case EM_486
: return "Intel 80486";
1653 case EM_860
: return "Intel 80860";
1654 case EM_MIPS
: return "MIPS R3000";
1655 case EM_S370
: return "IBM System/370";
1656 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1657 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1658 case EM_PARISC
: return "HPPA";
1659 case EM_PPC_OLD
: return "Power PC (old)";
1660 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1661 case EM_960
: return "Intel 90860";
1662 case EM_PPC
: return "PowerPC";
1663 case EM_PPC64
: return "PowerPC64";
1664 case EM_V800
: return "NEC V800";
1665 case EM_FR20
: return "Fujitsu FR20";
1666 case EM_RH32
: return "TRW RH32";
1667 case EM_MCORE
: return "MCORE";
1668 case EM_ARM
: return "ARM";
1669 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1670 case EM_SH
: return "Renesas / SuperH SH";
1671 case EM_SPARCV9
: return "Sparc v9";
1672 case EM_TRICORE
: return "Siemens Tricore";
1673 case EM_ARC
: return "ARC";
1674 case EM_H8_300
: return "Renesas H8/300";
1675 case EM_H8_300H
: return "Renesas H8/300H";
1676 case EM_H8S
: return "Renesas H8S";
1677 case EM_H8_500
: return "Renesas H8/500";
1678 case EM_IA_64
: return "Intel IA-64";
1679 case EM_MIPS_X
: return "Stanford MIPS-X";
1680 case EM_COLDFIRE
: return "Motorola Coldfire";
1681 case EM_68HC12
: return "Motorola M68HC12";
1682 case EM_ALPHA
: return "Alpha";
1683 case EM_CYGNUS_D10V
:
1684 case EM_D10V
: return "d10v";
1685 case EM_CYGNUS_D30V
:
1686 case EM_D30V
: return "d30v";
1687 case EM_CYGNUS_M32R
:
1688 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1689 case EM_CYGNUS_V850
:
1690 case EM_V850
: return "NEC v850";
1691 case EM_CYGNUS_MN10300
:
1692 case EM_MN10300
: return "mn10300";
1693 case EM_CYGNUS_MN10200
:
1694 case EM_MN10200
: return "mn10200";
1695 case EM_CYGNUS_FR30
:
1696 case EM_FR30
: return "Fujitsu FR30";
1697 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1699 case EM_PJ
: return "picoJava";
1700 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1701 case EM_PCP
: return "Siemens PCP";
1702 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1703 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1704 case EM_STARCORE
: return "Motorola Star*Core processor";
1705 case EM_ME16
: return "Toyota ME16 processor";
1706 case EM_ST100
: return "STMicroelectronics ST100 processor";
1707 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1708 case EM_FX66
: return "Siemens FX66 microcontroller";
1709 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1710 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1711 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1712 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1713 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1714 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1715 case EM_SVX
: return "Silicon Graphics SVx";
1716 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1717 case EM_VAX
: return "Digital VAX";
1719 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1720 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1721 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1722 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1723 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1724 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1725 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1726 case EM_PRISM
: return "Vitesse Prism";
1727 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1729 case EM_S390
: return "IBM S/390";
1730 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1732 case EM_OR32
: return "OpenRISC";
1733 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1734 case EM_DLX
: return "OpenDLX";
1736 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1737 case EM_IQ2000
: return "Vitesse IQ2000";
1739 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1740 case EM_M32C
: return "Renesas M32c";
1741 case EM_MS1
: return "Morpho Techologies MS1 processor";
1743 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_machine
);
1749 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
1754 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1755 e_flags
&= ~ EF_ARM_EABIMASK
;
1757 /* Handle "generic" ARM flags. */
1758 if (e_flags
& EF_ARM_RELEXEC
)
1760 strcat (buf
, ", relocatable executable");
1761 e_flags
&= ~ EF_ARM_RELEXEC
;
1764 if (e_flags
& EF_ARM_HASENTRY
)
1766 strcat (buf
, ", has entry point");
1767 e_flags
&= ~ EF_ARM_HASENTRY
;
1770 /* Now handle EABI specific flags. */
1774 strcat (buf
, ", <unrecognized EABI>");
1779 case EF_ARM_EABI_VER1
:
1780 strcat (buf
, ", Version1 EABI");
1785 /* Process flags one bit at a time. */
1786 flag
= e_flags
& - e_flags
;
1791 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1792 strcat (buf
, ", sorted symbol tables");
1802 case EF_ARM_EABI_VER2
:
1803 strcat (buf
, ", Version2 EABI");
1808 /* Process flags one bit at a time. */
1809 flag
= e_flags
& - e_flags
;
1814 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1815 strcat (buf
, ", sorted symbol tables");
1818 case EF_ARM_DYNSYMSUSESEGIDX
:
1819 strcat (buf
, ", dynamic symbols use segment index");
1822 case EF_ARM_MAPSYMSFIRST
:
1823 strcat (buf
, ", mapping symbols precede others");
1833 case EF_ARM_EABI_VER3
:
1834 strcat (buf
, ", Version3 EABI");
1837 case EF_ARM_EABI_VER4
:
1838 strcat (buf
, ", Version4 EABI");
1843 /* Process flags one bit at a time. */
1844 flag
= e_flags
& - e_flags
;
1850 strcat (buf
, ", BE8");
1854 strcat (buf
, ", LE8");
1864 case EF_ARM_EABI_UNKNOWN
:
1865 strcat (buf
, ", GNU EABI");
1870 /* Process flags one bit at a time. */
1871 flag
= e_flags
& - e_flags
;
1876 case EF_ARM_INTERWORK
:
1877 strcat (buf
, ", interworking enabled");
1880 case EF_ARM_APCS_26
:
1881 strcat (buf
, ", uses APCS/26");
1884 case EF_ARM_APCS_FLOAT
:
1885 strcat (buf
, ", uses APCS/float");
1889 strcat (buf
, ", position independent");
1893 strcat (buf
, ", 8 bit structure alignment");
1896 case EF_ARM_NEW_ABI
:
1897 strcat (buf
, ", uses new ABI");
1900 case EF_ARM_OLD_ABI
:
1901 strcat (buf
, ", uses old ABI");
1904 case EF_ARM_SOFT_FLOAT
:
1905 strcat (buf
, ", software FP");
1908 case EF_ARM_VFP_FLOAT
:
1909 strcat (buf
, ", VFP");
1912 case EF_ARM_MAVERICK_FLOAT
:
1913 strcat (buf
, ", Maverick FP");
1924 strcat (buf
,", <unknown>");
1928 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
1930 static char buf
[1024];
1942 decode_ARM_machine_flags (e_flags
, buf
);
1946 switch (e_flags
& EF_FRV_CPU_MASK
)
1948 case EF_FRV_CPU_GENERIC
:
1952 strcat (buf
, ", fr???");
1955 case EF_FRV_CPU_FR300
:
1956 strcat (buf
, ", fr300");
1959 case EF_FRV_CPU_FR400
:
1960 strcat (buf
, ", fr400");
1962 case EF_FRV_CPU_FR405
:
1963 strcat (buf
, ", fr405");
1966 case EF_FRV_CPU_FR450
:
1967 strcat (buf
, ", fr450");
1970 case EF_FRV_CPU_FR500
:
1971 strcat (buf
, ", fr500");
1973 case EF_FRV_CPU_FR550
:
1974 strcat (buf
, ", fr550");
1977 case EF_FRV_CPU_SIMPLE
:
1978 strcat (buf
, ", simple");
1980 case EF_FRV_CPU_TOMCAT
:
1981 strcat (buf
, ", tomcat");
1987 if (e_flags
& EF_CPU32
)
1988 strcat (buf
, ", cpu32");
1989 if (e_flags
& EF_M68000
)
1990 strcat (buf
, ", m68000");
1994 if (e_flags
& EF_PPC_EMB
)
1995 strcat (buf
, ", emb");
1997 if (e_flags
& EF_PPC_RELOCATABLE
)
1998 strcat (buf
, ", relocatable");
2000 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2001 strcat (buf
, ", relocatable-lib");
2005 case EM_CYGNUS_V850
:
2006 switch (e_flags
& EF_V850_ARCH
)
2009 strcat (buf
, ", v850e1");
2012 strcat (buf
, ", v850e");
2015 strcat (buf
, ", v850");
2018 strcat (buf
, ", unknown v850 architecture variant");
2024 case EM_CYGNUS_M32R
:
2025 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2026 strcat (buf
, ", m32r");
2031 case EM_MIPS_RS3_LE
:
2032 if (e_flags
& EF_MIPS_NOREORDER
)
2033 strcat (buf
, ", noreorder");
2035 if (e_flags
& EF_MIPS_PIC
)
2036 strcat (buf
, ", pic");
2038 if (e_flags
& EF_MIPS_CPIC
)
2039 strcat (buf
, ", cpic");
2041 if (e_flags
& EF_MIPS_UCODE
)
2042 strcat (buf
, ", ugen_reserved");
2044 if (e_flags
& EF_MIPS_ABI2
)
2045 strcat (buf
, ", abi2");
2047 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2048 strcat (buf
, ", odk first");
2050 if (e_flags
& EF_MIPS_32BITMODE
)
2051 strcat (buf
, ", 32bitmode");
2053 switch ((e_flags
& EF_MIPS_MACH
))
2055 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2056 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2057 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2058 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2059 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2060 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2061 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2062 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2063 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2064 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2066 /* We simply ignore the field in this case to avoid confusion:
2067 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2070 default: strcat (buf
, ", unknown CPU"); break;
2073 switch ((e_flags
& EF_MIPS_ABI
))
2075 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2076 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2077 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2078 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2080 /* We simply ignore the field in this case to avoid confusion:
2081 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2082 This means it is likely to be an o32 file, but not for
2085 default: strcat (buf
, ", unknown ABI"); break;
2088 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2089 strcat (buf
, ", mdmx");
2091 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2092 strcat (buf
, ", mips16");
2094 switch ((e_flags
& EF_MIPS_ARCH
))
2096 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2097 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2098 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2099 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2100 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2101 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2102 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2103 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2104 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2105 default: strcat (buf
, ", unknown ISA"); break;
2111 switch ((e_flags
& EF_SH_MACH_MASK
))
2113 case EF_SH1
: strcat (buf
, ", sh1"); break;
2114 case EF_SH2
: strcat (buf
, ", sh2"); break;
2115 case EF_SH3
: strcat (buf
, ", sh3"); break;
2116 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2117 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2118 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2119 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2120 case EF_SH4
: strcat (buf
, ", sh4"); break;
2121 case EF_SH5
: strcat (buf
, ", sh5"); break;
2122 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2123 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2124 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2125 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2126 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2127 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2128 default: strcat (buf
, ", unknown ISA"); break;
2134 if (e_flags
& EF_SPARC_32PLUS
)
2135 strcat (buf
, ", v8+");
2137 if (e_flags
& EF_SPARC_SUN_US1
)
2138 strcat (buf
, ", ultrasparcI");
2140 if (e_flags
& EF_SPARC_SUN_US3
)
2141 strcat (buf
, ", ultrasparcIII");
2143 if (e_flags
& EF_SPARC_HAL_R1
)
2144 strcat (buf
, ", halr1");
2146 if (e_flags
& EF_SPARC_LEDATA
)
2147 strcat (buf
, ", ledata");
2149 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2150 strcat (buf
, ", tso");
2152 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2153 strcat (buf
, ", pso");
2155 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2156 strcat (buf
, ", rmo");
2160 switch (e_flags
& EF_PARISC_ARCH
)
2162 case EFA_PARISC_1_0
:
2163 strcpy (buf
, ", PA-RISC 1.0");
2165 case EFA_PARISC_1_1
:
2166 strcpy (buf
, ", PA-RISC 1.1");
2168 case EFA_PARISC_2_0
:
2169 strcpy (buf
, ", PA-RISC 2.0");
2174 if (e_flags
& EF_PARISC_TRAPNIL
)
2175 strcat (buf
, ", trapnil");
2176 if (e_flags
& EF_PARISC_EXT
)
2177 strcat (buf
, ", ext");
2178 if (e_flags
& EF_PARISC_LSB
)
2179 strcat (buf
, ", lsb");
2180 if (e_flags
& EF_PARISC_WIDE
)
2181 strcat (buf
, ", wide");
2182 if (e_flags
& EF_PARISC_NO_KABP
)
2183 strcat (buf
, ", no kabp");
2184 if (e_flags
& EF_PARISC_LAZYSWAP
)
2185 strcat (buf
, ", lazyswap");
2190 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2191 strcat (buf
, ", new calling convention");
2193 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2194 strcat (buf
, ", gnu calling convention");
2198 if ((e_flags
& EF_IA_64_ABI64
))
2199 strcat (buf
, ", 64-bit");
2201 strcat (buf
, ", 32-bit");
2202 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2203 strcat (buf
, ", reduced fp model");
2204 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2205 strcat (buf
, ", no function descriptors, constant gp");
2206 else if ((e_flags
& EF_IA_64_CONS_GP
))
2207 strcat (buf
, ", constant gp");
2208 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2209 strcat (buf
, ", absolute");
2213 if ((e_flags
& EF_VAX_NONPIC
))
2214 strcat (buf
, ", non-PIC");
2215 if ((e_flags
& EF_VAX_DFLOAT
))
2216 strcat (buf
, ", D-Float");
2217 if ((e_flags
& EF_VAX_GFLOAT
))
2218 strcat (buf
, ", G-Float");
2227 get_osabi_name (unsigned int osabi
)
2229 static char buff
[32];
2233 case ELFOSABI_NONE
: return "UNIX - System V";
2234 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2235 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2236 case ELFOSABI_LINUX
: return "UNIX - Linux";
2237 case ELFOSABI_HURD
: return "GNU/Hurd";
2238 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2239 case ELFOSABI_AIX
: return "UNIX - AIX";
2240 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2241 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2242 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2243 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2244 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2245 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2246 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2247 case ELFOSABI_AROS
: return "Amiga Research OS";
2248 case ELFOSABI_STANDALONE
: return _("Standalone App");
2249 case ELFOSABI_ARM
: return "ARM";
2251 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2257 get_arm_segment_type (unsigned long type
)
2271 get_mips_segment_type (unsigned long type
)
2275 case PT_MIPS_REGINFO
:
2277 case PT_MIPS_RTPROC
:
2279 case PT_MIPS_OPTIONS
:
2289 get_parisc_segment_type (unsigned long type
)
2293 case PT_HP_TLS
: return "HP_TLS";
2294 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2295 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2296 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2297 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2298 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2299 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2300 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2301 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2302 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2303 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2304 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2305 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2306 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2307 case PT_HP_STACK
: return "HP_STACK";
2308 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2309 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2310 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2311 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2320 get_ia64_segment_type (unsigned long type
)
2324 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2325 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2326 case PT_HP_TLS
: return "HP_TLS";
2327 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2328 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2329 case PT_IA_64_HP_STACK
: return "HP_STACK";
2338 get_segment_type (unsigned long p_type
)
2340 static char buff
[32];
2344 case PT_NULL
: return "NULL";
2345 case PT_LOAD
: return "LOAD";
2346 case PT_DYNAMIC
: return "DYNAMIC";
2347 case PT_INTERP
: return "INTERP";
2348 case PT_NOTE
: return "NOTE";
2349 case PT_SHLIB
: return "SHLIB";
2350 case PT_PHDR
: return "PHDR";
2351 case PT_TLS
: return "TLS";
2353 case PT_GNU_EH_FRAME
:
2354 return "GNU_EH_FRAME";
2355 case PT_GNU_STACK
: return "GNU_STACK";
2356 case PT_GNU_RELRO
: return "GNU_RELRO";
2359 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2363 switch (elf_header
.e_machine
)
2366 result
= get_arm_segment_type (p_type
);
2369 case EM_MIPS_RS3_LE
:
2370 result
= get_mips_segment_type (p_type
);
2373 result
= get_parisc_segment_type (p_type
);
2376 result
= get_ia64_segment_type (p_type
);
2386 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2388 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2392 switch (elf_header
.e_machine
)
2395 result
= get_parisc_segment_type (p_type
);
2398 result
= get_ia64_segment_type (p_type
);
2408 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2411 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2418 get_mips_section_type_name (unsigned int sh_type
)
2422 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2423 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2424 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2425 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2426 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2427 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2428 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2429 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2430 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2431 case SHT_MIPS_RELD
: return "MIPS_RELD";
2432 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2433 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2434 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2435 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2436 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2437 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2438 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2439 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2440 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2441 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2442 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2443 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2444 case SHT_MIPS_LINE
: return "MIPS_LINE";
2445 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2446 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2447 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2448 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2449 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2450 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2451 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2452 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2453 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2454 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2455 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2456 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2457 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2458 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2459 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2460 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2468 get_parisc_section_type_name (unsigned int sh_type
)
2472 case SHT_PARISC_EXT
: return "PARISC_EXT";
2473 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2474 case SHT_PARISC_DOC
: return "PARISC_DOC";
2475 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
2476 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
2477 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
2478 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
2486 get_ia64_section_type_name (unsigned int sh_type
)
2488 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2489 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2490 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2494 case SHT_IA_64_EXT
: return "IA_64_EXT";
2495 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2496 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2504 get_x86_64_section_type_name (unsigned int sh_type
)
2508 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2516 get_arm_section_type_name (unsigned int sh_type
)
2522 case SHT_ARM_PREEMPTMAP
:
2523 return "ARM_PREEMPTMAP";
2524 case SHT_ARM_ATTRIBUTES
:
2525 return "ARM_ATTRIBUTES";
2533 get_section_type_name (unsigned int sh_type
)
2535 static char buff
[32];
2539 case SHT_NULL
: return "NULL";
2540 case SHT_PROGBITS
: return "PROGBITS";
2541 case SHT_SYMTAB
: return "SYMTAB";
2542 case SHT_STRTAB
: return "STRTAB";
2543 case SHT_RELA
: return "RELA";
2544 case SHT_HASH
: return "HASH";
2545 case SHT_DYNAMIC
: return "DYNAMIC";
2546 case SHT_NOTE
: return "NOTE";
2547 case SHT_NOBITS
: return "NOBITS";
2548 case SHT_REL
: return "REL";
2549 case SHT_SHLIB
: return "SHLIB";
2550 case SHT_DYNSYM
: return "DYNSYM";
2551 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2552 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2553 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2554 case SHT_GROUP
: return "GROUP";
2555 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2556 case SHT_GNU_verdef
: return "VERDEF";
2557 case SHT_GNU_verneed
: return "VERNEED";
2558 case SHT_GNU_versym
: return "VERSYM";
2559 case 0x6ffffff0: return "VERSYM";
2560 case 0x6ffffffc: return "VERDEF";
2561 case 0x7ffffffd: return "AUXILIARY";
2562 case 0x7fffffff: return "FILTER";
2563 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2566 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2570 switch (elf_header
.e_machine
)
2573 case EM_MIPS_RS3_LE
:
2574 result
= get_mips_section_type_name (sh_type
);
2577 result
= get_parisc_section_type_name (sh_type
);
2580 result
= get_ia64_section_type_name (sh_type
);
2583 result
= get_x86_64_section_type_name (sh_type
);
2586 result
= get_arm_section_type_name (sh_type
);
2596 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2598 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2599 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2600 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2601 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2603 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
2609 #define OPTION_DEBUG_DUMP 512
2611 static struct option options
[] =
2613 {"all", no_argument
, 0, 'a'},
2614 {"file-header", no_argument
, 0, 'h'},
2615 {"program-headers", no_argument
, 0, 'l'},
2616 {"headers", no_argument
, 0, 'e'},
2617 {"histogram", no_argument
, 0, 'I'},
2618 {"segments", no_argument
, 0, 'l'},
2619 {"sections", no_argument
, 0, 'S'},
2620 {"section-headers", no_argument
, 0, 'S'},
2621 {"section-groups", no_argument
, 0, 'g'},
2622 {"section-details", no_argument
, 0, 't'},
2623 {"full-section-name",no_argument
, 0, 'N'},
2624 {"symbols", no_argument
, 0, 's'},
2625 {"syms", no_argument
, 0, 's'},
2626 {"relocs", no_argument
, 0, 'r'},
2627 {"notes", no_argument
, 0, 'n'},
2628 {"dynamic", no_argument
, 0, 'd'},
2629 {"arch-specific", no_argument
, 0, 'A'},
2630 {"version-info", no_argument
, 0, 'V'},
2631 {"use-dynamic", no_argument
, 0, 'D'},
2632 {"hex-dump", required_argument
, 0, 'x'},
2633 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2634 {"unwind", no_argument
, 0, 'u'},
2635 #ifdef SUPPORT_DISASSEMBLY
2636 {"instruction-dump", required_argument
, 0, 'i'},
2639 {"version", no_argument
, 0, 'v'},
2640 {"wide", no_argument
, 0, 'W'},
2641 {"help", no_argument
, 0, 'H'},
2642 {0, no_argument
, 0, 0}
2648 fprintf (stdout
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2649 fprintf (stdout
, _(" Display information about the contents of ELF format files\n"));
2650 fprintf (stdout
, _(" Options are:\n\
2651 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2652 -h --file-header Display the ELF file header\n\
2653 -l --program-headers Display the program headers\n\
2654 --segments An alias for --program-headers\n\
2655 -S --section-headers Display the sections' header\n\
2656 --sections An alias for --section-headers\n\
2657 -g --section-groups Display the section groups\n\
2658 -t --section-details Display the section details\n\
2659 -e --headers Equivalent to: -h -l -S\n\
2660 -s --syms Display the symbol table\n\
2661 --symbols An alias for --syms\n\
2662 -n --notes Display the core notes (if present)\n\
2663 -r --relocs Display the relocations (if present)\n\
2664 -u --unwind Display the unwind info (if present)\n\
2665 -d --dynamic Display the dynamic section (if present)\n\
2666 -V --version-info Display the version sections (if present)\n\
2667 -A --arch-specific Display architecture specific information (if any).\n\
2668 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2669 -x --hex-dump=<number> Dump the contents of section <number>\n\
2670 -w[liaprmfFsoR] or\n\
2671 --debug-dump[=line,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
2672 Display the contents of DWARF2 debug sections\n"));
2673 #ifdef SUPPORT_DISASSEMBLY
2674 fprintf (stdout
, _("\
2675 -i --instruction-dump=<number>\n\
2676 Disassemble the contents of section <number>\n"));
2678 fprintf (stdout
, _("\
2679 -I --histogram Display histogram of bucket list lengths\n\
2680 -W --wide Allow output width to exceed 80 characters\n\
2681 -H --help Display this information\n\
2682 -v --version Display the version number of readelf\n"));
2683 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2688 /* Record the fact that the user wants the contents of section number
2689 SECTION to be displayed using the method(s) encoded as flags bits
2690 in TYPE. Note, TYPE can be zero if we are creating the array for
2694 request_dump (unsigned int section
, int type
)
2696 if (section
>= num_dump_sects
)
2698 char *new_dump_sects
;
2700 new_dump_sects
= calloc (section
+ 1, 1);
2702 if (new_dump_sects
== NULL
)
2703 error (_("Out of memory allocating dump request table."));
2706 /* Copy current flag settings. */
2707 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2711 dump_sects
= new_dump_sects
;
2712 num_dump_sects
= section
+ 1;
2717 dump_sects
[section
] |= type
;
2723 parse_args (int argc
, char **argv
)
2730 while ((c
= getopt_long
2731 (argc
, argv
, "ersuahnldSDAINtgw::x:i:vVWH", options
, NULL
)) != EOF
)
2752 do_section_groups
++;
2760 do_section_groups
++;
2765 do_section_details
++;
2807 section
= strtoul (optarg
, & cp
, 0);
2808 if (! *cp
&& section
>= 0)
2810 request_dump (section
, HEX_DUMP
);
2820 unsigned int index
= 0;
2824 while (optarg
[index
])
2825 switch (optarg
[index
++])
2834 do_debug_abbrevs
= 1;
2844 do_debug_pubnames
= 1;
2848 do_debug_aranges
= 1;
2852 do_debug_ranges
= 1;
2856 do_debug_frames_interp
= 1;
2858 do_debug_frames
= 1;
2863 do_debug_macinfo
= 1;
2877 warn (_("Unrecognized debug option '%s'\n"), optarg
);
2882 case OPTION_DEBUG_DUMP
:
2890 const char * option
;
2893 debug_dump_long_opts
;
2895 debug_dump_long_opts opts_table
[] =
2897 /* Please keep this table alpha- sorted. */
2898 { "Ranges", & do_debug_ranges
},
2899 { "abbrev", & do_debug_abbrevs
},
2900 { "aranges", & do_debug_aranges
},
2901 { "frames", & do_debug_frames
},
2902 { "frames-interp", & do_debug_frames_interp
},
2903 { "info", & do_debug_info
},
2904 { "line", & do_debug_lines
},
2905 { "loc", & do_debug_loc
},
2906 { "macro", & do_debug_macinfo
},
2907 { "pubnames", & do_debug_pubnames
},
2908 /* This entry is for compatability
2909 with earlier versions of readelf. */
2910 { "ranges", & do_debug_aranges
},
2911 { "str", & do_debug_str
},
2922 debug_dump_long_opts
* entry
;
2924 for (entry
= opts_table
; entry
->option
; entry
++)
2926 size_t len
= strlen (entry
->option
);
2928 if (strneq (p
, entry
->option
, len
)
2929 && (p
[len
] == ',' || p
[len
] == '\0'))
2931 * entry
->variable
= 1;
2933 /* The --debug-dump=frames-interp option also
2934 enables the --debug-dump=frames option. */
2935 if (do_debug_frames_interp
)
2936 do_debug_frames
= 1;
2943 if (entry
->option
== NULL
)
2945 warn (_("Unrecognized debug option '%s'\n"), p
);
2946 p
= strchr (p
, ',');
2956 #ifdef SUPPORT_DISASSEMBLY
2959 section
= strtoul (optarg
, & cp
, 0);
2960 if (! *cp
&& section
>= 0)
2962 request_dump (section
, DISASS_DUMP
);
2968 print_version (program_name
);
2978 /* xgettext:c-format */
2979 error (_("Invalid option '-%c'\n"), c
);
2986 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
2987 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
2988 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
2989 && !do_section_groups
)
2993 warn (_("Nothing to do.\n"));
2999 get_elf_class (unsigned int elf_class
)
3001 static char buff
[32];
3005 case ELFCLASSNONE
: return _("none");
3006 case ELFCLASS32
: return "ELF32";
3007 case ELFCLASS64
: return "ELF64";
3009 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3015 get_data_encoding (unsigned int encoding
)
3017 static char buff
[32];
3021 case ELFDATANONE
: return _("none");
3022 case ELFDATA2LSB
: return _("2's complement, little endian");
3023 case ELFDATA2MSB
: return _("2's complement, big endian");
3025 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3030 /* Decode the data held in 'elf_header'. */
3033 process_file_header (void)
3035 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3036 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3037 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3038 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3041 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3049 printf (_("ELF Header:\n"));
3050 printf (_(" Magic: "));
3051 for (i
= 0; i
< EI_NIDENT
; i
++)
3052 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3054 printf (_(" Class: %s\n"),
3055 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3056 printf (_(" Data: %s\n"),
3057 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3058 printf (_(" Version: %d %s\n"),
3059 elf_header
.e_ident
[EI_VERSION
],
3060 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3062 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3065 printf (_(" OS/ABI: %s\n"),
3066 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3067 printf (_(" ABI Version: %d\n"),
3068 elf_header
.e_ident
[EI_ABIVERSION
]);
3069 printf (_(" Type: %s\n"),
3070 get_file_type (elf_header
.e_type
));
3071 printf (_(" Machine: %s\n"),
3072 get_machine_name (elf_header
.e_machine
));
3073 printf (_(" Version: 0x%lx\n"),
3074 (unsigned long) elf_header
.e_version
);
3076 printf (_(" Entry point address: "));
3077 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3078 printf (_("\n Start of program headers: "));
3079 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3080 printf (_(" (bytes into file)\n Start of section headers: "));
3081 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3082 printf (_(" (bytes into file)\n"));
3084 printf (_(" Flags: 0x%lx%s\n"),
3085 (unsigned long) elf_header
.e_flags
,
3086 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3087 printf (_(" Size of this header: %ld (bytes)\n"),
3088 (long) elf_header
.e_ehsize
);
3089 printf (_(" Size of program headers: %ld (bytes)\n"),
3090 (long) elf_header
.e_phentsize
);
3091 printf (_(" Number of program headers: %ld\n"),
3092 (long) elf_header
.e_phnum
);
3093 printf (_(" Size of section headers: %ld (bytes)\n"),
3094 (long) elf_header
.e_shentsize
);
3095 printf (_(" Number of section headers: %ld"),
3096 (long) elf_header
.e_shnum
);
3097 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
3098 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3099 putc ('\n', stdout
);
3100 printf (_(" Section header string table index: %ld"),
3101 (long) elf_header
.e_shstrndx
);
3102 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
3103 printf (" (%ld)", (long) section_headers
[0].sh_link
);
3104 putc ('\n', stdout
);
3107 if (section_headers
!= NULL
)
3109 if (elf_header
.e_shnum
== 0)
3110 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3111 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
3112 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3113 free (section_headers
);
3114 section_headers
= NULL
;
3122 get_32bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3124 Elf32_External_Phdr
*phdrs
;
3125 Elf32_External_Phdr
*external
;
3126 Elf_Internal_Phdr
*internal
;
3129 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3130 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3131 _("program headers"));
3135 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3136 i
< elf_header
.e_phnum
;
3137 i
++, internal
++, external
++)
3139 internal
->p_type
= BYTE_GET (external
->p_type
);
3140 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3141 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3142 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3143 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3144 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3145 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3146 internal
->p_align
= BYTE_GET (external
->p_align
);
3155 get_64bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3157 Elf64_External_Phdr
*phdrs
;
3158 Elf64_External_Phdr
*external
;
3159 Elf_Internal_Phdr
*internal
;
3162 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3163 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3164 _("program headers"));
3168 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3169 i
< elf_header
.e_phnum
;
3170 i
++, internal
++, external
++)
3172 internal
->p_type
= BYTE_GET (external
->p_type
);
3173 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3174 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3175 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3176 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3177 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3178 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3179 internal
->p_align
= BYTE_GET (external
->p_align
);
3187 /* Returns 1 if the program headers were read into `program_headers'. */
3190 get_program_headers (FILE *file
)
3192 Elf_Internal_Phdr
*phdrs
;
3194 /* Check cache of prior read. */
3195 if (program_headers
!= NULL
)
3198 phdrs
= cmalloc (elf_header
.e_phnum
, sizeof (Elf_Internal_Phdr
));
3202 error (_("Out of memory\n"));
3207 ? get_32bit_program_headers (file
, phdrs
)
3208 : get_64bit_program_headers (file
, phdrs
))
3210 program_headers
= phdrs
;
3218 /* Returns 1 if the program headers were loaded. */
3221 process_program_headers (FILE *file
)
3223 Elf_Internal_Phdr
*segment
;
3226 if (elf_header
.e_phnum
== 0)
3229 printf (_("\nThere are no program headers in this file.\n"));
3233 if (do_segments
&& !do_header
)
3235 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3236 printf (_("Entry point "));
3237 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3238 printf (_("\nThere are %d program headers, starting at offset "),
3239 elf_header
.e_phnum
);
3240 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3244 if (! get_program_headers (file
))
3249 if (elf_header
.e_phnum
> 1)
3250 printf (_("\nProgram Headers:\n"));
3252 printf (_("\nProgram Headers:\n"));
3256 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3259 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3263 (_(" Type Offset VirtAddr PhysAddr\n"));
3265 (_(" FileSiz MemSiz Flags Align\n"));
3272 for (i
= 0, segment
= program_headers
;
3273 i
< elf_header
.e_phnum
;
3278 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3282 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3283 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3284 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3285 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3286 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3288 (segment
->p_flags
& PF_R
? 'R' : ' '),
3289 (segment
->p_flags
& PF_W
? 'W' : ' '),
3290 (segment
->p_flags
& PF_X
? 'E' : ' '));
3291 printf ("%#lx", (unsigned long) segment
->p_align
);
3295 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3296 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3299 print_vma (segment
->p_offset
, FULL_HEX
);
3303 print_vma (segment
->p_vaddr
, FULL_HEX
);
3305 print_vma (segment
->p_paddr
, FULL_HEX
);
3308 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3309 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3312 print_vma (segment
->p_filesz
, FULL_HEX
);
3316 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3317 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3320 print_vma (segment
->p_offset
, FULL_HEX
);
3324 (segment
->p_flags
& PF_R
? 'R' : ' '),
3325 (segment
->p_flags
& PF_W
? 'W' : ' '),
3326 (segment
->p_flags
& PF_X
? 'E' : ' '));
3328 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3329 printf ("%#lx", (unsigned long) segment
->p_align
);
3332 print_vma (segment
->p_align
, PREFIX_HEX
);
3337 print_vma (segment
->p_offset
, FULL_HEX
);
3339 print_vma (segment
->p_vaddr
, FULL_HEX
);
3341 print_vma (segment
->p_paddr
, FULL_HEX
);
3343 print_vma (segment
->p_filesz
, FULL_HEX
);
3345 print_vma (segment
->p_memsz
, FULL_HEX
);
3347 (segment
->p_flags
& PF_R
? 'R' : ' '),
3348 (segment
->p_flags
& PF_W
? 'W' : ' '),
3349 (segment
->p_flags
& PF_X
? 'E' : ' '));
3350 print_vma (segment
->p_align
, HEX
);
3354 switch (segment
->p_type
)
3358 error (_("more than one dynamic segment\n"));
3360 /* Try to locate the .dynamic section. If there is
3361 a section header table, we can easily locate it. */
3362 if (section_headers
!= NULL
)
3364 Elf_Internal_Shdr
*sec
;
3366 sec
= find_section (".dynamic");
3367 if (sec
== NULL
|| sec
->sh_size
== 0)
3369 error (_("no .dynamic section in the dynamic segment"));
3373 dynamic_addr
= sec
->sh_offset
;
3374 dynamic_size
= sec
->sh_size
;
3376 if (dynamic_addr
< segment
->p_offset
3377 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3378 warn (_("the .dynamic section is not contained within the dynamic segment"));
3379 else if (dynamic_addr
> segment
->p_offset
)
3380 warn (_("the .dynamic section is not the first section in the dynamic segment."));
3384 /* Otherwise, we can only assume that the .dynamic
3385 section is the first section in the DYNAMIC segment. */
3386 dynamic_addr
= segment
->p_offset
;
3387 dynamic_size
= segment
->p_filesz
;
3392 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3394 error (_("Unable to find program interpreter name\n"));
3397 program_interpreter
[0] = 0;
3398 fscanf (file
, "%63s", program_interpreter
);
3401 printf (_("\n [Requesting program interpreter: %s]"),
3402 program_interpreter
);
3408 putc ('\n', stdout
);
3411 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3413 printf (_("\n Section to Segment mapping:\n"));
3414 printf (_(" Segment Sections...\n"));
3416 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3419 Elf_Internal_Shdr
*section
;
3421 segment
= program_headers
+ i
;
3422 section
= section_headers
;
3424 printf (" %2.2d ", i
);
3426 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3428 if (section
->sh_size
> 0
3429 /* Compare allocated sections by VMA, unallocated
3430 sections by file offset. */
3431 && (section
->sh_flags
& SHF_ALLOC
3432 ? (section
->sh_addr
>= segment
->p_vaddr
3433 && section
->sh_addr
+ section
->sh_size
3434 <= segment
->p_vaddr
+ segment
->p_memsz
)
3435 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
3436 && (section
->sh_offset
+ section
->sh_size
3437 <= segment
->p_offset
+ segment
->p_filesz
)))
3438 /* .tbss is special. It doesn't contribute memory space
3439 to normal segments. */
3440 && (!((section
->sh_flags
& SHF_TLS
) != 0
3441 && section
->sh_type
== SHT_NOBITS
)
3442 || segment
->p_type
== PT_TLS
))
3443 printf ("%s ", SECTION_NAME (section
));
3454 /* Find the file offset corresponding to VMA by using the program headers. */
3457 offset_from_vma (FILE *file
, bfd_vma vma
, bfd_size_type size
)
3459 Elf_Internal_Phdr
*seg
;
3461 if (! get_program_headers (file
))
3463 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3467 for (seg
= program_headers
;
3468 seg
< program_headers
+ elf_header
.e_phnum
;
3471 if (seg
->p_type
!= PT_LOAD
)
3474 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3475 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3476 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3479 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3486 get_32bit_section_headers (FILE *file
, unsigned int num
)
3488 Elf32_External_Shdr
*shdrs
;
3489 Elf_Internal_Shdr
*internal
;
3492 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3493 elf_header
.e_shentsize
, num
, _("section headers"));
3497 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3499 if (section_headers
== NULL
)
3501 error (_("Out of memory\n"));
3505 for (i
= 0, internal
= section_headers
;
3509 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3510 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3511 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3512 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3513 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3514 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3515 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3516 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3517 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3518 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3527 get_64bit_section_headers (FILE *file
, unsigned int num
)
3529 Elf64_External_Shdr
*shdrs
;
3530 Elf_Internal_Shdr
*internal
;
3533 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3534 elf_header
.e_shentsize
, num
, _("section headers"));
3538 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3540 if (section_headers
== NULL
)
3542 error (_("Out of memory\n"));
3546 for (i
= 0, internal
= section_headers
;
3550 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3551 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3552 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3553 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3554 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3555 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3556 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3557 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3558 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3559 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3567 static Elf_Internal_Sym
*
3568 get_32bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3570 unsigned long number
;
3571 Elf32_External_Sym
*esyms
;
3572 Elf_External_Sym_Shndx
*shndx
;
3573 Elf_Internal_Sym
*isyms
;
3574 Elf_Internal_Sym
*psym
;
3577 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3583 if (symtab_shndx_hdr
!= NULL
3584 && (symtab_shndx_hdr
->sh_link
3585 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3587 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3588 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3596 number
= section
->sh_size
/ section
->sh_entsize
;
3597 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3601 error (_("Out of memory\n"));
3608 for (j
= 0, psym
= isyms
;
3612 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3613 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3614 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3615 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3616 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3618 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3619 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3620 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3630 static Elf_Internal_Sym
*
3631 get_64bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3633 unsigned long number
;
3634 Elf64_External_Sym
*esyms
;
3635 Elf_External_Sym_Shndx
*shndx
;
3636 Elf_Internal_Sym
*isyms
;
3637 Elf_Internal_Sym
*psym
;
3640 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3646 if (symtab_shndx_hdr
!= NULL
3647 && (symtab_shndx_hdr
->sh_link
3648 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3650 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3651 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3659 number
= section
->sh_size
/ section
->sh_entsize
;
3660 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3664 error (_("Out of memory\n"));
3671 for (j
= 0, psym
= isyms
;
3675 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3676 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3677 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3678 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3679 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3681 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3682 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3683 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3694 get_elf_section_flags (bfd_vma sh_flags
)
3696 static char buff
[1024];
3698 int field_size
= is_32bit_elf
? 8 : 16;
3699 int index
, size
= sizeof (buff
) - (field_size
+ 4 + 1);
3700 bfd_vma os_flags
= 0;
3701 bfd_vma proc_flags
= 0;
3702 bfd_vma unknown_flags
= 0;
3716 { "LINK ORDER", 10 },
3717 { "OS NONCONF", 10 },
3722 if (do_section_details
)
3724 sprintf (buff
, "[%*.*lx]: ",
3725 field_size
, field_size
, (unsigned long) sh_flags
);
3726 p
+= field_size
+ 4;
3733 flag
= sh_flags
& - sh_flags
;
3736 if (do_section_details
)
3740 case SHF_WRITE
: index
= 0; break;
3741 case SHF_ALLOC
: index
= 1; break;
3742 case SHF_EXECINSTR
: index
= 2; break;
3743 case SHF_MERGE
: index
= 3; break;
3744 case SHF_STRINGS
: index
= 4; break;
3745 case SHF_INFO_LINK
: index
= 5; break;
3746 case SHF_LINK_ORDER
: index
= 6; break;
3747 case SHF_OS_NONCONFORMING
: index
= 7; break;
3748 case SHF_GROUP
: index
= 8; break;
3749 case SHF_TLS
: index
= 9; break;
3758 if (p
!= buff
+ field_size
+ 4)
3760 if (size
< (10 + 2))
3767 size
-= flags
[index
].len
;
3768 p
= stpcpy (p
, flags
[index
].str
);
3770 else if (flag
& SHF_MASKOS
)
3772 else if (flag
& SHF_MASKPROC
)
3775 unknown_flags
|= flag
;
3781 case SHF_WRITE
: *p
= 'W'; break;
3782 case SHF_ALLOC
: *p
= 'A'; break;
3783 case SHF_EXECINSTR
: *p
= 'X'; break;
3784 case SHF_MERGE
: *p
= 'M'; break;
3785 case SHF_STRINGS
: *p
= 'S'; break;
3786 case SHF_INFO_LINK
: *p
= 'I'; break;
3787 case SHF_LINK_ORDER
: *p
= 'L'; break;
3788 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
3789 case SHF_GROUP
: *p
= 'G'; break;
3790 case SHF_TLS
: *p
= 'T'; break;
3793 if (elf_header
.e_machine
== EM_X86_64
3794 && flag
== SHF_X86_64_LARGE
)
3796 else if (flag
& SHF_MASKOS
)
3799 sh_flags
&= ~ SHF_MASKOS
;
3801 else if (flag
& SHF_MASKPROC
)
3804 sh_flags
&= ~ SHF_MASKPROC
;
3814 if (do_section_details
)
3818 size
-= 5 + field_size
;
3819 if (p
!= buff
+ field_size
+ 4)
3827 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
3828 (unsigned long) os_flags
);
3829 p
+= 5 + field_size
;
3833 size
-= 7 + field_size
;
3834 if (p
!= buff
+ field_size
+ 4)
3842 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
3843 (unsigned long) proc_flags
);
3844 p
+= 7 + field_size
;
3848 size
-= 10 + field_size
;
3849 if (p
!= buff
+ field_size
+ 4)
3857 sprintf (p
, "UNKNOWN (%*.*lx)", field_size
, field_size
,
3858 (unsigned long) unknown_flags
);
3859 p
+= 10 + field_size
;
3868 process_section_headers (FILE *file
)
3870 Elf_Internal_Shdr
*section
;
3873 section_headers
= NULL
;
3875 if (elf_header
.e_shnum
== 0)
3878 printf (_("\nThere are no sections in this file.\n"));
3883 if (do_sections
&& !do_header
)
3884 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3885 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
3889 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
3892 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
3895 /* Read in the string table, so that we have names to display. */
3896 if (SECTION_HEADER_INDEX (elf_header
.e_shstrndx
) < elf_header
.e_shnum
)
3898 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
3900 if (section
->sh_size
!= 0)
3902 string_table
= get_data (NULL
, file
, section
->sh_offset
,
3903 1, section
->sh_size
, _("string table"));
3905 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
3909 /* Scan the sections for the dynamic symbol table
3910 and dynamic string table and debug sections. */
3911 dynamic_symbols
= NULL
;
3912 dynamic_strings
= NULL
;
3913 dynamic_syminfo
= NULL
;
3914 symtab_shndx_hdr
= NULL
;
3916 eh_addr_size
= is_32bit_elf
? 4 : 8;
3917 switch (elf_header
.e_machine
)
3920 case EM_MIPS_RS3_LE
:
3921 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
3922 FDE addresses. However, the ABI also has a semi-official ILP32
3923 variant for which the normal FDE address size rules apply.
3925 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
3926 section, where XX is the size of longs in bits. Unfortunately,
3927 earlier compilers provided no way of distinguishing ILP32 objects
3928 from LP64 objects, so if there's any doubt, we should assume that
3929 the official LP64 form is being used. */
3930 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
3931 && find_section (".gcc_compiled_long32") == NULL
)
3936 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
3939 size_t expected_entsize \
3940 = is_32bit_elf ? size32 : size64; \
3941 if (section->sh_entsize != expected_entsize) \
3942 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
3943 i, (unsigned long int) section->sh_entsize, \
3944 (unsigned long int) expected_entsize); \
3945 section->sh_entsize = expected_entsize; \
3948 #define CHECK_ENTSIZE(section, i, type) \
3949 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
3950 sizeof (Elf64_External_##type))
3952 for (i
= 0, section
= section_headers
;
3953 i
< elf_header
.e_shnum
;
3956 char *name
= SECTION_NAME (section
);
3958 if (section
->sh_type
== SHT_DYNSYM
)
3960 if (dynamic_symbols
!= NULL
)
3962 error (_("File contains multiple dynamic symbol tables\n"));
3966 CHECK_ENTSIZE (section
, i
, Sym
);
3967 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
3968 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
3970 else if (section
->sh_type
== SHT_STRTAB
3971 && streq (name
, ".dynstr"))
3973 if (dynamic_strings
!= NULL
)
3975 error (_("File contains multiple dynamic string tables\n"));
3979 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
3980 1, section
->sh_size
, _("dynamic strings"));
3981 dynamic_strings_length
= section
->sh_size
;
3983 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
3985 if (symtab_shndx_hdr
!= NULL
)
3987 error (_("File contains multiple symtab shndx tables\n"));
3990 symtab_shndx_hdr
= section
;
3992 else if (section
->sh_type
== SHT_SYMTAB
)
3993 CHECK_ENTSIZE (section
, i
, Sym
);
3994 else if (section
->sh_type
== SHT_GROUP
)
3995 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
3996 else if (section
->sh_type
== SHT_REL
)
3997 CHECK_ENTSIZE (section
, i
, Rel
);
3998 else if (section
->sh_type
== SHT_RELA
)
3999 CHECK_ENTSIZE (section
, i
, Rela
);
4000 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4001 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
4002 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
4003 || do_debug_loc
|| do_debug_ranges
)
4004 && strneq (name
, ".debug_", 7))
4009 || (do_debug_info
&& streq (name
, "info"))
4010 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
4011 || (do_debug_lines
&& streq (name
, "line"))
4012 || (do_debug_pubnames
&& streq (name
, "pubnames"))
4013 || (do_debug_aranges
&& streq (name
, "aranges"))
4014 || (do_debug_ranges
&& streq (name
, "ranges"))
4015 || (do_debug_frames
&& streq (name
, "frame"))
4016 || (do_debug_macinfo
&& streq (name
, "macinfo"))
4017 || (do_debug_str
&& streq (name
, "str"))
4018 || (do_debug_loc
&& streq (name
, "loc"))
4020 request_dump (i
, DEBUG_DUMP
);
4022 /* linkonce section to be combined with .debug_info at link time. */
4023 else if ((do_debugging
|| do_debug_info
)
4024 && strneq (name
, ".gnu.linkonce.wi.", 17))
4025 request_dump (i
, DEBUG_DUMP
);
4026 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4027 request_dump (i
, DEBUG_DUMP
);
4033 if (elf_header
.e_shnum
> 1)
4034 printf (_("\nSection Headers:\n"));
4036 printf (_("\nSection Header:\n"));
4040 if (do_section_details
)
4042 printf (_(" [Nr] Name\n"));
4043 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4047 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4051 if (do_section_details
)
4053 printf (_(" [Nr] Name\n"));
4054 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4058 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4062 if (do_section_details
)
4064 printf (_(" [Nr] Name\n"));
4065 printf (_(" Type Address Offset Link\n"));
4066 printf (_(" Size EntSize Info Align\n"));
4070 printf (_(" [Nr] Name Type Address Offset\n"));
4071 printf (_(" Size EntSize Flags Link Info Align\n"));
4075 if (do_section_details
)
4076 printf (_(" Flags\n"));
4078 for (i
= 0, section
= section_headers
;
4079 i
< elf_header
.e_shnum
;
4082 if (do_section_details
)
4084 printf (" [%2u] %s\n",
4085 SECTION_HEADER_NUM (i
),
4086 SECTION_NAME (section
));
4087 if (is_32bit_elf
|| do_wide
)
4088 printf (" %-15.15s ",
4089 get_section_type_name (section
->sh_type
));
4092 printf (" [%2u] %-17.17s %-15.15s ",
4093 SECTION_HEADER_NUM (i
),
4094 SECTION_NAME (section
),
4095 get_section_type_name (section
->sh_type
));
4099 print_vma (section
->sh_addr
, LONG_HEX
);
4101 printf ( " %6.6lx %6.6lx %2.2lx",
4102 (unsigned long) section
->sh_offset
,
4103 (unsigned long) section
->sh_size
,
4104 (unsigned long) section
->sh_entsize
);
4106 if (do_section_details
)
4107 fputs (" ", stdout
);
4109 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4111 printf ("%2ld %3lu %2ld\n",
4112 (unsigned long) section
->sh_link
,
4113 (unsigned long) section
->sh_info
,
4114 (unsigned long) section
->sh_addralign
);
4118 print_vma (section
->sh_addr
, LONG_HEX
);
4120 if ((long) section
->sh_offset
== section
->sh_offset
)
4121 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4125 print_vma (section
->sh_offset
, LONG_HEX
);
4128 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4129 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4133 print_vma (section
->sh_size
, LONG_HEX
);
4136 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4137 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4141 print_vma (section
->sh_entsize
, LONG_HEX
);
4144 if (do_section_details
)
4145 fputs (" ", stdout
);
4147 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4149 printf ("%2ld %3lu ",
4150 (unsigned long) section
->sh_link
,
4151 (unsigned long) section
->sh_info
);
4153 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4154 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
4157 print_vma (section
->sh_addralign
, DEC
);
4161 else if (do_section_details
)
4163 printf (" %-15.15s ",
4164 get_section_type_name (section
->sh_type
));
4165 print_vma (section
->sh_addr
, LONG_HEX
);
4166 if ((long) section
->sh_offset
== section
->sh_offset
)
4167 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4171 print_vma (section
->sh_offset
, LONG_HEX
);
4173 printf (" %ld\n ", (unsigned long) section
->sh_link
);
4174 print_vma (section
->sh_size
, LONG_HEX
);
4176 print_vma (section
->sh_entsize
, LONG_HEX
);
4178 printf (" %-16lu %ld\n",
4179 (unsigned long) section
->sh_info
,
4180 (unsigned long) section
->sh_addralign
);
4185 print_vma (section
->sh_addr
, LONG_HEX
);
4186 if ((long) section
->sh_offset
== section
->sh_offset
)
4187 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4191 print_vma (section
->sh_offset
, LONG_HEX
);
4194 print_vma (section
->sh_size
, LONG_HEX
);
4196 print_vma (section
->sh_entsize
, LONG_HEX
);
4198 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4200 printf (" %2ld %3lu %ld\n",
4201 (unsigned long) section
->sh_link
,
4202 (unsigned long) section
->sh_info
,
4203 (unsigned long) section
->sh_addralign
);
4206 if (do_section_details
)
4207 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
4210 if (!do_section_details
)
4211 printf (_("Key to Flags:\n\
4212 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4213 I (info), L (link order), G (group), x (unknown)\n\
4214 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4220 get_group_flags (unsigned int flags
)
4222 static char buff
[32];
4229 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x]"), flags
);
4236 process_section_groups (FILE *file
)
4238 Elf_Internal_Shdr
*section
;
4240 struct group
*group
;
4241 Elf_Internal_Shdr
*symtab_sec
, *strtab_sec
;
4242 Elf_Internal_Sym
*symtab
;
4246 /* Don't process section groups unless needed. */
4247 if (!do_unwind
&& !do_section_groups
)
4250 if (elf_header
.e_shnum
== 0)
4252 if (do_section_groups
)
4253 printf (_("\nThere are no sections in this file.\n"));
4258 if (section_headers
== NULL
)
4260 error (_("Section headers are not available!\n"));
4264 section_headers_groups
= calloc (elf_header
.e_shnum
,
4265 sizeof (struct group
*));
4267 if (section_headers_groups
== NULL
)
4269 error (_("Out of memory\n"));
4273 /* Scan the sections for the group section. */
4275 for (i
= 0, section
= section_headers
;
4276 i
< elf_header
.e_shnum
;
4278 if (section
->sh_type
== SHT_GROUP
)
4281 if (group_count
== 0)
4283 if (do_section_groups
)
4284 printf (_("\nThere are no section groups in this file.\n"));
4289 section_groups
= calloc (group_count
, sizeof (struct group
));
4291 if (section_groups
== NULL
)
4293 error (_("Out of memory\n"));
4302 for (i
= 0, section
= section_headers
, group
= section_groups
;
4303 i
< elf_header
.e_shnum
;
4306 if (section
->sh_type
== SHT_GROUP
)
4308 char *name
= SECTION_NAME (section
);
4310 unsigned char *start
, *indices
;
4311 unsigned int entry
, j
, size
;
4312 Elf_Internal_Shdr
*sec
;
4313 Elf_Internal_Sym
*sym
;
4315 /* Get the symbol table. */
4316 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
4317 || ((sec
= SECTION_HEADER (section
->sh_link
))->sh_type
4320 error (_("Bad sh_link in group section `%s'\n"), name
);
4324 if (symtab_sec
!= sec
)
4329 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4332 sym
= symtab
+ section
->sh_info
;
4334 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4336 bfd_vma sec_index
= SECTION_HEADER_INDEX (sym
->st_shndx
);
4339 error (_("Bad sh_info in group section `%s'\n"), name
);
4343 group_name
= SECTION_NAME (section_headers
+ sec_index
);
4352 /* Get the string table. */
4353 if (SECTION_HEADER_INDEX (symtab_sec
->sh_link
)
4354 >= elf_header
.e_shnum
)
4363 != (sec
= SECTION_HEADER (symtab_sec
->sh_link
)))
4368 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
4369 1, strtab_sec
->sh_size
,
4371 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
4373 group_name
= sym
->st_name
< strtab_size
4374 ? strtab
+ sym
->st_name
: "<corrupt>";
4377 start
= get_data (NULL
, file
, section
->sh_offset
,
4378 1, section
->sh_size
, _("section data"));
4381 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4382 entry
= byte_get (indices
, 4);
4385 if (do_section_groups
)
4387 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4388 get_group_flags (entry
), i
, name
, group_name
, size
);
4390 printf (_(" [Index] Name\n"));
4393 group
->group_index
= i
;
4395 for (j
= 0; j
< size
; j
++)
4397 struct group_list
*g
;
4399 entry
= byte_get (indices
, 4);
4402 if (SECTION_HEADER_INDEX (entry
) >= elf_header
.e_shnum
)
4404 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4405 entry
, i
, elf_header
.e_shnum
- 1);
4408 else if (entry
>= SHN_LORESERVE
&& entry
<= SHN_HIRESERVE
)
4410 error (_("invalid section [%5u] in group section [%5u]\n"),
4415 if (section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4420 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4422 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4427 /* Intel C/C++ compiler may put section 0 in a
4428 section group. We just warn it the first time
4429 and ignore it afterwards. */
4430 static int warned
= 0;
4433 error (_("section 0 in group section [%5u]\n"),
4434 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4440 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4443 if (do_section_groups
)
4445 sec
= SECTION_HEADER (entry
);
4446 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
4449 g
= xmalloc (sizeof (struct group_list
));
4450 g
->section_index
= entry
;
4451 g
->next
= group
->root
;
4475 } dynamic_relocations
[] =
4477 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4478 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4479 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4482 /* Process the reloc section. */
4485 process_relocs (FILE *file
)
4487 unsigned long rel_size
;
4488 unsigned long rel_offset
;
4494 if (do_using_dynamic
)
4498 int has_dynamic_reloc
;
4501 has_dynamic_reloc
= 0;
4503 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4505 is_rela
= dynamic_relocations
[i
].rela
;
4506 name
= dynamic_relocations
[i
].name
;
4507 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4508 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4510 has_dynamic_reloc
|= rel_size
;
4512 if (is_rela
== UNKNOWN
)
4514 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4515 switch (dynamic_info
[DT_PLTREL
])
4529 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4530 name
, rel_offset
, rel_size
);
4532 dump_relocations (file
,
4533 offset_from_vma (file
, rel_offset
, rel_size
),
4535 dynamic_symbols
, num_dynamic_syms
,
4536 dynamic_strings
, dynamic_strings_length
, is_rela
);
4540 if (! has_dynamic_reloc
)
4541 printf (_("\nThere are no dynamic relocations in this file.\n"));
4545 Elf_Internal_Shdr
*section
;
4549 for (i
= 0, section
= section_headers
;
4550 i
< elf_header
.e_shnum
;
4553 if ( section
->sh_type
!= SHT_RELA
4554 && section
->sh_type
!= SHT_REL
)
4557 rel_offset
= section
->sh_offset
;
4558 rel_size
= section
->sh_size
;
4562 Elf_Internal_Shdr
*strsec
;
4565 printf (_("\nRelocation section "));
4567 if (string_table
== NULL
)
4568 printf ("%d", section
->sh_name
);
4570 printf (_("'%s'"), SECTION_NAME (section
));
4572 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4573 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4575 is_rela
= section
->sh_type
== SHT_RELA
;
4577 if (section
->sh_link
4578 && SECTION_HEADER_INDEX (section
->sh_link
)
4579 < elf_header
.e_shnum
)
4581 Elf_Internal_Shdr
*symsec
;
4582 Elf_Internal_Sym
*symtab
;
4583 unsigned long nsyms
;
4584 unsigned long strtablen
= 0;
4585 char *strtab
= NULL
;
4587 symsec
= SECTION_HEADER (section
->sh_link
);
4588 if (symsec
->sh_type
!= SHT_SYMTAB
4589 && symsec
->sh_type
!= SHT_DYNSYM
)
4592 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4593 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4598 if (SECTION_HEADER_INDEX (symsec
->sh_link
)
4599 < elf_header
.e_shnum
)
4601 strsec
= SECTION_HEADER (symsec
->sh_link
);
4603 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4606 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4609 dump_relocations (file
, rel_offset
, rel_size
,
4610 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4616 dump_relocations (file
, rel_offset
, rel_size
,
4617 NULL
, 0, NULL
, 0, is_rela
);
4624 printf (_("\nThere are no relocations in this file.\n"));
4630 /* Process the unwind section. */
4632 #include "unwind-ia64.h"
4634 /* An absolute address consists of a section and an offset. If the
4635 section is NULL, the offset itself is the address, otherwise, the
4636 address equals to LOAD_ADDRESS(section) + offset. */
4640 unsigned short section
;
4644 struct ia64_unw_aux_info
4646 struct ia64_unw_table_entry
4648 struct absaddr start
;
4650 struct absaddr info
;
4652 *table
; /* Unwind table. */
4653 unsigned long table_len
; /* Length of unwind table. */
4654 unsigned char *info
; /* Unwind info. */
4655 unsigned long info_size
; /* Size of unwind info. */
4656 bfd_vma info_addr
; /* starting address of unwind info. */
4657 bfd_vma seg_base
; /* Starting address of segment. */
4658 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4659 unsigned long nsyms
; /* Number of symbols. */
4660 char *strtab
; /* The string table. */
4661 unsigned long strtab_size
; /* Size of string table. */
4665 find_symbol_for_address (Elf_Internal_Sym
*symtab
,
4666 unsigned long nsyms
,
4668 unsigned long strtab_size
,
4669 struct absaddr addr
,
4670 const char **symname
,
4673 bfd_vma dist
= 0x100000;
4674 Elf_Internal_Sym
*sym
, *best
= NULL
;
4677 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
4679 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4680 && sym
->st_name
!= 0
4681 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4682 && addr
.offset
>= sym
->st_value
4683 && addr
.offset
- sym
->st_value
< dist
)
4686 dist
= addr
.offset
- sym
->st_value
;
4693 *symname
= (best
->st_name
>= strtab_size
4694 ? "<corrupt>" : strtab
+ best
->st_name
);
4699 *offset
= addr
.offset
;
4703 dump_ia64_unwind (struct ia64_unw_aux_info
*aux
)
4705 struct ia64_unw_table_entry
*tp
;
4708 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4712 const unsigned char *dp
;
4713 const unsigned char *head
;
4714 const char *procname
;
4716 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4717 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
4719 fputs ("\n<", stdout
);
4723 fputs (procname
, stdout
);
4726 printf ("+%lx", (unsigned long) offset
);
4729 fputs (">: [", stdout
);
4730 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4731 fputc ('-', stdout
);
4732 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4733 printf ("], info at +0x%lx\n",
4734 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4736 head
= aux
->info
+ (tp
->info
.offset
- aux
->info_addr
);
4737 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
4739 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4740 (unsigned) UNW_VER (stamp
),
4741 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4742 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4743 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4744 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
4746 if (UNW_VER (stamp
) != 1)
4748 printf ("\tUnknown version.\n");
4753 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
4754 dp
= unw_decode (dp
, in_body
, & in_body
);
4759 slurp_ia64_unwind_table (FILE *file
,
4760 struct ia64_unw_aux_info
*aux
,
4761 Elf_Internal_Shdr
*sec
)
4763 unsigned long size
, nrelas
, i
;
4764 Elf_Internal_Phdr
*seg
;
4765 struct ia64_unw_table_entry
*tep
;
4766 Elf_Internal_Shdr
*relsec
;
4767 Elf_Internal_Rela
*rela
, *rp
;
4768 unsigned char *table
, *tp
;
4769 Elf_Internal_Sym
*sym
;
4770 const char *relname
;
4772 /* First, find the starting address of the segment that includes
4775 if (elf_header
.e_phnum
)
4777 if (! get_program_headers (file
))
4780 for (seg
= program_headers
;
4781 seg
< program_headers
+ elf_header
.e_phnum
;
4784 if (seg
->p_type
!= PT_LOAD
)
4787 if (sec
->sh_addr
>= seg
->p_vaddr
4788 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4790 aux
->seg_base
= seg
->p_vaddr
;
4796 /* Second, build the unwind table from the contents of the unwind section: */
4797 size
= sec
->sh_size
;
4798 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
4802 aux
->table
= xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
4804 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * eh_addr_size
, ++tep
)
4806 tep
->start
.section
= SHN_UNDEF
;
4807 tep
->end
.section
= SHN_UNDEF
;
4808 tep
->info
.section
= SHN_UNDEF
;
4811 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4812 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4813 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
4817 tep
->start
.offset
= BYTE_GET ((unsigned char *) tp
+ 0);
4818 tep
->end
.offset
= BYTE_GET ((unsigned char *) tp
+ 8);
4819 tep
->info
.offset
= BYTE_GET ((unsigned char *) tp
+ 16);
4821 tep
->start
.offset
+= aux
->seg_base
;
4822 tep
->end
.offset
+= aux
->seg_base
;
4823 tep
->info
.offset
+= aux
->seg_base
;
4827 /* Third, apply any relocations to the unwind table: */
4829 for (relsec
= section_headers
;
4830 relsec
< section_headers
+ elf_header
.e_shnum
;
4833 if (relsec
->sh_type
!= SHT_RELA
4834 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
4835 || SECTION_HEADER (relsec
->sh_info
) != sec
)
4838 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
4842 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4846 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4847 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4851 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4852 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4855 if (! strneq (relname
, "R_IA64_SEGREL", 13))
4857 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4861 i
= rp
->r_offset
/ (3 * eh_addr_size
);
4863 switch (rp
->r_offset
/eh_addr_size
% 3)
4866 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4867 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
4870 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4871 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
4874 aux
->table
[i
].info
.section
= sym
->st_shndx
;
4875 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
4885 aux
->table_len
= size
/ (3 * eh_addr_size
);
4890 ia64_process_unwind (FILE *file
)
4892 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
4893 unsigned long i
, unwcount
= 0, unwstart
= 0;
4894 struct ia64_unw_aux_info aux
;
4896 memset (& aux
, 0, sizeof (aux
));
4898 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4900 if (sec
->sh_type
== SHT_SYMTAB
4901 && SECTION_HEADER_INDEX (sec
->sh_link
) < elf_header
.e_shnum
)
4903 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
4904 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
4906 strsec
= SECTION_HEADER (sec
->sh_link
);
4907 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4908 1, strsec
->sh_size
, _("string table"));
4909 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
4911 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4916 printf (_("\nThere are no unwind sections in this file.\n"));
4918 while (unwcount
-- > 0)
4923 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
4924 i
< elf_header
.e_shnum
; ++i
, ++sec
)
4925 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4932 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
4934 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
4936 /* We need to find which section group it is in. */
4937 struct group_list
*g
= section_headers_groups
[i
]->root
;
4939 for (; g
!= NULL
; g
= g
->next
)
4941 sec
= SECTION_HEADER (g
->section_index
);
4943 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
4948 i
= elf_header
.e_shnum
;
4950 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
4952 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
4953 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
4954 suffix
= SECTION_NAME (unwsec
) + len
;
4955 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4957 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
4958 && streq (SECTION_NAME (sec
) + len2
, suffix
))
4963 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
4964 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
4965 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
4966 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
4968 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
4969 suffix
= SECTION_NAME (unwsec
) + len
;
4970 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4972 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
4973 && streq (SECTION_NAME (sec
) + len2
, suffix
))
4977 if (i
== elf_header
.e_shnum
)
4979 printf (_("\nCould not find unwind info section for "));
4981 if (string_table
== NULL
)
4982 printf ("%d", unwsec
->sh_name
);
4984 printf (_("'%s'"), SECTION_NAME (unwsec
));
4988 aux
.info_size
= sec
->sh_size
;
4989 aux
.info_addr
= sec
->sh_addr
;
4990 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, 1, aux
.info_size
,
4993 printf (_("\nUnwind section "));
4995 if (string_table
== NULL
)
4996 printf ("%d", unwsec
->sh_name
);
4998 printf (_("'%s'"), SECTION_NAME (unwsec
));
5000 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5001 (unsigned long) unwsec
->sh_offset
,
5002 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
5004 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
5006 if (aux
.table_len
> 0)
5007 dump_ia64_unwind (& aux
);
5010 free ((char *) aux
.table
);
5012 free ((char *) aux
.info
);
5021 free ((char *) aux
.strtab
);
5026 struct hppa_unw_aux_info
5028 struct hppa_unw_table_entry
5030 struct absaddr start
;
5032 unsigned int Cannot_unwind
:1; /* 0 */
5033 unsigned int Millicode
:1; /* 1 */
5034 unsigned int Millicode_save_sr0
:1; /* 2 */
5035 unsigned int Region_description
:2; /* 3..4 */
5036 unsigned int reserved1
:1; /* 5 */
5037 unsigned int Entry_SR
:1; /* 6 */
5038 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
5039 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
5040 unsigned int Args_stored
:1; /* 16 */
5041 unsigned int Variable_Frame
:1; /* 17 */
5042 unsigned int Separate_Package_Body
:1; /* 18 */
5043 unsigned int Frame_Extension_Millicode
:1; /* 19 */
5044 unsigned int Stack_Overflow_Check
:1; /* 20 */
5045 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
5046 unsigned int Ada_Region
:1; /* 22 */
5047 unsigned int cxx_info
:1; /* 23 */
5048 unsigned int cxx_try_catch
:1; /* 24 */
5049 unsigned int sched_entry_seq
:1; /* 25 */
5050 unsigned int reserved2
:1; /* 26 */
5051 unsigned int Save_SP
:1; /* 27 */
5052 unsigned int Save_RP
:1; /* 28 */
5053 unsigned int Save_MRP_in_frame
:1; /* 29 */
5054 unsigned int extn_ptr_defined
:1; /* 30 */
5055 unsigned int Cleanup_defined
:1; /* 31 */
5057 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
5058 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
5059 unsigned int Large_frame
:1; /* 2 */
5060 unsigned int Pseudo_SP_Set
:1; /* 3 */
5061 unsigned int reserved4
:1; /* 4 */
5062 unsigned int Total_frame_size
:27; /* 5..31 */
5064 *table
; /* Unwind table. */
5065 unsigned long table_len
; /* Length of unwind table. */
5066 bfd_vma seg_base
; /* Starting address of segment. */
5067 Elf_Internal_Sym
*symtab
; /* The symbol table. */
5068 unsigned long nsyms
; /* Number of symbols. */
5069 char *strtab
; /* The string table. */
5070 unsigned long strtab_size
; /* Size of string table. */
5074 dump_hppa_unwind (struct hppa_unw_aux_info
*aux
)
5076 struct hppa_unw_table_entry
*tp
;
5078 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5081 const char *procname
;
5083 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5084 aux
->strtab_size
, tp
->start
, &procname
,
5087 fputs ("\n<", stdout
);
5091 fputs (procname
, stdout
);
5094 printf ("+%lx", (unsigned long) offset
);
5097 fputs (">: [", stdout
);
5098 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5099 fputc ('-', stdout
);
5100 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5103 #define PF(_m) if (tp->_m) printf (#_m " ");
5104 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5107 PF(Millicode_save_sr0
);
5108 /* PV(Region_description); */
5114 PF(Separate_Package_Body
);
5115 PF(Frame_Extension_Millicode
);
5116 PF(Stack_Overflow_Check
);
5117 PF(Two_Instruction_SP_Increment
);
5121 PF(sched_entry_seq
);
5124 PF(Save_MRP_in_frame
);
5125 PF(extn_ptr_defined
);
5126 PF(Cleanup_defined
);
5127 PF(MPE_XL_interrupt_marker
);
5128 PF(HP_UX_interrupt_marker
);
5131 PV(Total_frame_size
);
5140 slurp_hppa_unwind_table (FILE *file
,
5141 struct hppa_unw_aux_info
*aux
,
5142 Elf_Internal_Shdr
*sec
)
5144 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
5145 Elf_Internal_Phdr
*seg
;
5146 struct hppa_unw_table_entry
*tep
;
5147 Elf_Internal_Shdr
*relsec
;
5148 Elf_Internal_Rela
*rela
, *rp
;
5149 unsigned char *table
, *tp
;
5150 Elf_Internal_Sym
*sym
;
5151 const char *relname
;
5153 /* First, find the starting address of the segment that includes
5156 if (elf_header
.e_phnum
)
5158 if (! get_program_headers (file
))
5161 for (seg
= program_headers
;
5162 seg
< program_headers
+ elf_header
.e_phnum
;
5165 if (seg
->p_type
!= PT_LOAD
)
5168 if (sec
->sh_addr
>= seg
->p_vaddr
5169 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5171 aux
->seg_base
= seg
->p_vaddr
;
5177 /* Second, build the unwind table from the contents of the unwind
5179 size
= sec
->sh_size
;
5180 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
5185 nentries
= size
/ unw_ent_size
;
5186 size
= unw_ent_size
* nentries
;
5188 tep
= aux
->table
= xcmalloc (nentries
, sizeof (aux
->table
[0]));
5190 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
5192 unsigned int tmp1
, tmp2
;
5194 tep
->start
.section
= SHN_UNDEF
;
5195 tep
->end
.section
= SHN_UNDEF
;
5197 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5198 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5199 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
5200 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
5202 tep
->start
.offset
+= aux
->seg_base
;
5203 tep
->end
.offset
+= aux
->seg_base
;
5205 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
5206 tep
->Millicode
= (tmp1
>> 30) & 0x1;
5207 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
5208 tep
->Region_description
= (tmp1
>> 27) & 0x3;
5209 tep
->reserved1
= (tmp1
>> 26) & 0x1;
5210 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
5211 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
5212 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
5213 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
5214 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
5215 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
5216 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
5217 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
5218 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
5219 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
5220 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
5221 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
5222 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
5223 tep
->reserved2
= (tmp1
>> 5) & 0x1;
5224 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
5225 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
5226 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
5227 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
5228 tep
->Cleanup_defined
= tmp1
& 0x1;
5230 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5231 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5232 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5233 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5234 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5235 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5239 /* Third, apply any relocations to the unwind table. */
5241 for (relsec
= section_headers
;
5242 relsec
< section_headers
+ elf_header
.e_shnum
;
5245 if (relsec
->sh_type
!= SHT_RELA
5246 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
5247 || SECTION_HEADER (relsec
->sh_info
) != sec
)
5250 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5254 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5258 relname
= elf_hppa_reloc_type (ELF32_R_TYPE (rp
->r_info
));
5259 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
5263 relname
= elf_hppa_reloc_type (ELF64_R_TYPE (rp
->r_info
));
5264 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
5267 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5268 if (strncmp (relname
, "R_PARISC_SEGREL", 15) != 0)
5270 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5274 i
= rp
->r_offset
/ unw_ent_size
;
5276 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5279 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5280 aux
->table
[i
].start
.offset
+= sym
->st_value
+ rp
->r_addend
;
5283 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5284 aux
->table
[i
].end
.offset
+= sym
->st_value
+ rp
->r_addend
;
5294 aux
->table_len
= nentries
;
5300 hppa_process_unwind (FILE *file
)
5302 struct hppa_unw_aux_info aux
;
5303 Elf_Internal_Shdr
*unwsec
= NULL
;
5304 Elf_Internal_Shdr
*strsec
;
5305 Elf_Internal_Shdr
*sec
;
5308 memset (& aux
, 0, sizeof (aux
));
5310 if (string_table
== NULL
)
5313 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5315 if (sec
->sh_type
== SHT_SYMTAB
5316 && SECTION_HEADER_INDEX (sec
->sh_link
) < elf_header
.e_shnum
)
5318 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5319 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5321 strsec
= SECTION_HEADER (sec
->sh_link
);
5322 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5323 1, strsec
->sh_size
, _("string table"));
5324 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5326 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5331 printf (_("\nThere are no unwind sections in this file.\n"));
5333 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5335 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5337 printf (_("\nUnwind section "));
5338 printf (_("'%s'"), SECTION_NAME (sec
));
5340 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5341 (unsigned long) sec
->sh_offset
,
5342 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5344 slurp_hppa_unwind_table (file
, &aux
, sec
);
5345 if (aux
.table_len
> 0)
5346 dump_hppa_unwind (&aux
);
5349 free ((char *) aux
.table
);
5357 free ((char *) aux
.strtab
);
5363 process_unwind (FILE *file
)
5365 struct unwind_handler
{
5367 int (*handler
)(FILE *file
);
5369 { EM_IA_64
, ia64_process_unwind
},
5370 { EM_PARISC
, hppa_process_unwind
},
5378 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5379 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5380 return handlers
[i
].handler (file
);
5382 printf (_("\nThere are no unwind sections in this file.\n"));
5387 dynamic_section_mips_val (Elf_Internal_Dyn
*entry
)
5389 switch (entry
->d_tag
)
5392 if (entry
->d_un
.d_val
== 0)
5396 static const char * opts
[] =
5398 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5399 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5400 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5401 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5406 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++cnt
)
5407 if (entry
->d_un
.d_val
& (1 << cnt
))
5409 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5416 case DT_MIPS_IVERSION
:
5417 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5418 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5420 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5423 case DT_MIPS_TIME_STAMP
:
5428 time_t time
= entry
->d_un
.d_val
;
5429 tmp
= gmtime (&time
);
5430 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5431 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5432 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5433 printf ("Time Stamp: %s\n", timebuf
);
5437 case DT_MIPS_RLD_VERSION
:
5438 case DT_MIPS_LOCAL_GOTNO
:
5439 case DT_MIPS_CONFLICTNO
:
5440 case DT_MIPS_LIBLISTNO
:
5441 case DT_MIPS_SYMTABNO
:
5442 case DT_MIPS_UNREFEXTNO
:
5443 case DT_MIPS_HIPAGENO
:
5444 case DT_MIPS_DELTA_CLASS_NO
:
5445 case DT_MIPS_DELTA_INSTANCE_NO
:
5446 case DT_MIPS_DELTA_RELOC_NO
:
5447 case DT_MIPS_DELTA_SYM_NO
:
5448 case DT_MIPS_DELTA_CLASSSYM_NO
:
5449 case DT_MIPS_COMPACT_SIZE
:
5450 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5454 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
5460 dynamic_section_parisc_val (Elf_Internal_Dyn
*entry
)
5462 switch (entry
->d_tag
)
5464 case DT_HP_DLD_FLAGS
:
5473 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5474 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5475 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5476 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5477 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5478 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5479 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5480 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5481 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5482 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5483 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
5484 { DT_HP_GST
, "HP_GST" },
5485 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
5486 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
5487 { DT_HP_NODELETE
, "HP_NODELETE" },
5488 { DT_HP_GROUP
, "HP_GROUP" },
5489 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
5493 bfd_vma val
= entry
->d_un
.d_val
;
5495 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
5496 if (val
& flags
[cnt
].bit
)
5500 fputs (flags
[cnt
].str
, stdout
);
5502 val
^= flags
[cnt
].bit
;
5505 if (val
!= 0 || first
)
5509 print_vma (val
, HEX
);
5515 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5522 dynamic_section_ia64_val (Elf_Internal_Dyn
*entry
)
5524 switch (entry
->d_tag
)
5526 case DT_IA_64_PLT_RESERVE
:
5527 /* First 3 slots reserved. */
5528 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5530 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5534 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5541 get_32bit_dynamic_section (FILE *file
)
5543 Elf32_External_Dyn
*edyn
, *ext
;
5544 Elf_Internal_Dyn
*entry
;
5546 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5547 _("dynamic section"));
5551 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5552 might not have the luxury of section headers. Look for the DT_NULL
5553 terminator to determine the number of entries. */
5554 for (ext
= edyn
, dynamic_nent
= 0;
5555 (char *) ext
< (char *) edyn
+ dynamic_size
;
5559 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5563 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5564 if (dynamic_section
== NULL
)
5566 error (_("Out of memory\n"));
5571 for (ext
= edyn
, entry
= dynamic_section
;
5572 entry
< dynamic_section
+ dynamic_nent
;
5575 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5576 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5585 get_64bit_dynamic_section (FILE *file
)
5587 Elf64_External_Dyn
*edyn
, *ext
;
5588 Elf_Internal_Dyn
*entry
;
5590 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5591 _("dynamic section"));
5595 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5596 might not have the luxury of section headers. Look for the DT_NULL
5597 terminator to determine the number of entries. */
5598 for (ext
= edyn
, dynamic_nent
= 0;
5599 (char *) ext
< (char *) edyn
+ dynamic_size
;
5603 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5607 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5608 if (dynamic_section
== NULL
)
5610 error (_("Out of memory\n"));
5615 for (ext
= edyn
, entry
= dynamic_section
;
5616 entry
< dynamic_section
+ dynamic_nent
;
5619 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5620 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5629 print_dynamic_flags (bfd_vma flags
)
5637 flag
= flags
& - flags
;
5647 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
5648 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
5649 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
5650 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
5651 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
5652 default: fputs ("unknown", stdout
); break;
5658 /* Parse and display the contents of the dynamic section. */
5661 process_dynamic_section (FILE *file
)
5663 Elf_Internal_Dyn
*entry
;
5665 if (dynamic_size
== 0)
5668 printf (_("\nThere is no dynamic section in this file.\n"));
5675 if (! get_32bit_dynamic_section (file
))
5678 else if (! get_64bit_dynamic_section (file
))
5681 /* Find the appropriate symbol table. */
5682 if (dynamic_symbols
== NULL
)
5684 for (entry
= dynamic_section
;
5685 entry
< dynamic_section
+ dynamic_nent
;
5688 Elf_Internal_Shdr section
;
5690 if (entry
->d_tag
!= DT_SYMTAB
)
5693 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
5695 /* Since we do not know how big the symbol table is,
5696 we default to reading in the entire file (!) and
5697 processing that. This is overkill, I know, but it
5699 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5701 if (archive_file_offset
!= 0)
5702 section
.sh_size
= archive_file_size
- section
.sh_offset
;
5705 if (fseek (file
, 0, SEEK_END
))
5706 error (_("Unable to seek to end of file!"));
5708 section
.sh_size
= ftell (file
) - section
.sh_offset
;
5712 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
5714 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
5716 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
5717 if (num_dynamic_syms
< 1)
5719 error (_("Unable to determine the number of symbols to load\n"));
5723 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
5727 /* Similarly find a string table. */
5728 if (dynamic_strings
== NULL
)
5730 for (entry
= dynamic_section
;
5731 entry
< dynamic_section
+ dynamic_nent
;
5734 unsigned long offset
;
5737 if (entry
->d_tag
!= DT_STRTAB
)
5740 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
5742 /* Since we do not know how big the string table is,
5743 we default to reading in the entire file (!) and
5744 processing that. This is overkill, I know, but it
5747 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5749 if (archive_file_offset
!= 0)
5750 str_tab_len
= archive_file_size
- offset
;
5753 if (fseek (file
, 0, SEEK_END
))
5754 error (_("Unable to seek to end of file\n"));
5755 str_tab_len
= ftell (file
) - offset
;
5758 if (str_tab_len
< 1)
5761 (_("Unable to determine the length of the dynamic string table\n"));
5765 dynamic_strings
= get_data (NULL
, file
, offset
, 1, str_tab_len
,
5766 _("dynamic string table"));
5767 dynamic_strings_length
= str_tab_len
;
5772 /* And find the syminfo section if available. */
5773 if (dynamic_syminfo
== NULL
)
5775 unsigned long syminsz
= 0;
5777 for (entry
= dynamic_section
;
5778 entry
< dynamic_section
+ dynamic_nent
;
5781 if (entry
->d_tag
== DT_SYMINENT
)
5783 /* Note: these braces are necessary to avoid a syntax
5784 error from the SunOS4 C compiler. */
5785 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
5787 else if (entry
->d_tag
== DT_SYMINSZ
)
5788 syminsz
= entry
->d_un
.d_val
;
5789 else if (entry
->d_tag
== DT_SYMINFO
)
5790 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
5794 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
5796 Elf_External_Syminfo
*extsyminfo
, *extsym
;
5797 Elf_Internal_Syminfo
*syminfo
;
5799 /* There is a syminfo section. Read the data. */
5800 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, 1,
5801 syminsz
, _("symbol information"));
5805 dynamic_syminfo
= malloc (syminsz
);
5806 if (dynamic_syminfo
== NULL
)
5808 error (_("Out of memory\n"));
5812 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
5813 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
5814 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
5815 ++syminfo
, ++extsym
)
5817 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
5818 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
5825 if (do_dynamic
&& dynamic_addr
)
5826 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
5827 dynamic_addr
, dynamic_nent
);
5829 printf (_(" Tag Type Name/Value\n"));
5831 for (entry
= dynamic_section
;
5832 entry
< dynamic_section
+ dynamic_nent
;
5840 print_vma (entry
->d_tag
, FULL_HEX
);
5841 dtype
= get_dynamic_type (entry
->d_tag
);
5842 printf (" (%s)%*s", dtype
,
5843 ((is_32bit_elf
? 27 : 19)
5844 - (int) strlen (dtype
)),
5848 switch (entry
->d_tag
)
5852 print_dynamic_flags (entry
->d_un
.d_val
);
5862 switch (entry
->d_tag
)
5865 printf (_("Auxiliary library"));
5869 printf (_("Filter library"));
5873 printf (_("Configuration file"));
5877 printf (_("Dependency audit library"));
5881 printf (_("Audit library"));
5885 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5886 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5890 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5899 printf (_("Flags:"));
5901 if (entry
->d_un
.d_val
== 0)
5902 printf (_(" None\n"));
5905 unsigned long int val
= entry
->d_un
.d_val
;
5907 if (val
& DTF_1_PARINIT
)
5909 printf (" PARINIT");
5910 val
^= DTF_1_PARINIT
;
5912 if (val
& DTF_1_CONFEXP
)
5914 printf (" CONFEXP");
5915 val
^= DTF_1_CONFEXP
;
5918 printf (" %lx", val
);
5927 printf (_("Flags:"));
5929 if (entry
->d_un
.d_val
== 0)
5930 printf (_(" None\n"));
5933 unsigned long int val
= entry
->d_un
.d_val
;
5935 if (val
& DF_P1_LAZYLOAD
)
5937 printf (" LAZYLOAD");
5938 val
^= DF_P1_LAZYLOAD
;
5940 if (val
& DF_P1_GROUPPERM
)
5942 printf (" GROUPPERM");
5943 val
^= DF_P1_GROUPPERM
;
5946 printf (" %lx", val
);
5955 printf (_("Flags:"));
5956 if (entry
->d_un
.d_val
== 0)
5957 printf (_(" None\n"));
5960 unsigned long int val
= entry
->d_un
.d_val
;
5967 if (val
& DF_1_GLOBAL
)
5972 if (val
& DF_1_GROUP
)
5977 if (val
& DF_1_NODELETE
)
5979 printf (" NODELETE");
5980 val
^= DF_1_NODELETE
;
5982 if (val
& DF_1_LOADFLTR
)
5984 printf (" LOADFLTR");
5985 val
^= DF_1_LOADFLTR
;
5987 if (val
& DF_1_INITFIRST
)
5989 printf (" INITFIRST");
5990 val
^= DF_1_INITFIRST
;
5992 if (val
& DF_1_NOOPEN
)
5997 if (val
& DF_1_ORIGIN
)
6002 if (val
& DF_1_DIRECT
)
6007 if (val
& DF_1_TRANS
)
6012 if (val
& DF_1_INTERPOSE
)
6014 printf (" INTERPOSE");
6015 val
^= DF_1_INTERPOSE
;
6017 if (val
& DF_1_NODEFLIB
)
6019 printf (" NODEFLIB");
6020 val
^= DF_1_NODEFLIB
;
6022 if (val
& DF_1_NODUMP
)
6027 if (val
& DF_1_CONLFAT
)
6029 printf (" CONLFAT");
6030 val
^= DF_1_CONLFAT
;
6033 printf (" %lx", val
);
6040 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6042 puts (get_dynamic_type (entry
->d_un
.d_val
));
6062 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6068 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6069 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6075 switch (entry
->d_tag
)
6078 printf (_("Shared library: [%s]"), name
);
6080 if (streq (name
, program_interpreter
))
6081 printf (_(" program interpreter"));
6085 printf (_("Library soname: [%s]"), name
);
6089 printf (_("Library rpath: [%s]"), name
);
6093 printf (_("Library runpath: [%s]"), name
);
6097 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6102 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6115 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6119 case DT_INIT_ARRAYSZ
:
6120 case DT_FINI_ARRAYSZ
:
6121 case DT_GNU_CONFLICTSZ
:
6122 case DT_GNU_LIBLISTSZ
:
6125 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6126 printf (" (bytes)\n");
6136 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6149 if (entry
->d_tag
== DT_USED
6150 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6152 char *name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6156 printf (_("Not needed object: [%s]\n"), name
);
6161 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6167 /* The value of this entry is ignored. */
6172 case DT_GNU_PRELINKED
:
6176 time_t time
= entry
->d_un
.d_val
;
6178 tmp
= gmtime (&time
);
6179 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6180 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6181 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6187 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
6188 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
6193 switch (elf_header
.e_machine
)
6196 case EM_MIPS_RS3_LE
:
6197 dynamic_section_mips_val (entry
);
6200 dynamic_section_parisc_val (entry
);
6203 dynamic_section_ia64_val (entry
);
6206 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6218 get_ver_flags (unsigned int flags
)
6220 static char buff
[32];
6227 if (flags
& VER_FLG_BASE
)
6228 strcat (buff
, "BASE ");
6230 if (flags
& VER_FLG_WEAK
)
6232 if (flags
& VER_FLG_BASE
)
6233 strcat (buff
, "| ");
6235 strcat (buff
, "WEAK ");
6238 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
6239 strcat (buff
, "| <unknown>");
6244 /* Display the contents of the version sections. */
6246 process_version_sections (FILE *file
)
6248 Elf_Internal_Shdr
*section
;
6255 for (i
= 0, section
= section_headers
;
6256 i
< elf_header
.e_shnum
;
6259 switch (section
->sh_type
)
6261 case SHT_GNU_verdef
:
6263 Elf_External_Verdef
*edefs
;
6270 (_("\nVersion definition section '%s' contains %ld entries:\n"),
6271 SECTION_NAME (section
), section
->sh_info
);
6273 printf (_(" Addr: 0x"));
6274 printf_vma (section
->sh_addr
);
6275 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6276 (unsigned long) section
->sh_offset
, section
->sh_link
,
6277 SECTION_HEADER_INDEX (section
->sh_link
)
6278 < elf_header
.e_shnum
6279 ? SECTION_NAME (SECTION_HEADER (section
->sh_link
))
6282 edefs
= get_data (NULL
, file
, section
->sh_offset
, 1,
6284 _("version definition section"));
6288 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6291 Elf_External_Verdef
*edef
;
6292 Elf_Internal_Verdef ent
;
6293 Elf_External_Verdaux
*eaux
;
6294 Elf_Internal_Verdaux aux
;
6298 vstart
= ((char *) edefs
) + idx
;
6300 edef
= (Elf_External_Verdef
*) vstart
;
6302 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
6303 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
6304 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
6305 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
6306 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
6307 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
6308 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
6310 printf (_(" %#06x: Rev: %d Flags: %s"),
6311 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
6313 printf (_(" Index: %d Cnt: %d "),
6314 ent
.vd_ndx
, ent
.vd_cnt
);
6316 vstart
+= ent
.vd_aux
;
6318 eaux
= (Elf_External_Verdaux
*) vstart
;
6320 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6321 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6323 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6324 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6326 printf (_("Name index: %ld\n"), aux
.vda_name
);
6328 isum
= idx
+ ent
.vd_aux
;
6330 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6332 isum
+= aux
.vda_next
;
6333 vstart
+= aux
.vda_next
;
6335 eaux
= (Elf_External_Verdaux
*) vstart
;
6337 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6338 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6340 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6341 printf (_(" %#06x: Parent %d: %s\n"),
6342 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6344 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6345 isum
, j
, aux
.vda_name
);
6355 case SHT_GNU_verneed
:
6357 Elf_External_Verneed
*eneed
;
6363 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
6364 SECTION_NAME (section
), section
->sh_info
);
6366 printf (_(" Addr: 0x"));
6367 printf_vma (section
->sh_addr
);
6368 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
6369 (unsigned long) section
->sh_offset
, section
->sh_link
,
6370 SECTION_HEADER_INDEX (section
->sh_link
)
6371 < elf_header
.e_shnum
6372 ? SECTION_NAME (SECTION_HEADER (section
->sh_link
))
6375 eneed
= get_data (NULL
, file
, section
->sh_offset
, 1,
6377 _("version need section"));
6381 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6383 Elf_External_Verneed
*entry
;
6384 Elf_Internal_Verneed ent
;
6389 vstart
= ((char *) eneed
) + idx
;
6391 entry
= (Elf_External_Verneed
*) vstart
;
6393 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6394 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6395 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6396 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6397 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6399 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6401 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6402 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6404 printf (_(" File: %lx"), ent
.vn_file
);
6406 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6408 vstart
+= ent
.vn_aux
;
6410 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6412 Elf_External_Vernaux
*eaux
;
6413 Elf_Internal_Vernaux aux
;
6415 eaux
= (Elf_External_Vernaux
*) vstart
;
6417 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6418 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6419 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6420 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6421 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6423 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6424 printf (_(" %#06x: Name: %s"),
6425 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6427 printf (_(" %#06x: Name index: %lx"),
6428 isum
, aux
.vna_name
);
6430 printf (_(" Flags: %s Version: %d\n"),
6431 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6433 isum
+= aux
.vna_next
;
6434 vstart
+= aux
.vna_next
;
6444 case SHT_GNU_versym
:
6446 Elf_Internal_Shdr
*link_section
;
6449 unsigned char *edata
;
6450 unsigned short *data
;
6452 Elf_Internal_Sym
*symbols
;
6453 Elf_Internal_Shdr
*string_sec
;
6456 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
)
6459 link_section
= SECTION_HEADER (section
->sh_link
);
6460 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
6462 if (SECTION_HEADER_INDEX (link_section
->sh_link
)
6463 >= elf_header
.e_shnum
)
6468 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6470 string_sec
= SECTION_HEADER (link_section
->sh_link
);
6472 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
6473 string_sec
->sh_size
, _("version string table"));
6477 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6478 SECTION_NAME (section
), total
);
6480 printf (_(" Addr: "));
6481 printf_vma (section
->sh_addr
);
6482 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6483 (unsigned long) section
->sh_offset
, section
->sh_link
,
6484 SECTION_NAME (link_section
));
6486 off
= offset_from_vma (file
,
6487 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6488 total
* sizeof (short));
6489 edata
= get_data (NULL
, file
, off
, total
, sizeof (short),
6490 _("version symbol data"));
6497 data
= cmalloc (total
, sizeof (short));
6499 for (cnt
= total
; cnt
--;)
6500 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6505 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6508 int check_def
, check_need
;
6511 printf (" %03x:", cnt
);
6513 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6514 switch (data
[cnt
+ j
])
6517 fputs (_(" 0 (*local*) "), stdout
);
6521 fputs (_(" 1 (*global*) "), stdout
);
6525 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
6526 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
6530 if (SECTION_HEADER_INDEX (symbols
[cnt
+ j
].st_shndx
)
6531 >= elf_header
.e_shnum
6532 || SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
6535 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6542 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6544 Elf_Internal_Verneed ivn
;
6545 unsigned long offset
;
6547 offset
= offset_from_vma
6548 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6549 sizeof (Elf_External_Verneed
));
6553 Elf_Internal_Vernaux ivna
;
6554 Elf_External_Verneed evn
;
6555 Elf_External_Vernaux evna
;
6556 unsigned long a_off
;
6558 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
6561 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6562 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6564 a_off
= offset
+ ivn
.vn_aux
;
6568 get_data (&evna
, file
, a_off
, sizeof (evna
),
6569 1, _("version need aux (2)"));
6571 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6572 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6574 a_off
+= ivna
.vna_next
;
6576 while (ivna
.vna_other
!= data
[cnt
+ j
]
6577 && ivna
.vna_next
!= 0);
6579 if (ivna
.vna_other
== data
[cnt
+ j
])
6581 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6583 name
= strtab
+ ivna
.vna_name
;
6584 nn
+= printf ("(%s%-*s",
6586 12 - (int) strlen (name
),
6592 offset
+= ivn
.vn_next
;
6594 while (ivn
.vn_next
);
6597 if (check_def
&& data
[cnt
+ j
] != 0x8001
6598 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6600 Elf_Internal_Verdef ivd
;
6601 Elf_External_Verdef evd
;
6602 unsigned long offset
;
6604 offset
= offset_from_vma
6605 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6610 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
6613 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6614 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6616 offset
+= ivd
.vd_next
;
6618 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
6619 && ivd
.vd_next
!= 0);
6621 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
6623 Elf_External_Verdaux evda
;
6624 Elf_Internal_Verdaux ivda
;
6626 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6628 get_data (&evda
, file
,
6629 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
6631 _("version def aux"));
6633 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6635 name
= strtab
+ ivda
.vda_name
;
6636 nn
+= printf ("(%s%-*s",
6638 12 - (int) strlen (name
),
6644 printf ("%*c", 18 - nn
, ' ');
6662 printf (_("\nNo version information found in this file.\n"));
6668 get_symbol_binding (unsigned int binding
)
6670 static char buff
[32];
6674 case STB_LOCAL
: return "LOCAL";
6675 case STB_GLOBAL
: return "GLOBAL";
6676 case STB_WEAK
: return "WEAK";
6678 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
6679 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
6681 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
6682 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
6684 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
6690 get_symbol_type (unsigned int type
)
6692 static char buff
[32];
6696 case STT_NOTYPE
: return "NOTYPE";
6697 case STT_OBJECT
: return "OBJECT";
6698 case STT_FUNC
: return "FUNC";
6699 case STT_SECTION
: return "SECTION";
6700 case STT_FILE
: return "FILE";
6701 case STT_COMMON
: return "COMMON";
6702 case STT_TLS
: return "TLS";
6704 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
6706 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
6707 return "THUMB_FUNC";
6709 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
6712 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
6713 return "PARISC_MILLI";
6715 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
6717 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
6719 if (elf_header
.e_machine
== EM_PARISC
)
6721 if (type
== STT_HP_OPAQUE
)
6723 if (type
== STT_HP_STUB
)
6727 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
6730 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
6736 get_symbol_visibility (unsigned int visibility
)
6740 case STV_DEFAULT
: return "DEFAULT";
6741 case STV_INTERNAL
: return "INTERNAL";
6742 case STV_HIDDEN
: return "HIDDEN";
6743 case STV_PROTECTED
: return "PROTECTED";
6749 get_symbol_index_type (unsigned int type
)
6751 static char buff
[32];
6755 case SHN_UNDEF
: return "UND";
6756 case SHN_ABS
: return "ABS";
6757 case SHN_COMMON
: return "COM";
6759 if (type
== SHN_IA_64_ANSI_COMMON
6760 && elf_header
.e_machine
== EM_IA_64
6761 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
6763 else if (elf_header
.e_machine
== EM_X86_64
6764 && type
== SHN_X86_64_LCOMMON
)
6766 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
6767 sprintf (buff
, "PRC[0x%04x]", type
);
6768 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
6769 sprintf (buff
, "OS [0x%04x]", type
);
6770 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
6771 sprintf (buff
, "RSV[0x%04x]", type
);
6773 sprintf (buff
, "%3d", type
);
6781 get_dynamic_data (FILE *file
, unsigned int number
, unsigned int ent_size
)
6783 unsigned char *e_data
;
6786 e_data
= cmalloc (number
, ent_size
);
6790 error (_("Out of memory\n"));
6794 if (fread (e_data
, ent_size
, number
, file
) != number
)
6796 error (_("Unable to read in dynamic data\n"));
6800 i_data
= cmalloc (number
, sizeof (*i_data
));
6804 error (_("Out of memory\n"));
6810 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
6817 /* Dump the symbol table. */
6819 process_symbol_table (FILE *file
)
6821 Elf_Internal_Shdr
*section
;
6822 bfd_vma nbuckets
= 0;
6823 bfd_vma nchains
= 0;
6824 bfd_vma
*buckets
= NULL
;
6825 bfd_vma
*chains
= NULL
;
6827 if (! do_syms
&& !do_histogram
)
6830 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
6833 unsigned char nb
[8];
6834 unsigned char nc
[8];
6835 int hash_ent_size
= 4;
6837 if ((elf_header
.e_machine
== EM_ALPHA
6838 || elf_header
.e_machine
== EM_S390
6839 || elf_header
.e_machine
== EM_S390_OLD
)
6840 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
6844 (archive_file_offset
6845 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
6846 sizeof nb
+ sizeof nc
)),
6849 error (_("Unable to seek to start of dynamic information"));
6853 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
6855 error (_("Failed to read in number of buckets\n"));
6859 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
6861 error (_("Failed to read in number of chains\n"));
6865 nbuckets
= byte_get (nb
, hash_ent_size
);
6866 nchains
= byte_get (nc
, hash_ent_size
);
6868 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
6869 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
6871 if (buckets
== NULL
|| chains
== NULL
)
6876 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
6881 printf (_("\nSymbol table for image:\n"));
6883 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6885 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6887 for (hn
= 0; hn
< nbuckets
; hn
++)
6892 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
6894 Elf_Internal_Sym
*psym
;
6897 psym
= dynamic_symbols
+ si
;
6899 n
= print_vma (si
, DEC_5
);
6901 fputs (" " + n
, stdout
);
6902 printf (" %3lu: ", hn
);
6903 print_vma (psym
->st_value
, LONG_HEX
);
6905 print_vma (psym
->st_size
, DEC_5
);
6907 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6908 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6909 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6910 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
6911 if (VALID_DYNAMIC_NAME (psym
->st_name
))
6912 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
6914 printf (" <corrupt: %14ld>", psym
->st_name
);
6919 else if (do_syms
&& !do_using_dynamic
)
6923 for (i
= 0, section
= section_headers
;
6924 i
< elf_header
.e_shnum
;
6928 char *strtab
= NULL
;
6929 unsigned long int strtab_size
= 0;
6930 Elf_Internal_Sym
*symtab
;
6931 Elf_Internal_Sym
*psym
;
6934 if ( section
->sh_type
!= SHT_SYMTAB
6935 && section
->sh_type
!= SHT_DYNSYM
)
6938 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
6939 SECTION_NAME (section
),
6940 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
6942 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6944 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6946 symtab
= GET_ELF_SYMBOLS (file
, section
);
6950 if (section
->sh_link
== elf_header
.e_shstrndx
)
6952 strtab
= string_table
;
6953 strtab_size
= string_table_length
;
6955 else if (SECTION_HEADER_INDEX (section
->sh_link
) < elf_header
.e_shnum
)
6957 Elf_Internal_Shdr
*string_sec
;
6959 string_sec
= SECTION_HEADER (section
->sh_link
);
6961 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
6962 1, string_sec
->sh_size
, _("string table"));
6963 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
6966 for (si
= 0, psym
= symtab
;
6967 si
< section
->sh_size
/ section
->sh_entsize
;
6970 printf ("%6d: ", si
);
6971 print_vma (psym
->st_value
, LONG_HEX
);
6973 print_vma (psym
->st_size
, DEC_5
);
6974 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6975 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6976 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6977 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
6978 print_symbol (25, psym
->st_name
< strtab_size
6979 ? strtab
+ psym
->st_name
: "<corrupt>");
6981 if (section
->sh_type
== SHT_DYNSYM
&&
6982 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
6984 unsigned char data
[2];
6985 unsigned short vers_data
;
6986 unsigned long offset
;
6990 offset
= offset_from_vma
6991 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6992 sizeof data
+ si
* sizeof (vers_data
));
6994 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
6995 sizeof (data
), 1, _("version data"));
6997 vers_data
= byte_get (data
, 2);
6999 is_nobits
= (SECTION_HEADER_INDEX (psym
->st_shndx
)
7000 < elf_header
.e_shnum
7001 && SECTION_HEADER (psym
->st_shndx
)->sh_type
7004 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
7006 if ((vers_data
& 0x8000) || vers_data
> 1)
7008 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
7009 && (is_nobits
|| ! check_def
))
7011 Elf_External_Verneed evn
;
7012 Elf_Internal_Verneed ivn
;
7013 Elf_Internal_Vernaux ivna
;
7015 /* We must test both. */
7016 offset
= offset_from_vma
7017 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
7022 unsigned long vna_off
;
7024 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
7027 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
7028 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
7030 vna_off
= offset
+ ivn
.vn_aux
;
7034 Elf_External_Vernaux evna
;
7036 get_data (&evna
, file
, vna_off
,
7038 _("version need aux (3)"));
7040 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
7041 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
7042 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
7044 vna_off
+= ivna
.vna_next
;
7046 while (ivna
.vna_other
!= vers_data
7047 && ivna
.vna_next
!= 0);
7049 if (ivna
.vna_other
== vers_data
)
7052 offset
+= ivn
.vn_next
;
7054 while (ivn
.vn_next
!= 0);
7056 if (ivna
.vna_other
== vers_data
)
7059 ivna
.vna_name
< strtab_size
7060 ? strtab
+ ivna
.vna_name
: "<corrupt>",
7064 else if (! is_nobits
)
7065 error (_("bad dynamic symbol"));
7072 if (vers_data
!= 0x8001
7073 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7075 Elf_Internal_Verdef ivd
;
7076 Elf_Internal_Verdaux ivda
;
7077 Elf_External_Verdaux evda
;
7078 unsigned long offset
;
7080 offset
= offset_from_vma
7082 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7083 sizeof (Elf_External_Verdef
));
7087 Elf_External_Verdef evd
;
7089 get_data (&evd
, file
, offset
, sizeof (evd
),
7090 1, _("version def"));
7092 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7093 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7094 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7096 offset
+= ivd
.vd_next
;
7098 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
7099 && ivd
.vd_next
!= 0);
7101 offset
-= ivd
.vd_next
;
7102 offset
+= ivd
.vd_aux
;
7104 get_data (&evda
, file
, offset
, sizeof (evda
),
7105 1, _("version def aux"));
7107 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7109 if (psym
->st_name
!= ivda
.vda_name
)
7110 printf ((vers_data
& 0x8000)
7112 ivda
.vda_name
< strtab_size
7113 ? strtab
+ ivda
.vda_name
: "<corrupt>");
7123 if (strtab
!= string_table
)
7129 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7131 if (do_histogram
&& buckets
!= NULL
)
7133 unsigned long *lengths
;
7134 unsigned long *counts
;
7137 unsigned long maxlength
= 0;
7138 unsigned long nzero_counts
= 0;
7139 unsigned long nsyms
= 0;
7141 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7142 (unsigned long) nbuckets
);
7143 printf (_(" Length Number %% of total Coverage\n"));
7145 lengths
= calloc (nbuckets
, sizeof (*lengths
));
7146 if (lengths
== NULL
)
7148 error (_("Out of memory"));
7151 for (hn
= 0; hn
< nbuckets
; ++hn
)
7153 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
7156 if (maxlength
< ++lengths
[hn
])
7161 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7164 error (_("Out of memory"));
7168 for (hn
= 0; hn
< nbuckets
; ++hn
)
7169 ++counts
[lengths
[hn
]];
7174 printf (" 0 %-10lu (%5.1f%%)\n",
7175 counts
[0], (counts
[0] * 100.0) / nbuckets
);
7176 for (i
= 1; i
<= maxlength
; ++i
)
7178 nzero_counts
+= counts
[i
] * i
;
7179 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7180 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
7181 (nzero_counts
* 100.0) / nsyms
);
7189 if (buckets
!= NULL
)
7199 process_syminfo (FILE *file ATTRIBUTE_UNUSED
)
7203 if (dynamic_syminfo
== NULL
7205 /* No syminfo, this is ok. */
7208 /* There better should be a dynamic symbol section. */
7209 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
7213 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7214 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
7216 printf (_(" Num: Name BoundTo Flags\n"));
7217 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
7219 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
7221 printf ("%4d: ", i
);
7222 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
7223 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
7225 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
7228 switch (dynamic_syminfo
[i
].si_boundto
)
7230 case SYMINFO_BT_SELF
:
7231 fputs ("SELF ", stdout
);
7233 case SYMINFO_BT_PARENT
:
7234 fputs ("PARENT ", stdout
);
7237 if (dynamic_syminfo
[i
].si_boundto
> 0
7238 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
7239 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
7241 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
7245 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
7249 if (flags
& SYMINFO_FLG_DIRECT
)
7251 if (flags
& SYMINFO_FLG_PASSTHRU
)
7252 printf (" PASSTHRU");
7253 if (flags
& SYMINFO_FLG_COPY
)
7255 if (flags
& SYMINFO_FLG_LAZYLOAD
)
7256 printf (" LAZYLOAD");
7264 #ifdef SUPPORT_DISASSEMBLY
7266 disassemble_section (Elf_Internal_Shdr
*section
, FILE *file
)
7268 printf (_("\nAssembly dump of section %s\n"),
7269 SECTION_NAME (section
));
7271 /* XXX -- to be done --- XXX */
7278 dump_section (Elf_Internal_Shdr
*section
, FILE *file
)
7280 bfd_size_type bytes
;
7282 unsigned char *data
;
7283 unsigned char *start
;
7285 bytes
= section
->sh_size
;
7287 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
7289 printf (_("\nSection '%s' has no data to dump.\n"),
7290 SECTION_NAME (section
));
7294 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
7296 addr
= section
->sh_addr
;
7298 start
= get_data (NULL
, file
, section
->sh_offset
, 1, bytes
,
7311 lbytes
= (bytes
> 16 ? 16 : bytes
);
7313 printf (" 0x%8.8lx ", (unsigned long) addr
);
7315 switch (elf_header
.e_ident
[EI_DATA
])
7319 for (j
= 15; j
>= 0; j
--)
7322 printf ("%2.2x", data
[j
]);
7332 for (j
= 0; j
< 16; j
++)
7335 printf ("%2.2x", data
[j
]);
7345 for (j
= 0; j
< lbytes
; j
++)
7348 if (k
>= ' ' && k
< 0x7f)
7367 struct dwarf_section
7370 unsigned char *start
;
7375 static int process_debug_info (struct dwarf_section
*, void *, int);
7378 load_debug_section (struct dwarf_section
*section
, void *file
)
7380 Elf_Internal_Shdr
*sec
;
7383 /* If it is already loaded, do nothing. */
7384 if (section
->start
!= NULL
)
7387 /* Locate the debug section. */
7388 sec
= find_section (section
->name
);
7392 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
7393 section
->address
= sec
->sh_addr
;
7394 section
->size
= sec
->sh_size
;
7395 section
->start
= get_data (NULL
, file
, sec
->sh_offset
, 1,
7400 free_debug_section (struct dwarf_section
*section
)
7402 if (section
->start
== NULL
)
7405 free ((char *) section
->start
);
7406 section
->start
= NULL
;
7407 section
->address
= 0;
7411 /* Apply addends of RELA relocations. */
7414 debug_apply_rela_addends (void *file
,
7415 Elf_Internal_Shdr
*section
,
7416 unsigned char *start
)
7418 Elf_Internal_Shdr
*relsec
;
7419 unsigned char *end
= start
+ section
->sh_size
;
7420 /* FIXME: The relocation field size is relocation type dependent. */
7421 unsigned int reloc_size
= 4;
7423 if (!is_relocatable
)
7426 if (section
->sh_size
< reloc_size
)
7429 for (relsec
= section_headers
;
7430 relsec
< section_headers
+ elf_header
.e_shnum
;
7433 unsigned long nrelas
;
7434 Elf_Internal_Rela
*rela
, *rp
;
7435 Elf_Internal_Shdr
*symsec
;
7436 Elf_Internal_Sym
*symtab
;
7437 Elf_Internal_Sym
*sym
;
7439 if (relsec
->sh_type
!= SHT_RELA
7440 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
7441 || SECTION_HEADER (relsec
->sh_info
) != section
7442 || relsec
->sh_size
== 0
7443 || SECTION_HEADER_INDEX (relsec
->sh_link
) >= elf_header
.e_shnum
)
7446 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7450 symsec
= SECTION_HEADER (relsec
->sh_link
);
7451 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
7453 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7457 loc
= start
+ rp
->r_offset
;
7458 if ((loc
+ reloc_size
) > end
)
7460 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
7461 (unsigned long) rp
->r_offset
,
7462 SECTION_NAME (section
));
7468 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
7470 if (ELF32_R_SYM (rp
->r_info
) != 0
7471 && ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
7472 /* Relocations against object symbols can happen,
7473 eg when referencing a global array. For an
7474 example of this see the _clz.o binary in libgcc.a. */
7475 && ELF32_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7477 warn (_("skipping unexpected symbol type %s in relocation in section .rela%s\n"),
7478 get_symbol_type (ELF32_ST_TYPE (sym
->st_info
)),
7479 SECTION_NAME (section
));
7485 /* In MIPS little-endian objects, r_info isn't really a
7486 64-bit little-endian value: it has a 32-bit little-endian
7487 symbol index followed by four individual byte fields.
7488 Reorder INFO accordingly. */
7489 if (elf_header
.e_machine
== EM_MIPS
7490 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
7491 rp
->r_info
= (((rp
->r_info
& 0xffffffff) << 32)
7492 | ((rp
->r_info
>> 56) & 0xff)
7493 | ((rp
->r_info
>> 40) & 0xff00)
7494 | ((rp
->r_info
>> 24) & 0xff0000)
7495 | ((rp
->r_info
>> 8) & 0xff000000));
7497 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
7499 if (ELF64_R_SYM (rp
->r_info
) != 0
7500 && ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
7501 && ELF64_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7503 warn (_("skipping unexpected symbol type %s in relocation in section .rela.%s\n"),
7504 get_symbol_type (ELF64_ST_TYPE (sym
->st_info
)),
7505 SECTION_NAME (section
));
7510 byte_put (loc
, rp
->r_addend
, reloc_size
);
7521 byte_get_little_endian (unsigned char *field
, int size
)
7529 return ((unsigned int) (field
[0]))
7530 | (((unsigned int) (field
[1])) << 8);
7534 /* We want to extract data from an 8 byte wide field and
7535 place it into a 4 byte wide field. Since this is a little
7536 endian source we can just use the 4 byte extraction code. */
7540 return ((unsigned long) (field
[0]))
7541 | (((unsigned long) (field
[1])) << 8)
7542 | (((unsigned long) (field
[2])) << 16)
7543 | (((unsigned long) (field
[3])) << 24);
7547 return ((bfd_vma
) (field
[0]))
7548 | (((bfd_vma
) (field
[1])) << 8)
7549 | (((bfd_vma
) (field
[2])) << 16)
7550 | (((bfd_vma
) (field
[3])) << 24)
7551 | (((bfd_vma
) (field
[4])) << 32)
7552 | (((bfd_vma
) (field
[5])) << 40)
7553 | (((bfd_vma
) (field
[6])) << 48)
7554 | (((bfd_vma
) (field
[7])) << 56);
7557 error (_("Unhandled data length: %d\n"), size
);
7563 byte_get_signed (unsigned char *field
, int size
)
7565 bfd_vma x
= byte_get (field
, size
);
7570 return (x
^ 0x80) - 0x80;
7572 return (x
^ 0x8000) - 0x8000;
7574 return (x
^ 0x80000000) - 0x80000000;
7583 byte_get_big_endian (unsigned char *field
, int size
)
7591 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
7595 /* Although we are extracing data from an 8 byte wide field,
7596 we are returning only 4 bytes of data. */
7601 return ((unsigned long) (field
[3]))
7602 | (((unsigned long) (field
[2])) << 8)
7603 | (((unsigned long) (field
[1])) << 16)
7604 | (((unsigned long) (field
[0])) << 24);
7608 return ((bfd_vma
) (field
[7]))
7609 | (((bfd_vma
) (field
[6])) << 8)
7610 | (((bfd_vma
) (field
[5])) << 16)
7611 | (((bfd_vma
) (field
[4])) << 24)
7612 | (((bfd_vma
) (field
[3])) << 32)
7613 | (((bfd_vma
) (field
[2])) << 40)
7614 | (((bfd_vma
) (field
[1])) << 48)
7615 | (((bfd_vma
) (field
[0])) << 56);
7619 error (_("Unhandled data length: %d\n"), size
);
7624 static unsigned long int
7625 read_leb128 (unsigned char *data
, unsigned int *length_return
, int sign
)
7627 unsigned long int result
= 0;
7628 unsigned int num_read
= 0;
7629 unsigned int shift
= 0;
7637 result
|= ((unsigned long int) (byte
& 0x7f)) << shift
;
7642 while (byte
& 0x80);
7644 if (length_return
!= NULL
)
7645 *length_return
= num_read
;
7647 if (sign
&& (shift
< 8 * sizeof (result
)) && (byte
& 0x40))
7648 result
|= -1L << shift
;
7653 typedef struct State_Machine_Registers
7655 unsigned long address
;
7658 unsigned int column
;
7662 /* This variable hold the number of the last entry seen
7663 in the File Table. */
7664 unsigned int last_file_entry
;
7667 static SMR state_machine_regs
;
7670 reset_state_machine (int is_stmt
)
7672 state_machine_regs
.address
= 0;
7673 state_machine_regs
.file
= 1;
7674 state_machine_regs
.line
= 1;
7675 state_machine_regs
.column
= 0;
7676 state_machine_regs
.is_stmt
= is_stmt
;
7677 state_machine_regs
.basic_block
= 0;
7678 state_machine_regs
.end_sequence
= 0;
7679 state_machine_regs
.last_file_entry
= 0;
7682 /* Handled an extend line op.
7683 Returns the number of bytes read. */
7686 process_extended_line_op (unsigned char *data
, int is_stmt
, int pointer_size
)
7688 unsigned char op_code
;
7689 unsigned int bytes_read
;
7691 unsigned char *name
;
7694 len
= read_leb128 (data
, & bytes_read
, 0);
7699 warn (_("badly formed extended line op encountered!\n"));
7706 printf (_(" Extended opcode %d: "), op_code
);
7710 case DW_LNE_end_sequence
:
7711 printf (_("End of Sequence\n\n"));
7712 reset_state_machine (is_stmt
);
7715 case DW_LNE_set_address
:
7716 adr
= byte_get (data
, pointer_size
);
7717 printf (_("set Address to 0x%lx\n"), adr
);
7718 state_machine_regs
.address
= adr
;
7721 case DW_LNE_define_file
:
7722 printf (_(" define new File Table entry\n"));
7723 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
7725 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
7727 data
+= strlen ((char *) data
) + 1;
7728 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7730 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7732 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7733 printf (_("%s\n\n"), name
);
7737 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
7744 static struct dwarf_section debug_str_section
= {
7752 fetch_indirect_string (unsigned long offset
)
7754 if (debug_str_section
.start
== NULL
)
7755 return _("<no .debug_str section>");
7757 if (offset
> debug_str_section
.size
)
7759 warn (_("DW_FORM_strp offset too big: %lx\n"), offset
);
7760 return _("<offset is too big>");
7763 return debug_str_section
.start
+ offset
;
7766 static struct dwarf_section debug_abbrev_section
= {
7773 /* FIXME: There are better and more efficient ways to handle
7774 these structures. For now though, I just want something that
7775 is simple to implement. */
7776 typedef struct abbrev_attr
7778 unsigned long attribute
;
7780 struct abbrev_attr
*next
;
7784 typedef struct abbrev_entry
7786 unsigned long entry
;
7789 struct abbrev_attr
*first_attr
;
7790 struct abbrev_attr
*last_attr
;
7791 struct abbrev_entry
*next
;
7795 static abbrev_entry
*first_abbrev
= NULL
;
7796 static abbrev_entry
*last_abbrev
= NULL
;
7801 abbrev_entry
*abbrev
;
7803 for (abbrev
= first_abbrev
; abbrev
;)
7805 abbrev_entry
*next
= abbrev
->next
;
7808 for (attr
= abbrev
->first_attr
; attr
;)
7810 abbrev_attr
*next
= attr
->next
;
7820 last_abbrev
= first_abbrev
= NULL
;
7824 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
7826 abbrev_entry
*entry
;
7828 entry
= malloc (sizeof (*entry
));
7834 entry
->entry
= number
;
7836 entry
->children
= children
;
7837 entry
->first_attr
= NULL
;
7838 entry
->last_attr
= NULL
;
7841 if (first_abbrev
== NULL
)
7842 first_abbrev
= entry
;
7844 last_abbrev
->next
= entry
;
7846 last_abbrev
= entry
;
7850 add_abbrev_attr (unsigned long attribute
, unsigned long form
)
7854 attr
= malloc (sizeof (*attr
));
7860 attr
->attribute
= attribute
;
7864 if (last_abbrev
->first_attr
== NULL
)
7865 last_abbrev
->first_attr
= attr
;
7867 last_abbrev
->last_attr
->next
= attr
;
7869 last_abbrev
->last_attr
= attr
;
7872 /* Processes the (partial) contents of a .debug_abbrev section.
7873 Returns NULL if the end of the section was encountered.
7874 Returns the address after the last byte read if the end of
7875 an abbreviation set was found. */
7877 static unsigned char *
7878 process_abbrev_section (unsigned char *start
, unsigned char *end
)
7880 if (first_abbrev
!= NULL
)
7885 unsigned int bytes_read
;
7886 unsigned long entry
;
7888 unsigned long attribute
;
7891 entry
= read_leb128 (start
, & bytes_read
, 0);
7892 start
+= bytes_read
;
7894 /* A single zero is supposed to end the section according
7895 to the standard. If there's more, then signal that to
7898 return start
== end
? NULL
: start
;
7900 tag
= read_leb128 (start
, & bytes_read
, 0);
7901 start
+= bytes_read
;
7903 children
= *start
++;
7905 add_abbrev (entry
, tag
, children
);
7911 attribute
= read_leb128 (start
, & bytes_read
, 0);
7912 start
+= bytes_read
;
7914 form
= read_leb128 (start
, & bytes_read
, 0);
7915 start
+= bytes_read
;
7918 add_abbrev_attr (attribute
, form
);
7920 while (attribute
!= 0);
7927 get_TAG_name (unsigned long tag
)
7931 case DW_TAG_padding
: return "DW_TAG_padding";
7932 case DW_TAG_array_type
: return "DW_TAG_array_type";
7933 case DW_TAG_class_type
: return "DW_TAG_class_type";
7934 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
7935 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
7936 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
7937 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
7938 case DW_TAG_label
: return "DW_TAG_label";
7939 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
7940 case DW_TAG_member
: return "DW_TAG_member";
7941 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
7942 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
7943 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
7944 case DW_TAG_string_type
: return "DW_TAG_string_type";
7945 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
7946 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
7947 case DW_TAG_typedef
: return "DW_TAG_typedef";
7948 case DW_TAG_union_type
: return "DW_TAG_union_type";
7949 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
7950 case DW_TAG_variant
: return "DW_TAG_variant";
7951 case DW_TAG_common_block
: return "DW_TAG_common_block";
7952 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
7953 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
7954 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
7955 case DW_TAG_module
: return "DW_TAG_module";
7956 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
7957 case DW_TAG_set_type
: return "DW_TAG_set_type";
7958 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
7959 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
7960 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
7961 case DW_TAG_base_type
: return "DW_TAG_base_type";
7962 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
7963 case DW_TAG_const_type
: return "DW_TAG_const_type";
7964 case DW_TAG_constant
: return "DW_TAG_constant";
7965 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
7966 case DW_TAG_file_type
: return "DW_TAG_file_type";
7967 case DW_TAG_friend
: return "DW_TAG_friend";
7968 case DW_TAG_namelist
: return "DW_TAG_namelist";
7969 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
7970 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
7971 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
7972 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
7973 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
7974 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
7975 case DW_TAG_try_block
: return "DW_TAG_try_block";
7976 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
7977 case DW_TAG_variable
: return "DW_TAG_variable";
7978 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
7979 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
7980 case DW_TAG_format_label
: return "DW_TAG_format_label";
7981 case DW_TAG_function_template
: return "DW_TAG_function_template";
7982 case DW_TAG_class_template
: return "DW_TAG_class_template";
7983 /* DWARF 2.1 values. */
7984 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
7985 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
7986 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
7987 case DW_TAG_namespace
: return "DW_TAG_namespace";
7988 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
7989 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
7990 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
7991 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
7993 case DW_TAG_upc_shared_type
: return "DW_TAG_upc_shared_type";
7994 case DW_TAG_upc_strict_type
: return "DW_TAG_upc_strict_type";
7995 case DW_TAG_upc_relaxed_type
: return "DW_TAG_upc_relaxed_type";
7998 static char buffer
[100];
8000 snprintf (buffer
, sizeof (buffer
), _("Unknown TAG value: %lx"), tag
);
8007 get_FORM_name (unsigned long form
)
8011 case DW_FORM_addr
: return "DW_FORM_addr";
8012 case DW_FORM_block2
: return "DW_FORM_block2";
8013 case DW_FORM_block4
: return "DW_FORM_block4";
8014 case DW_FORM_data2
: return "DW_FORM_data2";
8015 case DW_FORM_data4
: return "DW_FORM_data4";
8016 case DW_FORM_data8
: return "DW_FORM_data8";
8017 case DW_FORM_string
: return "DW_FORM_string";
8018 case DW_FORM_block
: return "DW_FORM_block";
8019 case DW_FORM_block1
: return "DW_FORM_block1";
8020 case DW_FORM_data1
: return "DW_FORM_data1";
8021 case DW_FORM_flag
: return "DW_FORM_flag";
8022 case DW_FORM_sdata
: return "DW_FORM_sdata";
8023 case DW_FORM_strp
: return "DW_FORM_strp";
8024 case DW_FORM_udata
: return "DW_FORM_udata";
8025 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
8026 case DW_FORM_ref1
: return "DW_FORM_ref1";
8027 case DW_FORM_ref2
: return "DW_FORM_ref2";
8028 case DW_FORM_ref4
: return "DW_FORM_ref4";
8029 case DW_FORM_ref8
: return "DW_FORM_ref8";
8030 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
8031 case DW_FORM_indirect
: return "DW_FORM_indirect";
8034 static char buffer
[100];
8036 snprintf (buffer
, sizeof (buffer
), _("Unknown FORM value: %lx"), form
);
8042 static unsigned char *
8043 display_block (unsigned char *data
, unsigned long length
)
8045 printf (_(" %lu byte block: "), length
);
8048 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
8054 decode_location_expression (unsigned char * data
,
8055 unsigned int pointer_size
,
8056 unsigned long length
,
8057 unsigned long cu_offset
)
8060 unsigned int bytes_read
;
8061 unsigned long uvalue
;
8062 unsigned char *end
= data
+ length
;
8063 int need_frame_base
= 0;
8072 printf ("DW_OP_addr: %lx",
8073 (unsigned long) byte_get (data
, pointer_size
));
8074 data
+= pointer_size
;
8077 printf ("DW_OP_deref");
8080 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
8083 printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data
++, 1));
8086 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
8090 printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data
, 2));
8094 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
8098 printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data
, 4));
8102 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
8103 (unsigned long) byte_get (data
+ 4, 4));
8107 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
8108 (long) byte_get (data
+ 4, 4));
8112 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
8116 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
8120 printf ("DW_OP_dup");
8123 printf ("DW_OP_drop");
8126 printf ("DW_OP_over");
8129 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
8132 printf ("DW_OP_swap");
8135 printf ("DW_OP_rot");
8138 printf ("DW_OP_xderef");
8141 printf ("DW_OP_abs");
8144 printf ("DW_OP_and");
8147 printf ("DW_OP_div");
8150 printf ("DW_OP_minus");
8153 printf ("DW_OP_mod");
8156 printf ("DW_OP_mul");
8159 printf ("DW_OP_neg");
8162 printf ("DW_OP_not");
8165 printf ("DW_OP_or");
8168 printf ("DW_OP_plus");
8170 case DW_OP_plus_uconst
:
8171 printf ("DW_OP_plus_uconst: %lu",
8172 read_leb128 (data
, &bytes_read
, 0));
8176 printf ("DW_OP_shl");
8179 printf ("DW_OP_shr");
8182 printf ("DW_OP_shra");
8185 printf ("DW_OP_xor");
8188 printf ("DW_OP_bra: %ld", (long) byte_get_signed (data
, 2));
8192 printf ("DW_OP_eq");
8195 printf ("DW_OP_ge");
8198 printf ("DW_OP_gt");
8201 printf ("DW_OP_le");
8204 printf ("DW_OP_lt");
8207 printf ("DW_OP_ne");
8210 printf ("DW_OP_skip: %ld", (long) byte_get_signed (data
, 2));
8246 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
8281 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
8316 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
8317 read_leb128 (data
, &bytes_read
, 1));
8322 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
8326 need_frame_base
= 1;
8327 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
8331 uvalue
= read_leb128 (data
, &bytes_read
, 0);
8333 printf ("DW_OP_bregx: %lu %ld", uvalue
,
8334 read_leb128 (data
, &bytes_read
, 1));
8338 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
8341 case DW_OP_deref_size
:
8342 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
8344 case DW_OP_xderef_size
:
8345 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
8348 printf ("DW_OP_nop");
8351 /* DWARF 3 extensions. */
8352 case DW_OP_push_object_address
:
8353 printf ("DW_OP_push_object_address");
8356 /* XXX: Strictly speaking for 64-bit DWARF3 files
8357 this ought to be an 8-byte wide computation. */
8358 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2) + cu_offset
);
8362 /* XXX: Strictly speaking for 64-bit DWARF3 files
8363 this ought to be an 8-byte wide computation. */
8364 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4) + cu_offset
);
8367 case DW_OP_call_ref
:
8368 printf ("DW_OP_call_ref");
8371 /* GNU extensions. */
8372 case DW_OP_GNU_push_tls_address
:
8373 printf ("DW_OP_GNU_push_tls_address");
8377 if (op
>= DW_OP_lo_user
8378 && op
<= DW_OP_hi_user
)
8379 printf (_("(User defined location op)"));
8381 printf (_("(Unknown location op)"));
8382 /* No way to tell where the next op is, so just bail. */
8383 return need_frame_base
;
8386 /* Separate the ops. */
8391 return need_frame_base
;
8394 /* This structure records the information that
8395 we extract from the.debug_info section. */
8398 unsigned int pointer_size
;
8399 unsigned long cu_offset
;
8400 unsigned long base_address
;
8401 /* This is an array of offsets to the location list table. */
8402 unsigned long *loc_offsets
;
8403 int *have_frame_base
;
8404 unsigned int num_loc_offsets
;
8405 unsigned int max_loc_offsets
;
8406 unsigned long *range_lists
;
8407 unsigned int num_range_lists
;
8408 unsigned int max_range_lists
;
8412 static debug_info
* debug_information
= NULL
;
8413 static unsigned int num_debug_info_entries
= 0;
8414 static unsigned int last_pointer_size
= 0;
8415 static int warned_about_missing_comp_units
= FALSE
;
8417 static unsigned char *
8418 read_and_display_attr_value (unsigned long attribute
,
8420 unsigned char *data
,
8421 unsigned long cu_offset
,
8422 unsigned long pointer_size
,
8423 unsigned long offset_size
,
8425 debug_info
*debug_info_p
,
8428 unsigned long uvalue
= 0;
8429 unsigned char *block_start
= NULL
;
8430 unsigned int bytes_read
;
8437 case DW_FORM_ref_addr
:
8438 if (dwarf_version
== 2)
8440 uvalue
= byte_get (data
, pointer_size
);
8441 data
+= pointer_size
;
8443 else if (dwarf_version
== 3)
8445 uvalue
= byte_get (data
, offset_size
);
8446 data
+= offset_size
;
8450 error (_("Internal error: DWARF version is not 2 or 3.\n"));
8455 uvalue
= byte_get (data
, pointer_size
);
8456 data
+= pointer_size
;
8460 uvalue
= byte_get (data
, offset_size
);
8461 data
+= offset_size
;
8467 uvalue
= byte_get (data
++, 1);
8472 uvalue
= byte_get (data
, 2);
8478 uvalue
= byte_get (data
, 4);
8483 uvalue
= read_leb128 (data
, & bytes_read
, 1);
8487 case DW_FORM_ref_udata
:
8489 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8493 case DW_FORM_indirect
:
8494 form
= read_leb128 (data
, & bytes_read
, 0);
8497 printf (" %s", get_FORM_name (form
));
8498 return read_and_display_attr_value (attribute
, form
, data
,
8499 cu_offset
, pointer_size
,
8500 offset_size
, dwarf_version
,
8501 debug_info_p
, do_loc
);
8506 case DW_FORM_ref_addr
:
8508 printf (" <#%lx>", uvalue
);
8514 case DW_FORM_ref_udata
:
8516 printf (" <%lx>", uvalue
+ cu_offset
);
8522 printf (" %#lx", uvalue
);
8531 printf (" %ld", uvalue
);
8538 uvalue
= byte_get (data
, 4);
8539 printf (" %lx", uvalue
);
8540 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
8542 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8543 && num_debug_info_entries
== 0)
8545 if (sizeof (uvalue
) == 8)
8546 uvalue
= byte_get (data
, 8);
8548 error (_("DW_FORM_data8 is unsupported when sizeof (unsigned long) != 8\n"));
8553 case DW_FORM_string
:
8555 printf (" %s", data
);
8556 data
+= strlen ((char *) data
) + 1;
8560 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8561 block_start
= data
+ bytes_read
;
8563 data
= block_start
+ uvalue
;
8565 data
= display_block (block_start
, uvalue
);
8568 case DW_FORM_block1
:
8569 uvalue
= byte_get (data
, 1);
8570 block_start
= data
+ 1;
8572 data
= block_start
+ uvalue
;
8574 data
= display_block (block_start
, uvalue
);
8577 case DW_FORM_block2
:
8578 uvalue
= byte_get (data
, 2);
8579 block_start
= data
+ 2;
8581 data
= block_start
+ uvalue
;
8583 data
= display_block (block_start
, uvalue
);
8586 case DW_FORM_block4
:
8587 uvalue
= byte_get (data
, 4);
8588 block_start
= data
+ 4;
8590 data
= block_start
+ uvalue
;
8592 data
= display_block (block_start
, uvalue
);
8597 printf (_(" (indirect string, offset: 0x%lx): %s"),
8598 uvalue
, fetch_indirect_string (uvalue
));
8601 case DW_FORM_indirect
:
8602 /* Handled above. */
8606 warn (_("Unrecognized form: %lu\n"), form
);
8610 /* For some attributes we can display further information. */
8611 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8612 && num_debug_info_entries
== 0)
8616 case DW_AT_frame_base
:
8617 have_frame_base
= 1;
8618 case DW_AT_location
:
8619 case DW_AT_data_member_location
:
8620 case DW_AT_vtable_elem_location
:
8621 case DW_AT_allocated
:
8622 case DW_AT_associated
:
8623 case DW_AT_data_location
:
8625 case DW_AT_upper_bound
:
8626 case DW_AT_lower_bound
:
8627 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8629 /* Process location list. */
8630 unsigned int max
= debug_info_p
->max_loc_offsets
;
8631 unsigned int num
= debug_info_p
->num_loc_offsets
;
8633 if (max
== 0 || num
>= max
)
8636 debug_info_p
->loc_offsets
8637 = xcrealloc (debug_info_p
->loc_offsets
,
8638 max
, sizeof (*debug_info_p
->loc_offsets
));
8639 debug_info_p
->have_frame_base
8640 = xcrealloc (debug_info_p
->have_frame_base
,
8641 max
, sizeof (*debug_info_p
->have_frame_base
));
8642 debug_info_p
->max_loc_offsets
= max
;
8644 debug_info_p
->loc_offsets
[num
] = uvalue
;
8645 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
8646 debug_info_p
->num_loc_offsets
++;
8651 if (need_base_address
)
8652 debug_info_p
->base_address
= uvalue
;
8656 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8658 /* Process range list. */
8659 unsigned int max
= debug_info_p
->max_range_lists
;
8660 unsigned int num
= debug_info_p
->num_range_lists
;
8662 if (max
== 0 || num
>= max
)
8665 debug_info_p
->range_lists
8666 = xcrealloc (debug_info_p
->range_lists
,
8667 max
, sizeof (*debug_info_p
->range_lists
));
8668 debug_info_p
->max_range_lists
= max
;
8670 debug_info_p
->range_lists
[num
] = uvalue
;
8671 debug_info_p
->num_range_lists
++;
8690 case DW_INL_not_inlined
:
8691 printf (_("(not inlined)"));
8693 case DW_INL_inlined
:
8694 printf (_("(inlined)"));
8696 case DW_INL_declared_not_inlined
:
8697 printf (_("(declared as inline but ignored)"));
8699 case DW_INL_declared_inlined
:
8700 printf (_("(declared as inline and inlined)"));
8703 printf (_(" (Unknown inline attribute value: %lx)"), uvalue
);
8708 case DW_AT_language
:
8711 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
8712 case DW_LANG_C89
: printf ("(ANSI C)"); break;
8713 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
8714 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
8715 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
8716 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
8717 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
8718 case DW_LANG_Ada83
: printf ("(Ada)"); break;
8719 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
8720 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
8721 /* DWARF 2.1 values. */
8722 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
8723 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
8724 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
8725 /* MIPS extension. */
8726 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
8727 /* UPC extension. */
8728 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
8730 printf ("(Unknown: %lx)", uvalue
);
8735 case DW_AT_encoding
:
8738 case DW_ATE_void
: printf ("(void)"); break;
8739 case DW_ATE_address
: printf ("(machine address)"); break;
8740 case DW_ATE_boolean
: printf ("(boolean)"); break;
8741 case DW_ATE_complex_float
: printf ("(complex float)"); break;
8742 case DW_ATE_float
: printf ("(float)"); break;
8743 case DW_ATE_signed
: printf ("(signed)"); break;
8744 case DW_ATE_signed_char
: printf ("(signed char)"); break;
8745 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
8746 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
8747 /* DWARF 2.1 value. */
8748 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
8749 case DW_ATE_decimal_float
: printf ("(decimal float)"); break;
8751 if (uvalue
>= DW_ATE_lo_user
8752 && uvalue
<= DW_ATE_hi_user
)
8753 printf ("(user defined type)");
8755 printf ("(unknown type)");
8760 case DW_AT_accessibility
:
8763 case DW_ACCESS_public
: printf ("(public)"); break;
8764 case DW_ACCESS_protected
: printf ("(protected)"); break;
8765 case DW_ACCESS_private
: printf ("(private)"); break;
8767 printf ("(unknown accessibility)");
8772 case DW_AT_visibility
:
8775 case DW_VIS_local
: printf ("(local)"); break;
8776 case DW_VIS_exported
: printf ("(exported)"); break;
8777 case DW_VIS_qualified
: printf ("(qualified)"); break;
8778 default: printf ("(unknown visibility)"); break;
8782 case DW_AT_virtuality
:
8785 case DW_VIRTUALITY_none
: printf ("(none)"); break;
8786 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
8787 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
8788 default: printf ("(unknown virtuality)"); break;
8792 case DW_AT_identifier_case
:
8795 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
8796 case DW_ID_up_case
: printf ("(up_case)"); break;
8797 case DW_ID_down_case
: printf ("(down_case)"); break;
8798 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
8799 default: printf ("(unknown case)"); break;
8803 case DW_AT_calling_convention
:
8806 case DW_CC_normal
: printf ("(normal)"); break;
8807 case DW_CC_program
: printf ("(program)"); break;
8808 case DW_CC_nocall
: printf ("(nocall)"); break;
8810 if (uvalue
>= DW_CC_lo_user
8811 && uvalue
<= DW_CC_hi_user
)
8812 printf ("(user defined)");
8814 printf ("(unknown convention)");
8818 case DW_AT_ordering
:
8821 case -1: printf ("(undefined)"); break;
8822 case 0: printf ("(row major)"); break;
8823 case 1: printf ("(column major)"); break;
8827 case DW_AT_frame_base
:
8828 have_frame_base
= 1;
8829 case DW_AT_location
:
8830 case DW_AT_data_member_location
:
8831 case DW_AT_vtable_elem_location
:
8832 case DW_AT_allocated
:
8833 case DW_AT_associated
:
8834 case DW_AT_data_location
:
8836 case DW_AT_upper_bound
:
8837 case DW_AT_lower_bound
:
8840 int need_frame_base
;
8843 need_frame_base
= decode_location_expression (block_start
,
8848 if (need_frame_base
&& !have_frame_base
)
8849 printf (_(" [without DW_AT_frame_base]"));
8851 else if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8852 printf (_("(location list)"));
8864 get_AT_name (unsigned long attribute
)
8868 case DW_AT_sibling
: return "DW_AT_sibling";
8869 case DW_AT_location
: return "DW_AT_location";
8870 case DW_AT_name
: return "DW_AT_name";
8871 case DW_AT_ordering
: return "DW_AT_ordering";
8872 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
8873 case DW_AT_byte_size
: return "DW_AT_byte_size";
8874 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
8875 case DW_AT_bit_size
: return "DW_AT_bit_size";
8876 case DW_AT_element_list
: return "DW_AT_element_list";
8877 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
8878 case DW_AT_low_pc
: return "DW_AT_low_pc";
8879 case DW_AT_high_pc
: return "DW_AT_high_pc";
8880 case DW_AT_language
: return "DW_AT_language";
8881 case DW_AT_member
: return "DW_AT_member";
8882 case DW_AT_discr
: return "DW_AT_discr";
8883 case DW_AT_discr_value
: return "DW_AT_discr_value";
8884 case DW_AT_visibility
: return "DW_AT_visibility";
8885 case DW_AT_import
: return "DW_AT_import";
8886 case DW_AT_string_length
: return "DW_AT_string_length";
8887 case DW_AT_common_reference
: return "DW_AT_common_reference";
8888 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
8889 case DW_AT_const_value
: return "DW_AT_const_value";
8890 case DW_AT_containing_type
: return "DW_AT_containing_type";
8891 case DW_AT_default_value
: return "DW_AT_default_value";
8892 case DW_AT_inline
: return "DW_AT_inline";
8893 case DW_AT_is_optional
: return "DW_AT_is_optional";
8894 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
8895 case DW_AT_producer
: return "DW_AT_producer";
8896 case DW_AT_prototyped
: return "DW_AT_prototyped";
8897 case DW_AT_return_addr
: return "DW_AT_return_addr";
8898 case DW_AT_start_scope
: return "DW_AT_start_scope";
8899 case DW_AT_stride_size
: return "DW_AT_stride_size";
8900 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
8901 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
8902 case DW_AT_accessibility
: return "DW_AT_accessibility";
8903 case DW_AT_address_class
: return "DW_AT_address_class";
8904 case DW_AT_artificial
: return "DW_AT_artificial";
8905 case DW_AT_base_types
: return "DW_AT_base_types";
8906 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
8907 case DW_AT_count
: return "DW_AT_count";
8908 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
8909 case DW_AT_decl_column
: return "DW_AT_decl_column";
8910 case DW_AT_decl_file
: return "DW_AT_decl_file";
8911 case DW_AT_decl_line
: return "DW_AT_decl_line";
8912 case DW_AT_declaration
: return "DW_AT_declaration";
8913 case DW_AT_discr_list
: return "DW_AT_discr_list";
8914 case DW_AT_encoding
: return "DW_AT_encoding";
8915 case DW_AT_external
: return "DW_AT_external";
8916 case DW_AT_frame_base
: return "DW_AT_frame_base";
8917 case DW_AT_friend
: return "DW_AT_friend";
8918 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
8919 case DW_AT_macro_info
: return "DW_AT_macro_info";
8920 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
8921 case DW_AT_priority
: return "DW_AT_priority";
8922 case DW_AT_segment
: return "DW_AT_segment";
8923 case DW_AT_specification
: return "DW_AT_specification";
8924 case DW_AT_static_link
: return "DW_AT_static_link";
8925 case DW_AT_type
: return "DW_AT_type";
8926 case DW_AT_use_location
: return "DW_AT_use_location";
8927 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
8928 case DW_AT_virtuality
: return "DW_AT_virtuality";
8929 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
8930 /* DWARF 2.1 values. */
8931 case DW_AT_allocated
: return "DW_AT_allocated";
8932 case DW_AT_associated
: return "DW_AT_associated";
8933 case DW_AT_data_location
: return "DW_AT_data_location";
8934 case DW_AT_stride
: return "DW_AT_stride";
8935 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
8936 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
8937 case DW_AT_extension
: return "DW_AT_extension";
8938 case DW_AT_ranges
: return "DW_AT_ranges";
8939 case DW_AT_trampoline
: return "DW_AT_trampoline";
8940 case DW_AT_call_column
: return "DW_AT_call_column";
8941 case DW_AT_call_file
: return "DW_AT_call_file";
8942 case DW_AT_call_line
: return "DW_AT_call_line";
8943 /* SGI/MIPS extensions. */
8944 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
8945 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
8946 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
8947 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
8948 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
8949 case DW_AT_MIPS_software_pipeline_depth
:
8950 return "DW_AT_MIPS_software_pipeline_depth";
8951 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
8952 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
8953 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
8954 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
8955 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
8956 /* GNU extensions. */
8957 case DW_AT_sf_names
: return "DW_AT_sf_names";
8958 case DW_AT_src_info
: return "DW_AT_src_info";
8959 case DW_AT_mac_info
: return "DW_AT_mac_info";
8960 case DW_AT_src_coords
: return "DW_AT_src_coords";
8961 case DW_AT_body_begin
: return "DW_AT_body_begin";
8962 case DW_AT_body_end
: return "DW_AT_body_end";
8963 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
8964 /* UPC extension. */
8965 case DW_AT_upc_threads_scaled
: return "DW_AT_upc_threads_scaled";
8968 static char buffer
[100];
8970 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
8977 static unsigned char *
8978 read_and_display_attr (unsigned long attribute
,
8980 unsigned char *data
,
8981 unsigned long cu_offset
,
8982 unsigned long pointer_size
,
8983 unsigned long offset_size
,
8985 debug_info
*debug_info_p
,
8989 printf (" %-18s:", get_AT_name (attribute
));
8990 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
8991 pointer_size
, offset_size
,
8992 dwarf_version
, debug_info_p
,
9000 /* Process the contents of a .debug_info section. If do_loc is non-zero
9001 then we are scanning for location lists and we do not want to display
9002 anything to the user. */
9005 process_debug_info (struct dwarf_section
*section
, void *file
,
9008 unsigned char *start
= section
->start
;
9009 unsigned char *end
= start
+ section
->size
;
9010 unsigned char *section_begin
;
9012 unsigned int num_units
= 0;
9014 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
9015 && num_debug_info_entries
== 0)
9017 unsigned long length
;
9019 /* First scan the section to get the number of comp units. */
9020 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
9023 /* Read the first 4 bytes. For a 32-bit DWARF section, this
9024 will be the length. For a 64-bit DWARF section, it'll be
9025 the escape code 0xffffffff followed by an 8 byte length. */
9026 length
= byte_get (section_begin
, 4);
9028 if (length
== 0xffffffff)
9030 length
= byte_get (section_begin
+ 4, 8);
9031 section_begin
+= length
+ 12;
9034 section_begin
+= length
+ 4;
9039 error (_("No comp units in %s section ?"), section
->name
);
9043 /* Then allocate an array to hold the information. */
9044 debug_information
= cmalloc (num_units
,
9045 sizeof (* debug_information
));
9046 if (debug_information
== NULL
)
9048 error (_("Not enough memory for a debug info array of %u entries"),
9056 printf (_("The section %s contains:\n\n"), section
->name
);
9058 load_debug_section (&debug_str_section
, file
);
9061 load_debug_section (&debug_abbrev_section
, file
);
9062 if (debug_abbrev_section
.start
== NULL
)
9064 warn (_("Unable to locate %s section!\n"),
9065 debug_abbrev_section
.name
);
9069 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
9071 DWARF2_Internal_CompUnit compunit
;
9072 unsigned char *hdrptr
;
9073 unsigned char *cu_abbrev_offset_ptr
;
9074 unsigned char *tags
;
9076 unsigned long cu_offset
;
9078 int initial_length_size
;
9082 compunit
.cu_length
= byte_get (hdrptr
, 4);
9085 if (compunit
.cu_length
== 0xffffffff)
9087 compunit
.cu_length
= byte_get (hdrptr
, 8);
9090 initial_length_size
= 12;
9095 initial_length_size
= 4;
9098 compunit
.cu_version
= byte_get (hdrptr
, 2);
9101 cu_offset
= start
- section_begin
;
9102 start
+= compunit
.cu_length
+ initial_length_size
;
9104 cu_abbrev_offset_ptr
= hdrptr
;
9105 compunit
.cu_abbrev_offset
= byte_get (hdrptr
, offset_size
);
9106 hdrptr
+= offset_size
;
9108 compunit
.cu_pointer_size
= byte_get (hdrptr
, 1);
9110 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
9111 && num_debug_info_entries
== 0)
9113 debug_information
[unit
].cu_offset
= cu_offset
;
9114 debug_information
[unit
].pointer_size
9115 = compunit
.cu_pointer_size
;
9116 debug_information
[unit
].base_address
= 0;
9117 debug_information
[unit
].loc_offsets
= NULL
;
9118 debug_information
[unit
].have_frame_base
= NULL
;
9119 debug_information
[unit
].max_loc_offsets
= 0;
9120 debug_information
[unit
].num_loc_offsets
= 0;
9121 debug_information
[unit
].range_lists
= NULL
;
9122 debug_information
[unit
].max_range_lists
= 0;
9123 debug_information
[unit
].num_range_lists
= 0;
9130 printf (_(" Compilation Unit @ offset 0x%lx:\n"), cu_offset
);
9131 printf (_(" Length: %ld\n"), compunit
.cu_length
);
9132 printf (_(" Version: %d\n"), compunit
.cu_version
);
9133 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
9134 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
9137 if (compunit
.cu_version
!= 2 && compunit
.cu_version
!= 3)
9139 warn (_("Only version 2 and 3 DWARF debug information is currently supported.\n"));
9145 /* Process the abbrevs used by this compilation unit. */
9146 process_abbrev_section
9147 ((unsigned char *) debug_abbrev_section
.start
9148 + compunit
.cu_abbrev_offset
,
9149 (unsigned char *) debug_abbrev_section
.start
9150 + debug_abbrev_section
.size
);
9153 while (tags
< start
)
9155 unsigned int bytes_read
;
9156 unsigned long abbrev_number
;
9157 abbrev_entry
*entry
;
9160 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
9163 /* A null DIE marks the end of a list of children. */
9164 if (abbrev_number
== 0)
9170 /* Scan through the abbreviation list until we reach the
9172 for (entry
= first_abbrev
;
9173 entry
&& entry
->entry
!= abbrev_number
;
9174 entry
= entry
->next
)
9179 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
9185 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
9187 (unsigned long) (tags
- section_begin
9190 get_TAG_name (entry
->tag
));
9195 need_base_address
= 0;
9197 case DW_TAG_compile_unit
:
9198 need_base_address
= 1;
9200 case DW_TAG_entry_point
:
9201 case DW_TAG_inlined_subroutine
:
9202 case DW_TAG_subprogram
:
9203 need_base_address
= 0;
9204 /* Assuming that there is no DW_AT_frame_base. */
9205 have_frame_base
= 0;
9209 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
9210 tags
= read_and_display_attr (attr
->attribute
,
9213 compunit
.cu_pointer_size
,
9215 compunit
.cu_version
,
9216 &debug_information
[unit
],
9219 if (entry
->children
)
9224 free_debug_section (&debug_abbrev_section
);
9226 /* Set num_debug_info_entries here so that it can be used to check if
9227 we need to process .debug_loc and .debug_ranges sections. */
9228 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
9229 && num_debug_info_entries
== 0)
9230 num_debug_info_entries
= num_units
;
9234 free_debug_section (&debug_str_section
);
9242 /* Retrieve the pointer size associated with the given compilation unit.
9243 Optionally the offset of this unit into the .debug_info section is
9244 also retutned. If there is no .debug_info section then an error
9245 message is issued and 0 is returned. If the requested comp unit has
9246 not been defined in the .debug_info section then a warning message
9247 is issued and the last know pointer size is returned. This message
9248 is only issued once per section dumped per file dumped. */
9251 get_pointer_size_and_offset_of_comp_unit (unsigned int comp_unit
,
9252 const char * section_name
,
9253 unsigned long * offset_return
)
9255 unsigned long offset
= 0;
9257 if (num_debug_info_entries
== 0)
9258 error (_("%s section needs a populated .debug_info section\n"),
9261 else if (comp_unit
>= num_debug_info_entries
)
9263 if (!warned_about_missing_comp_units
)
9265 warn (_("%s section has more comp units than .debug_info section\n"),
9267 warn (_("assuming that the pointer size is %d, from the last comp unit in .debug_info\n\n"),
9269 warned_about_missing_comp_units
= TRUE
;
9274 last_pointer_size
= debug_information
[comp_unit
].pointer_size
;
9275 offset
= debug_information
[comp_unit
].cu_offset
;
9278 if (offset_return
!= NULL
)
9279 * offset_return
= offset
;
9281 return last_pointer_size
;
9284 /* Locate and scan the .debug_info section in the file and record the pointer
9285 sizes and offsets for the compilation units in it. Usually an executable
9286 will have just one pointer size, but this is not guaranteed, and so we try
9287 not to make any assumptions. Returns zero upon failure, or the number of
9288 compilation units upon success. */
9291 get_debug_info (void * file
)
9293 Elf_Internal_Shdr
* section
;
9294 struct dwarf_section sec
;
9297 /* Reset the last pointer size so that we can issue correct error
9298 messages if we are displaying the contents of more than one section. */
9299 last_pointer_size
= 0;
9300 warned_about_missing_comp_units
= FALSE
;
9302 /* If we already have the information there is nothing else to do. */
9303 if (num_debug_info_entries
> 0)
9304 return num_debug_info_entries
;
9306 sec
.name
= ".debug_info";
9307 section
= find_section (sec
.name
);
9308 if (section
== NULL
)
9311 sec
.start
= get_data (NULL
, file
, section
->sh_offset
, 1,
9313 _("extracting information from .debug_info section"));
9314 if (sec
.start
== NULL
)
9317 sec
.address
= section
->sh_addr
;
9318 sec
.size
= section
->sh_size
;
9319 ret
= (debug_apply_rela_addends (file
, section
, sec
.start
)
9320 && process_debug_info (&sec
, file
, 1));
9324 return ret
? num_debug_info_entries
: 0;
9328 display_debug_lines (struct dwarf_section
*section
, void *file
)
9330 unsigned char *start
= section
->start
;
9331 unsigned char *data
= start
;
9332 unsigned char *end
= start
+ section
->size
;
9333 unsigned int comp_unit
= 0;
9335 printf (_("\nDump of debug contents of section %s:\n\n"),
9338 get_debug_info (file
);
9342 DWARF2_Internal_LineInfo info
;
9343 unsigned char *standard_opcodes
;
9344 unsigned char *end_of_sequence
;
9345 unsigned char *hdrptr
;
9346 unsigned int pointer_size
;
9347 int initial_length_size
;
9353 /* Check the length of the block. */
9354 info
.li_length
= byte_get (hdrptr
, 4);
9357 if (info
.li_length
== 0xffffffff)
9359 /* This section is 64-bit DWARF 3. */
9360 info
.li_length
= byte_get (hdrptr
, 8);
9363 initial_length_size
= 12;
9368 initial_length_size
= 4;
9371 if (info
.li_length
+ initial_length_size
> section
->size
)
9374 (_("The line info appears to be corrupt - the section is too small\n"));
9378 /* Check its version number. */
9379 info
.li_version
= byte_get (hdrptr
, 2);
9381 if (info
.li_version
!= 2 && info
.li_version
!= 3)
9383 warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
9387 info
.li_prologue_length
= byte_get (hdrptr
, offset_size
);
9388 hdrptr
+= offset_size
;
9389 info
.li_min_insn_length
= byte_get (hdrptr
, 1);
9391 info
.li_default_is_stmt
= byte_get (hdrptr
, 1);
9393 info
.li_line_base
= byte_get (hdrptr
, 1);
9395 info
.li_line_range
= byte_get (hdrptr
, 1);
9397 info
.li_opcode_base
= byte_get (hdrptr
, 1);
9400 /* Sign extend the line base field. */
9401 info
.li_line_base
<<= 24;
9402 info
.li_line_base
>>= 24;
9404 /* Get the pointer size from the comp unit associated
9405 with this block of line number information. */
9406 pointer_size
= get_pointer_size_and_offset_of_comp_unit
9407 (comp_unit
, ".debug_line", NULL
);
9410 printf (_(" Length: %ld\n"), info
.li_length
);
9411 printf (_(" DWARF Version: %d\n"), info
.li_version
);
9412 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
9413 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
9414 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
9415 printf (_(" Line Base: %d\n"), info
.li_line_base
);
9416 printf (_(" Line Range: %d\n"), info
.li_line_range
);
9417 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
9418 printf (_(" (Pointer size: %u)%s\n"),
9420 warned_about_missing_comp_units
? " [assumed]" : "" );
9422 end_of_sequence
= data
+ info
.li_length
+ initial_length_size
;
9424 reset_state_machine (info
.li_default_is_stmt
);
9426 /* Display the contents of the Opcodes table. */
9427 standard_opcodes
= hdrptr
;
9429 printf (_("\n Opcodes:\n"));
9431 for (i
= 1; i
< info
.li_opcode_base
; i
++)
9432 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
9434 /* Display the contents of the Directory table. */
9435 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
9438 printf (_("\n The Directory Table is empty.\n"));
9441 printf (_("\n The Directory Table:\n"));
9445 printf (_(" %s\n"), data
);
9447 data
+= strlen ((char *) data
) + 1;
9451 /* Skip the NUL at the end of the table. */
9454 /* Display the contents of the File Name table. */
9456 printf (_("\n The File Name Table is empty.\n"));
9459 printf (_("\n The File Name Table:\n"));
9460 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
9464 unsigned char *name
;
9465 unsigned int bytes_read
;
9467 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
9470 data
+= strlen ((char *) data
) + 1;
9472 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9474 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9476 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9478 printf (_("%s\n"), name
);
9482 /* Skip the NUL at the end of the table. */
9485 /* Now display the statements. */
9486 printf (_("\n Line Number Statements:\n"));
9488 while (data
< end_of_sequence
)
9490 unsigned char op_code
;
9492 unsigned long int uladv
;
9493 unsigned int bytes_read
;
9497 if (op_code
>= info
.li_opcode_base
)
9499 op_code
-= info
.li_opcode_base
;
9500 uladv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
9501 state_machine_regs
.address
+= uladv
;
9502 printf (_(" Special opcode %d: advance Address by %lu to 0x%lx"),
9503 op_code
, uladv
, state_machine_regs
.address
);
9504 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
9505 state_machine_regs
.line
+= adv
;
9506 printf (_(" and Line by %d to %d\n"),
9507 adv
, state_machine_regs
.line
);
9509 else switch (op_code
)
9511 case DW_LNS_extended_op
:
9512 if (pointer_size
== 0)
9514 warn (_("Extend line ops need a valid pointer size, guessing at 4\n"));
9518 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
9523 printf (_(" Copy\n"));
9526 case DW_LNS_advance_pc
:
9527 uladv
= read_leb128 (data
, & bytes_read
, 0);
9528 uladv
*= info
.li_min_insn_length
;
9530 state_machine_regs
.address
+= uladv
;
9531 printf (_(" Advance PC by %lu to 0x%lx\n"), uladv
,
9532 state_machine_regs
.address
);
9535 case DW_LNS_advance_line
:
9536 adv
= read_leb128 (data
, & bytes_read
, 1);
9538 state_machine_regs
.line
+= adv
;
9539 printf (_(" Advance Line by %d to %d\n"), adv
,
9540 state_machine_regs
.line
);
9543 case DW_LNS_set_file
:
9544 adv
= read_leb128 (data
, & bytes_read
, 0);
9546 printf (_(" Set File Name to entry %d in the File Name Table\n"),
9548 state_machine_regs
.file
= adv
;
9551 case DW_LNS_set_column
:
9552 uladv
= read_leb128 (data
, & bytes_read
, 0);
9554 printf (_(" Set column to %lu\n"), uladv
);
9555 state_machine_regs
.column
= uladv
;
9558 case DW_LNS_negate_stmt
:
9559 adv
= state_machine_regs
.is_stmt
;
9561 printf (_(" Set is_stmt to %d\n"), adv
);
9562 state_machine_regs
.is_stmt
= adv
;
9565 case DW_LNS_set_basic_block
:
9566 printf (_(" Set basic block\n"));
9567 state_machine_regs
.basic_block
= 1;
9570 case DW_LNS_const_add_pc
:
9571 uladv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
9572 * info
.li_min_insn_length
);
9573 state_machine_regs
.address
+= uladv
;
9574 printf (_(" Advance PC by constant %lu to 0x%lx\n"), uladv
,
9575 state_machine_regs
.address
);
9578 case DW_LNS_fixed_advance_pc
:
9579 uladv
= byte_get (data
, 2);
9581 state_machine_regs
.address
+= uladv
;
9582 printf (_(" Advance PC by fixed size amount %lu to 0x%lx\n"),
9583 uladv
, state_machine_regs
.address
);
9586 case DW_LNS_set_prologue_end
:
9587 printf (_(" Set prologue_end to true\n"));
9590 case DW_LNS_set_epilogue_begin
:
9591 printf (_(" Set epilogue_begin to true\n"));
9594 case DW_LNS_set_isa
:
9595 uladv
= read_leb128 (data
, & bytes_read
, 0);
9597 printf (_(" Set ISA to %lu\n"), uladv
);
9601 printf (_(" Unknown opcode %d with operands: "), op_code
);
9603 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
9605 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
9606 i
== 1 ? "" : ", ");
9620 display_debug_pubnames (struct dwarf_section
*section
,
9621 void *file ATTRIBUTE_UNUSED
)
9623 DWARF2_Internal_PubNames pubnames
;
9624 unsigned char *start
= section
->start
;
9625 unsigned char *end
= start
+ section
->size
;
9627 printf (_("Contents of the %s section:\n\n"), section
->name
);
9631 unsigned char *data
;
9632 unsigned long offset
;
9633 int offset_size
, initial_length_size
;
9637 pubnames
.pn_length
= byte_get (data
, 4);
9639 if (pubnames
.pn_length
== 0xffffffff)
9641 pubnames
.pn_length
= byte_get (data
, 8);
9644 initial_length_size
= 12;
9649 initial_length_size
= 4;
9652 pubnames
.pn_version
= byte_get (data
, 2);
9654 pubnames
.pn_offset
= byte_get (data
, offset_size
);
9655 data
+= offset_size
;
9656 pubnames
.pn_size
= byte_get (data
, offset_size
);
9657 data
+= offset_size
;
9659 start
+= pubnames
.pn_length
+ initial_length_size
;
9661 if (pubnames
.pn_version
!= 2 && pubnames
.pn_version
!= 3)
9663 static int warned
= 0;
9667 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
9674 printf (_(" Length: %ld\n"),
9675 pubnames
.pn_length
);
9676 printf (_(" Version: %d\n"),
9677 pubnames
.pn_version
);
9678 printf (_(" Offset into .debug_info section: %ld\n"),
9679 pubnames
.pn_offset
);
9680 printf (_(" Size of area in .debug_info section: %ld\n"),
9683 printf (_("\n Offset\tName\n"));
9687 offset
= byte_get (data
, offset_size
);
9691 data
+= offset_size
;
9692 printf (" %-6ld\t\t%s\n", offset
, data
);
9693 data
+= strlen ((char *) data
) + 1;
9696 while (offset
!= 0);
9704 display_debug_macinfo (struct dwarf_section
*section
,
9705 void *file ATTRIBUTE_UNUSED
)
9707 unsigned char *start
= section
->start
;
9708 unsigned char *end
= start
+ section
->size
;
9709 unsigned char *curr
= start
;
9710 unsigned int bytes_read
;
9711 enum dwarf_macinfo_record_type op
;
9713 printf (_("Contents of the %s section:\n\n"), section
->name
);
9717 unsigned int lineno
;
9725 case DW_MACINFO_start_file
:
9727 unsigned int filenum
;
9729 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9731 filenum
= read_leb128 (curr
, & bytes_read
, 0);
9734 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
9739 case DW_MACINFO_end_file
:
9740 printf (_(" DW_MACINFO_end_file\n"));
9743 case DW_MACINFO_define
:
9744 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9746 string
= (char *) curr
;
9747 curr
+= strlen (string
) + 1;
9748 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
9752 case DW_MACINFO_undef
:
9753 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9755 string
= (char *) curr
;
9756 curr
+= strlen (string
) + 1;
9757 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
9761 case DW_MACINFO_vendor_ext
:
9763 unsigned int constant
;
9765 constant
= read_leb128 (curr
, & bytes_read
, 0);
9767 string
= (char *) curr
;
9768 curr
+= strlen (string
) + 1;
9769 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
9781 display_debug_abbrev (struct dwarf_section
*section
,
9782 void *file ATTRIBUTE_UNUSED
)
9784 abbrev_entry
*entry
;
9785 unsigned char *start
= section
->start
;
9786 unsigned char *end
= start
+ section
->size
;
9788 printf (_("Contents of the %s section:\n\n"), section
->name
);
9792 start
= process_abbrev_section (start
, end
);
9794 if (first_abbrev
== NULL
)
9797 printf (_(" Number TAG\n"));
9799 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
9803 printf (_(" %ld %s [%s]\n"),
9805 get_TAG_name (entry
->tag
),
9806 entry
->children
? _("has children") : _("no children"));
9808 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
9809 printf (_(" %-18s %s\n"),
9810 get_AT_name (attr
->attribute
),
9811 get_FORM_name (attr
->form
));
9824 display_debug_loc (struct dwarf_section
*section
, void *file
)
9826 unsigned char *start
= section
->start
;
9827 unsigned char *section_end
;
9828 unsigned long bytes
;
9829 unsigned char *section_begin
= start
;
9830 unsigned int num_loc_list
= 0;
9831 unsigned long last_offset
= 0;
9832 unsigned int first
= 0;
9835 int seen_first_offset
= 0;
9836 int use_debug_info
= 1;
9837 unsigned char *next
;
9839 bytes
= section
->size
;
9840 section_end
= start
+ bytes
;
9844 printf (_("\nThe %s section is empty.\n"), section
->name
);
9848 get_debug_info (file
);
9850 /* Check the order of location list in .debug_info section. If
9851 offsets of location lists are in the ascending order, we can
9852 use `debug_information' directly. */
9853 for (i
= 0; i
< num_debug_info_entries
; i
++)
9857 num
= debug_information
[i
].num_loc_offsets
;
9858 num_loc_list
+= num
;
9860 /* Check if we can use `debug_information' directly. */
9861 if (use_debug_info
&& num
!= 0)
9863 if (!seen_first_offset
)
9865 /* This is the first location list. */
9866 last_offset
= debug_information
[i
].loc_offsets
[0];
9868 seen_first_offset
= 1;
9874 for (; j
< num
; j
++)
9877 debug_information
[i
].loc_offsets
[j
])
9882 last_offset
= debug_information
[i
].loc_offsets
[j
];
9887 if (!use_debug_info
)
9888 /* FIXME: Should we handle this case? */
9889 error (_("Location lists in .debug_info section aren't in ascending order!\n"));
9891 if (!seen_first_offset
)
9892 error (_("No location lists in .debug_info section!\n"));
9894 if (debug_information
[first
].loc_offsets
[0] != 0)
9895 warn (_("Location lists in %s section start at 0x%lx\n"),
9896 section
->name
, debug_information
[first
].loc_offsets
[0]);
9898 printf (_("Contents of the %s section:\n\n"), section
->name
);
9899 printf (_(" Offset Begin End Expression\n"));
9901 seen_first_offset
= 0;
9902 for (i
= first
; i
< num_debug_info_entries
; i
++)
9904 unsigned long begin
;
9906 unsigned short length
;
9907 unsigned long offset
;
9908 unsigned int pointer_size
;
9909 unsigned long cu_offset
;
9910 unsigned long base_address
;
9911 int need_frame_base
;
9914 pointer_size
= debug_information
[i
].pointer_size
;
9915 cu_offset
= debug_information
[i
].cu_offset
;
9917 for (j
= 0; j
< debug_information
[i
].num_loc_offsets
; j
++)
9919 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
9920 offset
= debug_information
[i
].loc_offsets
[j
];
9921 next
= section_begin
+ offset
;
9922 base_address
= debug_information
[i
].base_address
;
9924 if (!seen_first_offset
)
9925 seen_first_offset
= 1;
9929 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
9930 (long)(start
- section_begin
), (long)(next
- section_begin
));
9931 else if (start
> next
)
9932 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
9933 (long)(start
- section_begin
), (long)(next
- section_begin
));
9937 if (offset
>= bytes
)
9939 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
9946 if (start
+ 2 * pointer_size
> section_end
)
9948 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
9953 begin
= byte_get (start
, pointer_size
);
9954 start
+= pointer_size
;
9955 end
= byte_get (start
, pointer_size
);
9956 start
+= pointer_size
;
9958 if (begin
== 0 && end
== 0)
9960 printf (_(" %8.8lx <End of list>\n"), offset
);
9964 /* Check base address specifiers. */
9965 if (begin
== -1UL && end
!= -1UL)
9968 printf (_(" %8.8lx %8.8lx %8.8lx (base address)\n"),
9969 offset
, begin
, end
);
9973 if (start
+ 2 > section_end
)
9975 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
9980 length
= byte_get (start
, 2);
9983 if (start
+ length
> section_end
)
9985 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
9990 printf (" %8.8lx %8.8lx %8.8lx (",
9991 offset
, begin
+ base_address
, end
+ base_address
);
9992 need_frame_base
= decode_location_expression (start
,
9998 if (need_frame_base
&& !has_frame_base
)
9999 printf (_(" [without DW_AT_frame_base]"));
10002 fputs (_(" (start == end)"), stdout
);
10003 else if (begin
> end
)
10004 fputs (_(" (start > end)"), stdout
);
10016 display_debug_str (struct dwarf_section
*section
,
10017 void *file ATTRIBUTE_UNUSED
)
10019 unsigned char *start
= section
->start
;
10020 unsigned long bytes
= section
->size
;
10021 bfd_vma addr
= section
->address
;
10025 printf (_("\nThe %s section is empty.\n"), section
->name
);
10029 printf (_("Contents of the %s section:\n\n"), section
->name
);
10037 lbytes
= (bytes
> 16 ? 16 : bytes
);
10039 printf (" 0x%8.8lx ", (unsigned long) addr
);
10041 for (j
= 0; j
< 16; j
++)
10044 printf ("%2.2x", start
[j
]);
10052 for (j
= 0; j
< lbytes
; j
++)
10055 if (k
>= ' ' && k
< 0x80)
10075 display_debug_info (struct dwarf_section
*section
, void *file
)
10077 return process_debug_info (section
, file
, 0);
10082 display_debug_aranges (struct dwarf_section
*section
,
10083 void *file ATTRIBUTE_UNUSED
)
10085 unsigned char *start
= section
->start
;
10086 unsigned char *end
= start
+ section
->size
;
10088 printf (_("The section %s contains:\n\n"), section
->name
);
10090 while (start
< end
)
10092 unsigned char *hdrptr
;
10093 DWARF2_Internal_ARange arange
;
10094 unsigned char *ranges
;
10095 unsigned long length
;
10096 unsigned long address
;
10099 int initial_length_size
;
10103 arange
.ar_length
= byte_get (hdrptr
, 4);
10106 if (arange
.ar_length
== 0xffffffff)
10108 arange
.ar_length
= byte_get (hdrptr
, 8);
10111 initial_length_size
= 12;
10116 initial_length_size
= 4;
10119 arange
.ar_version
= byte_get (hdrptr
, 2);
10122 arange
.ar_info_offset
= byte_get (hdrptr
, offset_size
);
10123 hdrptr
+= offset_size
;
10125 arange
.ar_pointer_size
= byte_get (hdrptr
, 1);
10128 arange
.ar_segment_size
= byte_get (hdrptr
, 1);
10131 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
10133 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
10137 printf (_(" Length: %ld\n"), arange
.ar_length
);
10138 printf (_(" Version: %d\n"), arange
.ar_version
);
10139 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
10140 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
10141 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
10143 printf (_("\n Address Length\n"));
10147 /* Must pad to an alignment boundary that is twice the pointer size. */
10148 excess
= (hdrptr
- start
) % (2 * arange
.ar_pointer_size
);
10150 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
10154 address
= byte_get (ranges
, arange
.ar_pointer_size
);
10156 ranges
+= arange
.ar_pointer_size
;
10158 length
= byte_get (ranges
, arange
.ar_pointer_size
);
10160 ranges
+= arange
.ar_pointer_size
;
10162 /* A pair of zeros marks the end of the list. */
10163 if (address
== 0 && length
== 0)
10166 printf (" %8.8lx %lu\n", address
, length
);
10169 start
+= arange
.ar_length
+ initial_length_size
;
10178 display_debug_ranges (struct dwarf_section
*section
,
10179 void *file ATTRIBUTE_UNUSED
)
10181 unsigned char *start
= section
->start
;
10182 unsigned char *section_end
;
10183 unsigned long bytes
;
10184 unsigned char *section_begin
= start
;
10185 unsigned int num_range_list
= 0;
10186 unsigned long last_offset
= 0;
10187 unsigned int first
= 0;
10190 int seen_first_offset
= 0;
10191 int use_debug_info
= 1;
10192 unsigned char *next
;
10194 bytes
= section
->size
;
10195 section_end
= start
+ bytes
;
10199 printf (_("\nThe %s section is empty.\n"), section
->name
);
10203 get_debug_info (file
);
10205 /* Check the order of range list in .debug_info section. If
10206 offsets of range lists are in the ascending order, we can
10207 use `debug_information' directly. */
10208 for (i
= 0; i
< num_debug_info_entries
; i
++)
10212 num
= debug_information
[i
].num_range_lists
;
10213 num_range_list
+= num
;
10215 /* Check if we can use `debug_information' directly. */
10216 if (use_debug_info
&& num
!= 0)
10218 if (!seen_first_offset
)
10220 /* This is the first range list. */
10221 last_offset
= debug_information
[i
].range_lists
[0];
10223 seen_first_offset
= 1;
10229 for (; j
< num
; j
++)
10232 debug_information
[i
].range_lists
[j
])
10234 use_debug_info
= 0;
10237 last_offset
= debug_information
[i
].range_lists
[j
];
10242 if (!use_debug_info
)
10243 /* FIXME: Should we handle this case? */
10244 error (_("Range lists in .debug_info section aren't in ascending order!\n"));
10246 if (!seen_first_offset
)
10247 error (_("No range lists in .debug_info section!\n"));
10249 if (debug_information
[first
].range_lists
[0] != 0)
10250 warn (_("Range lists in %s section start at 0x%lx\n"),
10251 section
->name
, debug_information
[first
].range_lists
[0]);
10253 printf (_("Contents of the %s section:\n\n"), section
->name
);
10254 printf (_(" Offset Begin End\n"));
10256 seen_first_offset
= 0;
10257 for (i
= first
; i
< num_debug_info_entries
; i
++)
10259 unsigned long begin
;
10261 unsigned long offset
;
10262 unsigned int pointer_size
;
10263 unsigned long base_address
;
10265 pointer_size
= debug_information
[i
].pointer_size
;
10267 for (j
= 0; j
< debug_information
[i
].num_range_lists
; j
++)
10269 offset
= debug_information
[i
].range_lists
[j
];
10270 next
= section_begin
+ offset
;
10271 base_address
= debug_information
[i
].base_address
;
10273 if (!seen_first_offset
)
10274 seen_first_offset
= 1;
10278 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
10279 (long)(start
- section_begin
),
10280 (long)(next
- section_begin
), section
->name
);
10281 else if (start
> next
)
10282 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
10283 (long)(start
- section_begin
),
10284 (long)(next
- section_begin
), section
->name
);
10290 begin
= byte_get (start
, pointer_size
);
10291 start
+= pointer_size
;
10292 end
= byte_get (start
, pointer_size
);
10293 start
+= pointer_size
;
10295 if (begin
== 0 && end
== 0)
10297 printf (_(" %8.8lx <End of list>\n"), offset
);
10301 /* Check base address specifiers. */
10302 if (begin
== -1UL && end
!= -1UL)
10304 base_address
= end
;
10305 printf (" %8.8lx %8.8lx %8.8lx (base address)\n",
10306 offset
, begin
, end
);
10310 printf (" %8.8lx %8.8lx %8.8lx",
10311 offset
, begin
+ base_address
, end
+ base_address
);
10314 fputs (_(" (start == end)"), stdout
);
10315 else if (begin
> end
)
10316 fputs (_(" (start > end)"), stdout
);
10326 typedef struct Frame_Chunk
10328 struct Frame_Chunk
*next
;
10329 unsigned char *chunk_start
;
10331 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
10332 short int *col_type
;
10334 char *augmentation
;
10335 unsigned int code_factor
;
10337 unsigned long pc_begin
;
10338 unsigned long pc_range
;
10342 unsigned char fde_encoding
;
10343 unsigned char cfa_exp
;
10347 /* A marker for a col_type that means this column was never referenced
10348 in the frame info. */
10349 #define DW_CFA_unreferenced (-1)
10352 frame_need_space (Frame_Chunk
*fc
, int reg
)
10354 int prev
= fc
->ncols
;
10356 if (reg
< fc
->ncols
)
10359 fc
->ncols
= reg
+ 1;
10360 fc
->col_type
= xcrealloc (fc
->col_type
, fc
->ncols
, sizeof (short int));
10361 fc
->col_offset
= xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
10363 while (prev
< fc
->ncols
)
10365 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
10366 fc
->col_offset
[prev
] = 0;
10372 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, int *max_regs
)
10377 if (*max_regs
< fc
->ncols
)
10378 *max_regs
= fc
->ncols
;
10380 if (*need_col_headers
)
10382 *need_col_headers
= 0;
10384 printf (" LOC CFA ");
10386 for (r
= 0; r
< *max_regs
; r
++)
10387 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
10392 printf ("r%-4d", r
);
10398 printf ("%08lx ", fc
->pc_begin
);
10400 strcpy (tmp
, "exp");
10402 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
10403 printf ("%-8s ", tmp
);
10405 for (r
= 0; r
< fc
->ncols
; r
++)
10407 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
10409 switch (fc
->col_type
[r
])
10411 case DW_CFA_undefined
:
10414 case DW_CFA_same_value
:
10417 case DW_CFA_offset
:
10418 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
10420 case DW_CFA_register
:
10421 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
10423 case DW_CFA_expression
:
10424 strcpy (tmp
, "exp");
10427 strcpy (tmp
, "n/a");
10430 printf ("%-5s", tmp
);
10437 size_of_encoded_value (int encoding
)
10439 switch (encoding
& 0x7)
10442 case 0: return eh_addr_size
;
10450 get_encoded_value (unsigned char *data
, int encoding
)
10452 int size
= size_of_encoded_value (encoding
);
10453 if (encoding
& DW_EH_PE_signed
)
10454 return byte_get_signed (data
, size
);
10456 return byte_get (data
, size
);
10459 #define GET(N) byte_get (start, N); start += N
10460 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
10461 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
10464 display_debug_frames (struct dwarf_section
*section
,
10465 void *file ATTRIBUTE_UNUSED
)
10467 unsigned char *start
= section
->start
;
10468 unsigned char *end
= start
+ section
->size
;
10469 unsigned char *section_start
= start
;
10470 Frame_Chunk
*chunks
= 0;
10471 Frame_Chunk
*remembered_state
= 0;
10473 int is_eh
= streq (section
->name
, ".eh_frame");
10474 unsigned int length_return
;
10477 printf (_("The section %s contains:\n"), section
->name
);
10479 while (start
< end
)
10481 unsigned char *saved_start
;
10482 unsigned char *block_end
;
10483 unsigned long length
;
10484 unsigned long cie_id
;
10487 int need_col_headers
= 1;
10488 unsigned char *augmentation_data
= NULL
;
10489 unsigned long augmentation_data_len
= 0;
10490 int encoded_ptr_size
= eh_addr_size
;
10492 int initial_length_size
;
10494 saved_start
= start
;
10495 length
= byte_get (start
, 4); start
+= 4;
10499 printf ("\n%08lx ZERO terminator\n\n",
10500 (unsigned long)(saved_start
- section_start
));
10504 if (length
== 0xffffffff)
10506 length
= byte_get (start
, 8);
10509 initial_length_size
= 12;
10514 initial_length_size
= 4;
10517 block_end
= saved_start
+ length
+ initial_length_size
;
10518 cie_id
= byte_get (start
, offset_size
); start
+= offset_size
;
10520 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
10524 fc
= xmalloc (sizeof (Frame_Chunk
));
10525 memset (fc
, 0, sizeof (Frame_Chunk
));
10529 fc
->chunk_start
= saved_start
;
10531 fc
->col_type
= xmalloc (sizeof (short int));
10532 fc
->col_offset
= xmalloc (sizeof (int));
10533 frame_need_space (fc
, max_regs
-1);
10535 version
= *start
++;
10537 fc
->augmentation
= (char *) start
;
10538 start
= (unsigned char *) strchr ((char *) start
, '\0') + 1;
10540 if (fc
->augmentation
[0] == 'z')
10542 fc
->code_factor
= LEB ();
10543 fc
->data_factor
= SLEB ();
10552 augmentation_data_len
= LEB ();
10553 augmentation_data
= start
;
10554 start
+= augmentation_data_len
;
10556 else if (streq (fc
->augmentation
, "eh"))
10558 start
+= eh_addr_size
;
10559 fc
->code_factor
= LEB ();
10560 fc
->data_factor
= SLEB ();
10572 fc
->code_factor
= LEB ();
10573 fc
->data_factor
= SLEB ();
10585 if (do_debug_frames_interp
)
10586 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
10587 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
10588 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
10592 printf ("\n%08lx %08lx %08lx CIE\n",
10593 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
10594 printf (" Version: %d\n", version
);
10595 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
10596 printf (" Code alignment factor: %u\n", fc
->code_factor
);
10597 printf (" Data alignment factor: %d\n", fc
->data_factor
);
10598 printf (" Return address column: %d\n", fc
->ra
);
10600 if (augmentation_data_len
)
10603 printf (" Augmentation data: ");
10604 for (i
= 0; i
< augmentation_data_len
; ++i
)
10605 printf (" %02x", augmentation_data
[i
]);
10611 if (augmentation_data_len
)
10613 unsigned char *p
, *q
;
10614 p
= (unsigned char *) fc
->augmentation
+ 1;
10615 q
= augmentation_data
;
10621 else if (*p
== 'P')
10622 q
+= 1 + size_of_encoded_value (*q
);
10623 else if (*p
== 'R')
10624 fc
->fde_encoding
= *q
++;
10630 if (fc
->fde_encoding
)
10631 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
10634 frame_need_space (fc
, fc
->ra
);
10638 unsigned char *look_for
;
10639 static Frame_Chunk fde_fc
;
10642 memset (fc
, 0, sizeof (Frame_Chunk
));
10644 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
10646 for (cie
= chunks
; cie
; cie
= cie
->next
)
10647 if (cie
->chunk_start
== look_for
)
10652 warn ("Invalid CIE pointer %08lx in FDE at %p\n",
10653 cie_id
, saved_start
);
10656 fc
->col_type
= xmalloc (sizeof (short int));
10657 fc
->col_offset
= xmalloc (sizeof (int));
10658 frame_need_space (fc
, max_regs
- 1);
10660 fc
->augmentation
= "";
10661 fc
->fde_encoding
= 0;
10665 fc
->ncols
= cie
->ncols
;
10666 fc
->col_type
= xcmalloc (fc
->ncols
, sizeof (short int));
10667 fc
->col_offset
= xcmalloc (fc
->ncols
, sizeof (int));
10668 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
10669 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
10670 fc
->augmentation
= cie
->augmentation
;
10671 fc
->code_factor
= cie
->code_factor
;
10672 fc
->data_factor
= cie
->data_factor
;
10673 fc
->cfa_reg
= cie
->cfa_reg
;
10674 fc
->cfa_offset
= cie
->cfa_offset
;
10676 frame_need_space (fc
, max_regs
-1);
10677 fc
->fde_encoding
= cie
->fde_encoding
;
10680 if (fc
->fde_encoding
)
10681 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
10683 fc
->pc_begin
= get_encoded_value (start
, fc
->fde_encoding
);
10684 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
10685 /* Don't adjust for relocatable file since there's
10686 invariably a pcrel reloc here, which we haven't
10688 && !is_relocatable
)
10689 fc
->pc_begin
+= section
->address
+ (start
- section_start
);
10690 start
+= encoded_ptr_size
;
10691 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
10692 start
+= encoded_ptr_size
;
10694 if (cie
->augmentation
[0] == 'z')
10696 augmentation_data_len
= LEB ();
10697 augmentation_data
= start
;
10698 start
+= augmentation_data_len
;
10701 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
10702 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
10703 (unsigned long)(cie
->chunk_start
- section_start
),
10704 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
10705 if (! do_debug_frames_interp
&& augmentation_data_len
)
10709 printf (" Augmentation data: ");
10710 for (i
= 0; i
< augmentation_data_len
; ++i
)
10711 printf (" %02x", augmentation_data
[i
]);
10717 /* At this point, fc is the current chunk, cie (if any) is set, and
10718 we're about to interpret instructions for the chunk. */
10719 /* ??? At present we need to do this always, since this sizes the
10720 fc->col_type and fc->col_offset arrays, which we write into always.
10721 We should probably split the interpreted and non-interpreted bits
10722 into two different routines, since there's so much that doesn't
10723 really overlap between them. */
10724 if (1 || do_debug_frames_interp
)
10726 /* Start by making a pass over the chunk, allocating storage
10727 and taking note of what registers are used. */
10728 unsigned char *tmp
= start
;
10730 while (start
< block_end
)
10733 unsigned long reg
, tmp
;
10740 /* Warning: if you add any more cases to this switch, be
10741 sure to add them to the corresponding switch below. */
10744 case DW_CFA_advance_loc
:
10746 case DW_CFA_offset
:
10748 frame_need_space (fc
, opa
);
10749 fc
->col_type
[opa
] = DW_CFA_undefined
;
10751 case DW_CFA_restore
:
10752 frame_need_space (fc
, opa
);
10753 fc
->col_type
[opa
] = DW_CFA_undefined
;
10755 case DW_CFA_set_loc
:
10756 start
+= encoded_ptr_size
;
10758 case DW_CFA_advance_loc1
:
10761 case DW_CFA_advance_loc2
:
10764 case DW_CFA_advance_loc4
:
10767 case DW_CFA_offset_extended
:
10768 reg
= LEB (); LEB ();
10769 frame_need_space (fc
, reg
);
10770 fc
->col_type
[reg
] = DW_CFA_undefined
;
10772 case DW_CFA_restore_extended
:
10774 frame_need_space (fc
, reg
);
10775 fc
->col_type
[reg
] = DW_CFA_undefined
;
10777 case DW_CFA_undefined
:
10779 frame_need_space (fc
, reg
);
10780 fc
->col_type
[reg
] = DW_CFA_undefined
;
10782 case DW_CFA_same_value
:
10784 frame_need_space (fc
, reg
);
10785 fc
->col_type
[reg
] = DW_CFA_undefined
;
10787 case DW_CFA_register
:
10788 reg
= LEB (); LEB ();
10789 frame_need_space (fc
, reg
);
10790 fc
->col_type
[reg
] = DW_CFA_undefined
;
10792 case DW_CFA_def_cfa
:
10795 case DW_CFA_def_cfa_register
:
10798 case DW_CFA_def_cfa_offset
:
10801 case DW_CFA_def_cfa_expression
:
10805 case DW_CFA_expression
:
10809 frame_need_space (fc
, reg
);
10810 fc
->col_type
[reg
] = DW_CFA_undefined
;
10812 case DW_CFA_offset_extended_sf
:
10813 reg
= LEB (); SLEB ();
10814 frame_need_space (fc
, reg
);
10815 fc
->col_type
[reg
] = DW_CFA_undefined
;
10817 case DW_CFA_def_cfa_sf
:
10820 case DW_CFA_def_cfa_offset_sf
:
10823 case DW_CFA_MIPS_advance_loc8
:
10826 case DW_CFA_GNU_args_size
:
10829 case DW_CFA_GNU_negative_offset_extended
:
10830 reg
= LEB (); LEB ();
10831 frame_need_space (fc
, reg
);
10832 fc
->col_type
[reg
] = DW_CFA_undefined
;
10841 /* Now we know what registers are used, make a second pass over
10842 the chunk, this time actually printing out the info. */
10844 while (start
< block_end
)
10847 unsigned long ul
, reg
, roffs
;
10856 /* Warning: if you add any more cases to this switch, be
10857 sure to add them to the corresponding switch above. */
10860 case DW_CFA_advance_loc
:
10861 if (do_debug_frames_interp
)
10862 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10864 printf (" DW_CFA_advance_loc: %d to %08lx\n",
10865 opa
* fc
->code_factor
,
10866 fc
->pc_begin
+ opa
* fc
->code_factor
);
10867 fc
->pc_begin
+= opa
* fc
->code_factor
;
10870 case DW_CFA_offset
:
10872 if (! do_debug_frames_interp
)
10873 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
10874 opa
, roffs
* fc
->data_factor
);
10875 fc
->col_type
[opa
] = DW_CFA_offset
;
10876 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
10879 case DW_CFA_restore
:
10880 if (! do_debug_frames_interp
)
10881 printf (" DW_CFA_restore: r%d\n", opa
);
10882 fc
->col_type
[opa
] = cie
->col_type
[opa
];
10883 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
10886 case DW_CFA_set_loc
:
10887 vma
= get_encoded_value (start
, fc
->fde_encoding
);
10888 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
10889 && !is_relocatable
)
10890 vma
+= section
->address
+ (start
- section_start
);
10891 start
+= encoded_ptr_size
;
10892 if (do_debug_frames_interp
)
10893 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10895 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
10896 fc
->pc_begin
= vma
;
10899 case DW_CFA_advance_loc1
:
10900 ofs
= byte_get (start
, 1); start
+= 1;
10901 if (do_debug_frames_interp
)
10902 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10904 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
10905 ofs
* fc
->code_factor
,
10906 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10907 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10910 case DW_CFA_advance_loc2
:
10911 ofs
= byte_get (start
, 2); start
+= 2;
10912 if (do_debug_frames_interp
)
10913 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10915 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
10916 ofs
* fc
->code_factor
,
10917 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10918 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10921 case DW_CFA_advance_loc4
:
10922 ofs
= byte_get (start
, 4); start
+= 4;
10923 if (do_debug_frames_interp
)
10924 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10926 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
10927 ofs
* fc
->code_factor
,
10928 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10929 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10932 case DW_CFA_offset_extended
:
10935 if (! do_debug_frames_interp
)
10936 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
10937 reg
, roffs
* fc
->data_factor
);
10938 fc
->col_type
[reg
] = DW_CFA_offset
;
10939 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
10942 case DW_CFA_restore_extended
:
10944 if (! do_debug_frames_interp
)
10945 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
10946 fc
->col_type
[reg
] = cie
->col_type
[reg
];
10947 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
10950 case DW_CFA_undefined
:
10952 if (! do_debug_frames_interp
)
10953 printf (" DW_CFA_undefined: r%ld\n", reg
);
10954 fc
->col_type
[reg
] = DW_CFA_undefined
;
10955 fc
->col_offset
[reg
] = 0;
10958 case DW_CFA_same_value
:
10960 if (! do_debug_frames_interp
)
10961 printf (" DW_CFA_same_value: r%ld\n", reg
);
10962 fc
->col_type
[reg
] = DW_CFA_same_value
;
10963 fc
->col_offset
[reg
] = 0;
10966 case DW_CFA_register
:
10969 if (! do_debug_frames_interp
)
10970 printf (" DW_CFA_register: r%ld in r%ld\n", reg
, roffs
);
10971 fc
->col_type
[reg
] = DW_CFA_register
;
10972 fc
->col_offset
[reg
] = roffs
;
10975 case DW_CFA_remember_state
:
10976 if (! do_debug_frames_interp
)
10977 printf (" DW_CFA_remember_state\n");
10978 rs
= xmalloc (sizeof (Frame_Chunk
));
10979 rs
->ncols
= fc
->ncols
;
10980 rs
->col_type
= xcmalloc (rs
->ncols
, sizeof (short int));
10981 rs
->col_offset
= xcmalloc (rs
->ncols
, sizeof (int));
10982 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
10983 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
10984 rs
->next
= remembered_state
;
10985 remembered_state
= rs
;
10988 case DW_CFA_restore_state
:
10989 if (! do_debug_frames_interp
)
10990 printf (" DW_CFA_restore_state\n");
10991 rs
= remembered_state
;
10994 remembered_state
= rs
->next
;
10995 frame_need_space (fc
, rs
->ncols
-1);
10996 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
10997 memcpy (fc
->col_offset
, rs
->col_offset
,
10998 rs
->ncols
* sizeof (int));
10999 free (rs
->col_type
);
11000 free (rs
->col_offset
);
11003 else if (do_debug_frames_interp
)
11004 printf ("Mismatched DW_CFA_restore_state\n");
11007 case DW_CFA_def_cfa
:
11008 fc
->cfa_reg
= LEB ();
11009 fc
->cfa_offset
= LEB ();
11011 if (! do_debug_frames_interp
)
11012 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
11013 fc
->cfa_reg
, fc
->cfa_offset
);
11016 case DW_CFA_def_cfa_register
:
11017 fc
->cfa_reg
= LEB ();
11019 if (! do_debug_frames_interp
)
11020 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
11023 case DW_CFA_def_cfa_offset
:
11024 fc
->cfa_offset
= LEB ();
11025 if (! do_debug_frames_interp
)
11026 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
11030 if (! do_debug_frames_interp
)
11031 printf (" DW_CFA_nop\n");
11034 case DW_CFA_def_cfa_expression
:
11036 if (! do_debug_frames_interp
)
11038 printf (" DW_CFA_def_cfa_expression (");
11039 decode_location_expression (start
, eh_addr_size
, ul
, 0);
11046 case DW_CFA_expression
:
11049 if (! do_debug_frames_interp
)
11051 printf (" DW_CFA_expression: r%ld (", reg
);
11052 decode_location_expression (start
, eh_addr_size
, ul
, 0);
11055 fc
->col_type
[reg
] = DW_CFA_expression
;
11059 case DW_CFA_offset_extended_sf
:
11062 frame_need_space (fc
, reg
);
11063 if (! do_debug_frames_interp
)
11064 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
11065 reg
, l
* fc
->data_factor
);
11066 fc
->col_type
[reg
] = DW_CFA_offset
;
11067 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
11070 case DW_CFA_def_cfa_sf
:
11071 fc
->cfa_reg
= LEB ();
11072 fc
->cfa_offset
= SLEB ();
11073 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
11075 if (! do_debug_frames_interp
)
11076 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
11077 fc
->cfa_reg
, fc
->cfa_offset
);
11080 case DW_CFA_def_cfa_offset_sf
:
11081 fc
->cfa_offset
= SLEB ();
11082 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
11083 if (! do_debug_frames_interp
)
11084 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
11087 case DW_CFA_MIPS_advance_loc8
:
11088 ofs
= byte_get (start
, 8); start
+= 8;
11089 if (do_debug_frames_interp
)
11090 frame_display_row (fc
, &need_col_headers
, &max_regs
);
11092 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
11093 ofs
* fc
->code_factor
,
11094 fc
->pc_begin
+ ofs
* fc
->code_factor
);
11095 fc
->pc_begin
+= ofs
* fc
->code_factor
;
11098 case DW_CFA_GNU_window_save
:
11099 if (! do_debug_frames_interp
)
11100 printf (" DW_CFA_GNU_window_save\n");
11103 case DW_CFA_GNU_args_size
:
11105 if (! do_debug_frames_interp
)
11106 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
11109 case DW_CFA_GNU_negative_offset_extended
:
11112 frame_need_space (fc
, reg
);
11113 if (! do_debug_frames_interp
)
11114 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
11115 reg
, l
* fc
->data_factor
);
11116 fc
->col_type
[reg
] = DW_CFA_offset
;
11117 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
11121 warn (_("unsupported or unknown DW_CFA_%d\n"), op
);
11126 if (do_debug_frames_interp
)
11127 frame_display_row (fc
, &need_col_headers
, &max_regs
);
11142 display_debug_not_supported (struct dwarf_section
*section
,
11143 void *file ATTRIBUTE_UNUSED
)
11145 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
11151 /* A structure containing the name of a debug section
11152 and a pointer to a function that can decode it. */
11155 const char *const name
;
11156 int (*display
) (struct dwarf_section
*, void *);
11157 unsigned int relocate
: 1;
11161 { ".debug_abbrev", display_debug_abbrev
, 0 },
11162 { ".debug_aranges", display_debug_aranges
, 0 },
11163 { ".debug_frame", display_debug_frames
, 1 },
11164 { ".debug_info", display_debug_info
, 1 },
11165 { ".debug_line", display_debug_lines
, 0 },
11166 { ".debug_pubnames", display_debug_pubnames
, 0 },
11167 { ".eh_frame", display_debug_frames
, 1 },
11168 { ".debug_macinfo", display_debug_macinfo
, 0 },
11169 { ".debug_str", display_debug_str
, 0 },
11170 { ".debug_loc", display_debug_loc
, 0 },
11171 { ".debug_pubtypes", display_debug_pubnames
, 0 },
11172 { ".debug_ranges", display_debug_ranges
, 0 },
11173 { ".debug_static_func", display_debug_not_supported
, 0 },
11174 { ".debug_static_vars", display_debug_not_supported
, 0 },
11175 { ".debug_types", display_debug_not_supported
, 0 },
11176 { ".debug_weaknames", display_debug_not_supported
, 0 }
11180 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
11182 char *name
= SECTION_NAME (section
);
11183 bfd_size_type length
;
11187 length
= section
->sh_size
;
11190 printf (_("\nSection '%s' has no debugging data.\n"), name
);
11194 if (strneq (name
, ".gnu.linkonce.wi.", 17))
11195 name
= ".debug_info";
11197 /* See if we know how to display the contents of this section. */
11198 for (i
= NUM_ELEM (debug_displays
); i
--;)
11199 if (streq (debug_displays
[i
].name
, name
))
11201 struct dwarf_section sec
;
11204 sec
.address
= section
->sh_addr
;
11205 sec
.size
= section
->sh_size
;
11206 sec
.start
= get_data (NULL
, file
, section
->sh_offset
, 1,
11207 length
, _("debug section data"));
11208 if (sec
.start
== NULL
)
11214 if (!debug_displays
[i
].relocate
11215 || debug_apply_rela_addends (file
, section
, sec
.start
))
11216 result
&= debug_displays
[i
].display (&sec
, file
);
11220 /* If we loaded in the abbrev section
11221 at some point, we must release it here. */
11229 printf (_("Unrecognized debug section: %s\n"), name
);
11237 process_section_contents (FILE *file
)
11239 Elf_Internal_Shdr
*section
;
11245 for (i
= 0, section
= section_headers
;
11246 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
11249 #ifdef SUPPORT_DISASSEMBLY
11250 if (dump_sects
[i
] & DISASS_DUMP
)
11251 disassemble_section (section
, file
);
11253 if (dump_sects
[i
] & HEX_DUMP
)
11254 dump_section (section
, file
);
11256 if (dump_sects
[i
] & DEBUG_DUMP
)
11257 display_debug_section (section
, file
);
11260 /* Check to see if the user requested a
11261 dump of a section that does not exist. */
11262 while (i
++ < num_dump_sects
)
11264 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
11268 process_mips_fpe_exception (int mask
)
11273 if (mask
& OEX_FPU_INEX
)
11274 fputs ("INEX", stdout
), first
= 0;
11275 if (mask
& OEX_FPU_UFLO
)
11276 printf ("%sUFLO", first
? "" : "|"), first
= 0;
11277 if (mask
& OEX_FPU_OFLO
)
11278 printf ("%sOFLO", first
? "" : "|"), first
= 0;
11279 if (mask
& OEX_FPU_DIV0
)
11280 printf ("%sDIV0", first
? "" : "|"), first
= 0;
11281 if (mask
& OEX_FPU_INVAL
)
11282 printf ("%sINVAL", first
? "" : "|");
11285 fputs ("0", stdout
);
11289 process_mips_specific (FILE *file
)
11291 Elf_Internal_Dyn
*entry
;
11292 size_t liblist_offset
= 0;
11293 size_t liblistno
= 0;
11294 size_t conflictsno
= 0;
11295 size_t options_offset
= 0;
11296 size_t conflicts_offset
= 0;
11298 /* We have a lot of special sections. Thanks SGI! */
11299 if (dynamic_section
== NULL
)
11300 /* No information available. */
11303 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
11304 switch (entry
->d_tag
)
11306 case DT_MIPS_LIBLIST
:
11308 = offset_from_vma (file
, entry
->d_un
.d_val
,
11309 liblistno
* sizeof (Elf32_External_Lib
));
11311 case DT_MIPS_LIBLISTNO
:
11312 liblistno
= entry
->d_un
.d_val
;
11314 case DT_MIPS_OPTIONS
:
11315 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
11317 case DT_MIPS_CONFLICT
:
11319 = offset_from_vma (file
, entry
->d_un
.d_val
,
11320 conflictsno
* sizeof (Elf32_External_Conflict
));
11322 case DT_MIPS_CONFLICTNO
:
11323 conflictsno
= entry
->d_un
.d_val
;
11329 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
11331 Elf32_External_Lib
*elib
;
11334 elib
= get_data (NULL
, file
, liblist_offset
,
11335 liblistno
, sizeof (Elf32_External_Lib
),
11339 printf ("\nSection '.liblist' contains %lu entries:\n",
11340 (unsigned long) liblistno
);
11341 fputs (" Library Time Stamp Checksum Version Flags\n",
11344 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
11351 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
11352 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
11353 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
11354 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
11355 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
11357 tmp
= gmtime (&time
);
11358 snprintf (timebuf
, sizeof (timebuf
),
11359 "%04u-%02u-%02uT%02u:%02u:%02u",
11360 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11361 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11363 printf ("%3lu: ", (unsigned long) cnt
);
11364 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
11365 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
11367 printf ("<corrupt: %9ld>", liblist
.l_name
);
11368 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
11369 liblist
.l_version
);
11371 if (liblist
.l_flags
== 0)
11375 static const struct
11382 { " EXACT_MATCH", LL_EXACT_MATCH
},
11383 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
11384 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
11385 { " EXPORTS", LL_EXPORTS
},
11386 { " DELAY_LOAD", LL_DELAY_LOAD
},
11387 { " DELTA", LL_DELTA
}
11389 int flags
= liblist
.l_flags
;
11393 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
11395 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
11397 fputs (l_flags_vals
[fcnt
].name
, stdout
);
11398 flags
^= l_flags_vals
[fcnt
].bit
;
11401 printf (" %#x", (unsigned int) flags
);
11411 if (options_offset
!= 0)
11413 Elf_External_Options
*eopt
;
11414 Elf_Internal_Shdr
*sect
= section_headers
;
11415 Elf_Internal_Options
*iopt
;
11416 Elf_Internal_Options
*option
;
11420 /* Find the section header so that we get the size. */
11421 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
11424 eopt
= get_data (NULL
, file
, options_offset
, 1, sect
->sh_size
,
11428 iopt
= cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (*iopt
));
11431 error (_("Out of memory"));
11438 while (offset
< sect
->sh_size
)
11440 Elf_External_Options
*eoption
;
11442 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
11444 option
->kind
= BYTE_GET (eoption
->kind
);
11445 option
->size
= BYTE_GET (eoption
->size
);
11446 option
->section
= BYTE_GET (eoption
->section
);
11447 option
->info
= BYTE_GET (eoption
->info
);
11449 offset
+= option
->size
;
11455 printf (_("\nSection '%s' contains %d entries:\n"),
11456 SECTION_NAME (sect
), cnt
);
11464 switch (option
->kind
)
11467 /* This shouldn't happen. */
11468 printf (" NULL %d %lx", option
->section
, option
->info
);
11471 printf (" REGINFO ");
11472 if (elf_header
.e_machine
== EM_MIPS
)
11475 Elf32_External_RegInfo
*ereg
;
11476 Elf32_RegInfo reginfo
;
11478 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
11479 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
11480 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
11481 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
11482 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
11483 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
11484 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
11486 printf ("GPR %08lx GP 0x%lx\n",
11487 reginfo
.ri_gprmask
,
11488 (unsigned long) reginfo
.ri_gp_value
);
11489 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11490 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11491 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11496 Elf64_External_RegInfo
*ereg
;
11497 Elf64_Internal_RegInfo reginfo
;
11499 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
11500 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
11501 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
11502 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
11503 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
11504 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
11505 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
11507 printf ("GPR %08lx GP 0x",
11508 reginfo
.ri_gprmask
);
11509 printf_vma (reginfo
.ri_gp_value
);
11512 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11513 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11514 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11518 case ODK_EXCEPTIONS
:
11519 fputs (" EXCEPTIONS fpe_min(", stdout
);
11520 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
11521 fputs (") fpe_max(", stdout
);
11522 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
11523 fputs (")", stdout
);
11525 if (option
->info
& OEX_PAGE0
)
11526 fputs (" PAGE0", stdout
);
11527 if (option
->info
& OEX_SMM
)
11528 fputs (" SMM", stdout
);
11529 if (option
->info
& OEX_FPDBUG
)
11530 fputs (" FPDBUG", stdout
);
11531 if (option
->info
& OEX_DISMISS
)
11532 fputs (" DISMISS", stdout
);
11535 fputs (" PAD ", stdout
);
11536 if (option
->info
& OPAD_PREFIX
)
11537 fputs (" PREFIX", stdout
);
11538 if (option
->info
& OPAD_POSTFIX
)
11539 fputs (" POSTFIX", stdout
);
11540 if (option
->info
& OPAD_SYMBOL
)
11541 fputs (" SYMBOL", stdout
);
11544 fputs (" HWPATCH ", stdout
);
11545 if (option
->info
& OHW_R4KEOP
)
11546 fputs (" R4KEOP", stdout
);
11547 if (option
->info
& OHW_R8KPFETCH
)
11548 fputs (" R8KPFETCH", stdout
);
11549 if (option
->info
& OHW_R5KEOP
)
11550 fputs (" R5KEOP", stdout
);
11551 if (option
->info
& OHW_R5KCVTL
)
11552 fputs (" R5KCVTL", stdout
);
11555 fputs (" FILL ", stdout
);
11556 /* XXX Print content of info word? */
11559 fputs (" TAGS ", stdout
);
11560 /* XXX Print content of info word? */
11563 fputs (" HWAND ", stdout
);
11564 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11565 fputs (" R4KEOP_CHECKED", stdout
);
11566 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11567 fputs (" R4KEOP_CLEAN", stdout
);
11570 fputs (" HWOR ", stdout
);
11571 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11572 fputs (" R4KEOP_CHECKED", stdout
);
11573 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11574 fputs (" R4KEOP_CLEAN", stdout
);
11577 printf (" GP_GROUP %#06lx self-contained %#06lx",
11578 option
->info
& OGP_GROUP
,
11579 (option
->info
& OGP_SELF
) >> 16);
11582 printf (" IDENT %#06lx self-contained %#06lx",
11583 option
->info
& OGP_GROUP
,
11584 (option
->info
& OGP_SELF
) >> 16);
11587 /* This shouldn't happen. */
11588 printf (" %3d ??? %d %lx",
11589 option
->kind
, option
->section
, option
->info
);
11593 len
= sizeof (*eopt
);
11594 while (len
< option
->size
)
11595 if (((char *) option
)[len
] >= ' '
11596 && ((char *) option
)[len
] < 0x7f)
11597 printf ("%c", ((char *) option
)[len
++]);
11599 printf ("\\%03o", ((char *) option
)[len
++]);
11601 fputs ("\n", stdout
);
11609 if (conflicts_offset
!= 0 && conflictsno
!= 0)
11611 Elf32_Conflict
*iconf
;
11614 if (dynamic_symbols
== NULL
)
11616 error (_("conflict list found without a dynamic symbol table"));
11620 iconf
= cmalloc (conflictsno
, sizeof (*iconf
));
11623 error (_("Out of memory"));
11629 Elf32_External_Conflict
*econf32
;
11631 econf32
= get_data (NULL
, file
, conflicts_offset
,
11632 conflictsno
, sizeof (*econf32
), _("conflict"));
11636 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11637 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
11643 Elf64_External_Conflict
*econf64
;
11645 econf64
= get_data (NULL
, file
, conflicts_offset
,
11646 conflictsno
, sizeof (*econf64
), _("conflict"));
11650 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11651 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
11656 printf (_("\nSection '.conflict' contains %lu entries:\n"),
11657 (unsigned long) conflictsno
);
11658 puts (_(" Num: Index Value Name"));
11660 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11662 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
11664 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
11665 print_vma (psym
->st_value
, FULL_HEX
);
11667 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11668 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11670 printf ("<corrupt: %14ld>", psym
->st_name
);
11681 process_gnu_liblist (FILE *file
)
11683 Elf_Internal_Shdr
*section
, *string_sec
;
11684 Elf32_External_Lib
*elib
;
11686 size_t strtab_size
;
11693 for (i
= 0, section
= section_headers
;
11694 i
< elf_header
.e_shnum
;
11697 switch (section
->sh_type
)
11699 case SHT_GNU_LIBLIST
:
11700 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
)
11703 elib
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
11708 string_sec
= SECTION_HEADER (section
->sh_link
);
11710 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
11711 string_sec
->sh_size
, _("liblist string table"));
11712 strtab_size
= string_sec
->sh_size
;
11715 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
11721 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
11722 SECTION_NAME (section
),
11723 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
11725 puts (" Library Time Stamp Checksum Version Flags");
11727 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
11735 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
11736 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
11737 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
11738 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
11739 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
11741 tmp
= gmtime (&time
);
11742 snprintf (timebuf
, sizeof (timebuf
),
11743 "%04u-%02u-%02uT%02u:%02u:%02u",
11744 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11745 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11747 printf ("%3lu: ", (unsigned long) cnt
);
11749 printf ("%-20s", liblist
.l_name
< strtab_size
11750 ? strtab
+ liblist
.l_name
: "<corrupt>");
11752 printf ("%-20.20s", liblist
.l_name
< strtab_size
11753 ? strtab
+ liblist
.l_name
: "<corrupt>");
11754 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
11755 liblist
.l_version
, liblist
.l_flags
);
11765 static const char *
11766 get_note_type (unsigned e_type
)
11768 static char buff
[64];
11770 if (elf_header
.e_type
== ET_CORE
)
11774 return _("NT_AUXV (auxiliary vector)");
11776 return _("NT_PRSTATUS (prstatus structure)");
11778 return _("NT_FPREGSET (floating point registers)");
11780 return _("NT_PRPSINFO (prpsinfo structure)");
11781 case NT_TASKSTRUCT
:
11782 return _("NT_TASKSTRUCT (task structure)");
11784 return _("NT_PRXFPREG (user_xfpregs structure)");
11786 return _("NT_PSTATUS (pstatus structure)");
11788 return _("NT_FPREGS (floating point registers)");
11790 return _("NT_PSINFO (psinfo structure)");
11792 return _("NT_LWPSTATUS (lwpstatus_t structure)");
11794 return _("NT_LWPSINFO (lwpsinfo_t structure)");
11795 case NT_WIN32PSTATUS
:
11796 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
11804 return _("NT_VERSION (version)");
11806 return _("NT_ARCH (architecture)");
11811 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11815 static const char *
11816 get_netbsd_elfcore_note_type (unsigned e_type
)
11818 static char buff
[64];
11820 if (e_type
== NT_NETBSDCORE_PROCINFO
)
11822 /* NetBSD core "procinfo" structure. */
11823 return _("NetBSD procinfo structure");
11826 /* As of Jan 2002 there are no other machine-independent notes
11827 defined for NetBSD core files. If the note type is less
11828 than the start of the machine-dependent note types, we don't
11831 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
11833 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11837 switch (elf_header
.e_machine
)
11839 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
11840 and PT_GETFPREGS == mach+2. */
11845 case EM_SPARC32PLUS
:
11849 case NT_NETBSDCORE_FIRSTMACH
+0:
11850 return _("PT_GETREGS (reg structure)");
11851 case NT_NETBSDCORE_FIRSTMACH
+2:
11852 return _("PT_GETFPREGS (fpreg structure)");
11858 /* On all other arch's, PT_GETREGS == mach+1 and
11859 PT_GETFPREGS == mach+3. */
11863 case NT_NETBSDCORE_FIRSTMACH
+1:
11864 return _("PT_GETREGS (reg structure)");
11865 case NT_NETBSDCORE_FIRSTMACH
+3:
11866 return _("PT_GETFPREGS (fpreg structure)");
11872 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
11873 e_type
- NT_NETBSDCORE_FIRSTMACH
);
11877 /* Note that by the ELF standard, the name field is already null byte
11878 terminated, and namesz includes the terminating null byte.
11879 I.E. the value of namesz for the name "FSF" is 4.
11881 If the value of namesz is zero, there is no name present. */
11883 process_note (Elf_Internal_Note
*pnote
)
11887 if (pnote
->namesz
== 0)
11888 /* If there is no note name, then use the default set of
11889 note type strings. */
11890 nt
= get_note_type (pnote
->type
);
11892 else if (strneq (pnote
->namedata
, "NetBSD-CORE", 11))
11893 /* NetBSD-specific core file notes. */
11894 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
11897 /* Don't recognize this note name; just use the default set of
11898 note type strings. */
11899 nt
= get_note_type (pnote
->type
);
11901 printf (" %s\t\t0x%08lx\t%s\n",
11902 pnote
->namesz
? pnote
->namedata
: "(NONE)",
11903 pnote
->descsz
, nt
);
11909 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
11911 Elf_External_Note
*pnotes
;
11912 Elf_External_Note
*external
;
11918 pnotes
= get_data (NULL
, file
, offset
, 1, length
, _("notes"));
11924 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
11925 (unsigned long) offset
, (unsigned long) length
);
11926 printf (_(" Owner\t\tData size\tDescription\n"));
11928 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
11930 Elf_External_Note
*next
;
11931 Elf_Internal_Note inote
;
11934 inote
.type
= BYTE_GET (external
->type
);
11935 inote
.namesz
= BYTE_GET (external
->namesz
);
11936 inote
.namedata
= external
->name
;
11937 inote
.descsz
= BYTE_GET (external
->descsz
);
11938 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
11939 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
11941 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
11943 if (((char *) next
) > (((char *) pnotes
) + length
))
11945 warn (_("corrupt note found at offset %lx into core notes\n"),
11946 (long)((char *)external
- (char *)pnotes
));
11947 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
11948 inote
.type
, inote
.namesz
, inote
.descsz
);
11954 /* Verify that name is null terminated. It appears that at least
11955 one version of Linux (RedHat 6.0) generates corefiles that don't
11956 comply with the ELF spec by failing to include the null byte in
11958 if (inote
.namedata
[inote
.namesz
] != '\0')
11960 temp
= malloc (inote
.namesz
+ 1);
11964 error (_("Out of memory\n"));
11969 strncpy (temp
, inote
.namedata
, inote
.namesz
);
11970 temp
[inote
.namesz
] = 0;
11972 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
11973 inote
.namedata
= temp
;
11976 res
&= process_note (& inote
);
11991 process_corefile_note_segments (FILE *file
)
11993 Elf_Internal_Phdr
*segment
;
11997 if (! get_program_headers (file
))
12000 for (i
= 0, segment
= program_headers
;
12001 i
< elf_header
.e_phnum
;
12004 if (segment
->p_type
== PT_NOTE
)
12005 res
&= process_corefile_note_segment (file
,
12006 (bfd_vma
) segment
->p_offset
,
12007 (bfd_vma
) segment
->p_filesz
);
12014 process_note_sections (FILE *file
)
12016 Elf_Internal_Shdr
*section
;
12020 for (i
= 0, section
= section_headers
;
12021 i
< elf_header
.e_shnum
;
12023 if (section
->sh_type
== SHT_NOTE
)
12024 res
&= process_corefile_note_segment (file
,
12025 (bfd_vma
) section
->sh_offset
,
12026 (bfd_vma
) section
->sh_size
);
12032 process_notes (FILE *file
)
12034 /* If we have not been asked to display the notes then do nothing. */
12038 if (elf_header
.e_type
!= ET_CORE
)
12039 return process_note_sections (file
);
12041 /* No program headers means no NOTE segment. */
12042 if (elf_header
.e_phnum
> 0)
12043 return process_corefile_note_segments (file
);
12045 printf (_("No note segments present in the core file.\n"));
12050 process_arch_specific (FILE *file
)
12055 switch (elf_header
.e_machine
)
12058 case EM_MIPS_RS3_LE
:
12059 return process_mips_specific (file
);
12068 get_file_header (FILE *file
)
12070 /* Read in the identity array. */
12071 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
12074 /* Determine how to read the rest of the header. */
12075 switch (elf_header
.e_ident
[EI_DATA
])
12077 default: /* fall through */
12078 case ELFDATANONE
: /* fall through */
12080 byte_get
= byte_get_little_endian
;
12081 byte_put
= byte_put_little_endian
;
12084 byte_get
= byte_get_big_endian
;
12085 byte_put
= byte_put_big_endian
;
12089 /* For now we only support 32 bit and 64 bit ELF files. */
12090 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
12092 /* Read in the rest of the header. */
12095 Elf32_External_Ehdr ehdr32
;
12097 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
12100 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
12101 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
12102 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
12103 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
12104 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
12105 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
12106 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
12107 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
12108 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
12109 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
12110 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
12111 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
12112 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
12116 Elf64_External_Ehdr ehdr64
;
12118 /* If we have been compiled with sizeof (bfd_vma) == 4, then
12119 we will not be able to cope with the 64bit data found in
12120 64 ELF files. Detect this now and abort before we start
12121 overwriting things. */
12122 if (sizeof (bfd_vma
) < 8)
12124 error (_("This instance of readelf has been built without support for a\n\
12125 64 bit data type and so it cannot read 64 bit ELF files.\n"));
12129 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
12132 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
12133 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
12134 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
12135 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
12136 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
12137 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
12138 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
12139 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
12140 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
12141 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
12142 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
12143 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
12144 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
12147 if (elf_header
.e_shoff
)
12149 /* There may be some extensions in the first section header. Don't
12150 bomb if we can't read it. */
12152 get_32bit_section_headers (file
, 1);
12154 get_64bit_section_headers (file
, 1);
12157 is_relocatable
= elf_header
.e_type
== ET_REL
;
12162 /* Process one ELF object file according to the command line options.
12163 This file may actually be stored in an archive. The file is
12164 positioned at the start of the ELF object. */
12167 process_object (char *file_name
, FILE *file
)
12171 if (! get_file_header (file
))
12173 error (_("%s: Failed to read file header\n"), file_name
);
12177 /* Initialise per file variables. */
12178 for (i
= NUM_ELEM (version_info
); i
--;)
12179 version_info
[i
] = 0;
12181 for (i
= NUM_ELEM (dynamic_info
); i
--;)
12182 dynamic_info
[i
] = 0;
12184 /* Process the file. */
12186 printf (_("\nFile: %s\n"), file_name
);
12188 /* Initialise the dump_sects array from the cmdline_dump_sects array.
12189 Note we do this even if cmdline_dump_sects is empty because we
12190 must make sure that the dump_sets array is zeroed out before each
12191 object file is processed. */
12192 if (num_dump_sects
> num_cmdline_dump_sects
)
12193 memset (dump_sects
, 0, num_dump_sects
);
12195 if (num_cmdline_dump_sects
> 0)
12197 if (num_dump_sects
== 0)
12198 /* A sneaky way of allocating the dump_sects array. */
12199 request_dump (num_cmdline_dump_sects
, 0);
12201 assert (num_dump_sects
>= num_cmdline_dump_sects
);
12202 memcpy (dump_sects
, cmdline_dump_sects
, num_cmdline_dump_sects
);
12205 if (! process_file_header ())
12208 if (! process_section_headers (file
))
12210 /* Without loaded section headers we cannot process lots of
12212 do_unwind
= do_version
= do_dump
= do_arch
= 0;
12214 if (! do_using_dynamic
)
12215 do_syms
= do_reloc
= 0;
12218 if (! process_section_groups (file
))
12220 /* Without loaded section groups we cannot process unwind. */
12224 if (process_program_headers (file
))
12225 process_dynamic_section (file
);
12227 process_relocs (file
);
12229 process_unwind (file
);
12231 process_symbol_table (file
);
12233 process_syminfo (file
);
12235 process_version_sections (file
);
12237 process_section_contents (file
);
12239 process_notes (file
);
12241 process_gnu_liblist (file
);
12243 process_arch_specific (file
);
12245 if (program_headers
)
12247 free (program_headers
);
12248 program_headers
= NULL
;
12251 if (section_headers
)
12253 free (section_headers
);
12254 section_headers
= NULL
;
12259 free (string_table
);
12260 string_table
= NULL
;
12261 string_table_length
= 0;
12264 if (dynamic_strings
)
12266 free (dynamic_strings
);
12267 dynamic_strings
= NULL
;
12268 dynamic_strings_length
= 0;
12271 if (dynamic_symbols
)
12273 free (dynamic_symbols
);
12274 dynamic_symbols
= NULL
;
12275 num_dynamic_syms
= 0;
12278 if (dynamic_syminfo
)
12280 free (dynamic_syminfo
);
12281 dynamic_syminfo
= NULL
;
12284 if (section_headers_groups
)
12286 free (section_headers_groups
);
12287 section_headers_groups
= NULL
;
12290 if (section_groups
)
12292 struct group_list
*g
, *next
;
12294 for (i
= 0; i
< group_count
; i
++)
12296 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
12303 free (section_groups
);
12304 section_groups
= NULL
;
12307 if (debug_information
)
12309 for (i
= 0; i
< num_debug_info_entries
; i
++)
12311 if (!debug_information
[i
].max_loc_offsets
)
12313 free (debug_information
[i
].loc_offsets
);
12314 free (debug_information
[i
].have_frame_base
);
12316 if (!debug_information
[i
].max_range_lists
)
12317 free (debug_information
[i
].range_lists
);
12319 free (debug_information
);
12320 debug_information
= NULL
;
12321 num_debug_info_entries
= 0;
12327 /* Process an ELF archive. The file is positioned just after the
12331 process_archive (char *file_name
, FILE *file
)
12333 struct ar_hdr arhdr
;
12335 unsigned long size
;
12336 char *longnames
= NULL
;
12337 unsigned long longnames_size
= 0;
12338 size_t file_name_size
;
12343 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12344 if (got
!= sizeof arhdr
)
12349 error (_("%s: failed to read archive header\n"), file_name
);
12353 if (memcmp (arhdr
.ar_name
, "/ ", 16) == 0)
12355 /* This is the archive symbol table. Skip it.
12356 FIXME: We should have an option to dump it. */
12357 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
12358 if (fseek (file
, size
+ (size
& 1), SEEK_CUR
) != 0)
12360 error (_("%s: failed to skip archive symbol table\n"), file_name
);
12364 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12365 if (got
!= sizeof arhdr
)
12370 error (_("%s: failed to read archive header\n"), file_name
);
12375 if (memcmp (arhdr
.ar_name
, "// ", 16) == 0)
12377 /* This is the archive string table holding long member
12380 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
12382 longnames
= malloc (longnames_size
);
12383 if (longnames
== NULL
)
12385 error (_("Out of memory\n"));
12389 if (fread (longnames
, longnames_size
, 1, file
) != 1)
12392 error (_("%s: failed to read string table\n"), file_name
);
12396 if ((longnames_size
& 1) != 0)
12399 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12400 if (got
!= sizeof arhdr
)
12407 error (_("%s: failed to read archive header\n"), file_name
);
12412 file_name_size
= strlen (file_name
);
12421 if (arhdr
.ar_name
[0] == '/')
12425 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
12426 if (off
>= longnames_size
)
12428 error (_("%s: invalid archive string table offset %lu\n"), file_name
, off
);
12433 name
= longnames
+ off
;
12434 nameend
= memchr (name
, '/', longnames_size
- off
);
12438 name
= arhdr
.ar_name
;
12439 nameend
= memchr (name
, '/', 16);
12442 if (nameend
== NULL
)
12444 error (_("%s: bad archive file name\n"), file_name
);
12449 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
12450 if (namealc
== NULL
)
12452 error (_("Out of memory\n"));
12457 memcpy (namealc
, file_name
, file_name_size
);
12458 namealc
[file_name_size
] = '(';
12459 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
12460 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
12461 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
12463 archive_file_offset
= ftell (file
);
12464 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
12466 ret
|= process_object (namealc
, file
);
12471 (archive_file_offset
12472 + archive_file_size
12473 + (archive_file_size
& 1)),
12476 error (_("%s: failed to seek to next archive header\n"), file_name
);
12481 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12482 if (got
!= sizeof arhdr
)
12487 error (_("%s: failed to read archive header\n"), file_name
);
12493 if (longnames
!= 0)
12500 process_file (char *file_name
)
12503 struct stat statbuf
;
12504 char armag
[SARMAG
];
12507 if (stat (file_name
, &statbuf
) < 0)
12509 if (errno
== ENOENT
)
12510 error (_("'%s': No such file\n"), file_name
);
12512 error (_("Could not locate '%s'. System error message: %s\n"),
12513 file_name
, strerror (errno
));
12517 if (! S_ISREG (statbuf
.st_mode
))
12519 error (_("'%s' is not an ordinary file\n"), file_name
);
12523 file
= fopen (file_name
, "rb");
12526 error (_("Input file '%s' is not readable.\n"), file_name
);
12530 if (fread (armag
, SARMAG
, 1, file
) != 1)
12532 error (_("%s: Failed to read file header\n"), file_name
);
12537 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
12538 ret
= process_archive (file_name
, file
);
12542 archive_file_size
= archive_file_offset
= 0;
12543 ret
= process_object (file_name
, file
);
12551 #ifdef SUPPORT_DISASSEMBLY
12552 /* Needed by the i386 disassembler. For extra credit, someone could
12553 fix this so that we insert symbolic addresses here, esp for GOT/PLT
12557 print_address (unsigned int addr
, FILE *outfile
)
12559 fprintf (outfile
,"0x%8.8x", addr
);
12562 /* Needed by the i386 disassembler. */
12564 db_task_printsym (unsigned int addr
)
12566 print_address (addr
, stderr
);
12571 main (int argc
, char **argv
)
12575 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
12576 setlocale (LC_MESSAGES
, "");
12578 #if defined (HAVE_SETLOCALE)
12579 setlocale (LC_CTYPE
, "");
12581 bindtextdomain (PACKAGE
, LOCALEDIR
);
12582 textdomain (PACKAGE
);
12584 parse_args (argc
, argv
);
12586 if (num_dump_sects
> 0)
12588 /* Make a copy of the dump_sects array. */
12589 cmdline_dump_sects
= malloc (num_dump_sects
);
12590 if (cmdline_dump_sects
== NULL
)
12591 error (_("Out of memory allocating dump request table."));
12594 memcpy (cmdline_dump_sects
, dump_sects
, num_dump_sects
);
12595 num_cmdline_dump_sects
= num_dump_sects
;
12599 if (optind
< (argc
- 1))
12603 while (optind
< argc
)
12604 err
|= process_file (argv
[optind
++]);
12606 if (dump_sects
!= NULL
)
12608 if (cmdline_dump_sects
!= NULL
)
12609 free (cmdline_dump_sects
);