1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
26 #include <sys/types.h>
32 /* Define BFD64 here, even if our default architecture is 32 bit ELF
33 as this will allow us to read in and parse 64bit and 32bit ELF files.
34 Only do this if we belive that the compiler can support a 64 bit
35 data type. For now we only rely on GCC being able to do this. */
41 #include "elf/common.h"
42 #include "elf/external.h"
43 #include "elf/internal.h"
44 #include "elf/dwarf2.h"
46 /* The following headers use the elf/reloc-macros.h file to
47 automatically generate relocation recognition functions
48 such as elf_mips_reloc_type() */
50 #define RELOC_MACROS_GEN_FUNC
52 #include "elf/alpha.h"
69 #include "elf/mcore.h"
72 #include "elf/mn10200.h"
73 #include "elf/mn10300.h"
79 #include "elf/sparc.h"
81 #include "elf/x86-64.h"
82 #include "elf/xstormy16.h"
87 char * program_name
= "readelf";
88 unsigned int dynamic_addr
;
89 bfd_size_type dynamic_size
;
90 unsigned int rela_addr
;
91 unsigned int rela_size
;
92 char * dynamic_strings
;
94 unsigned long string_table_length
;
95 unsigned long num_dynamic_syms
;
96 Elf_Internal_Sym
* dynamic_symbols
;
97 Elf_Internal_Syminfo
* dynamic_syminfo
;
98 unsigned long dynamic_syminfo_offset
;
99 unsigned int dynamic_syminfo_nent
;
100 char program_interpreter
[64];
101 int dynamic_info
[DT_JMPREL
+ 1];
102 int version_info
[16];
104 Elf_Internal_Ehdr elf_header
;
105 Elf_Internal_Shdr
* section_headers
;
106 Elf_Internal_Dyn
* dynamic_segment
;
107 Elf_Internal_Shdr
* symtab_shndx_hdr
;
115 int do_using_dynamic
;
123 int do_debug_abbrevs
;
125 int do_debug_pubnames
;
126 int do_debug_aranges
;
128 int do_debug_frames_interp
;
129 int do_debug_macinfo
;
136 /* A dynamic array of flags indicating which sections require dumping. */
137 char * dump_sects
= NULL
;
138 unsigned int num_dump_sects
= 0;
140 #define HEX_DUMP (1 << 0)
141 #define DISASS_DUMP (1 << 1)
142 #define DEBUG_DUMP (1 << 2)
144 /* How to rpint a vma value. */
145 typedef enum print_mode
157 /* Forward declarations for dumb compilers. */
158 static void print_vma
PARAMS ((bfd_vma
, print_mode
));
159 static void print_symbol
PARAMS ((int, char *));
160 static bfd_vma (* byte_get
) PARAMS ((unsigned char *, int));
161 static bfd_vma byte_get_little_endian
PARAMS ((unsigned char *, int));
162 static bfd_vma byte_get_big_endian
PARAMS ((unsigned char *, int));
163 static const char * get_mips_dynamic_type
PARAMS ((unsigned long));
164 static const char * get_sparc64_dynamic_type
PARAMS ((unsigned long));
165 static const char * get_ppc64_dynamic_type
PARAMS ((unsigned long));
166 static const char * get_parisc_dynamic_type
PARAMS ((unsigned long));
167 static const char * get_dynamic_type
PARAMS ((unsigned long));
168 static int slurp_rela_relocs
PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Rela
**, unsigned long *));
169 static int slurp_rel_relocs
PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Rel
**, unsigned long *));
170 static int dump_relocations
PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Sym
*, unsigned long, char *, int));
171 static char * get_file_type
PARAMS ((unsigned));
172 static char * get_machine_name
PARAMS ((unsigned));
173 static void decode_ARM_machine_flags
PARAMS ((unsigned, char []));
174 static char * get_machine_flags
PARAMS ((unsigned, unsigned));
175 static const char * get_mips_segment_type
PARAMS ((unsigned long));
176 static const char * get_parisc_segment_type
PARAMS ((unsigned long));
177 static const char * get_ia64_segment_type
PARAMS ((unsigned long));
178 static const char * get_segment_type
PARAMS ((unsigned long));
179 static const char * get_mips_section_type_name
PARAMS ((unsigned int));
180 static const char * get_parisc_section_type_name
PARAMS ((unsigned int));
181 static const char * get_ia64_section_type_name
PARAMS ((unsigned int));
182 static const char * get_section_type_name
PARAMS ((unsigned int));
183 static const char * get_symbol_binding
PARAMS ((unsigned int));
184 static const char * get_symbol_type
PARAMS ((unsigned int));
185 static const char * get_symbol_visibility
PARAMS ((unsigned int));
186 static const char * get_symbol_index_type
PARAMS ((unsigned int));
187 static const char * get_dynamic_flags
PARAMS ((bfd_vma
));
188 static void usage
PARAMS ((void));
189 static void parse_args
PARAMS ((int, char **));
190 static int process_file_header
PARAMS ((void));
191 static int process_program_headers
PARAMS ((FILE *));
192 static int process_section_headers
PARAMS ((FILE *));
193 static int process_unwind
PARAMS ((FILE *));
194 static void dynamic_segment_mips_val
PARAMS ((Elf_Internal_Dyn
*));
195 static void dynamic_segment_parisc_val
PARAMS ((Elf_Internal_Dyn
*));
196 static int process_dynamic_segment
PARAMS ((FILE *));
197 static int process_symbol_table
PARAMS ((FILE *));
198 static int process_syminfo
PARAMS ((FILE *));
199 static int process_section_contents
PARAMS ((FILE *));
200 static void process_mips_fpe_exception
PARAMS ((int));
201 static int process_mips_specific
PARAMS ((FILE *));
202 static int process_file
PARAMS ((char *));
203 static int process_relocs
PARAMS ((FILE *));
204 static int process_version_sections
PARAMS ((FILE *));
205 static char * get_ver_flags
PARAMS ((unsigned int));
206 static int get_32bit_section_headers
PARAMS ((FILE *, unsigned int));
207 static int get_64bit_section_headers
PARAMS ((FILE *, unsigned int));
208 static int get_32bit_program_headers
PARAMS ((FILE *, Elf_Internal_Phdr
*));
209 static int get_64bit_program_headers
PARAMS ((FILE *, Elf_Internal_Phdr
*));
210 static int get_file_header
PARAMS ((FILE *));
211 static Elf_Internal_Sym
* get_32bit_elf_symbols
PARAMS ((FILE *, Elf_Internal_Shdr
*));
212 static Elf_Internal_Sym
* get_64bit_elf_symbols
PARAMS ((FILE *, Elf_Internal_Shdr
*));
213 static const char * get_elf_section_flags
PARAMS ((bfd_vma
));
214 static int * get_dynamic_data
PARAMS ((FILE *, unsigned int));
215 static int get_32bit_dynamic_segment
PARAMS ((FILE *));
216 static int get_64bit_dynamic_segment
PARAMS ((FILE *));
217 #ifdef SUPPORT_DISASSEMBLY
218 static int disassemble_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
220 static int dump_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
221 static int display_debug_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
222 static int display_debug_info
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
223 static int display_debug_not_supported
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
224 static int prescan_debug_info
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
225 static int display_debug_lines
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
226 static int display_debug_pubnames
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
227 static int display_debug_abbrev
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
228 static int display_debug_aranges
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
229 static int display_debug_frames
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
230 static int display_debug_macinfo
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
231 static int display_debug_str
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
232 static int display_debug_loc
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
233 static unsigned char * process_abbrev_section
PARAMS ((unsigned char *, unsigned char *));
234 static void load_debug_str
PARAMS ((FILE *));
235 static void free_debug_str
PARAMS ((void));
236 static const char * fetch_indirect_string
PARAMS ((unsigned long));
237 static void load_debug_loc
PARAMS ((FILE *));
238 static void free_debug_loc
PARAMS ((void));
239 static unsigned long read_leb128
PARAMS ((unsigned char *, int *, int));
240 static int process_extended_line_op
PARAMS ((unsigned char *, int, int));
241 static void reset_state_machine
PARAMS ((int));
242 static char * get_TAG_name
PARAMS ((unsigned long));
243 static char * get_AT_name
PARAMS ((unsigned long));
244 static char * get_FORM_name
PARAMS ((unsigned long));
245 static void free_abbrevs
PARAMS ((void));
246 static void add_abbrev
PARAMS ((unsigned long, unsigned long, int));
247 static void add_abbrev_attr
PARAMS ((unsigned long, unsigned long));
248 static unsigned char * read_and_display_attr
PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long, unsigned long));
249 static unsigned char * read_and_display_attr_value
PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long, unsigned long));
250 static unsigned char * display_block
PARAMS ((unsigned char *, unsigned long));
251 static void decode_location_expression
PARAMS ((unsigned char *, unsigned int, unsigned long));
252 static void request_dump
PARAMS ((unsigned int, int));
253 static const char * get_elf_class
PARAMS ((unsigned int));
254 static const char * get_data_encoding
PARAMS ((unsigned int));
255 static const char * get_osabi_name
PARAMS ((unsigned int));
256 static int guess_is_rela
PARAMS ((unsigned long));
257 static const char * get_note_type
PARAMS ((unsigned int));
258 static const char * get_netbsd_elfcore_note_type
PARAMS ((unsigned int));
259 static int process_note
PARAMS ((Elf32_Internal_Note
*));
260 static int process_corefile_note_segment
PARAMS ((FILE *, bfd_vma
, bfd_vma
));
261 static int process_corefile_note_segments
PARAMS ((FILE *));
262 static int process_corefile_contents
PARAMS ((FILE *));
263 static int process_arch_specific
PARAMS ((FILE *));
265 typedef int Elf32_Word
;
273 #define SECTION_NAME(X) ((X) == NULL ? "<none>" : \
274 ((X)->sh_name >= string_table_length \
275 ? "<corrupt>" : string_table + (X)->sh_name))
277 /* Given st_shndx I, map to section_headers index. */
278 #define SECTION_HEADER_INDEX(I) \
279 ((I) < SHN_LORESERVE \
281 : ((I) <= SHN_HIRESERVE \
283 : (I) - (SHN_HIRESERVE + 1 - SHN_LORESERVE)))
285 /* Reverse of the above. */
286 #define SECTION_HEADER_NUM(N) \
287 ((N) < SHN_LORESERVE \
289 : (N) + (SHN_HIRESERVE + 1 - SHN_LORESERVE))
291 #define SECTION_HEADER(I) (section_headers + SECTION_HEADER_INDEX (I))
293 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
295 #define BYTE_GET(field) byte_get (field, sizeof (field))
297 /* If we can support a 64 bit data type then BFD64 should be defined
298 and sizeof (bfd_vma) == 8. In this case when translating from an
299 external 8 byte field to an internal field, we can assume that the
300 internal field is also 8 bytes wide and so we can extract all the data.
301 If, however, BFD64 is not defined, then we must assume that the
302 internal data structure only has 4 byte wide fields that are the
303 equivalent of the 8 byte wide external counterparts, and so we must
304 truncate the data. */
306 #define BYTE_GET8(field) byte_get (field, -8)
308 #define BYTE_GET8(field) byte_get (field, 8)
311 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
313 #define GET_ELF_SYMBOLS(file, section) \
314 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
315 : get_64bit_elf_symbols (file, section))
319 error
VPARAMS ((const char *message
, ...))
321 VA_OPEN (args
, message
);
322 VA_FIXEDARG (args
, const char *, message
);
324 fprintf (stderr
, _("%s: Error: "), program_name
);
325 vfprintf (stderr
, message
, args
);
330 warn
VPARAMS ((const char *message
, ...))
332 VA_OPEN (args
, message
);
333 VA_FIXEDARG (args
, const char *, message
);
335 fprintf (stderr
, _("%s: Warning: "), program_name
);
336 vfprintf (stderr
, message
, args
);
340 static PTR get_data
PARAMS ((PTR
, FILE *, long, size_t, const char *));
343 get_data (var
, file
, offset
, size
, reason
)
355 if (fseek (file
, offset
, SEEK_SET
))
357 error (_("Unable to seek to %x for %s\n"), offset
, reason
);
364 mvar
= (PTR
) malloc (size
);
368 error (_("Out of memory allocating %d bytes for %s\n"),
374 if (fread (mvar
, size
, 1, file
) != 1)
376 error (_("Unable to read in %d bytes of %s\n"), size
, reason
);
386 byte_get_little_endian (field
, size
)
387 unsigned char * field
;
396 return ((unsigned int) (field
[0]))
397 | (((unsigned int) (field
[1])) << 8);
401 /* We want to extract data from an 8 byte wide field and
402 place it into a 4 byte wide field. Since this is a little
403 endian source we can juts use the 4 byte extraction code. */
407 return ((unsigned long) (field
[0]))
408 | (((unsigned long) (field
[1])) << 8)
409 | (((unsigned long) (field
[2])) << 16)
410 | (((unsigned long) (field
[3])) << 24);
415 /* This is a special case, generated by the BYTE_GET8 macro.
416 It means that we are loading an 8 byte value from a field
417 in an external structure into an 8 byte value in a field
418 in an internal strcuture. */
419 return ((bfd_vma
) (field
[0]))
420 | (((bfd_vma
) (field
[1])) << 8)
421 | (((bfd_vma
) (field
[2])) << 16)
422 | (((bfd_vma
) (field
[3])) << 24)
423 | (((bfd_vma
) (field
[4])) << 32)
424 | (((bfd_vma
) (field
[5])) << 40)
425 | (((bfd_vma
) (field
[6])) << 48)
426 | (((bfd_vma
) (field
[7])) << 56);
429 error (_("Unhandled data length: %d\n"), size
);
434 /* Print a VMA value. */
436 print_vma (vma
, mode
)
446 case FULL_HEX
: printf ("0x"); /* drop through */
447 case LONG_HEX
: printf ("%8.8lx", (unsigned long) vma
); break;
448 case PREFIX_HEX
: printf ("0x"); /* drop through */
449 case HEX
: printf ("%lx", (unsigned long) vma
); break;
450 case DEC
: printf ("%ld", (unsigned long) vma
); break;
451 case DEC_5
: printf ("%5ld", (long) vma
); break;
452 case UNSIGNED
: printf ("%lu", (unsigned long) vma
); break;
473 #if BFD_HOST_64BIT_LONG
476 if (_bfd_int64_high (vma
))
477 printf ("%lx%8.8lx", _bfd_int64_high (vma
), _bfd_int64_low (vma
));
479 printf ("%lx", _bfd_int64_low (vma
));
484 #if BFD_HOST_64BIT_LONG
487 if (_bfd_int64_high (vma
))
489 printf ("++%ld", _bfd_int64_low (vma
));
491 printf ("%ld", _bfd_int64_low (vma
));
496 #if BFD_HOST_64BIT_LONG
497 printf ("%5ld", vma
);
499 if (_bfd_int64_high (vma
))
501 printf ("++%ld", _bfd_int64_low (vma
));
503 printf ("%5ld", _bfd_int64_low (vma
));
508 #if BFD_HOST_64BIT_LONG
511 if (_bfd_int64_high (vma
))
513 printf ("++%lu", _bfd_int64_low (vma
));
515 printf ("%lu", _bfd_int64_low (vma
));
523 /* Display a symbol on stdout. If do_wide is not true then
524 format the symbol to be at most WIDTH characters,
525 truhncating as necessary. If WIDTH is negative then
526 format the string to be exactly - WIDTH characters,
527 truncating or padding as necessary. */
530 print_symbol (width
, symbol
)
537 printf ("%-*.*s", width
, width
, symbol
);
539 printf ("%-.*s", width
, symbol
);
543 byte_get_big_endian (field
, size
)
544 unsigned char * field
;
553 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
556 return ((unsigned long) (field
[3]))
557 | (((unsigned long) (field
[2])) << 8)
558 | (((unsigned long) (field
[1])) << 16)
559 | (((unsigned long) (field
[0])) << 24);
563 /* Although we are extracing data from an 8 byte wide field, we
564 are returning only 4 bytes of data. */
565 return ((unsigned long) (field
[7]))
566 | (((unsigned long) (field
[6])) << 8)
567 | (((unsigned long) (field
[5])) << 16)
568 | (((unsigned long) (field
[4])) << 24);
572 /* This is a special case, generated by the BYTE_GET8 macro.
573 It means that we are loading an 8 byte value from a field
574 in an external structure into an 8 byte value in a field
575 in an internal strcuture. */
576 return ((bfd_vma
) (field
[7]))
577 | (((bfd_vma
) (field
[6])) << 8)
578 | (((bfd_vma
) (field
[5])) << 16)
579 | (((bfd_vma
) (field
[4])) << 24)
580 | (((bfd_vma
) (field
[3])) << 32)
581 | (((bfd_vma
) (field
[2])) << 40)
582 | (((bfd_vma
) (field
[1])) << 48)
583 | (((bfd_vma
) (field
[0])) << 56);
587 error (_("Unhandled data length: %d\n"), size
);
592 /* Guess the relocation size commonly used by the specific machines. */
595 guess_is_rela (e_machine
)
596 unsigned long e_machine
;
600 /* Targets that use REL relocations. */
616 /* Targets that use RELA relocations. */
631 case EM_CYGNUS_MN10200
:
633 case EM_CYGNUS_MN10300
:
670 warn (_("Don't know about relocations on this machine architecture\n"));
676 slurp_rela_relocs (file
, rel_offset
, rel_size
, relasp
, nrelasp
)
678 unsigned long rel_offset
;
679 unsigned long rel_size
;
680 Elf_Internal_Rela
**relasp
;
681 unsigned long *nrelasp
;
683 Elf_Internal_Rela
*relas
;
684 unsigned long nrelas
;
689 Elf32_External_Rela
* erelas
;
691 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
,
692 rel_size
, _("relocs"));
696 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
698 relas
= (Elf_Internal_Rela
*)
699 malloc (nrelas
* sizeof (Elf_Internal_Rela
));
703 error(_("out of memory parsing relocs"));
707 for (i
= 0; i
< nrelas
; i
++)
709 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
710 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
711 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
718 Elf64_External_Rela
* erelas
;
720 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
,
721 rel_size
, _("relocs"));
725 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
727 relas
= (Elf_Internal_Rela
*)
728 malloc (nrelas
* sizeof (Elf_Internal_Rela
));
732 error(_("out of memory parsing relocs"));
736 for (i
= 0; i
< nrelas
; i
++)
738 relas
[i
].r_offset
= BYTE_GET8 (erelas
[i
].r_offset
);
739 relas
[i
].r_info
= BYTE_GET8 (erelas
[i
].r_info
);
740 relas
[i
].r_addend
= BYTE_GET8 (erelas
[i
].r_addend
);
751 slurp_rel_relocs (file
, rel_offset
, rel_size
, relsp
, nrelsp
)
753 unsigned long rel_offset
;
754 unsigned long rel_size
;
755 Elf_Internal_Rel
**relsp
;
756 unsigned long *nrelsp
;
758 Elf_Internal_Rel
*rels
;
764 Elf32_External_Rel
* erels
;
766 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
,
767 rel_size
, _("relocs"));
771 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
773 rels
= (Elf_Internal_Rel
*) malloc (nrels
* sizeof (Elf_Internal_Rel
));
777 error(_("out of memory parsing relocs"));
781 for (i
= 0; i
< nrels
; i
++)
783 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
784 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
791 Elf64_External_Rel
* erels
;
793 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
,
794 rel_size
, _("relocs"));
798 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
800 rels
= (Elf_Internal_Rel
*) malloc (nrels
* sizeof (Elf_Internal_Rel
));
804 error(_("out of memory parsing relocs"));
808 for (i
= 0; i
< nrels
; i
++)
810 rels
[i
].r_offset
= BYTE_GET8 (erels
[i
].r_offset
);
811 rels
[i
].r_info
= BYTE_GET8 (erels
[i
].r_info
);
821 /* Display the contents of the relocation data found at the specified offset. */
823 dump_relocations (file
, rel_offset
, rel_size
, symtab
, nsyms
, strtab
, is_rela
)
825 unsigned long rel_offset
;
826 unsigned long rel_size
;
827 Elf_Internal_Sym
* symtab
;
833 Elf_Internal_Rel
* rels
;
834 Elf_Internal_Rela
* relas
;
837 if (is_rela
== UNKNOWN
)
838 is_rela
= guess_is_rela (elf_header
.e_machine
);
842 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &relas
, &rel_size
))
847 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
856 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
858 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
863 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
865 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
873 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
875 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
880 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
882 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
886 for (i
= 0; i
< rel_size
; i
++)
889 const char * rtype2
= NULL
;
890 const char * rtype3
= NULL
;
893 bfd_vma symtab_index
;
895 bfd_vma type2
= (bfd_vma
) NULL
;
896 bfd_vma type3
= (bfd_vma
) NULL
;
900 offset
= relas
[i
].r_offset
;
901 info
= relas
[i
].r_info
;
905 offset
= rels
[i
].r_offset
;
906 info
= rels
[i
].r_info
;
911 type
= ELF32_R_TYPE (info
);
912 symtab_index
= ELF32_R_SYM (info
);
916 if (elf_header
.e_machine
== EM_MIPS
)
918 type
= ELF64_MIPS_R_TYPE (info
);
919 type2
= ELF64_MIPS_R_TYPE2 (info
);
920 type3
= ELF64_MIPS_R_TYPE3 (info
);
922 else if (elf_header
.e_machine
== EM_SPARCV9
)
923 type
= ELF64_R_TYPE_ID (info
);
925 type
= ELF64_R_TYPE (info
);
926 /* The #ifdef BFD64 below is to prevent a compile time warning.
927 We know that if we do not have a 64 bit data type that we
928 will never execute this code anyway. */
930 symtab_index
= ELF64_R_SYM (info
);
936 #ifdef _bfd_int64_low
937 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset
), _bfd_int64_low (info
));
939 printf ("%8.8lx %8.8lx ", offset
, info
);
944 #ifdef _bfd_int64_low
946 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
947 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
948 _bfd_int64_high (offset
),
949 _bfd_int64_low (offset
),
950 _bfd_int64_high (info
),
951 _bfd_int64_low (info
));
954 ? "%16.16lx %16.16lx "
955 : "%12.12lx %12.12lx ",
960 switch (elf_header
.e_machine
)
968 rtype
= elf_m32r_reloc_type (type
);
973 rtype
= elf_i386_reloc_type (type
);
977 rtype
= elf_m68k_reloc_type (type
);
981 rtype
= elf_i960_reloc_type (type
);
986 rtype
= elf_avr_reloc_type (type
);
993 rtype
= elf_sparc_reloc_type (type
);
998 rtype
= v850_reloc_type (type
);
1002 case EM_CYGNUS_D10V
:
1003 rtype
= elf_d10v_reloc_type (type
);
1007 case EM_CYGNUS_D30V
:
1008 rtype
= elf_d30v_reloc_type (type
);
1012 rtype
= elf_dlx_reloc_type (type
);
1016 rtype
= elf_sh_reloc_type (type
);
1020 case EM_CYGNUS_MN10300
:
1021 rtype
= elf_mn10300_reloc_type (type
);
1025 case EM_CYGNUS_MN10200
:
1026 rtype
= elf_mn10200_reloc_type (type
);
1030 case EM_CYGNUS_FR30
:
1031 rtype
= elf_fr30_reloc_type (type
);
1035 rtype
= elf_mcore_reloc_type (type
);
1039 rtype
= elf_mmix_reloc_type (type
);
1044 rtype
= elf_ppc_reloc_type (type
);
1048 case EM_MIPS_RS3_LE
:
1049 rtype
= elf_mips_reloc_type (type
);
1052 rtype2
= elf_mips_reloc_type (type2
);
1053 rtype3
= elf_mips_reloc_type (type3
);
1058 rtype
= elf_alpha_reloc_type (type
);
1062 rtype
= elf_arm_reloc_type (type
);
1066 rtype
= elf_arc_reloc_type (type
);
1070 rtype
= elf_hppa_reloc_type (type
);
1076 rtype
= elf_h8_reloc_type (type
);
1081 rtype
= elf_or32_reloc_type (type
);
1086 rtype
= elf_pj_reloc_type (type
);
1089 rtype
= elf_ia64_reloc_type (type
);
1093 rtype
= elf_cris_reloc_type (type
);
1097 rtype
= elf_i860_reloc_type (type
);
1101 rtype
= elf_x86_64_reloc_type (type
);
1106 rtype
= elf_s390_reloc_type (type
);
1110 rtype
= elf_xstormy16_reloc_type (type
);
1115 #ifdef _bfd_int64_low
1116 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type
));
1118 printf (_("unrecognized: %-7lx"), type
);
1121 printf (do_wide
? "%-21.21s" : "%-17.17s", rtype
);
1125 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1126 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1129 Elf_Internal_Sym
* psym
;
1131 psym
= symtab
+ symtab_index
;
1134 print_vma (psym
->st_value
, LONG_HEX
);
1135 printf (is_32bit_elf
? " " : " ");
1137 if (psym
->st_name
== 0)
1138 print_symbol (22, SECTION_NAME (section_headers
+ psym
->st_shndx
));
1139 else if (strtab
== NULL
)
1140 printf (_("<string table index %3ld>"), psym
->st_name
);
1142 print_symbol (22, strtab
+ psym
->st_name
);
1145 printf (" + %lx", (unsigned long) relas
[i
].r_addend
);
1150 printf ("%*c", is_32bit_elf
? (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1151 print_vma (relas
[i
].r_addend
, LONG_HEX
);
1154 if (elf_header
.e_machine
== EM_SPARCV9
1155 && !strcmp (rtype
, "R_SPARC_OLO10"))
1156 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1160 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1162 printf (" Type2: ");
1165 #ifdef _bfd_int64_low
1166 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2
));
1168 printf (_("unrecognized: %-7lx"), type2
);
1171 printf ("%-17.17s", rtype2
);
1173 printf("\n Type3: ");
1176 #ifdef _bfd_int64_low
1177 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3
));
1179 printf (_("unrecognized: %-7lx"), type3
);
1182 printf ("%-17.17s", rtype3
);
1197 get_mips_dynamic_type (type
)
1202 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1203 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1204 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1205 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1206 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1207 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1208 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1209 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1210 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1211 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1212 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1213 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1214 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1215 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1216 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1217 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1218 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1219 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1220 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1221 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1222 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1223 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1224 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1225 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1226 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1227 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1228 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1229 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1230 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1231 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1232 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1233 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1234 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1235 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1236 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1237 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1238 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1239 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1240 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1241 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1242 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1243 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1244 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1251 get_sparc64_dynamic_type (type
)
1256 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1263 get_ppc64_dynamic_type (type
)
1268 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1269 case DT_PPC64_OPD
: return "PPC64_OPD";
1270 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1277 get_parisc_dynamic_type (type
)
1282 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1283 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1284 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1285 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1286 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1287 case DT_HP_PREINIT
: return "HP_PREINIT";
1288 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1289 case DT_HP_NEEDED
: return "HP_NEEDED";
1290 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1291 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1292 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1293 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1294 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1301 get_dynamic_type (type
)
1304 static char buff
[32];
1308 case DT_NULL
: return "NULL";
1309 case DT_NEEDED
: return "NEEDED";
1310 case DT_PLTRELSZ
: return "PLTRELSZ";
1311 case DT_PLTGOT
: return "PLTGOT";
1312 case DT_HASH
: return "HASH";
1313 case DT_STRTAB
: return "STRTAB";
1314 case DT_SYMTAB
: return "SYMTAB";
1315 case DT_RELA
: return "RELA";
1316 case DT_RELASZ
: return "RELASZ";
1317 case DT_RELAENT
: return "RELAENT";
1318 case DT_STRSZ
: return "STRSZ";
1319 case DT_SYMENT
: return "SYMENT";
1320 case DT_INIT
: return "INIT";
1321 case DT_FINI
: return "FINI";
1322 case DT_SONAME
: return "SONAME";
1323 case DT_RPATH
: return "RPATH";
1324 case DT_SYMBOLIC
: return "SYMBOLIC";
1325 case DT_REL
: return "REL";
1326 case DT_RELSZ
: return "RELSZ";
1327 case DT_RELENT
: return "RELENT";
1328 case DT_PLTREL
: return "PLTREL";
1329 case DT_DEBUG
: return "DEBUG";
1330 case DT_TEXTREL
: return "TEXTREL";
1331 case DT_JMPREL
: return "JMPREL";
1332 case DT_BIND_NOW
: return "BIND_NOW";
1333 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1334 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1335 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1336 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1337 case DT_RUNPATH
: return "RUNPATH";
1338 case DT_FLAGS
: return "FLAGS";
1340 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1341 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1343 case DT_CHECKSUM
: return "CHECKSUM";
1344 case DT_PLTPADSZ
: return "PLTPADSZ";
1345 case DT_MOVEENT
: return "MOVEENT";
1346 case DT_MOVESZ
: return "MOVESZ";
1347 case DT_FEATURE
: return "FEATURE";
1348 case DT_POSFLAG_1
: return "POSFLAG_1";
1349 case DT_SYMINSZ
: return "SYMINSZ";
1350 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1352 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1353 case DT_CONFIG
: return "CONFIG";
1354 case DT_DEPAUDIT
: return "DEPAUDIT";
1355 case DT_AUDIT
: return "AUDIT";
1356 case DT_PLTPAD
: return "PLTPAD";
1357 case DT_MOVETAB
: return "MOVETAB";
1358 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1360 case DT_VERSYM
: return "VERSYM";
1362 case DT_RELACOUNT
: return "RELACOUNT";
1363 case DT_RELCOUNT
: return "RELCOUNT";
1364 case DT_FLAGS_1
: return "FLAGS_1";
1365 case DT_VERDEF
: return "VERDEF";
1366 case DT_VERDEFNUM
: return "VERDEFNUM";
1367 case DT_VERNEED
: return "VERNEED";
1368 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1370 case DT_AUXILIARY
: return "AUXILIARY";
1371 case DT_USED
: return "USED";
1372 case DT_FILTER
: return "FILTER";
1375 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1377 const char * result
;
1379 switch (elf_header
.e_machine
)
1382 case EM_MIPS_RS3_LE
:
1383 result
= get_mips_dynamic_type (type
);
1386 result
= get_sparc64_dynamic_type (type
);
1389 result
= get_ppc64_dynamic_type (type
);
1399 sprintf (buff
, _("Processor Specific: %lx"), type
);
1401 else if ((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1403 const char * result
;
1405 switch (elf_header
.e_machine
)
1408 result
= get_parisc_dynamic_type (type
);
1418 sprintf (buff
, _("Operating System specific: %lx"), type
);
1421 sprintf (buff
, _("<unknown>: %lx"), type
);
1428 get_file_type (e_type
)
1431 static char buff
[32];
1435 case ET_NONE
: return _("NONE (None)");
1436 case ET_REL
: return _("REL (Relocatable file)");
1437 case ET_EXEC
: return _("EXEC (Executable file)");
1438 case ET_DYN
: return _("DYN (Shared object file)");
1439 case ET_CORE
: return _("CORE (Core file)");
1442 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1443 sprintf (buff
, _("Processor Specific: (%x)"), e_type
);
1444 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1445 sprintf (buff
, _("OS Specific: (%x)"), e_type
);
1447 sprintf (buff
, _("<unknown>: %x"), e_type
);
1453 get_machine_name (e_machine
)
1456 static char buff
[64]; /* XXX */
1460 case EM_NONE
: return _("None");
1461 case EM_M32
: return "WE32100";
1462 case EM_SPARC
: return "Sparc";
1463 case EM_386
: return "Intel 80386";
1464 case EM_68K
: return "MC68000";
1465 case EM_88K
: return "MC88000";
1466 case EM_486
: return "Intel 80486";
1467 case EM_860
: return "Intel 80860";
1468 case EM_MIPS
: return "MIPS R3000";
1469 case EM_S370
: return "IBM System/370";
1470 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1471 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1472 case EM_PARISC
: return "HPPA";
1473 case EM_PPC_OLD
: return "Power PC (old)";
1474 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1475 case EM_960
: return "Intel 90860";
1476 case EM_PPC
: return "PowerPC";
1477 case EM_PPC64
: return "PowerPC64";
1478 case EM_V800
: return "NEC V800";
1479 case EM_FR20
: return "Fujitsu FR20";
1480 case EM_RH32
: return "TRW RH32";
1481 case EM_MCORE
: return "MCORE";
1482 case EM_ARM
: return "ARM";
1483 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1484 case EM_SH
: return "Hitachi SH";
1485 case EM_SPARCV9
: return "Sparc v9";
1486 case EM_TRICORE
: return "Siemens Tricore";
1487 case EM_ARC
: return "ARC";
1488 case EM_H8_300
: return "Hitachi H8/300";
1489 case EM_H8_300H
: return "Hitachi H8/300H";
1490 case EM_H8S
: return "Hitachi H8S";
1491 case EM_H8_500
: return "Hitachi H8/500";
1492 case EM_IA_64
: return "Intel IA-64";
1493 case EM_MIPS_X
: return "Stanford MIPS-X";
1494 case EM_COLDFIRE
: return "Motorola Coldfire";
1495 case EM_68HC12
: return "Motorola M68HC12";
1496 case EM_ALPHA
: return "Alpha";
1497 case EM_CYGNUS_D10V
:
1498 case EM_D10V
: return "d10v";
1499 case EM_CYGNUS_D30V
:
1500 case EM_D30V
: return "d30v";
1501 case EM_CYGNUS_M32R
:
1502 case EM_M32R
: return "Mitsubishi M32r";
1503 case EM_CYGNUS_V850
:
1504 case EM_V850
: return "NEC v850";
1505 case EM_CYGNUS_MN10300
:
1506 case EM_MN10300
: return "mn10300";
1507 case EM_CYGNUS_MN10200
:
1508 case EM_MN10200
: return "mn10200";
1509 case EM_CYGNUS_FR30
:
1510 case EM_FR30
: return "Fujitsu FR30";
1512 case EM_PJ
: return "picoJava";
1513 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1514 case EM_PCP
: return "Siemens PCP";
1515 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1516 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1517 case EM_STARCORE
: return "Motorola Star*Core processor";
1518 case EM_ME16
: return "Toyota ME16 processor";
1519 case EM_ST100
: return "STMicroelectronics ST100 processor";
1520 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1521 case EM_FX66
: return "Siemens FX66 microcontroller";
1522 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1523 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1524 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1525 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1526 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1527 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1528 case EM_SVX
: return "Silicon Graphics SVx";
1529 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1530 case EM_VAX
: return "Digital VAX";
1532 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1533 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1534 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1535 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1536 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1537 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1538 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1539 case EM_PRISM
: return "SiTera Prism";
1540 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1542 case EM_S390
: return "IBM S/390";
1543 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1545 case EM_OR32
: return "OpenRISC";
1546 case EM_DLX
: return "OpenDLX";
1548 sprintf (buff
, _("<unknown>: %x"), e_machine
);
1554 decode_ARM_machine_flags (e_flags
, buf
)
1561 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1562 e_flags
&= ~ EF_ARM_EABIMASK
;
1564 /* Handle "generic" ARM flags. */
1565 if (e_flags
& EF_ARM_RELEXEC
)
1567 strcat (buf
, ", relocatable executable");
1568 e_flags
&= ~ EF_ARM_RELEXEC
;
1571 if (e_flags
& EF_ARM_HASENTRY
)
1573 strcat (buf
, ", has entry point");
1574 e_flags
&= ~ EF_ARM_HASENTRY
;
1577 /* Now handle EABI specific flags. */
1581 strcat (buf
, ", <unrecognized EABI>");
1586 case EF_ARM_EABI_VER1
:
1587 strcat (buf
, ", Version1 EABI");
1592 /* Process flags one bit at a time. */
1593 flag
= e_flags
& - e_flags
;
1598 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1599 strcat (buf
, ", sorted symbol tables");
1609 case EF_ARM_EABI_VER2
:
1610 strcat (buf
, ", Version2 EABI");
1615 /* Process flags one bit at a time. */
1616 flag
= e_flags
& - e_flags
;
1621 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1622 strcat (buf
, ", sorted symbol tables");
1625 case EF_ARM_DYNSYMSUSESEGIDX
:
1626 strcat (buf
, ", dynamic symbols use segment index");
1629 case EF_ARM_MAPSYMSFIRST
:
1630 strcat (buf
, ", mapping symbols precede others");
1640 case EF_ARM_EABI_UNKNOWN
:
1641 strcat (buf
, ", GNU EABI");
1646 /* Process flags one bit at a time. */
1647 flag
= e_flags
& - e_flags
;
1652 case EF_ARM_INTERWORK
:
1653 strcat (buf
, ", interworking enabled");
1656 case EF_ARM_APCS_26
:
1657 strcat (buf
, ", uses APCS/26");
1660 case EF_ARM_APCS_FLOAT
:
1661 strcat (buf
, ", uses APCS/float");
1665 strcat (buf
, ", position independent");
1669 strcat (buf
, ", 8 bit structure alignment");
1672 case EF_ARM_NEW_ABI
:
1673 strcat (buf
, ", uses new ABI");
1676 case EF_ARM_OLD_ABI
:
1677 strcat (buf
, ", uses old ABI");
1680 case EF_ARM_SOFT_FLOAT
:
1681 strcat (buf
, ", software FP");
1692 strcat (buf
,", <unknown>");
1696 get_machine_flags (e_flags
, e_machine
)
1700 static char buf
[1024];
1712 decode_ARM_machine_flags (e_flags
, buf
);
1716 if (e_flags
& EF_CPU32
)
1717 strcat (buf
, ", cpu32");
1718 if (e_flags
& EF_M68000
)
1719 strcat (buf
, ", m68000");
1723 if (e_flags
& EF_PPC_EMB
)
1724 strcat (buf
, ", emb");
1726 if (e_flags
& EF_PPC_RELOCATABLE
)
1727 strcat (buf
, ", relocatable");
1729 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
1730 strcat (buf
, ", relocatable-lib");
1734 case EM_CYGNUS_V850
:
1735 switch (e_flags
& EF_V850_ARCH
)
1738 strcat (buf
, ", v850e");
1741 strcat (buf
, ", v850ea");
1744 strcat (buf
, ", v850");
1747 strcat (buf
, ", unknown v850 architecture variant");
1753 case EM_CYGNUS_M32R
:
1754 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
1755 strcat (buf
, ", m32r");
1760 case EM_MIPS_RS3_LE
:
1761 if (e_flags
& EF_MIPS_NOREORDER
)
1762 strcat (buf
, ", noreorder");
1764 if (e_flags
& EF_MIPS_PIC
)
1765 strcat (buf
, ", pic");
1767 if (e_flags
& EF_MIPS_CPIC
)
1768 strcat (buf
, ", cpic");
1770 if (e_flags
& EF_MIPS_UCODE
)
1771 strcat (buf
, ", ugen_reserved");
1773 if (e_flags
& EF_MIPS_ABI2
)
1774 strcat (buf
, ", abi2");
1776 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
1777 strcat (buf
, ", odk first");
1779 if (e_flags
& EF_MIPS_32BITMODE
)
1780 strcat (buf
, ", 32bitmode");
1782 switch ((e_flags
& EF_MIPS_MACH
))
1784 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
1785 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
1786 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
1787 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
1788 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
1789 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
1791 /* We simply ignore the field in this case to avoid confusion:
1792 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
1795 default: strcat (buf
, ", unknown CPU"); break;
1798 switch ((e_flags
& EF_MIPS_ABI
))
1800 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
1801 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
1802 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
1803 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
1805 /* We simply ignore the field in this case to avoid confusion:
1806 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
1807 This means it is likely to be an o32 file, but not for
1810 default: strcat (buf
, ", unknown ABI"); break;
1813 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
1814 strcat (buf
, ", mdmx");
1816 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
1817 strcat (buf
, ", mips16");
1819 switch ((e_flags
& EF_MIPS_ARCH
))
1821 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
1822 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
1823 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
1824 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
1825 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
1826 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
1827 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
1828 default: strcat (buf
, ", unknown ISA"); break;
1834 if (e_flags
& EF_SPARC_32PLUS
)
1835 strcat (buf
, ", v8+");
1837 if (e_flags
& EF_SPARC_SUN_US1
)
1838 strcat (buf
, ", ultrasparcI");
1840 if (e_flags
& EF_SPARC_SUN_US3
)
1841 strcat (buf
, ", ultrasparcIII");
1843 if (e_flags
& EF_SPARC_HAL_R1
)
1844 strcat (buf
, ", halr1");
1846 if (e_flags
& EF_SPARC_LEDATA
)
1847 strcat (buf
, ", ledata");
1849 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
1850 strcat (buf
, ", tso");
1852 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
1853 strcat (buf
, ", pso");
1855 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
1856 strcat (buf
, ", rmo");
1860 switch (e_flags
& EF_PARISC_ARCH
)
1862 case EFA_PARISC_1_0
:
1863 strcpy (buf
, ", PA-RISC 1.0");
1865 case EFA_PARISC_1_1
:
1866 strcpy (buf
, ", PA-RISC 1.1");
1868 case EFA_PARISC_2_0
:
1869 strcpy (buf
, ", PA-RISC 2.0");
1874 if (e_flags
& EF_PARISC_TRAPNIL
)
1875 strcat (buf
, ", trapnil");
1876 if (e_flags
& EF_PARISC_EXT
)
1877 strcat (buf
, ", ext");
1878 if (e_flags
& EF_PARISC_LSB
)
1879 strcat (buf
, ", lsb");
1880 if (e_flags
& EF_PARISC_WIDE
)
1881 strcat (buf
, ", wide");
1882 if (e_flags
& EF_PARISC_NO_KABP
)
1883 strcat (buf
, ", no kabp");
1884 if (e_flags
& EF_PARISC_LAZYSWAP
)
1885 strcat (buf
, ", lazyswap");
1890 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
1891 strcat (buf
, ", new calling convention");
1893 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
1894 strcat (buf
, ", gnu calling convention");
1898 if ((e_flags
& EF_IA_64_ABI64
))
1899 strcat (buf
, ", 64-bit");
1901 strcat (buf
, ", 32-bit");
1902 if ((e_flags
& EF_IA_64_REDUCEDFP
))
1903 strcat (buf
, ", reduced fp model");
1904 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
1905 strcat (buf
, ", no function descriptors, constant gp");
1906 else if ((e_flags
& EF_IA_64_CONS_GP
))
1907 strcat (buf
, ", constant gp");
1908 if ((e_flags
& EF_IA_64_ABSOLUTE
))
1909 strcat (buf
, ", absolute");
1918 get_mips_segment_type (type
)
1923 case PT_MIPS_REGINFO
:
1925 case PT_MIPS_RTPROC
:
1927 case PT_MIPS_OPTIONS
:
1937 get_parisc_segment_type (type
)
1942 case PT_HP_TLS
: return "HP_TLS";
1943 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
1944 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
1945 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
1946 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
1947 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
1948 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
1949 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
1950 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
1951 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
1952 case PT_HP_PARALLEL
: return "HP_PARALLEL";
1953 case PT_HP_FASTBIND
: return "HP_FASTBIND";
1954 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
1955 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
1964 get_ia64_segment_type (type
)
1969 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
1970 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
1971 case PT_HP_TLS
: return "HP_TLS";
1972 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
1973 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
1974 case PT_IA_64_HP_STACK
: return "HP_STACK";
1983 get_segment_type (p_type
)
1984 unsigned long p_type
;
1986 static char buff
[32];
1990 case PT_NULL
: return "NULL";
1991 case PT_LOAD
: return "LOAD";
1992 case PT_DYNAMIC
: return "DYNAMIC";
1993 case PT_INTERP
: return "INTERP";
1994 case PT_NOTE
: return "NOTE";
1995 case PT_SHLIB
: return "SHLIB";
1996 case PT_PHDR
: return "PHDR";
1997 case PT_TLS
: return "TLS";
1999 case PT_GNU_EH_FRAME
:
2000 return "GNU_EH_FRAME";
2003 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2005 const char * result
;
2007 switch (elf_header
.e_machine
)
2010 case EM_MIPS_RS3_LE
:
2011 result
= get_mips_segment_type (p_type
);
2014 result
= get_parisc_segment_type (p_type
);
2017 result
= get_ia64_segment_type (p_type
);
2027 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2029 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2031 const char * result
;
2033 switch (elf_header
.e_machine
)
2036 result
= get_parisc_segment_type (p_type
);
2039 result
= get_ia64_segment_type (p_type
);
2049 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2052 sprintf (buff
, _("<unknown>: %lx"), p_type
);
2059 get_mips_section_type_name (sh_type
)
2060 unsigned int sh_type
;
2064 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2065 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2066 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2067 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2068 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2069 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2070 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2071 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2072 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2073 case SHT_MIPS_RELD
: return "MIPS_RELD";
2074 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2075 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2076 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2077 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2078 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2079 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2080 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2081 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2082 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2083 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2084 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2085 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2086 case SHT_MIPS_LINE
: return "MIPS_LINE";
2087 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2088 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2089 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2090 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2091 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2092 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2093 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2094 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2095 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2096 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2097 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2098 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2099 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2100 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2101 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2102 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2110 get_parisc_section_type_name (sh_type
)
2111 unsigned int sh_type
;
2115 case SHT_PARISC_EXT
: return "PARISC_EXT";
2116 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2117 case SHT_PARISC_DOC
: return "PARISC_DOC";
2125 get_ia64_section_type_name (sh_type
)
2126 unsigned int sh_type
;
2130 case SHT_IA_64_EXT
: return "IA_64_EXT";
2131 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2139 get_section_type_name (sh_type
)
2140 unsigned int sh_type
;
2142 static char buff
[32];
2146 case SHT_NULL
: return "NULL";
2147 case SHT_PROGBITS
: return "PROGBITS";
2148 case SHT_SYMTAB
: return "SYMTAB";
2149 case SHT_STRTAB
: return "STRTAB";
2150 case SHT_RELA
: return "RELA";
2151 case SHT_HASH
: return "HASH";
2152 case SHT_DYNAMIC
: return "DYNAMIC";
2153 case SHT_NOTE
: return "NOTE";
2154 case SHT_NOBITS
: return "NOBITS";
2155 case SHT_REL
: return "REL";
2156 case SHT_SHLIB
: return "SHLIB";
2157 case SHT_DYNSYM
: return "DYNSYM";
2158 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2159 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2160 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2161 case SHT_GROUP
: return "GROUP";
2162 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2163 case SHT_GNU_verdef
: return "VERDEF";
2164 case SHT_GNU_verneed
: return "VERNEED";
2165 case SHT_GNU_versym
: return "VERSYM";
2166 case 0x6ffffff0: return "VERSYM";
2167 case 0x6ffffffc: return "VERDEF";
2168 case 0x7ffffffd: return "AUXILIARY";
2169 case 0x7fffffff: return "FILTER";
2172 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2174 const char * result
;
2176 switch (elf_header
.e_machine
)
2179 case EM_MIPS_RS3_LE
:
2180 result
= get_mips_section_type_name (sh_type
);
2183 result
= get_parisc_section_type_name (sh_type
);
2186 result
= get_ia64_section_type_name (sh_type
);
2196 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2198 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2199 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2200 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2201 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2203 sprintf (buff
, _("<unknown>: %x"), sh_type
);
2209 struct option options
[] =
2211 {"all", no_argument
, 0, 'a'},
2212 {"file-header", no_argument
, 0, 'h'},
2213 {"program-headers", no_argument
, 0, 'l'},
2214 {"headers", no_argument
, 0, 'e'},
2215 {"histogram", no_argument
, 0, 'I'},
2216 {"segments", no_argument
, 0, 'l'},
2217 {"sections", no_argument
, 0, 'S'},
2218 {"section-headers", no_argument
, 0, 'S'},
2219 {"symbols", no_argument
, 0, 's'},
2220 {"syms", no_argument
, 0, 's'},
2221 {"relocs", no_argument
, 0, 'r'},
2222 {"notes", no_argument
, 0, 'n'},
2223 {"dynamic", no_argument
, 0, 'd'},
2224 {"arch-specific", no_argument
, 0, 'A'},
2225 {"version-info", no_argument
, 0, 'V'},
2226 {"use-dynamic", no_argument
, 0, 'D'},
2227 {"hex-dump", required_argument
, 0, 'x'},
2228 {"debug-dump", optional_argument
, 0, 'w'},
2229 {"unwind", no_argument
, 0, 'u'},
2230 #ifdef SUPPORT_DISASSEMBLY
2231 {"instruction-dump", required_argument
, 0, 'i'},
2234 {"version", no_argument
, 0, 'v'},
2235 {"wide", no_argument
, 0, 'W'},
2236 {"help", no_argument
, 0, 'H'},
2237 {0, no_argument
, 0, 0}
2243 fprintf (stdout
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2244 fprintf (stdout
, _(" Display information about the contents of ELF format files\n"));
2245 fprintf (stdout
, _(" Options are:\n\
2246 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2247 -h --file-header Display the ELF file header\n\
2248 -l --program-headers Display the program headers\n\
2249 --segments An alias for --program-headers\n\
2250 -S --section-headers Display the sections' header\n\
2251 --sections An alias for --section-headers\n\
2252 -e --headers Equivalent to: -h -l -S\n\
2253 -s --syms Display the symbol table\n\
2254 --symbols An alias for --syms\n\
2255 -n --notes Display the core notes (if present)\n\
2256 -r --relocs Display the relocations (if present)\n\
2257 -u --unwind Display the unwind info (if present)\n\
2258 -d --dynamic Display the dynamic segment (if present)\n\
2259 -V --version-info Display the version sections (if present)\n\
2260 -A --arch-specific Display architecture specific information (if any).\n\
2261 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2262 -x --hex-dump=<number> Dump the contents of section <number>\n\
2263 -w --debug-dump[=line,=info,=abbrev,=pubnames,=ranges,=macro,=frames,=str,=loc]\n\
2264 Display the contents of DWARF2 debug sections\n"));
2265 #ifdef SUPPORT_DISASSEMBLY
2266 fprintf (stdout
, _("\
2267 -i --instruction-dump=<number>\n\
2268 Disassemble the contents of section <number>\n"));
2270 fprintf (stdout
, _("\
2271 -I --histogram Display histogram of bucket list lengths\n\
2272 -W --wide Allow output width to exceed 80 characters\n\
2273 -H --help Display this information\n\
2274 -v --version Display the version number of readelf\n"));
2275 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2281 request_dump (section
, type
)
2282 unsigned int section
;
2285 if (section
>= num_dump_sects
)
2287 char * new_dump_sects
;
2289 new_dump_sects
= (char *) calloc (section
+ 1, 1);
2291 if (new_dump_sects
== NULL
)
2292 error (_("Out of memory allocating dump request table."));
2295 /* Copy current flag settings. */
2296 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2300 dump_sects
= new_dump_sects
;
2301 num_dump_sects
= section
+ 1;
2306 dump_sects
[section
] |= type
;
2312 parse_args (argc
, argv
)
2321 while ((c
= getopt_long
2322 (argc
, argv
, "ersuahnldSDAIw::x:i:vVW", options
, NULL
)) != EOF
)
2358 do_using_dynamic
++;
2389 section
= strtoul (optarg
, & cp
, 0);
2390 if (! * cp
&& section
>= 0)
2392 request_dump (section
, HEX_DUMP
);
2402 unsigned int index
= 0;
2406 while (optarg
[index
])
2407 switch (optarg
[index
++])
2416 do_debug_abbrevs
= 1;
2426 do_debug_pubnames
= 1;
2431 do_debug_aranges
= 1;
2435 do_debug_frames_interp
= 1;
2437 do_debug_frames
= 1;
2442 do_debug_macinfo
= 1;
2456 warn (_("Unrecognized debug option '%s'\n"), optarg
);
2461 #ifdef SUPPORT_DISASSEMBLY
2464 section
= strtoul (optarg
, & cp
, 0);
2465 if (! * cp
&& section
>= 0)
2467 request_dump (section
, DISASS_DUMP
);
2473 print_version (program_name
);
2483 /* xgettext:c-format */
2484 error (_("Invalid option '-%c'\n"), c
);
2491 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
2492 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
2493 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
)
2497 warn (_("Nothing to do.\n"));
2503 get_elf_class (elf_class
)
2504 unsigned int elf_class
;
2506 static char buff
[32];
2510 case ELFCLASSNONE
: return _("none");
2511 case ELFCLASS32
: return "ELF32";
2512 case ELFCLASS64
: return "ELF64";
2514 sprintf (buff
, _("<unknown: %x>"), elf_class
);
2520 get_data_encoding (encoding
)
2521 unsigned int encoding
;
2523 static char buff
[32];
2527 case ELFDATANONE
: return _("none");
2528 case ELFDATA2LSB
: return _("2's complement, little endian");
2529 case ELFDATA2MSB
: return _("2's complement, big endian");
2531 sprintf (buff
, _("<unknown: %x>"), encoding
);
2537 get_osabi_name (osabi
)
2540 static char buff
[32];
2544 case ELFOSABI_NONE
: return "UNIX - System V";
2545 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2546 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2547 case ELFOSABI_LINUX
: return "UNIX - Linux";
2548 case ELFOSABI_HURD
: return "GNU/Hurd";
2549 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2550 case ELFOSABI_AIX
: return "UNIX - AIX";
2551 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2552 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2553 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2554 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2555 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2556 case ELFOSABI_STANDALONE
: return _("Standalone App");
2557 case ELFOSABI_ARM
: return "ARM";
2559 sprintf (buff
, _("<unknown: %x>"), osabi
);
2564 /* Decode the data held in 'elf_header'. */
2566 process_file_header ()
2568 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
2569 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
2570 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
2571 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
2574 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2582 printf (_("ELF Header:\n"));
2583 printf (_(" Magic: "));
2584 for (i
= 0; i
< EI_NIDENT
; i
++)
2585 printf ("%2.2x ", elf_header
.e_ident
[i
]);
2587 printf (_(" Class: %s\n"),
2588 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
2589 printf (_(" Data: %s\n"),
2590 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
2591 printf (_(" Version: %d %s\n"),
2592 elf_header
.e_ident
[EI_VERSION
],
2593 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
2595 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
2598 printf (_(" OS/ABI: %s\n"),
2599 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
2600 printf (_(" ABI Version: %d\n"),
2601 elf_header
.e_ident
[EI_ABIVERSION
]);
2602 printf (_(" Type: %s\n"),
2603 get_file_type (elf_header
.e_type
));
2604 printf (_(" Machine: %s\n"),
2605 get_machine_name (elf_header
.e_machine
));
2606 printf (_(" Version: 0x%lx\n"),
2607 (unsigned long) elf_header
.e_version
);
2609 printf (_(" Entry point address: "));
2610 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2611 printf (_("\n Start of program headers: "));
2612 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2613 printf (_(" (bytes into file)\n Start of section headers: "));
2614 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
2615 printf (_(" (bytes into file)\n"));
2617 printf (_(" Flags: 0x%lx%s\n"),
2618 (unsigned long) elf_header
.e_flags
,
2619 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
2620 printf (_(" Size of this header: %ld (bytes)\n"),
2621 (long) elf_header
.e_ehsize
);
2622 printf (_(" Size of program headers: %ld (bytes)\n"),
2623 (long) elf_header
.e_phentsize
);
2624 printf (_(" Number of program headers: %ld\n"),
2625 (long) elf_header
.e_phnum
);
2626 printf (_(" Size of section headers: %ld (bytes)\n"),
2627 (long) elf_header
.e_shentsize
);
2628 printf (_(" Number of section headers: %ld"),
2629 (long) elf_header
.e_shnum
);
2630 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
2631 printf (" (%ld)", (long) section_headers
[0].sh_size
);
2632 putc ('\n', stdout
);
2633 printf (_(" Section header string table index: %ld"),
2634 (long) elf_header
.e_shstrndx
);
2635 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
2636 printf (" (%ld)", (long) section_headers
[0].sh_link
);
2637 putc ('\n', stdout
);
2640 if (section_headers
!= NULL
)
2642 if (elf_header
.e_shnum
== 0)
2643 elf_header
.e_shnum
= section_headers
[0].sh_size
;
2644 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
2645 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
2646 free (section_headers
);
2647 section_headers
= NULL
;
2655 get_32bit_program_headers (file
, program_headers
)
2657 Elf_Internal_Phdr
* program_headers
;
2659 Elf32_External_Phdr
* phdrs
;
2660 Elf32_External_Phdr
* external
;
2661 Elf32_Internal_Phdr
* internal
;
2664 phdrs
= ((Elf32_External_Phdr
*)
2665 get_data (NULL
, file
, elf_header
.e_phoff
,
2666 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2667 _("program headers")));
2671 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2672 i
< elf_header
.e_phnum
;
2673 i
++, internal
++, external
++)
2675 internal
->p_type
= BYTE_GET (external
->p_type
);
2676 internal
->p_offset
= BYTE_GET (external
->p_offset
);
2677 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
2678 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
2679 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
2680 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
2681 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2682 internal
->p_align
= BYTE_GET (external
->p_align
);
2691 get_64bit_program_headers (file
, program_headers
)
2693 Elf_Internal_Phdr
* program_headers
;
2695 Elf64_External_Phdr
* phdrs
;
2696 Elf64_External_Phdr
* external
;
2697 Elf64_Internal_Phdr
* internal
;
2700 phdrs
= ((Elf64_External_Phdr
*)
2701 get_data (NULL
, file
, elf_header
.e_phoff
,
2702 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2703 _("program headers")));
2707 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2708 i
< elf_header
.e_phnum
;
2709 i
++, internal
++, external
++)
2711 internal
->p_type
= BYTE_GET (external
->p_type
);
2712 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2713 internal
->p_offset
= BYTE_GET8 (external
->p_offset
);
2714 internal
->p_vaddr
= BYTE_GET8 (external
->p_vaddr
);
2715 internal
->p_paddr
= BYTE_GET8 (external
->p_paddr
);
2716 internal
->p_filesz
= BYTE_GET8 (external
->p_filesz
);
2717 internal
->p_memsz
= BYTE_GET8 (external
->p_memsz
);
2718 internal
->p_align
= BYTE_GET8 (external
->p_align
);
2727 process_program_headers (file
)
2730 Elf_Internal_Phdr
* program_headers
;
2731 Elf_Internal_Phdr
* segment
;
2734 if (elf_header
.e_phnum
== 0)
2737 printf (_("\nThere are no program headers in this file.\n"));
2741 if (do_segments
&& !do_header
)
2743 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
2744 printf (_("Entry point "));
2745 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2746 printf (_("\nThere are %d program headers, starting at offset "),
2747 elf_header
.e_phnum
);
2748 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2752 program_headers
= (Elf_Internal_Phdr
*) malloc
2753 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
2755 if (program_headers
== NULL
)
2757 error (_("Out of memory\n"));
2762 i
= get_32bit_program_headers (file
, program_headers
);
2764 i
= get_64bit_program_headers (file
, program_headers
);
2768 free (program_headers
);
2774 if (elf_header
.e_phnum
> 1)
2775 printf (_("\nProgram Headers:\n"));
2777 printf (_("\nProgram Headers:\n"));
2781 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2784 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2788 (_(" Type Offset VirtAddr PhysAddr\n"));
2790 (_(" FileSiz MemSiz Flags Align\n"));
2798 for (i
= 0, segment
= program_headers
;
2799 i
< elf_header
.e_phnum
;
2804 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
2808 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
2809 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
2810 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
2811 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
2812 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
2814 (segment
->p_flags
& PF_R
? 'R' : ' '),
2815 (segment
->p_flags
& PF_W
? 'W' : ' '),
2816 (segment
->p_flags
& PF_X
? 'E' : ' '));
2817 printf ("%#lx", (unsigned long) segment
->p_align
);
2821 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
2822 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
2825 print_vma (segment
->p_offset
, FULL_HEX
);
2829 print_vma (segment
->p_vaddr
, FULL_HEX
);
2831 print_vma (segment
->p_paddr
, FULL_HEX
);
2834 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
2835 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
2838 print_vma (segment
->p_filesz
, FULL_HEX
);
2842 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
2843 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
2846 print_vma (segment
->p_offset
, FULL_HEX
);
2850 (segment
->p_flags
& PF_R
? 'R' : ' '),
2851 (segment
->p_flags
& PF_W
? 'W' : ' '),
2852 (segment
->p_flags
& PF_X
? 'E' : ' '));
2854 if ((unsigned long) segment
->p_align
== segment
->p_align
)
2855 printf ("%#lx", (unsigned long) segment
->p_align
);
2858 print_vma (segment
->p_align
, PREFIX_HEX
);
2863 print_vma (segment
->p_offset
, FULL_HEX
);
2865 print_vma (segment
->p_vaddr
, FULL_HEX
);
2867 print_vma (segment
->p_paddr
, FULL_HEX
);
2869 print_vma (segment
->p_filesz
, FULL_HEX
);
2871 print_vma (segment
->p_memsz
, FULL_HEX
);
2873 (segment
->p_flags
& PF_R
? 'R' : ' '),
2874 (segment
->p_flags
& PF_W
? 'W' : ' '),
2875 (segment
->p_flags
& PF_X
? 'E' : ' '));
2876 print_vma (segment
->p_align
, HEX
);
2880 switch (segment
->p_type
)
2884 loadaddr
= (segment
->p_vaddr
& 0xfffff000)
2885 - (segment
->p_offset
& 0xfffff000);
2890 error (_("more than one dynamic segment\n"));
2892 dynamic_addr
= segment
->p_offset
;
2893 dynamic_size
= segment
->p_filesz
;
2897 if (fseek (file
, (long) segment
->p_offset
, SEEK_SET
))
2898 error (_("Unable to find program interpreter name\n"));
2901 program_interpreter
[0] = 0;
2902 fscanf (file
, "%63s", program_interpreter
);
2905 printf (_("\n [Requesting program interpreter: %s]"),
2906 program_interpreter
);
2912 putc ('\n', stdout
);
2921 if (do_segments
&& section_headers
!= NULL
)
2923 printf (_("\n Section to Segment mapping:\n"));
2924 printf (_(" Segment Sections...\n"));
2926 assert (string_table
!= NULL
);
2928 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
2931 Elf_Internal_Shdr
* section
;
2933 segment
= program_headers
+ i
;
2934 section
= section_headers
;
2936 printf (" %2.2d ", i
);
2938 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
2940 if (section
->sh_size
> 0
2941 /* Compare allocated sections by VMA, unallocated
2942 sections by file offset. */
2943 && (section
->sh_flags
& SHF_ALLOC
2944 ? (section
->sh_addr
>= segment
->p_vaddr
2945 && section
->sh_addr
+ section
->sh_size
2946 <= segment
->p_vaddr
+ segment
->p_memsz
)
2947 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
2948 && (section
->sh_offset
+ section
->sh_size
2949 <= segment
->p_offset
+ segment
->p_filesz
))))
2950 printf ("%s ", SECTION_NAME (section
));
2957 free (program_headers
);
2964 get_32bit_section_headers (file
, num
)
2968 Elf32_External_Shdr
* shdrs
;
2969 Elf32_Internal_Shdr
* internal
;
2972 shdrs
= ((Elf32_External_Shdr
*)
2973 get_data (NULL
, file
, elf_header
.e_shoff
,
2974 elf_header
.e_shentsize
* num
,
2975 _("section headers")));
2979 section_headers
= ((Elf_Internal_Shdr
*)
2980 malloc (num
* sizeof (Elf_Internal_Shdr
)));
2982 if (section_headers
== NULL
)
2984 error (_("Out of memory\n"));
2988 for (i
= 0, internal
= section_headers
;
2992 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
2993 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
2994 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
2995 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
2996 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
2997 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
2998 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
2999 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3000 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3001 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3010 get_64bit_section_headers (file
, num
)
3014 Elf64_External_Shdr
* shdrs
;
3015 Elf64_Internal_Shdr
* internal
;
3018 shdrs
= ((Elf64_External_Shdr
*)
3019 get_data (NULL
, file
, elf_header
.e_shoff
,
3020 elf_header
.e_shentsize
* num
,
3021 _("section headers")));
3025 section_headers
= ((Elf_Internal_Shdr
*)
3026 malloc (num
* sizeof (Elf_Internal_Shdr
)));
3028 if (section_headers
== NULL
)
3030 error (_("Out of memory\n"));
3034 for (i
= 0, internal
= section_headers
;
3038 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3039 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3040 internal
->sh_flags
= BYTE_GET8 (shdrs
[i
].sh_flags
);
3041 internal
->sh_addr
= BYTE_GET8 (shdrs
[i
].sh_addr
);
3042 internal
->sh_size
= BYTE_GET8 (shdrs
[i
].sh_size
);
3043 internal
->sh_entsize
= BYTE_GET8 (shdrs
[i
].sh_entsize
);
3044 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3045 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3046 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3047 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3055 static Elf_Internal_Sym
*
3056 get_32bit_elf_symbols (file
, section
)
3058 Elf_Internal_Shdr
*section
;
3060 unsigned long number
;
3061 Elf32_External_Sym
* esyms
;
3062 Elf_External_Sym_Shndx
*shndx
;
3063 Elf_Internal_Sym
* isyms
;
3064 Elf_Internal_Sym
* psym
;
3067 esyms
= ((Elf32_External_Sym
*)
3068 get_data (NULL
, file
, section
->sh_offset
,
3069 section
->sh_size
, _("symbols")));
3074 if (symtab_shndx_hdr
!= NULL
3075 && (symtab_shndx_hdr
->sh_link
3076 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3078 shndx
= ((Elf_External_Sym_Shndx
*)
3079 get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3080 symtab_shndx_hdr
->sh_size
, _("symtab shndx")));
3088 number
= section
->sh_size
/ section
->sh_entsize
;
3089 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
3093 error (_("Out of memory\n"));
3100 for (j
= 0, psym
= isyms
;
3104 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3105 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3106 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3107 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3108 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3110 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3111 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3112 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3122 static Elf_Internal_Sym
*
3123 get_64bit_elf_symbols (file
, section
)
3125 Elf_Internal_Shdr
*section
;
3127 unsigned long number
;
3128 Elf64_External_Sym
* esyms
;
3129 Elf_External_Sym_Shndx
*shndx
;
3130 Elf_Internal_Sym
* isyms
;
3131 Elf_Internal_Sym
* psym
;
3134 esyms
= ((Elf64_External_Sym
*)
3135 get_data (NULL
, file
, section
->sh_offset
,
3136 section
->sh_size
, _("symbols")));
3141 if (symtab_shndx_hdr
!= NULL
3142 && (symtab_shndx_hdr
->sh_link
3143 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3145 shndx
= ((Elf_External_Sym_Shndx
*)
3146 get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3147 symtab_shndx_hdr
->sh_size
, _("symtab shndx")));
3155 number
= section
->sh_size
/ section
->sh_entsize
;
3156 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
3160 error (_("Out of memory\n"));
3167 for (j
= 0, psym
= isyms
;
3171 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3172 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3173 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3174 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3175 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3177 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3178 psym
->st_value
= BYTE_GET8 (esyms
[j
].st_value
);
3179 psym
->st_size
= BYTE_GET8 (esyms
[j
].st_size
);
3190 get_elf_section_flags (sh_flags
)
3193 static char buff
[32];
3201 flag
= sh_flags
& - sh_flags
;
3206 case SHF_WRITE
: strcat (buff
, "W"); break;
3207 case SHF_ALLOC
: strcat (buff
, "A"); break;
3208 case SHF_EXECINSTR
: strcat (buff
, "X"); break;
3209 case SHF_MERGE
: strcat (buff
, "M"); break;
3210 case SHF_STRINGS
: strcat (buff
, "S"); break;
3211 case SHF_INFO_LINK
: strcat (buff
, "I"); break;
3212 case SHF_LINK_ORDER
: strcat (buff
, "L"); break;
3213 case SHF_OS_NONCONFORMING
: strcat (buff
, "O"); break;
3214 case SHF_GROUP
: strcat (buff
, "G"); break;
3215 case SHF_TLS
: strcat (buff
, "T"); break;
3218 if (flag
& SHF_MASKOS
)
3221 sh_flags
&= ~ SHF_MASKOS
;
3223 else if (flag
& SHF_MASKPROC
)
3226 sh_flags
&= ~ SHF_MASKPROC
;
3238 process_section_headers (file
)
3241 Elf_Internal_Shdr
* section
;
3244 section_headers
= NULL
;
3246 if (elf_header
.e_shnum
== 0)
3249 printf (_("\nThere are no sections in this file.\n"));
3254 if (do_sections
&& !do_header
)
3255 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3256 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
3260 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
3263 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
3266 /* Read in the string table, so that we have names to display. */
3267 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
3269 if (section
->sh_size
!= 0)
3271 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
3272 section
->sh_size
, _("string table"));
3274 string_table_length
= section
->sh_size
;
3277 /* Scan the sections for the dynamic symbol table
3278 and dynamic string table and debug sections. */
3279 dynamic_symbols
= NULL
;
3280 dynamic_strings
= NULL
;
3281 dynamic_syminfo
= NULL
;
3283 for (i
= 0, section
= section_headers
;
3284 i
< elf_header
.e_shnum
;
3287 char * name
= SECTION_NAME (section
);
3289 if (section
->sh_type
== SHT_DYNSYM
)
3291 if (dynamic_symbols
!= NULL
)
3293 error (_("File contains multiple dynamic symbol tables\n"));
3297 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
3298 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
3300 else if (section
->sh_type
== SHT_STRTAB
3301 && strcmp (name
, ".dynstr") == 0)
3303 if (dynamic_strings
!= NULL
)
3305 error (_("File contains multiple dynamic string tables\n"));
3309 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
3311 _("dynamic strings"));
3313 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
3315 if (symtab_shndx_hdr
!= NULL
)
3317 error (_("File contains multiple symtab shndx tables\n"));
3320 symtab_shndx_hdr
= section
;
3322 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
3323 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
3324 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
3326 && strncmp (name
, ".debug_", 7) == 0)
3331 || (do_debug_info
&& (strcmp (name
, "info") == 0))
3332 || (do_debug_abbrevs
&& (strcmp (name
, "abbrev") == 0))
3333 || (do_debug_lines
&& (strcmp (name
, "line") == 0))
3334 || (do_debug_pubnames
&& (strcmp (name
, "pubnames") == 0))
3335 || (do_debug_aranges
&& (strcmp (name
, "aranges") == 0))
3336 || (do_debug_frames
&& (strcmp (name
, "frame") == 0))
3337 || (do_debug_macinfo
&& (strcmp (name
, "macinfo") == 0))
3338 || (do_debug_str
&& (strcmp (name
, "str") == 0))
3339 || (do_debug_loc
&& (strcmp (name
, "loc") == 0))
3341 request_dump (i
, DEBUG_DUMP
);
3343 /* linkonce section to be combined with .debug_info at link time. */
3344 else if ((do_debugging
|| do_debug_info
)
3345 && strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
3346 request_dump (i
, DEBUG_DUMP
);
3347 else if (do_debug_frames
&& strcmp (name
, ".eh_frame") == 0)
3348 request_dump (i
, DEBUG_DUMP
);
3354 if (elf_header
.e_shnum
> 1)
3355 printf (_("\nSection Headers:\n"));
3357 printf (_("\nSection Header:\n"));
3361 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
3364 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
3367 printf (_(" [Nr] Name Type Address Offset\n"));
3368 printf (_(" Size EntSize Flags Link Info Align\n"));
3371 for (i
= 0, section
= section_headers
;
3372 i
< elf_header
.e_shnum
;
3375 printf (" [%2u] %-17.17s %-15.15s ",
3376 SECTION_HEADER_NUM (i
),
3377 SECTION_NAME (section
),
3378 get_section_type_name (section
->sh_type
));
3382 print_vma (section
->sh_addr
, LONG_HEX
);
3384 printf ( " %6.6lx %6.6lx %2.2lx",
3385 (unsigned long) section
->sh_offset
,
3386 (unsigned long) section
->sh_size
,
3387 (unsigned long) section
->sh_entsize
);
3389 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3391 printf ("%2ld %3lx %2ld\n",
3392 (unsigned long) section
->sh_link
,
3393 (unsigned long) section
->sh_info
,
3394 (unsigned long) section
->sh_addralign
);
3398 print_vma (section
->sh_addr
, LONG_HEX
);
3400 if ((long) section
->sh_offset
== section
->sh_offset
)
3401 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
3405 print_vma (section
->sh_offset
, LONG_HEX
);
3408 if ((unsigned long) section
->sh_size
== section
->sh_size
)
3409 printf (" %6.6lx", (unsigned long) section
->sh_size
);
3413 print_vma (section
->sh_size
, LONG_HEX
);
3416 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
3417 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
3421 print_vma (section
->sh_entsize
, LONG_HEX
);
3424 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3426 printf ("%2ld %3lx ",
3427 (unsigned long) section
->sh_link
,
3428 (unsigned long) section
->sh_info
);
3430 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
3431 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
3434 print_vma (section
->sh_addralign
, DEC
);
3441 print_vma (section
->sh_addr
, LONG_HEX
);
3442 if ((long) section
->sh_offset
== section
->sh_offset
)
3443 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
3447 print_vma (section
->sh_offset
, LONG_HEX
);
3450 print_vma (section
->sh_size
, LONG_HEX
);
3452 print_vma (section
->sh_entsize
, LONG_HEX
);
3454 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3456 printf (" %2ld %3lx %ld\n",
3457 (unsigned long) section
->sh_link
,
3458 (unsigned long) section
->sh_info
,
3459 (unsigned long) section
->sh_addralign
);
3463 printf (_("Key to Flags:\n\
3464 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
3465 I (info), L (link order), G (group), x (unknown)\n\
3466 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3471 /* Process the reloc section. */
3473 process_relocs (file
)
3476 unsigned long rel_size
;
3477 unsigned long rel_offset
;
3483 if (do_using_dynamic
)
3485 int is_rela
= FALSE
;
3490 if (dynamic_info
[DT_REL
])
3492 rel_offset
= dynamic_info
[DT_REL
];
3493 rel_size
= dynamic_info
[DT_RELSZ
];
3496 else if (dynamic_info
[DT_RELA
])
3498 rel_offset
= dynamic_info
[DT_RELA
];
3499 rel_size
= dynamic_info
[DT_RELASZ
];
3502 else if (dynamic_info
[DT_JMPREL
])
3504 rel_offset
= dynamic_info
[DT_JMPREL
];
3505 rel_size
= dynamic_info
[DT_PLTRELSZ
];
3507 switch (dynamic_info
[DT_PLTREL
])
3524 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
3525 rel_offset
, rel_size
);
3527 dump_relocations (file
, rel_offset
- loadaddr
, rel_size
,
3528 dynamic_symbols
, num_dynamic_syms
, dynamic_strings
, is_rela
);
3531 printf (_("\nThere are no dynamic relocations in this file.\n"));
3535 Elf32_Internal_Shdr
* section
;
3539 for (i
= 0, section
= section_headers
;
3540 i
< elf_header
.e_shnum
;
3543 if ( section
->sh_type
!= SHT_RELA
3544 && section
->sh_type
!= SHT_REL
)
3547 rel_offset
= section
->sh_offset
;
3548 rel_size
= section
->sh_size
;
3552 Elf32_Internal_Shdr
* strsec
;
3553 Elf_Internal_Sym
* symtab
;
3556 unsigned long nsyms
;
3558 printf (_("\nRelocation section "));
3560 if (string_table
== NULL
)
3561 printf ("%d", section
->sh_name
);
3563 printf (_("'%s'"), SECTION_NAME (section
));
3565 printf (_(" at offset 0x%lx contains %lu entries:\n"),
3566 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
3571 if (section
->sh_link
)
3573 Elf32_Internal_Shdr
* symsec
;
3575 symsec
= SECTION_HEADER (section
->sh_link
);
3576 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
3577 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
3582 strsec
= SECTION_HEADER (symsec
->sh_link
);
3584 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
3588 is_rela
= section
->sh_type
== SHT_RELA
;
3590 dump_relocations (file
, rel_offset
, rel_size
,
3591 symtab
, nsyms
, strtab
, is_rela
);
3603 printf (_("\nThere are no relocations in this file.\n"));
3609 #include "unwind-ia64.h"
3611 /* An absolute address consists of a section and an offset. If the
3612 section is NULL, the offset itself is the address, otherwise, the
3613 address equals to LOAD_ADDRESS(section) + offset. */
3617 unsigned short section
;
3623 struct unw_table_entry
3625 struct absaddr start
;
3627 struct absaddr info
;
3629 *table
; /* Unwind table. */
3630 unsigned long table_len
; /* Length of unwind table. */
3631 unsigned char * info
; /* Unwind info. */
3632 unsigned long info_size
; /* Size of unwind info. */
3633 bfd_vma info_addr
; /* starting address of unwind info. */
3634 bfd_vma seg_base
; /* Starting address of segment. */
3635 Elf_Internal_Sym
* symtab
; /* The symbol table. */
3636 unsigned long nsyms
; /* Number of symbols. */
3637 char * strtab
; /* The string table. */
3638 unsigned long strtab_size
; /* Size of string table. */
3641 static void find_symbol_for_address
PARAMS ((struct unw_aux_info
*,
3642 struct absaddr
, const char **,
3644 static void dump_ia64_unwind
PARAMS ((struct unw_aux_info
*));
3645 static int slurp_ia64_unwind_table
PARAMS ((FILE *, struct unw_aux_info
*,
3646 Elf32_Internal_Shdr
*));
3649 find_symbol_for_address (aux
, addr
, symname
, offset
)
3650 struct unw_aux_info
*aux
;
3651 struct absaddr addr
;
3652 const char **symname
;
3655 bfd_vma dist
= (bfd_vma
) 0x100000;
3656 Elf_Internal_Sym
*sym
, *best
= NULL
;
3659 for (i
= 0, sym
= aux
->symtab
; i
< aux
->nsyms
; ++i
, ++sym
)
3661 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
3662 && sym
->st_name
!= 0
3663 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
3664 && addr
.offset
>= sym
->st_value
3665 && addr
.offset
- sym
->st_value
< dist
)
3668 dist
= addr
.offset
- sym
->st_value
;
3675 *symname
= (best
->st_name
>= aux
->strtab_size
3676 ? "<corrupt>" : aux
->strtab
+ best
->st_name
);
3681 *offset
= addr
.offset
;
3685 dump_ia64_unwind (aux
)
3686 struct unw_aux_info
*aux
;
3689 struct unw_table_entry
* tp
;
3692 addr_size
= is_32bit_elf
? 4 : 8;
3694 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
3698 const unsigned char * dp
;
3699 const unsigned char * head
;
3700 const char * procname
;
3702 find_symbol_for_address (aux
, tp
->start
, &procname
, &offset
);
3704 fputs ("\n<", stdout
);
3708 fputs (procname
, stdout
);
3711 printf ("+%lx", (unsigned long) offset
);
3714 fputs (">: [", stdout
);
3715 print_vma (tp
->start
.offset
, PREFIX_HEX
);
3716 fputc ('-', stdout
);
3717 print_vma (tp
->end
.offset
, PREFIX_HEX
);
3718 printf ("), info at +0x%lx\n",
3719 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
3721 head
= aux
->info
+ (tp
->info
.offset
- aux
->info_addr
);
3722 stamp
= BYTE_GET8 ((unsigned char *) head
);
3724 printf (" v%u, flags=0x%lx (%s%s ), len=%lu bytes\n",
3725 (unsigned) UNW_VER (stamp
),
3726 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
3727 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
3728 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
3729 (unsigned long) (addr_size
* UNW_LENGTH (stamp
)));
3731 if (UNW_VER (stamp
) != 1)
3733 printf ("\tUnknown version.\n");
3738 for (dp
= head
+ 8; dp
< head
+ 8 + addr_size
* UNW_LENGTH (stamp
);)
3739 dp
= unw_decode (dp
, in_body
, & in_body
);
3744 slurp_ia64_unwind_table (file
, aux
, sec
)
3746 struct unw_aux_info
*aux
;
3747 Elf32_Internal_Shdr
*sec
;
3749 unsigned long size
, addr_size
, nrelas
, i
;
3750 Elf_Internal_Phdr
*prog_hdrs
, *seg
;
3751 struct unw_table_entry
*tep
;
3752 Elf32_Internal_Shdr
*relsec
;
3753 Elf_Internal_Rela
*rela
, *rp
;
3754 unsigned char *table
, *tp
;
3755 Elf_Internal_Sym
*sym
;
3756 const char *relname
;
3759 addr_size
= is_32bit_elf
? 4 : 8;
3761 /* First, find the starting address of the segment that includes
3764 if (elf_header
.e_phnum
)
3766 prog_hdrs
= (Elf_Internal_Phdr
*)
3767 xmalloc (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
3770 result
= get_32bit_program_headers (file
, prog_hdrs
);
3772 result
= get_64bit_program_headers (file
, prog_hdrs
);
3780 for (seg
= prog_hdrs
; seg
< prog_hdrs
+ elf_header
.e_phnum
; ++seg
)
3782 if (seg
->p_type
!= PT_LOAD
)
3785 if (sec
->sh_addr
>= seg
->p_vaddr
3786 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
3788 aux
->seg_base
= seg
->p_vaddr
;
3796 /* Second, build the unwind table from the contents of the unwind section: */
3797 size
= sec
->sh_size
;
3798 table
= (char *) get_data (NULL
, file
, sec
->sh_offset
,
3799 size
, _("unwind table"));
3803 tep
= aux
->table
= xmalloc (size
/ (3 * addr_size
) * sizeof (aux
->table
[0]));
3804 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * addr_size
, ++ tep
)
3806 tep
->start
.section
= SHN_UNDEF
;
3807 tep
->end
.section
= SHN_UNDEF
;
3808 tep
->info
.section
= SHN_UNDEF
;
3811 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
3812 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
3813 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
3817 tep
->start
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 0);
3818 tep
->end
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 8);
3819 tep
->info
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 16);
3821 tep
->start
.offset
+= aux
->seg_base
;
3822 tep
->end
.offset
+= aux
->seg_base
;
3823 tep
->info
.offset
+= aux
->seg_base
;
3827 /* Third, apply any relocations to the unwind table: */
3829 for (relsec
= section_headers
;
3830 relsec
< section_headers
+ elf_header
.e_shnum
;
3833 if (relsec
->sh_type
!= SHT_RELA
3834 || SECTION_HEADER (relsec
->sh_info
) != sec
)
3837 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
3841 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
3845 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
3846 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
3848 if (ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
3850 warn (_("Skipping unexpected symbol type %u\n"),
3851 ELF32_ST_TYPE (sym
->st_info
));
3857 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
3858 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
3860 if (ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
3862 warn (_("Skipping unexpected symbol type %u\n"),
3863 ELF64_ST_TYPE (sym
->st_info
));
3868 if (strncmp (relname
, "R_IA64_SEGREL", 13) != 0)
3870 warn (_("Skipping unexpected relocation type %s\n"), relname
);
3874 i
= rp
->r_offset
/ (3 * addr_size
);
3876 switch (rp
->r_offset
/addr_size
% 3)
3879 aux
->table
[i
].start
.section
= sym
->st_shndx
;
3880 aux
->table
[i
].start
.offset
+= rp
->r_addend
;
3883 aux
->table
[i
].end
.section
= sym
->st_shndx
;
3884 aux
->table
[i
].end
.offset
+= rp
->r_addend
;
3887 aux
->table
[i
].info
.section
= sym
->st_shndx
;
3888 aux
->table
[i
].info
.offset
+= rp
->r_addend
;
3898 aux
->table_len
= size
/ (3 * addr_size
);
3903 process_unwind (file
)
3906 Elf32_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
3907 unsigned long i
, addr_size
, unwcount
= 0, unwstart
= 0;
3908 struct unw_aux_info aux
;
3913 if (elf_header
.e_machine
!= EM_IA_64
)
3915 printf (_("\nThere are no unwind sections in this file.\n"));
3919 memset (& aux
, 0, sizeof (aux
));
3921 addr_size
= is_32bit_elf
? 4 : 8;
3923 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
3925 if (sec
->sh_type
== SHT_SYMTAB
)
3927 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
3928 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
3930 strsec
= SECTION_HEADER (sec
->sh_link
);
3931 aux
.strtab_size
= strsec
->sh_size
;
3932 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
3933 aux
.strtab_size
, _("string table"));
3935 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
3940 printf (_("\nThere are no unwind sections in this file.\n"));
3942 while (unwcount
-- > 0)
3947 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
3948 i
< elf_header
.e_shnum
; ++i
, ++sec
)
3949 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
3956 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
3958 if (strncmp (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
,
3961 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO */
3962 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
3963 suffix
= SECTION_NAME (unwsec
) + len
;
3964 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
3966 if (strncmp (SECTION_NAME (sec
),
3967 ELF_STRING_ia64_unwind_info_once
, len2
) == 0
3968 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
3973 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
3974 .IA_64.unwind or BAR -> .IA_64.unwind_info */
3975 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
3976 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
3978 if (strncmp (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
,
3980 suffix
= SECTION_NAME (unwsec
) + len
;
3981 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
3983 if (strncmp (SECTION_NAME (sec
),
3984 ELF_STRING_ia64_unwind_info
, len2
) == 0
3985 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
3989 if (i
== elf_header
.e_shnum
)
3991 printf (_("\nCould not find unwind info section for "));
3993 if (string_table
== NULL
)
3994 printf ("%d", unwsec
->sh_name
);
3996 printf (_("'%s'"), SECTION_NAME (unwsec
));
4000 aux
.info_size
= sec
->sh_size
;
4001 aux
.info_addr
= sec
->sh_addr
;
4002 aux
.info
= (char *) get_data (NULL
, file
, sec
->sh_offset
,
4003 aux
.info_size
, _("unwind info"));
4005 printf (_("\nUnwind section "));
4007 if (string_table
== NULL
)
4008 printf ("%d", unwsec
->sh_name
);
4010 printf (_("'%s'"), SECTION_NAME (unwsec
));
4012 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4013 (unsigned long) unwsec
->sh_offset
,
4014 (unsigned long) (unwsec
->sh_size
/ (3 * addr_size
)));
4016 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
4018 if (aux
.table_len
> 0)
4019 dump_ia64_unwind (& aux
);
4022 free ((char *) aux
.table
);
4024 free ((char *) aux
.info
);
4033 free ((char *) aux
.strtab
);
4039 dynamic_segment_mips_val (entry
)
4040 Elf_Internal_Dyn
* entry
;
4042 switch (entry
->d_tag
)
4045 if (entry
->d_un
.d_val
== 0)
4049 static const char * opts
[] =
4051 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
4052 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
4053 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
4054 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
4059 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++ cnt
)
4060 if (entry
->d_un
.d_val
& (1 << cnt
))
4062 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
4069 case DT_MIPS_IVERSION
:
4070 if (dynamic_strings
!= NULL
)
4071 printf ("Interface Version: %s\n",
4072 dynamic_strings
+ entry
->d_un
.d_val
);
4074 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
4077 case DT_MIPS_TIME_STAMP
:
4082 time_t time
= entry
->d_un
.d_val
;
4083 tmp
= gmtime (&time
);
4084 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
4085 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
4086 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
4087 printf ("Time Stamp: %s\n", timebuf
);
4091 case DT_MIPS_RLD_VERSION
:
4092 case DT_MIPS_LOCAL_GOTNO
:
4093 case DT_MIPS_CONFLICTNO
:
4094 case DT_MIPS_LIBLISTNO
:
4095 case DT_MIPS_SYMTABNO
:
4096 case DT_MIPS_UNREFEXTNO
:
4097 case DT_MIPS_HIPAGENO
:
4098 case DT_MIPS_DELTA_CLASS_NO
:
4099 case DT_MIPS_DELTA_INSTANCE_NO
:
4100 case DT_MIPS_DELTA_RELOC_NO
:
4101 case DT_MIPS_DELTA_SYM_NO
:
4102 case DT_MIPS_DELTA_CLASSSYM_NO
:
4103 case DT_MIPS_COMPACT_SIZE
:
4104 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
4108 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
4114 dynamic_segment_parisc_val (entry
)
4115 Elf_Internal_Dyn
* entry
;
4117 switch (entry
->d_tag
)
4119 case DT_HP_DLD_FLAGS
:
4128 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
4129 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
4130 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
4131 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
4132 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
4133 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
4134 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
4135 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
4136 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
4137 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
4138 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
4142 bfd_vma val
= entry
->d_un
.d_val
;
4144 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
4145 if (val
& flags
[cnt
].bit
)
4149 fputs (flags
[cnt
].str
, stdout
);
4151 val
^= flags
[cnt
].bit
;
4154 if (val
!= 0 || first
)
4158 print_vma (val
, HEX
);
4164 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
4170 get_32bit_dynamic_segment (file
)
4173 Elf32_External_Dyn
* edyn
;
4174 Elf_Internal_Dyn
* entry
;
4177 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
,
4178 dynamic_size
, _("dynamic segment"));
4182 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
4183 how large this .dynamic is now. We can do this even before the byte
4184 swapping since the DT_NULL tag is recognizable. */
4186 while (*(Elf32_Word
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
4189 dynamic_segment
= (Elf_Internal_Dyn
*)
4190 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
4192 if (dynamic_segment
== NULL
)
4194 error (_("Out of memory\n"));
4199 for (i
= 0, entry
= dynamic_segment
;
4203 entry
->d_tag
= BYTE_GET (edyn
[i
].d_tag
);
4204 entry
->d_un
.d_val
= BYTE_GET (edyn
[i
].d_un
.d_val
);
4213 get_64bit_dynamic_segment (file
)
4216 Elf64_External_Dyn
* edyn
;
4217 Elf_Internal_Dyn
* entry
;
4220 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
,
4221 dynamic_size
, _("dynamic segment"));
4225 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
4226 how large this .dynamic is now. We can do this even before the byte
4227 swapping since the DT_NULL tag is recognizable. */
4229 while (*(bfd_vma
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
4232 dynamic_segment
= (Elf_Internal_Dyn
*)
4233 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
4235 if (dynamic_segment
== NULL
)
4237 error (_("Out of memory\n"));
4242 for (i
= 0, entry
= dynamic_segment
;
4246 entry
->d_tag
= BYTE_GET8 (edyn
[i
].d_tag
);
4247 entry
->d_un
.d_val
= BYTE_GET8 (edyn
[i
].d_un
.d_val
);
4256 get_dynamic_flags (flags
)
4259 static char buff
[128];
4267 flag
= flags
& - flags
;
4275 case DF_ORIGIN
: strcpy (p
, "ORIGIN"); break;
4276 case DF_SYMBOLIC
: strcpy (p
, "SYMBOLIC"); break;
4277 case DF_TEXTREL
: strcpy (p
, "TEXTREL"); break;
4278 case DF_BIND_NOW
: strcpy (p
, "BIND_NOW"); break;
4279 case DF_STATIC_TLS
: strcpy (p
, "STATIC_TLS"); break;
4280 default: strcpy (p
, "unknown"); break;
4283 p
= strchr (p
, '\0');
4288 /* Parse and display the contents of the dynamic segment. */
4290 process_dynamic_segment (file
)
4293 Elf_Internal_Dyn
* entry
;
4296 if (dynamic_size
== 0)
4299 printf (_("\nThere is no dynamic segment in this file.\n"));
4306 if (! get_32bit_dynamic_segment (file
))
4309 else if (! get_64bit_dynamic_segment (file
))
4312 /* Find the appropriate symbol table. */
4313 if (dynamic_symbols
== NULL
)
4315 for (i
= 0, entry
= dynamic_segment
;
4319 Elf32_Internal_Shdr section
;
4321 if (entry
->d_tag
!= DT_SYMTAB
)
4324 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
4326 /* Since we do not know how big the symbol table is,
4327 we default to reading in the entire file (!) and
4328 processing that. This is overkill, I know, but it
4330 section
.sh_offset
= entry
->d_un
.d_val
- loadaddr
;
4332 if (fseek (file
, 0, SEEK_END
))
4333 error (_("Unable to seek to end of file!"));
4335 section
.sh_size
= ftell (file
) - section
.sh_offset
;
4337 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
4339 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
4341 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
4342 if (num_dynamic_syms
< 1)
4344 error (_("Unable to determine the number of symbols to load\n"));
4348 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
4352 /* Similarly find a string table. */
4353 if (dynamic_strings
== NULL
)
4355 for (i
= 0, entry
= dynamic_segment
;
4359 unsigned long offset
;
4362 if (entry
->d_tag
!= DT_STRTAB
)
4365 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
4367 /* Since we do not know how big the string table is,
4368 we default to reading in the entire file (!) and
4369 processing that. This is overkill, I know, but it
4372 offset
= entry
->d_un
.d_val
- loadaddr
;
4373 if (fseek (file
, 0, SEEK_END
))
4374 error (_("Unable to seek to end of file\n"));
4375 str_tab_len
= ftell (file
) - offset
;
4377 if (str_tab_len
< 1)
4380 (_("Unable to determine the length of the dynamic string table\n"));
4384 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, str_tab_len
,
4385 _("dynamic string table"));
4390 /* And find the syminfo section if available. */
4391 if (dynamic_syminfo
== NULL
)
4393 unsigned int syminsz
= 0;
4395 for (i
= 0, entry
= dynamic_segment
;
4399 if (entry
->d_tag
== DT_SYMINENT
)
4401 /* Note: these braces are necessary to avoid a syntax
4402 error from the SunOS4 C compiler. */
4403 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
4405 else if (entry
->d_tag
== DT_SYMINSZ
)
4406 syminsz
= entry
->d_un
.d_val
;
4407 else if (entry
->d_tag
== DT_SYMINFO
)
4408 dynamic_syminfo_offset
= entry
->d_un
.d_val
- loadaddr
;
4411 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
4413 Elf_External_Syminfo
* extsyminfo
;
4414 Elf_Internal_Syminfo
* syminfo
;
4416 /* There is a syminfo section. Read the data. */
4417 extsyminfo
= ((Elf_External_Syminfo
*)
4418 get_data (NULL
, file
, dynamic_syminfo_offset
,
4419 syminsz
, _("symbol information")));
4423 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
4424 if (dynamic_syminfo
== NULL
)
4426 error (_("Out of memory\n"));
4430 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
4431 for (i
= 0, syminfo
= dynamic_syminfo
; i
< dynamic_syminfo_nent
;
4434 syminfo
->si_boundto
= BYTE_GET (extsyminfo
[i
].si_boundto
);
4435 syminfo
->si_flags
= BYTE_GET (extsyminfo
[i
].si_flags
);
4442 if (do_dynamic
&& dynamic_addr
)
4443 printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
4444 dynamic_addr
, (long) dynamic_size
);
4446 printf (_(" Tag Type Name/Value\n"));
4448 for (i
= 0, entry
= dynamic_segment
;
4457 print_vma (entry
->d_tag
, FULL_HEX
);
4458 dtype
= get_dynamic_type (entry
->d_tag
);
4459 printf (" (%s)%*s", dtype
,
4460 ((is_32bit_elf
? 27 : 19)
4461 - (int) strlen (dtype
)),
4465 switch (entry
->d_tag
)
4469 puts (get_dynamic_flags (entry
->d_un
.d_val
));
4479 switch (entry
->d_tag
)
4482 printf (_("Auxiliary library"));
4486 printf (_("Filter library"));
4490 printf (_("Configuration file"));
4494 printf (_("Dependency audit library"));
4498 printf (_("Audit library"));
4502 if (dynamic_strings
)
4503 printf (": [%s]\n", dynamic_strings
+ entry
->d_un
.d_val
);
4507 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4516 printf (_("Flags:"));
4517 if (entry
->d_un
.d_val
== 0)
4518 printf (_(" None\n"));
4521 unsigned long int val
= entry
->d_un
.d_val
;
4522 if (val
& DTF_1_PARINIT
)
4524 printf (" PARINIT");
4525 val
^= DTF_1_PARINIT
;
4527 if (val
& DTF_1_CONFEXP
)
4529 printf (" CONFEXP");
4530 val
^= DTF_1_CONFEXP
;
4533 printf (" %lx", val
);
4542 printf (_("Flags:"));
4543 if (entry
->d_un
.d_val
== 0)
4544 printf (_(" None\n"));
4547 unsigned long int val
= entry
->d_un
.d_val
;
4548 if (val
& DF_P1_LAZYLOAD
)
4550 printf (" LAZYLOAD");
4551 val
^= DF_P1_LAZYLOAD
;
4553 if (val
& DF_P1_GROUPPERM
)
4555 printf (" GROUPPERM");
4556 val
^= DF_P1_GROUPPERM
;
4559 printf (" %lx", val
);
4568 printf (_("Flags:"));
4569 if (entry
->d_un
.d_val
== 0)
4570 printf (_(" None\n"));
4573 unsigned long int val
= entry
->d_un
.d_val
;
4579 if (val
& DF_1_GLOBAL
)
4584 if (val
& DF_1_GROUP
)
4589 if (val
& DF_1_NODELETE
)
4591 printf (" NODELETE");
4592 val
^= DF_1_NODELETE
;
4594 if (val
& DF_1_LOADFLTR
)
4596 printf (" LOADFLTR");
4597 val
^= DF_1_LOADFLTR
;
4599 if (val
& DF_1_INITFIRST
)
4601 printf (" INITFIRST");
4602 val
^= DF_1_INITFIRST
;
4604 if (val
& DF_1_NOOPEN
)
4609 if (val
& DF_1_ORIGIN
)
4614 if (val
& DF_1_DIRECT
)
4619 if (val
& DF_1_TRANS
)
4624 if (val
& DF_1_INTERPOSE
)
4626 printf (" INTERPOSE");
4627 val
^= DF_1_INTERPOSE
;
4629 if (val
& DF_1_NODEFLIB
)
4631 printf (" NODEFLIB");
4632 val
^= DF_1_NODEFLIB
;
4634 if (val
& DF_1_NODUMP
)
4639 if (val
& DF_1_CONLFAT
)
4641 printf (" CONLFAT");
4642 val
^= DF_1_CONLFAT
;
4645 printf (" %lx", val
);
4653 puts (get_dynamic_type (entry
->d_un
.d_val
));
4673 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
4679 if (dynamic_strings
== NULL
)
4682 name
= dynamic_strings
+ entry
->d_un
.d_val
;
4686 switch (entry
->d_tag
)
4689 printf (_("Shared library: [%s]"), name
);
4691 if (strcmp (name
, program_interpreter
) == 0)
4692 printf (_(" program interpreter"));
4696 printf (_("Library soname: [%s]"), name
);
4700 printf (_("Library rpath: [%s]"), name
);
4704 printf (_("Library runpath: [%s]"), name
);
4708 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4713 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4729 case DT_INIT_ARRAYSZ
:
4730 case DT_FINI_ARRAYSZ
:
4733 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
4734 printf (" (bytes)\n");
4744 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
4757 if (dynamic_strings
!= NULL
&& entry
->d_tag
== DT_USED
)
4761 name
= dynamic_strings
+ entry
->d_un
.d_val
;
4765 printf (_("Not needed object: [%s]\n"), name
);
4770 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4776 /* The value of this entry is ignored. */
4780 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
4781 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
4786 switch (elf_header
.e_machine
)
4789 case EM_MIPS_RS3_LE
:
4790 dynamic_segment_mips_val (entry
);
4793 dynamic_segment_parisc_val (entry
);
4796 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4808 get_ver_flags (flags
)
4811 static char buff
[32];
4818 if (flags
& VER_FLG_BASE
)
4819 strcat (buff
, "BASE ");
4821 if (flags
& VER_FLG_WEAK
)
4823 if (flags
& VER_FLG_BASE
)
4824 strcat (buff
, "| ");
4826 strcat (buff
, "WEAK ");
4829 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
4830 strcat (buff
, "| <unknown>");
4835 /* Display the contents of the version sections. */
4837 process_version_sections (file
)
4840 Elf32_Internal_Shdr
* section
;
4847 for (i
= 0, section
= section_headers
;
4848 i
< elf_header
.e_shnum
;
4851 switch (section
->sh_type
)
4853 case SHT_GNU_verdef
:
4855 Elf_External_Verdef
* edefs
;
4862 (_("\nVersion definition section '%s' contains %ld entries:\n"),
4863 SECTION_NAME (section
), section
->sh_info
);
4865 printf (_(" Addr: 0x"));
4866 printf_vma (section
->sh_addr
);
4867 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
4868 (unsigned long) section
->sh_offset
, section
->sh_link
,
4869 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
4871 edefs
= ((Elf_External_Verdef
*)
4872 get_data (NULL
, file
, section
->sh_offset
,
4874 _("version definition section")));
4878 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++ cnt
)
4881 Elf_External_Verdef
* edef
;
4882 Elf_Internal_Verdef ent
;
4883 Elf_External_Verdaux
* eaux
;
4884 Elf_Internal_Verdaux aux
;
4888 vstart
= ((char *) edefs
) + idx
;
4890 edef
= (Elf_External_Verdef
*) vstart
;
4892 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
4893 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
4894 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
4895 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
4896 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
4897 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
4898 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
4900 printf (_(" %#06x: Rev: %d Flags: %s"),
4901 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
4903 printf (_(" Index: %d Cnt: %d "),
4904 ent
.vd_ndx
, ent
.vd_cnt
);
4906 vstart
+= ent
.vd_aux
;
4908 eaux
= (Elf_External_Verdaux
*) vstart
;
4910 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
4911 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
4913 if (dynamic_strings
)
4914 printf (_("Name: %s\n"), dynamic_strings
+ aux
.vda_name
);
4916 printf (_("Name index: %ld\n"), aux
.vda_name
);
4918 isum
= idx
+ ent
.vd_aux
;
4920 for (j
= 1; j
< ent
.vd_cnt
; j
++)
4922 isum
+= aux
.vda_next
;
4923 vstart
+= aux
.vda_next
;
4925 eaux
= (Elf_External_Verdaux
*) vstart
;
4927 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
4928 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
4930 if (dynamic_strings
)
4931 printf (_(" %#06x: Parent %d: %s\n"),
4932 isum
, j
, dynamic_strings
+ aux
.vda_name
);
4934 printf (_(" %#06x: Parent %d, name index: %ld\n"),
4935 isum
, j
, aux
.vda_name
);
4945 case SHT_GNU_verneed
:
4947 Elf_External_Verneed
* eneed
;
4953 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
4954 SECTION_NAME (section
), section
->sh_info
);
4956 printf (_(" Addr: 0x"));
4957 printf_vma (section
->sh_addr
);
4958 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
4959 (unsigned long) section
->sh_offset
, section
->sh_link
,
4960 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
4962 eneed
= ((Elf_External_Verneed
*)
4963 get_data (NULL
, file
, section
->sh_offset
,
4964 section
->sh_size
, _("version need section")));
4968 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
4970 Elf_External_Verneed
* entry
;
4971 Elf_Internal_Verneed ent
;
4976 vstart
= ((char *) eneed
) + idx
;
4978 entry
= (Elf_External_Verneed
*) vstart
;
4980 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
4981 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
4982 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
4983 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
4984 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
4986 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
4988 if (dynamic_strings
)
4989 printf (_(" File: %s"), dynamic_strings
+ ent
.vn_file
);
4991 printf (_(" File: %lx"), ent
.vn_file
);
4993 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
4995 vstart
+= ent
.vn_aux
;
4997 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
4999 Elf_External_Vernaux
* eaux
;
5000 Elf_Internal_Vernaux aux
;
5002 eaux
= (Elf_External_Vernaux
*) vstart
;
5004 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
5005 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
5006 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
5007 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
5008 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
5010 if (dynamic_strings
)
5011 printf (_(" %#06x: Name: %s"),
5012 isum
, dynamic_strings
+ aux
.vna_name
);
5014 printf (_(" %#06x: Name index: %lx"),
5015 isum
, aux
.vna_name
);
5017 printf (_(" Flags: %s Version: %d\n"),
5018 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
5020 isum
+= aux
.vna_next
;
5021 vstart
+= aux
.vna_next
;
5031 case SHT_GNU_versym
:
5033 Elf32_Internal_Shdr
* link_section
;
5036 unsigned char * edata
;
5037 unsigned short * data
;
5039 Elf_Internal_Sym
* symbols
;
5040 Elf32_Internal_Shdr
* string_sec
;
5042 link_section
= SECTION_HEADER (section
->sh_link
);
5043 total
= section
->sh_size
/ section
->sh_entsize
;
5047 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
5049 string_sec
= SECTION_HEADER (link_section
->sh_link
);
5051 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
5052 string_sec
->sh_size
,
5053 _("version string table"));
5057 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
5058 SECTION_NAME (section
), total
);
5060 printf (_(" Addr: "));
5061 printf_vma (section
->sh_addr
);
5062 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5063 (unsigned long) section
->sh_offset
, section
->sh_link
,
5064 SECTION_NAME (link_section
));
5068 get_data (NULL
, file
,
5069 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] - loadaddr
,
5070 total
* sizeof (short), _("version symbol data")));
5077 data
= (unsigned short *) malloc (total
* sizeof (short));
5079 for (cnt
= total
; cnt
--;)
5080 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
5085 for (cnt
= 0; cnt
< total
; cnt
+= 4)
5088 int check_def
, check_need
;
5091 printf (" %03x:", cnt
);
5093 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
5094 switch (data
[cnt
+ j
])
5097 fputs (_(" 0 (*local*) "), stdout
);
5101 fputs (_(" 1 (*global*) "), stdout
);
5105 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
5106 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
5110 if (SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
5113 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
5120 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
5122 Elf_Internal_Verneed ivn
;
5123 unsigned long offset
;
5125 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
5130 Elf_Internal_Vernaux ivna
;
5131 Elf_External_Verneed evn
;
5132 Elf_External_Vernaux evna
;
5133 unsigned long a_off
;
5135 get_data (&evn
, file
, offset
, sizeof (evn
),
5138 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
5139 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
5141 a_off
= offset
+ ivn
.vn_aux
;
5145 get_data (&evna
, file
, a_off
, sizeof (evna
),
5146 _("version need aux (2)"));
5148 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
5149 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
5151 a_off
+= ivna
.vna_next
;
5153 while (ivna
.vna_other
!= data
[cnt
+ j
]
5154 && ivna
.vna_next
!= 0);
5156 if (ivna
.vna_other
== data
[cnt
+ j
])
5158 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
5160 name
= strtab
+ ivna
.vna_name
;
5161 nn
+= printf ("(%s%-*s",
5163 12 - (int) strlen (name
),
5169 offset
+= ivn
.vn_next
;
5171 while (ivn
.vn_next
);
5174 if (check_def
&& data
[cnt
+ j
] != 0x8001
5175 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
5177 Elf_Internal_Verdef ivd
;
5178 Elf_External_Verdef evd
;
5179 unsigned long offset
;
5181 offset
= version_info
5182 [DT_VERSIONTAGIDX (DT_VERDEF
)] - loadaddr
;
5186 get_data (&evd
, file
, offset
, sizeof (evd
),
5189 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
5190 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
5192 offset
+= ivd
.vd_next
;
5194 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
5195 && ivd
.vd_next
!= 0);
5197 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
5199 Elf_External_Verdaux evda
;
5200 Elf_Internal_Verdaux ivda
;
5202 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
5204 get_data (&evda
, file
,
5205 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
5206 sizeof (evda
), _("version def aux"));
5208 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
5210 name
= strtab
+ ivda
.vda_name
;
5211 nn
+= printf ("(%s%-*s",
5213 12 - (int) strlen (name
),
5219 printf ("%*c", 18 - nn
, ' ');
5237 printf (_("\nNo version information found in this file.\n"));
5243 get_symbol_binding (binding
)
5244 unsigned int binding
;
5246 static char buff
[32];
5250 case STB_LOCAL
: return "LOCAL";
5251 case STB_GLOBAL
: return "GLOBAL";
5252 case STB_WEAK
: return "WEAK";
5254 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
5255 sprintf (buff
, _("<processor specific>: %d"), binding
);
5256 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
5257 sprintf (buff
, _("<OS specific>: %d"), binding
);
5259 sprintf (buff
, _("<unknown>: %d"), binding
);
5265 get_symbol_type (type
)
5268 static char buff
[32];
5272 case STT_NOTYPE
: return "NOTYPE";
5273 case STT_OBJECT
: return "OBJECT";
5274 case STT_FUNC
: return "FUNC";
5275 case STT_SECTION
: return "SECTION";
5276 case STT_FILE
: return "FILE";
5277 case STT_COMMON
: return "COMMON";
5278 case STT_TLS
: return "TLS";
5280 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
5282 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
5283 return "THUMB_FUNC";
5285 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
5288 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
5289 return "PARISC_MILLI";
5291 sprintf (buff
, _("<processor specific>: %d"), type
);
5293 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
5295 if (elf_header
.e_machine
== EM_PARISC
)
5297 if (type
== STT_HP_OPAQUE
)
5299 if (type
== STT_HP_STUB
)
5303 sprintf (buff
, _("<OS specific>: %d"), type
);
5306 sprintf (buff
, _("<unknown>: %d"), type
);
5312 get_symbol_visibility (visibility
)
5313 unsigned int visibility
;
5317 case STV_DEFAULT
: return "DEFAULT";
5318 case STV_INTERNAL
: return "INTERNAL";
5319 case STV_HIDDEN
: return "HIDDEN";
5320 case STV_PROTECTED
: return "PROTECTED";
5326 get_symbol_index_type (type
)
5331 case SHN_UNDEF
: return "UND";
5332 case SHN_ABS
: return "ABS";
5333 case SHN_COMMON
: return "COM";
5335 if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
5337 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
5339 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
5343 static char buff
[32];
5345 sprintf (buff
, "%3d", type
);
5352 get_dynamic_data (file
, number
)
5354 unsigned int number
;
5356 unsigned char * e_data
;
5359 e_data
= (unsigned char *) malloc (number
* 4);
5363 error (_("Out of memory\n"));
5367 if (fread (e_data
, 4, number
, file
) != number
)
5369 error (_("Unable to read in dynamic data\n"));
5373 i_data
= (int *) malloc (number
* sizeof (* i_data
));
5377 error (_("Out of memory\n"));
5383 i_data
[number
] = byte_get (e_data
+ number
* 4, 4);
5390 /* Dump the symbol table. */
5392 process_symbol_table (file
)
5395 Elf32_Internal_Shdr
* section
;
5396 unsigned char nb
[4];
5397 unsigned char nc
[4];
5400 int * buckets
= NULL
;
5401 int * chains
= NULL
;
5403 if (! do_syms
&& !do_histogram
)
5406 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
5409 if (fseek (file
, dynamic_info
[DT_HASH
] - loadaddr
, SEEK_SET
))
5411 error (_("Unable to seek to start of dynamic information"));
5415 if (fread (nb
, sizeof (nb
), 1, file
) != 1)
5417 error (_("Failed to read in number of buckets\n"));
5421 if (fread (nc
, sizeof (nc
), 1, file
) != 1)
5423 error (_("Failed to read in number of chains\n"));
5427 nbuckets
= byte_get (nb
, 4);
5428 nchains
= byte_get (nc
, 4);
5430 buckets
= get_dynamic_data (file
, nbuckets
);
5431 chains
= get_dynamic_data (file
, nchains
);
5433 if (buckets
== NULL
|| chains
== NULL
)
5438 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
5443 printf (_("\nSymbol table for image:\n"));
5445 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5447 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5449 for (hn
= 0; hn
< nbuckets
; hn
++)
5454 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
5456 Elf_Internal_Sym
* psym
;
5458 psym
= dynamic_symbols
+ si
;
5460 printf (" %3d %3d: ", si
, hn
);
5461 print_vma (psym
->st_value
, LONG_HEX
);
5463 print_vma (psym
->st_size
, DEC_5
);
5465 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
5466 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
5467 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
5468 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
5469 print_symbol (25, dynamic_strings
+ psym
->st_name
);
5474 else if (do_syms
&& !do_using_dynamic
)
5478 for (i
= 0, section
= section_headers
;
5479 i
< elf_header
.e_shnum
;
5484 Elf_Internal_Sym
* symtab
;
5485 Elf_Internal_Sym
* psym
;
5488 if ( section
->sh_type
!= SHT_SYMTAB
5489 && section
->sh_type
!= SHT_DYNSYM
)
5492 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
5493 SECTION_NAME (section
),
5494 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
5496 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5498 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5500 symtab
= GET_ELF_SYMBOLS (file
, section
);
5504 if (section
->sh_link
== elf_header
.e_shstrndx
)
5505 strtab
= string_table
;
5508 Elf32_Internal_Shdr
* string_sec
;
5510 string_sec
= SECTION_HEADER (section
->sh_link
);
5512 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
5513 string_sec
->sh_size
,
5517 for (si
= 0, psym
= symtab
;
5518 si
< section
->sh_size
/ section
->sh_entsize
;
5521 printf ("%6d: ", si
);
5522 print_vma (psym
->st_value
, LONG_HEX
);
5524 print_vma (psym
->st_size
, DEC_5
);
5525 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
5526 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
5527 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
5528 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
5529 print_symbol (25, strtab
+ psym
->st_name
);
5531 if (section
->sh_type
== SHT_DYNSYM
&&
5532 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
5534 unsigned char data
[2];
5535 unsigned short vers_data
;
5536 unsigned long offset
;
5540 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
5543 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
5544 sizeof (data
), _("version data"));
5546 vers_data
= byte_get (data
, 2);
5548 is_nobits
= (SECTION_HEADER (psym
->st_shndx
)->sh_type
5551 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
5553 if ((vers_data
& 0x8000) || vers_data
> 1)
5555 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
5556 && (is_nobits
|| ! check_def
))
5558 Elf_External_Verneed evn
;
5559 Elf_Internal_Verneed ivn
;
5560 Elf_Internal_Vernaux ivna
;
5562 /* We must test both. */
5563 offset
= version_info
5564 [DT_VERSIONTAGIDX (DT_VERNEED
)] - loadaddr
;
5568 unsigned long vna_off
;
5570 get_data (&evn
, file
, offset
, sizeof (evn
),
5573 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
5574 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
5576 vna_off
= offset
+ ivn
.vn_aux
;
5580 Elf_External_Vernaux evna
;
5582 get_data (&evna
, file
, vna_off
,
5584 _("version need aux (3)"));
5586 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
5587 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
5588 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
5590 vna_off
+= ivna
.vna_next
;
5592 while (ivna
.vna_other
!= vers_data
5593 && ivna
.vna_next
!= 0);
5595 if (ivna
.vna_other
== vers_data
)
5598 offset
+= ivn
.vn_next
;
5600 while (ivn
.vn_next
!= 0);
5602 if (ivna
.vna_other
== vers_data
)
5605 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
5608 else if (! is_nobits
)
5609 error (_("bad dynamic symbol"));
5616 if (vers_data
!= 0x8001
5617 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
5619 Elf_Internal_Verdef ivd
;
5620 Elf_Internal_Verdaux ivda
;
5621 Elf_External_Verdaux evda
;
5622 unsigned long offset
;
5625 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)]
5630 Elf_External_Verdef evd
;
5632 get_data (&evd
, file
, offset
, sizeof (evd
),
5635 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
5636 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
5637 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
5639 offset
+= ivd
.vd_next
;
5641 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
5642 && ivd
.vd_next
!= 0);
5644 offset
-= ivd
.vd_next
;
5645 offset
+= ivd
.vd_aux
;
5647 get_data (&evda
, file
, offset
, sizeof (evda
),
5648 _("version def aux"));
5650 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
5652 if (psym
->st_name
!= ivda
.vda_name
)
5653 printf ((vers_data
& 0x8000)
5655 strtab
+ ivda
.vda_name
);
5665 if (strtab
!= string_table
)
5671 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
5673 if (do_histogram
&& buckets
!= NULL
)
5680 int nzero_counts
= 0;
5683 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
5685 printf (_(" Length Number %% of total Coverage\n"));
5687 lengths
= (int *) calloc (nbuckets
, sizeof (int));
5688 if (lengths
== NULL
)
5690 error (_("Out of memory"));
5693 for (hn
= 0; hn
< nbuckets
; ++hn
)
5698 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
5701 if (maxlength
< ++lengths
[hn
])
5706 counts
= (int *) calloc (maxlength
+ 1, sizeof (int));
5709 error (_("Out of memory"));
5713 for (hn
= 0; hn
< nbuckets
; ++hn
)
5714 ++ counts
[lengths
[hn
]];
5718 printf (" 0 %-10d (%5.1f%%)\n",
5719 counts
[0], (counts
[0] * 100.0) / nbuckets
);
5720 for (si
= 1; si
<= maxlength
; ++si
)
5722 nzero_counts
+= counts
[si
] * si
;
5723 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
5724 si
, counts
[si
], (counts
[si
] * 100.0) / nbuckets
,
5725 (nzero_counts
* 100.0) / nsyms
);
5733 if (buckets
!= NULL
)
5743 process_syminfo (file
)
5744 FILE * file ATTRIBUTE_UNUSED
;
5748 if (dynamic_syminfo
== NULL
5750 /* No syminfo, this is ok. */
5753 /* There better should be a dynamic symbol section. */
5754 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
5758 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
5759 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
5761 printf (_(" Num: Name BoundTo Flags\n"));
5762 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
5764 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
5766 printf ("%4d: ", i
);
5767 print_symbol (30, dynamic_strings
+ dynamic_symbols
[i
].st_name
);
5770 switch (dynamic_syminfo
[i
].si_boundto
)
5772 case SYMINFO_BT_SELF
:
5773 fputs ("SELF ", stdout
);
5775 case SYMINFO_BT_PARENT
:
5776 fputs ("PARENT ", stdout
);
5779 if (dynamic_syminfo
[i
].si_boundto
> 0
5780 && dynamic_syminfo
[i
].si_boundto
< dynamic_size
)
5782 print_symbol (10, dynamic_strings
5784 [dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
);
5788 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
5792 if (flags
& SYMINFO_FLG_DIRECT
)
5794 if (flags
& SYMINFO_FLG_PASSTHRU
)
5795 printf (" PASSTHRU");
5796 if (flags
& SYMINFO_FLG_COPY
)
5798 if (flags
& SYMINFO_FLG_LAZYLOAD
)
5799 printf (" LAZYLOAD");
5807 #ifdef SUPPORT_DISASSEMBLY
5809 disassemble_section (section
, file
)
5810 Elf32_Internal_Shdr
* section
;
5813 printf (_("\nAssembly dump of section %s\n"),
5814 SECTION_NAME (section
));
5816 /* XXX -- to be done --- XXX */
5823 dump_section (section
, file
)
5824 Elf32_Internal_Shdr
* section
;
5827 bfd_size_type bytes
;
5829 unsigned char * data
;
5830 unsigned char * start
;
5832 bytes
= section
->sh_size
;
5836 printf (_("\nSection '%s' has no data to dump.\n"),
5837 SECTION_NAME (section
));
5841 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
5843 addr
= section
->sh_addr
;
5845 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
, bytes
,
5858 lbytes
= (bytes
> 16 ? 16 : bytes
);
5860 printf (" 0x%8.8lx ", (unsigned long) addr
);
5862 switch (elf_header
.e_ident
[EI_DATA
])
5866 for (j
= 15; j
>= 0; j
--)
5869 printf ("%2.2x", data
[j
]);
5879 for (j
= 0; j
< 16; j
++)
5882 printf ("%2.2x", data
[j
]);
5892 for (j
= 0; j
< lbytes
; j
++)
5895 if (k
>= ' ' && k
< 0x80)
5914 static unsigned long int
5915 read_leb128 (data
, length_return
, sign
)
5916 unsigned char * data
;
5917 int * length_return
;
5920 unsigned long int result
= 0;
5921 unsigned int num_read
= 0;
5930 result
|= (byte
& 0x7f) << shift
;
5935 while (byte
& 0x80);
5937 if (length_return
!= NULL
)
5938 * length_return
= num_read
;
5940 if (sign
&& (shift
< 32) && (byte
& 0x40))
5941 result
|= -1 << shift
;
5946 typedef struct State_Machine_Registers
5948 unsigned long address
;
5951 unsigned int column
;
5955 /* This variable hold the number of the last entry seen
5956 in the File Table. */
5957 unsigned int last_file_entry
;
5960 static SMR state_machine_regs
;
5963 reset_state_machine (is_stmt
)
5966 state_machine_regs
.address
= 0;
5967 state_machine_regs
.file
= 1;
5968 state_machine_regs
.line
= 1;
5969 state_machine_regs
.column
= 0;
5970 state_machine_regs
.is_stmt
= is_stmt
;
5971 state_machine_regs
.basic_block
= 0;
5972 state_machine_regs
.end_sequence
= 0;
5973 state_machine_regs
.last_file_entry
= 0;
5976 /* Handled an extend line op. Returns true if this is the end
5979 process_extended_line_op (data
, is_stmt
, pointer_size
)
5980 unsigned char * data
;
5984 unsigned char op_code
;
5987 unsigned char * name
;
5990 len
= read_leb128 (data
, & bytes_read
, 0);
5995 warn (_("badly formed extended line op encountered!\n"));
6000 op_code
= * data
++;
6002 printf (_(" Extended opcode %d: "), op_code
);
6006 case DW_LNE_end_sequence
:
6007 printf (_("End of Sequence\n\n"));
6008 reset_state_machine (is_stmt
);
6011 case DW_LNE_set_address
:
6012 adr
= byte_get (data
, pointer_size
);
6013 printf (_("set Address to 0x%lx\n"), adr
);
6014 state_machine_regs
.address
= adr
;
6017 case DW_LNE_define_file
:
6018 printf (_(" define new File Table entry\n"));
6019 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6021 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
6023 data
+= strlen ((char *) data
) + 1;
6024 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6026 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6028 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6029 printf (_("%s\n\n"), name
);
6033 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
6040 /* Size of pointers in the .debug_line section. This information is not
6041 really present in that section. It's obtained before dumping the debug
6042 sections by doing some pre-scan of the .debug_info section. */
6043 static int debug_line_pointer_size
= 4;
6046 display_debug_lines (section
, start
, file
)
6047 Elf32_Internal_Shdr
* section
;
6048 unsigned char * start
;
6049 FILE * file ATTRIBUTE_UNUSED
;
6051 DWARF2_External_LineInfo
* external
;
6052 DWARF2_Internal_LineInfo info
;
6053 unsigned char * standard_opcodes
;
6054 unsigned char * data
= start
;
6055 unsigned char * end
= start
+ section
->sh_size
;
6056 unsigned char * end_of_sequence
;
6059 printf (_("\nDump of debug contents of section %s:\n\n"),
6060 SECTION_NAME (section
));
6064 external
= (DWARF2_External_LineInfo
*) data
;
6066 /* Check the length of the block. */
6067 info
.li_length
= BYTE_GET (external
->li_length
);
6069 if (info
.li_length
== 0xffffffff)
6071 warn (_("64-bit DWARF line info is not supported yet.\n"));
6075 if (info
.li_length
+ sizeof (external
->li_length
) > section
->sh_size
)
6078 (_("The line info appears to be corrupt - the section is too small\n"));
6082 /* Check its version number. */
6083 info
.li_version
= BYTE_GET (external
->li_version
);
6084 if (info
.li_version
!= 2)
6086 warn (_("Only DWARF version 2 line info is currently supported.\n"));
6090 info
.li_prologue_length
= BYTE_GET (external
->li_prologue_length
);
6091 info
.li_min_insn_length
= BYTE_GET (external
->li_min_insn_length
);
6092 info
.li_default_is_stmt
= BYTE_GET (external
->li_default_is_stmt
);
6093 info
.li_line_base
= BYTE_GET (external
->li_line_base
);
6094 info
.li_line_range
= BYTE_GET (external
->li_line_range
);
6095 info
.li_opcode_base
= BYTE_GET (external
->li_opcode_base
);
6097 /* Sign extend the line base field. */
6098 info
.li_line_base
<<= 24;
6099 info
.li_line_base
>>= 24;
6101 printf (_(" Length: %ld\n"), info
.li_length
);
6102 printf (_(" DWARF Version: %d\n"), info
.li_version
);
6103 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
6104 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
6105 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
6106 printf (_(" Line Base: %d\n"), info
.li_line_base
);
6107 printf (_(" Line Range: %d\n"), info
.li_line_range
);
6108 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
6110 end_of_sequence
= data
+ info
.li_length
+ sizeof (external
->li_length
);
6112 reset_state_machine (info
.li_default_is_stmt
);
6114 /* Display the contents of the Opcodes table. */
6115 standard_opcodes
= data
+ sizeof (* external
);
6117 printf (_("\n Opcodes:\n"));
6119 for (i
= 1; i
< info
.li_opcode_base
; i
++)
6120 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
6122 /* Display the contents of the Directory table. */
6123 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
6126 printf (_("\n The Directory Table is empty.\n"));
6129 printf (_("\n The Directory Table:\n"));
6133 printf (_(" %s\n"), data
);
6135 data
+= strlen ((char *) data
) + 1;
6139 /* Skip the NUL at the end of the table. */
6142 /* Display the contents of the File Name table. */
6144 printf (_("\n The File Name Table is empty.\n"));
6147 printf (_("\n The File Name Table:\n"));
6148 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6152 unsigned char * name
;
6155 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
6158 data
+= strlen ((char *) data
) + 1;
6160 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6162 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6164 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6166 printf (_("%s\n"), name
);
6170 /* Skip the NUL at the end of the table. */
6173 /* Now display the statements. */
6174 printf (_("\n Line Number Statements:\n"));
6177 while (data
< end_of_sequence
)
6179 unsigned char op_code
;
6183 op_code
= * data
++;
6185 if (op_code
>= info
.li_opcode_base
)
6187 op_code
-= info
.li_opcode_base
;
6188 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
6189 state_machine_regs
.address
+= adv
;
6190 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
6191 op_code
, adv
, state_machine_regs
.address
);
6192 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
6193 state_machine_regs
.line
+= adv
;
6194 printf (_(" and Line by %d to %d\n"),
6195 adv
, state_machine_regs
.line
);
6197 else switch (op_code
)
6199 case DW_LNS_extended_op
:
6200 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
6201 debug_line_pointer_size
);
6205 printf (_(" Copy\n"));
6208 case DW_LNS_advance_pc
:
6209 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
6211 state_machine_regs
.address
+= adv
;
6212 printf (_(" Advance PC by %d to %lx\n"), adv
,
6213 state_machine_regs
.address
);
6216 case DW_LNS_advance_line
:
6217 adv
= read_leb128 (data
, & bytes_read
, 1);
6219 state_machine_regs
.line
+= adv
;
6220 printf (_(" Advance Line by %d to %d\n"), adv
,
6221 state_machine_regs
.line
);
6224 case DW_LNS_set_file
:
6225 adv
= read_leb128 (data
, & bytes_read
, 0);
6227 printf (_(" Set File Name to entry %d in the File Name Table\n"),
6229 state_machine_regs
.file
= adv
;
6232 case DW_LNS_set_column
:
6233 adv
= read_leb128 (data
, & bytes_read
, 0);
6235 printf (_(" Set column to %d\n"), adv
);
6236 state_machine_regs
.column
= adv
;
6239 case DW_LNS_negate_stmt
:
6240 adv
= state_machine_regs
.is_stmt
;
6242 printf (_(" Set is_stmt to %d\n"), adv
);
6243 state_machine_regs
.is_stmt
= adv
;
6246 case DW_LNS_set_basic_block
:
6247 printf (_(" Set basic block\n"));
6248 state_machine_regs
.basic_block
= 1;
6251 case DW_LNS_const_add_pc
:
6252 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
6253 * info
.li_min_insn_length
);
6254 state_machine_regs
.address
+= adv
;
6255 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
6256 state_machine_regs
.address
);
6259 case DW_LNS_fixed_advance_pc
:
6260 adv
= byte_get (data
, 2);
6262 state_machine_regs
.address
+= adv
;
6263 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
6264 adv
, state_machine_regs
.address
);
6267 case DW_LNS_set_prologue_end
:
6268 printf (_(" Set prologue_end to true\n"));
6271 case DW_LNS_set_epilogue_begin
:
6272 printf (_(" Set epilogue_begin to true\n"));
6275 case DW_LNS_set_isa
:
6276 adv
= read_leb128 (data
, & bytes_read
, 0);
6278 printf (_(" Set ISA to %d\n"), adv
);
6282 printf (_(" Unknown opcode %d with operands: "), op_code
);
6285 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
6287 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
6288 i
== 1 ? "" : ", ");
6303 display_debug_pubnames (section
, start
, file
)
6304 Elf32_Internal_Shdr
* section
;
6305 unsigned char * start
;
6306 FILE * file ATTRIBUTE_UNUSED
;
6308 DWARF2_External_PubNames
* external
;
6309 DWARF2_Internal_PubNames pubnames
;
6310 unsigned char * end
;
6312 end
= start
+ section
->sh_size
;
6314 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
6318 unsigned char * data
;
6319 unsigned long offset
;
6321 external
= (DWARF2_External_PubNames
*) start
;
6323 pubnames
.pn_length
= BYTE_GET (external
->pn_length
);
6324 pubnames
.pn_version
= BYTE_GET (external
->pn_version
);
6325 pubnames
.pn_offset
= BYTE_GET (external
->pn_offset
);
6326 pubnames
.pn_size
= BYTE_GET (external
->pn_size
);
6328 data
= start
+ sizeof (* external
);
6329 start
+= pubnames
.pn_length
+ sizeof (external
->pn_length
);
6331 if (pubnames
.pn_length
== 0xffffffff)
6333 warn (_("64-bit DWARF pubnames are not supported yet.\n"));
6337 if (pubnames
.pn_version
!= 2)
6339 static int warned
= 0;
6343 warn (_("Only DWARF 2 pubnames are currently supported\n"));
6350 printf (_(" Length: %ld\n"),
6351 pubnames
.pn_length
);
6352 printf (_(" Version: %d\n"),
6353 pubnames
.pn_version
);
6354 printf (_(" Offset into .debug_info section: %ld\n"),
6355 pubnames
.pn_offset
);
6356 printf (_(" Size of area in .debug_info section: %ld\n"),
6359 printf (_("\n Offset\tName\n"));
6363 offset
= byte_get (data
, 4);
6368 printf (" %ld\t\t%s\n", offset
, data
);
6369 data
+= strlen ((char *) data
) + 1;
6372 while (offset
!= 0);
6385 case DW_TAG_padding
: return "DW_TAG_padding";
6386 case DW_TAG_array_type
: return "DW_TAG_array_type";
6387 case DW_TAG_class_type
: return "DW_TAG_class_type";
6388 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
6389 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
6390 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
6391 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
6392 case DW_TAG_label
: return "DW_TAG_label";
6393 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
6394 case DW_TAG_member
: return "DW_TAG_member";
6395 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
6396 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
6397 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
6398 case DW_TAG_string_type
: return "DW_TAG_string_type";
6399 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
6400 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
6401 case DW_TAG_typedef
: return "DW_TAG_typedef";
6402 case DW_TAG_union_type
: return "DW_TAG_union_type";
6403 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
6404 case DW_TAG_variant
: return "DW_TAG_variant";
6405 case DW_TAG_common_block
: return "DW_TAG_common_block";
6406 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
6407 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
6408 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
6409 case DW_TAG_module
: return "DW_TAG_module";
6410 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
6411 case DW_TAG_set_type
: return "DW_TAG_set_type";
6412 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
6413 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
6414 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
6415 case DW_TAG_base_type
: return "DW_TAG_base_type";
6416 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
6417 case DW_TAG_const_type
: return "DW_TAG_const_type";
6418 case DW_TAG_constant
: return "DW_TAG_constant";
6419 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
6420 case DW_TAG_file_type
: return "DW_TAG_file_type";
6421 case DW_TAG_friend
: return "DW_TAG_friend";
6422 case DW_TAG_namelist
: return "DW_TAG_namelist";
6423 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
6424 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
6425 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
6426 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
6427 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
6428 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
6429 case DW_TAG_try_block
: return "DW_TAG_try_block";
6430 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
6431 case DW_TAG_variable
: return "DW_TAG_variable";
6432 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
6433 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
6434 case DW_TAG_format_label
: return "DW_TAG_format_label";
6435 case DW_TAG_function_template
: return "DW_TAG_function_template";
6436 case DW_TAG_class_template
: return "DW_TAG_class_template";
6437 /* DWARF 2.1 values. */
6438 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
6439 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
6440 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
6441 case DW_TAG_namespace
: return "DW_TAG_namespace";
6442 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
6443 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
6444 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
6445 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
6448 static char buffer
[100];
6450 sprintf (buffer
, _("Unknown TAG value: %lx"), tag
);
6457 get_AT_name (attribute
)
6458 unsigned long attribute
;
6462 case DW_AT_sibling
: return "DW_AT_sibling";
6463 case DW_AT_location
: return "DW_AT_location";
6464 case DW_AT_name
: return "DW_AT_name";
6465 case DW_AT_ordering
: return "DW_AT_ordering";
6466 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
6467 case DW_AT_byte_size
: return "DW_AT_byte_size";
6468 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
6469 case DW_AT_bit_size
: return "DW_AT_bit_size";
6470 case DW_AT_element_list
: return "DW_AT_element_list";
6471 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
6472 case DW_AT_low_pc
: return "DW_AT_low_pc";
6473 case DW_AT_high_pc
: return "DW_AT_high_pc";
6474 case DW_AT_language
: return "DW_AT_language";
6475 case DW_AT_member
: return "DW_AT_member";
6476 case DW_AT_discr
: return "DW_AT_discr";
6477 case DW_AT_discr_value
: return "DW_AT_discr_value";
6478 case DW_AT_visibility
: return "DW_AT_visibility";
6479 case DW_AT_import
: return "DW_AT_import";
6480 case DW_AT_string_length
: return "DW_AT_string_length";
6481 case DW_AT_common_reference
: return "DW_AT_common_reference";
6482 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
6483 case DW_AT_const_value
: return "DW_AT_const_value";
6484 case DW_AT_containing_type
: return "DW_AT_containing_type";
6485 case DW_AT_default_value
: return "DW_AT_default_value";
6486 case DW_AT_inline
: return "DW_AT_inline";
6487 case DW_AT_is_optional
: return "DW_AT_is_optional";
6488 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
6489 case DW_AT_producer
: return "DW_AT_producer";
6490 case DW_AT_prototyped
: return "DW_AT_prototyped";
6491 case DW_AT_return_addr
: return "DW_AT_return_addr";
6492 case DW_AT_start_scope
: return "DW_AT_start_scope";
6493 case DW_AT_stride_size
: return "DW_AT_stride_size";
6494 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
6495 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
6496 case DW_AT_accessibility
: return "DW_AT_accessibility";
6497 case DW_AT_address_class
: return "DW_AT_address_class";
6498 case DW_AT_artificial
: return "DW_AT_artificial";
6499 case DW_AT_base_types
: return "DW_AT_base_types";
6500 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
6501 case DW_AT_count
: return "DW_AT_count";
6502 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
6503 case DW_AT_decl_column
: return "DW_AT_decl_column";
6504 case DW_AT_decl_file
: return "DW_AT_decl_file";
6505 case DW_AT_decl_line
: return "DW_AT_decl_line";
6506 case DW_AT_declaration
: return "DW_AT_declaration";
6507 case DW_AT_discr_list
: return "DW_AT_discr_list";
6508 case DW_AT_encoding
: return "DW_AT_encoding";
6509 case DW_AT_external
: return "DW_AT_external";
6510 case DW_AT_frame_base
: return "DW_AT_frame_base";
6511 case DW_AT_friend
: return "DW_AT_friend";
6512 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
6513 case DW_AT_macro_info
: return "DW_AT_macro_info";
6514 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
6515 case DW_AT_priority
: return "DW_AT_priority";
6516 case DW_AT_segment
: return "DW_AT_segment";
6517 case DW_AT_specification
: return "DW_AT_specification";
6518 case DW_AT_static_link
: return "DW_AT_static_link";
6519 case DW_AT_type
: return "DW_AT_type";
6520 case DW_AT_use_location
: return "DW_AT_use_location";
6521 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
6522 case DW_AT_virtuality
: return "DW_AT_virtuality";
6523 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
6524 /* DWARF 2.1 values. */
6525 case DW_AT_allocated
: return "DW_AT_allocated";
6526 case DW_AT_associated
: return "DW_AT_associated";
6527 case DW_AT_data_location
: return "DW_AT_data_location";
6528 case DW_AT_stride
: return "DW_AT_stride";
6529 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
6530 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
6531 case DW_AT_extension
: return "DW_AT_extension";
6532 case DW_AT_ranges
: return "DW_AT_ranges";
6533 case DW_AT_trampoline
: return "DW_AT_trampoline";
6534 case DW_AT_call_column
: return "DW_AT_call_column";
6535 case DW_AT_call_file
: return "DW_AT_call_file";
6536 case DW_AT_call_line
: return "DW_AT_call_line";
6537 /* SGI/MIPS extensions. */
6538 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
6539 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
6540 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
6541 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
6542 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
6543 case DW_AT_MIPS_software_pipeline_depth
: return "DW_AT_MIPS_software_pipeline_depth";
6544 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
6545 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
6546 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
6547 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
6548 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
6549 /* GNU extensions. */
6550 case DW_AT_sf_names
: return "DW_AT_sf_names";
6551 case DW_AT_src_info
: return "DW_AT_src_info";
6552 case DW_AT_mac_info
: return "DW_AT_mac_info";
6553 case DW_AT_src_coords
: return "DW_AT_src_coords";
6554 case DW_AT_body_begin
: return "DW_AT_body_begin";
6555 case DW_AT_body_end
: return "DW_AT_body_end";
6556 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
6559 static char buffer
[100];
6561 sprintf (buffer
, _("Unknown AT value: %lx"), attribute
);
6568 get_FORM_name (form
)
6573 case DW_FORM_addr
: return "DW_FORM_addr";
6574 case DW_FORM_block2
: return "DW_FORM_block2";
6575 case DW_FORM_block4
: return "DW_FORM_block4";
6576 case DW_FORM_data2
: return "DW_FORM_data2";
6577 case DW_FORM_data4
: return "DW_FORM_data4";
6578 case DW_FORM_data8
: return "DW_FORM_data8";
6579 case DW_FORM_string
: return "DW_FORM_string";
6580 case DW_FORM_block
: return "DW_FORM_block";
6581 case DW_FORM_block1
: return "DW_FORM_block1";
6582 case DW_FORM_data1
: return "DW_FORM_data1";
6583 case DW_FORM_flag
: return "DW_FORM_flag";
6584 case DW_FORM_sdata
: return "DW_FORM_sdata";
6585 case DW_FORM_strp
: return "DW_FORM_strp";
6586 case DW_FORM_udata
: return "DW_FORM_udata";
6587 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
6588 case DW_FORM_ref1
: return "DW_FORM_ref1";
6589 case DW_FORM_ref2
: return "DW_FORM_ref2";
6590 case DW_FORM_ref4
: return "DW_FORM_ref4";
6591 case DW_FORM_ref8
: return "DW_FORM_ref8";
6592 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
6593 case DW_FORM_indirect
: return "DW_FORM_indirect";
6596 static char buffer
[100];
6598 sprintf (buffer
, _("Unknown FORM value: %lx"), form
);
6604 /* FIXME: There are better and more effiecint ways to handle
6605 these structures. For now though, I just want something that
6606 is simple to implement. */
6607 typedef struct abbrev_attr
6609 unsigned long attribute
;
6611 struct abbrev_attr
* next
;
6615 typedef struct abbrev_entry
6617 unsigned long entry
;
6620 struct abbrev_attr
* first_attr
;
6621 struct abbrev_attr
* last_attr
;
6622 struct abbrev_entry
* next
;
6626 static abbrev_entry
* first_abbrev
= NULL
;
6627 static abbrev_entry
* last_abbrev
= NULL
;
6630 free_abbrevs
PARAMS ((void))
6632 abbrev_entry
* abbrev
;
6634 for (abbrev
= first_abbrev
; abbrev
;)
6636 abbrev_entry
* next
= abbrev
->next
;
6639 for (attr
= abbrev
->first_attr
; attr
;)
6641 abbrev_attr
* next
= attr
->next
;
6651 last_abbrev
= first_abbrev
= NULL
;
6655 add_abbrev (number
, tag
, children
)
6656 unsigned long number
;
6660 abbrev_entry
* entry
;
6662 entry
= (abbrev_entry
*) malloc (sizeof (* entry
));
6668 entry
->entry
= number
;
6670 entry
->children
= children
;
6671 entry
->first_attr
= NULL
;
6672 entry
->last_attr
= NULL
;
6675 if (first_abbrev
== NULL
)
6676 first_abbrev
= entry
;
6678 last_abbrev
->next
= entry
;
6680 last_abbrev
= entry
;
6684 add_abbrev_attr (attribute
, form
)
6685 unsigned long attribute
;
6690 attr
= (abbrev_attr
*) malloc (sizeof (* attr
));
6696 attr
->attribute
= attribute
;
6700 if (last_abbrev
->first_attr
== NULL
)
6701 last_abbrev
->first_attr
= attr
;
6703 last_abbrev
->last_attr
->next
= attr
;
6705 last_abbrev
->last_attr
= attr
;
6708 /* Processes the (partial) contents of a .debug_abbrev section.
6709 Returns NULL if the end of the section was encountered.
6710 Returns the address after the last byte read if the end of
6711 an abbreviation set was found. */
6713 static unsigned char *
6714 process_abbrev_section (start
, end
)
6715 unsigned char * start
;
6716 unsigned char * end
;
6718 if (first_abbrev
!= NULL
)
6724 unsigned long entry
;
6726 unsigned long attribute
;
6729 entry
= read_leb128 (start
, & bytes_read
, 0);
6730 start
+= bytes_read
;
6732 /* A single zero is supposed to end the section according
6733 to the standard. If there's more, then signal that to
6736 return start
== end
? NULL
: start
;
6738 tag
= read_leb128 (start
, & bytes_read
, 0);
6739 start
+= bytes_read
;
6741 children
= * start
++;
6743 add_abbrev (entry
, tag
, children
);
6749 attribute
= read_leb128 (start
, & bytes_read
, 0);
6750 start
+= bytes_read
;
6752 form
= read_leb128 (start
, & bytes_read
, 0);
6753 start
+= bytes_read
;
6756 add_abbrev_attr (attribute
, form
);
6758 while (attribute
!= 0);
6766 display_debug_macinfo (section
, start
, file
)
6767 Elf32_Internal_Shdr
* section
;
6768 unsigned char * start
;
6769 FILE * file ATTRIBUTE_UNUSED
;
6771 unsigned char * end
= start
+ section
->sh_size
;
6772 unsigned char * curr
= start
;
6773 unsigned int bytes_read
;
6774 enum dwarf_macinfo_record_type op
;
6776 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
6780 unsigned int lineno
;
6781 const char * string
;
6788 case DW_MACINFO_start_file
:
6790 unsigned int filenum
;
6792 lineno
= read_leb128 (curr
, & bytes_read
, 0);
6794 filenum
= read_leb128 (curr
, & bytes_read
, 0);
6797 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"), lineno
, filenum
);
6801 case DW_MACINFO_end_file
:
6802 printf (_(" DW_MACINFO_end_file\n"));
6805 case DW_MACINFO_define
:
6806 lineno
= read_leb128 (curr
, & bytes_read
, 0);
6809 curr
+= strlen (string
) + 1;
6810 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"), lineno
, string
);
6813 case DW_MACINFO_undef
:
6814 lineno
= read_leb128 (curr
, & bytes_read
, 0);
6817 curr
+= strlen (string
) + 1;
6818 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"), lineno
, string
);
6821 case DW_MACINFO_vendor_ext
:
6823 unsigned int constant
;
6825 constant
= read_leb128 (curr
, & bytes_read
, 0);
6828 curr
+= strlen (string
) + 1;
6829 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"), constant
, string
);
6840 display_debug_abbrev (section
, start
, file
)
6841 Elf32_Internal_Shdr
* section
;
6842 unsigned char * start
;
6843 FILE * file ATTRIBUTE_UNUSED
;
6845 abbrev_entry
* entry
;
6846 unsigned char * end
= start
+ section
->sh_size
;
6848 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
6852 start
= process_abbrev_section (start
, end
);
6854 if (first_abbrev
== NULL
)
6857 printf (_(" Number TAG\n"));
6859 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
6863 printf (_(" %ld %s [%s]\n"),
6865 get_TAG_name (entry
->tag
),
6866 entry
->children
? _("has children") : _("no children"));
6868 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
6870 printf (_(" %-18s %s\n"),
6871 get_AT_name (attr
->attribute
),
6872 get_FORM_name (attr
->form
));
6886 static unsigned char *
6887 display_block (data
, length
)
6888 unsigned char * data
;
6889 unsigned long length
;
6891 printf (_(" %lu byte block: "), length
);
6894 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
6900 decode_location_expression (data
, pointer_size
, length
)
6901 unsigned char * data
;
6902 unsigned int pointer_size
;
6903 unsigned long length
;
6907 unsigned long uvalue
;
6908 unsigned char * end
= data
+ length
;
6917 printf ("DW_OP_addr: %lx",
6918 (unsigned long) byte_get (data
, pointer_size
));
6919 data
+= pointer_size
;
6922 printf ("DW_OP_deref");
6925 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
6928 printf ("DW_OP_const1s: %ld", (long) byte_get (data
++, 1));
6931 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
6935 printf ("DW_OP_const2s: %ld", (long) byte_get (data
, 2));
6939 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
6943 printf ("DW_OP_const4s: %ld", (long) byte_get (data
, 4));
6947 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
6948 (unsigned long) byte_get (data
+ 4, 4));
6952 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
6953 (long) byte_get (data
+ 4, 4));
6957 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
6961 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
6965 printf ("DW_OP_dup");
6968 printf ("DW_OP_drop");
6971 printf ("DW_OP_over");
6974 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
6977 printf ("DW_OP_swap");
6980 printf ("DW_OP_rot");
6983 printf ("DW_OP_xderef");
6986 printf ("DW_OP_abs");
6989 printf ("DW_OP_and");
6992 printf ("DW_OP_div");
6995 printf ("DW_OP_minus");
6998 printf ("DW_OP_mod");
7001 printf ("DW_OP_mul");
7004 printf ("DW_OP_neg");
7007 printf ("DW_OP_not");
7010 printf ("DW_OP_or");
7013 printf ("DW_OP_plus");
7015 case DW_OP_plus_uconst
:
7016 printf ("DW_OP_plus_uconst: %lu",
7017 read_leb128 (data
, &bytes_read
, 0));
7021 printf ("DW_OP_shl");
7024 printf ("DW_OP_shr");
7027 printf ("DW_OP_shra");
7030 printf ("DW_OP_xor");
7033 printf ("DW_OP_bra: %ld", (long) byte_get (data
, 2));
7037 printf ("DW_OP_eq");
7040 printf ("DW_OP_ge");
7043 printf ("DW_OP_gt");
7046 printf ("DW_OP_le");
7049 printf ("DW_OP_lt");
7052 printf ("DW_OP_ne");
7055 printf ("DW_OP_skip: %ld", (long) byte_get (data
, 2));
7091 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
7126 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
7161 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
7162 read_leb128 (data
, &bytes_read
, 1));
7167 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
7171 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
7175 uvalue
= read_leb128 (data
, &bytes_read
, 0);
7177 printf ("DW_OP_bregx: %lu %ld", uvalue
,
7178 read_leb128 (data
, &bytes_read
, 1));
7182 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
7185 case DW_OP_deref_size
:
7186 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
7188 case DW_OP_xderef_size
:
7189 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
7192 printf ("DW_OP_nop");
7195 /* DWARF 2.1 extensions. */
7196 case DW_OP_push_object_address
:
7197 printf ("DW_OP_push_object_address");
7200 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2));
7204 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4));
7208 printf ("DW_OP_calli");
7212 if (op
>= DW_OP_lo_user
7213 && op
<= DW_OP_hi_user
)
7214 printf (_("(User defined location op)"));
7216 printf (_("(Unknown location op)"));
7217 /* No way to tell where the next op is, so just bail. */
7221 /* Separate the ops. */
7226 static const char * debug_loc_contents
;
7227 static bfd_vma debug_loc_size
;
7230 load_debug_loc (file
)
7233 Elf32_Internal_Shdr
* sec
;
7236 /* If it is already loaded, do nothing. */
7237 if (debug_loc_contents
!= NULL
)
7240 /* Locate the .debug_loc section. */
7241 for (i
= 0, sec
= section_headers
;
7242 i
< elf_header
.e_shnum
;
7244 if (strcmp (SECTION_NAME (sec
), ".debug_loc") == 0)
7247 if (i
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
7250 debug_loc_size
= sec
->sh_size
;
7252 debug_loc_contents
= ((char *)
7253 get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7254 _("debug_loc section data")));
7260 if (debug_loc_contents
== NULL
)
7263 free ((char *) debug_loc_contents
);
7264 debug_loc_contents
= NULL
;
7270 display_debug_loc (section
, start
, file
)
7271 Elf32_Internal_Shdr
* section
;
7272 unsigned char * start
;
7273 FILE * file ATTRIBUTE_UNUSED
;
7275 unsigned char *section_end
;
7276 unsigned long bytes
;
7277 unsigned char *section_begin
= start
;
7280 addr
= section
->sh_addr
;
7281 bytes
= section
->sh_size
;
7282 section_end
= start
+ bytes
;
7285 printf (_("\nThe .debug_loc section is empty.\n"));
7288 printf (_("Contents of the .debug_loc section:\n\n"));
7289 printf (_("\n Offset Begin End Expression\n"));
7290 while (start
< section_end
)
7292 unsigned long begin
;
7294 unsigned short length
;
7295 unsigned long offset
;
7297 offset
= start
- section_begin
;
7301 /* Normally, the lists in the debug_loc section are related to a
7302 given compilation unit, and thus, we would use the
7303 pointer size of that compilation unit. However, since we are
7304 displaying it seperately here, we either have to store
7305 pointer sizes of all compilation units, or assume they don't
7306 change. We assume, like the debug_line display, that
7307 it doesn't change. */
7308 begin
= byte_get (start
, debug_line_pointer_size
);
7309 start
+= debug_line_pointer_size
;
7310 end
= byte_get (start
, debug_line_pointer_size
);
7311 start
+= debug_line_pointer_size
;
7313 if (begin
== 0 && end
== 0)
7319 length
= byte_get (start
, 2);
7322 printf (" %8.8lx %8.8lx %8.8lx (", offset
, begin
, end
);
7323 decode_location_expression (start
, debug_line_pointer_size
, length
);
7333 static const char * debug_str_contents
;
7334 static bfd_vma debug_str_size
;
7337 load_debug_str (file
)
7340 Elf32_Internal_Shdr
* sec
;
7343 /* If it is already loaded, do nothing. */
7344 if (debug_str_contents
!= NULL
)
7347 /* Locate the .debug_str section. */
7348 for (i
= 0, sec
= section_headers
;
7349 i
< elf_header
.e_shnum
;
7351 if (strcmp (SECTION_NAME (sec
), ".debug_str") == 0)
7354 if (i
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
7357 debug_str_size
= sec
->sh_size
;
7359 debug_str_contents
= ((char *)
7360 get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7361 _("debug_str section data")));
7367 if (debug_str_contents
== NULL
)
7370 free ((char *) debug_str_contents
);
7371 debug_str_contents
= NULL
;
7376 fetch_indirect_string (offset
)
7377 unsigned long offset
;
7379 if (debug_str_contents
== NULL
)
7380 return _("<no .debug_str section>");
7382 if (offset
> debug_str_size
)
7383 return _("<offset is too big>");
7385 return debug_str_contents
+ offset
;
7390 display_debug_str (section
, start
, file
)
7391 Elf32_Internal_Shdr
* section
;
7392 unsigned char * start
;
7393 FILE * file ATTRIBUTE_UNUSED
;
7395 unsigned long bytes
;
7398 addr
= section
->sh_addr
;
7399 bytes
= section
->sh_size
;
7403 printf (_("\nThe .debug_str section is empty.\n"));
7407 printf (_("Contents of the .debug_str section:\n\n"));
7415 lbytes
= (bytes
> 16 ? 16 : bytes
);
7417 printf (" 0x%8.8lx ", (unsigned long) addr
);
7419 for (j
= 0; j
< 16; j
++)
7422 printf ("%2.2x", start
[j
]);
7430 for (j
= 0; j
< lbytes
; j
++)
7433 if (k
>= ' ' && k
< 0x80)
7450 static unsigned char *
7451 read_and_display_attr_value (attribute
, form
, data
, cu_offset
, pointer_size
)
7452 unsigned long attribute
;
7454 unsigned char * data
;
7455 unsigned long cu_offset
;
7456 unsigned long pointer_size
;
7458 unsigned long uvalue
= 0;
7459 unsigned char * block_start
= NULL
;
7467 case DW_FORM_ref_addr
:
7469 uvalue
= byte_get (data
, pointer_size
);
7470 data
+= pointer_size
;
7474 uvalue
= byte_get (data
, /* offset_size */ 4);
7475 data
+= /* offset_size */ 4;
7481 uvalue
= byte_get (data
++, 1);
7486 uvalue
= byte_get (data
, 2);
7492 uvalue
= byte_get (data
, 4);
7497 uvalue
= read_leb128 (data
, & bytes_read
, 1);
7501 case DW_FORM_ref_udata
:
7503 uvalue
= read_leb128 (data
, & bytes_read
, 0);
7507 case DW_FORM_indirect
:
7508 form
= read_leb128 (data
, & bytes_read
, 0);
7510 printf (" %s", get_FORM_name (form
));
7511 return read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
7517 case DW_FORM_ref_addr
:
7518 printf (" <#%lx>", uvalue
);
7524 case DW_FORM_ref_udata
:
7525 printf (" <%lx>", uvalue
+ cu_offset
);
7529 printf (" %#lx", uvalue
);
7537 printf (" %ld", uvalue
);
7542 uvalue
= byte_get (data
, 4);
7543 printf (" %lx", uvalue
);
7544 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
7548 case DW_FORM_string
:
7549 printf (" %s", data
);
7550 data
+= strlen ((char *) data
) + 1;
7554 uvalue
= read_leb128 (data
, & bytes_read
, 0);
7555 block_start
= data
+ bytes_read
;
7556 data
= display_block (block_start
, uvalue
);
7559 case DW_FORM_block1
:
7560 uvalue
= byte_get (data
, 1);
7561 block_start
= data
+ 1;
7562 data
= display_block (block_start
, uvalue
);
7565 case DW_FORM_block2
:
7566 uvalue
= byte_get (data
, 2);
7567 block_start
= data
+ 2;
7568 data
= display_block (block_start
, uvalue
);
7571 case DW_FORM_block4
:
7572 uvalue
= byte_get (data
, 4);
7573 block_start
= data
+ 4;
7574 data
= display_block (block_start
, uvalue
);
7578 printf (_(" (indirect string, offset: 0x%lx): "), uvalue
);
7579 printf (fetch_indirect_string (uvalue
));
7582 case DW_FORM_indirect
:
7583 /* Handled above. */
7587 warn (_("Unrecognized form: %d\n"), form
);
7591 /* For some attributes we can display futher information. */
7600 case DW_INL_not_inlined
: printf (_("(not inlined)")); break;
7601 case DW_INL_inlined
: printf (_("(inlined)")); break;
7602 case DW_INL_declared_not_inlined
: printf (_("(declared as inline but ignored)")); break;
7603 case DW_INL_declared_inlined
: printf (_("(declared as inline and inlined)")); break;
7604 default: printf (_(" (Unknown inline attribute value: %lx)"), uvalue
); break;
7608 case DW_AT_language
:
7611 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
7612 case DW_LANG_C89
: printf ("(ANSI C)"); break;
7613 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
7614 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
7615 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
7616 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
7617 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
7618 case DW_LANG_Ada83
: printf ("(Ada)"); break;
7619 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
7620 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
7621 /* DWARF 2.1 values. */
7622 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
7623 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
7624 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
7625 /* MIPS extension. */
7626 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
7627 default: printf ("(Unknown: %lx)", uvalue
); break;
7631 case DW_AT_encoding
:
7634 case DW_ATE_void
: printf ("(void)"); break;
7635 case DW_ATE_address
: printf ("(machine address)"); break;
7636 case DW_ATE_boolean
: printf ("(boolean)"); break;
7637 case DW_ATE_complex_float
: printf ("(complex float)"); break;
7638 case DW_ATE_float
: printf ("(float)"); break;
7639 case DW_ATE_signed
: printf ("(signed)"); break;
7640 case DW_ATE_signed_char
: printf ("(signed char)"); break;
7641 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
7642 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
7643 /* DWARF 2.1 value. */
7644 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
7646 if (uvalue
>= DW_ATE_lo_user
7647 && uvalue
<= DW_ATE_hi_user
)
7648 printf ("(user defined type)");
7650 printf ("(unknown type)");
7655 case DW_AT_accessibility
:
7658 case DW_ACCESS_public
: printf ("(public)"); break;
7659 case DW_ACCESS_protected
: printf ("(protected)"); break;
7660 case DW_ACCESS_private
: printf ("(private)"); break;
7661 default: printf ("(unknown accessibility)"); break;
7665 case DW_AT_visibility
:
7668 case DW_VIS_local
: printf ("(local)"); break;
7669 case DW_VIS_exported
: printf ("(exported)"); break;
7670 case DW_VIS_qualified
: printf ("(qualified)"); break;
7671 default: printf ("(unknown visibility)"); break;
7675 case DW_AT_virtuality
:
7678 case DW_VIRTUALITY_none
: printf ("(none)"); break;
7679 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
7680 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
7681 default: printf ("(unknown virtuality)"); break;
7685 case DW_AT_identifier_case
:
7688 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
7689 case DW_ID_up_case
: printf ("(up_case)"); break;
7690 case DW_ID_down_case
: printf ("(down_case)"); break;
7691 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
7692 default: printf ("(unknown case)"); break;
7696 case DW_AT_calling_convention
:
7699 case DW_CC_normal
: printf ("(normal)"); break;
7700 case DW_CC_program
: printf ("(program)"); break;
7701 case DW_CC_nocall
: printf ("(nocall)"); break;
7703 if (uvalue
>= DW_CC_lo_user
7704 && uvalue
<= DW_CC_hi_user
)
7705 printf ("(user defined)");
7707 printf ("(unknown convention)");
7711 case DW_AT_ordering
:
7714 case -1: printf ("(undefined)"); break;
7715 case 0: printf ("(row major)"); break;
7716 case 1: printf ("(column major)"); break;
7720 case DW_AT_frame_base
:
7721 case DW_AT_location
:
7722 case DW_AT_data_member_location
:
7723 case DW_AT_vtable_elem_location
:
7724 case DW_AT_allocated
:
7725 case DW_AT_associated
:
7726 case DW_AT_data_location
:
7728 case DW_AT_upper_bound
:
7729 case DW_AT_lower_bound
:
7733 decode_location_expression (block_start
, pointer_size
, uvalue
);
7736 else if (form
== DW_FORM_data4
)
7739 printf ("location list");
7751 static unsigned char *
7752 read_and_display_attr (attribute
, form
, data
, cu_offset
, pointer_size
)
7753 unsigned long attribute
;
7755 unsigned char * data
;
7756 unsigned long cu_offset
;
7757 unsigned long pointer_size
;
7759 printf (" %-18s:", get_AT_name (attribute
));
7760 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
7767 display_debug_info (section
, start
, file
)
7768 Elf32_Internal_Shdr
* section
;
7769 unsigned char * start
;
7772 unsigned char * end
= start
+ section
->sh_size
;
7773 unsigned char * section_begin
= start
;
7775 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
7777 load_debug_str (file
);
7778 load_debug_loc (file
);
7782 DWARF2_External_CompUnit
* external
;
7783 DWARF2_Internal_CompUnit compunit
;
7784 Elf32_Internal_Shdr
* relsec
;
7785 unsigned char * tags
;
7788 unsigned long cu_offset
;
7790 external
= (DWARF2_External_CompUnit
*) start
;
7792 compunit
.cu_length
= BYTE_GET (external
->cu_length
);
7793 compunit
.cu_version
= BYTE_GET (external
->cu_version
);
7794 compunit
.cu_abbrev_offset
= BYTE_GET (external
->cu_abbrev_offset
);
7795 compunit
.cu_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
7797 if (compunit
.cu_length
== 0xffffffff)
7799 warn (_("64-bit DWARF debug info is not supported yet.\n"));
7803 /* Check for RELA relocations in the abbrev_offset address, and
7805 for (relsec
= section_headers
;
7806 relsec
< section_headers
+ elf_header
.e_shnum
;
7809 unsigned long nrelas
;
7810 Elf_Internal_Rela
*rela
, *rp
;
7811 Elf32_Internal_Shdr
*symsec
;
7812 Elf_Internal_Sym
*symtab
;
7813 Elf_Internal_Sym
*sym
;
7815 if (relsec
->sh_type
!= SHT_RELA
7816 || SECTION_HEADER (relsec
->sh_info
) != section
)
7819 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7823 symsec
= SECTION_HEADER (relsec
->sh_link
);
7824 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
7826 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7829 != (bfd_vma
) ((unsigned char *) &external
->cu_abbrev_offset
7835 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
7837 if (ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
7839 warn (_("Skipping unexpected symbol type %u\n"),
7840 ELF32_ST_TYPE (sym
->st_info
));
7846 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
7848 if (ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
7850 warn (_("Skipping unexpected symbol type %u\n"),
7851 ELF64_ST_TYPE (sym
->st_info
));
7856 compunit
.cu_abbrev_offset
+= rp
->r_addend
;
7864 tags
= start
+ sizeof (* external
);
7865 cu_offset
= start
- section_begin
;
7866 start
+= compunit
.cu_length
+ sizeof (external
->cu_length
);
7868 printf (_(" Compilation Unit @ %lx:\n"), cu_offset
);
7869 printf (_(" Length: %ld\n"), compunit
.cu_length
);
7870 printf (_(" Version: %d\n"), compunit
.cu_version
);
7871 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
7872 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
7874 if (compunit
.cu_version
!= 2)
7876 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
7882 /* Read in the abbrevs used by this compilation unit. */
7885 Elf32_Internal_Shdr
* sec
;
7886 unsigned char * begin
;
7888 /* Locate the .debug_abbrev section and process it. */
7889 for (i
= 0, sec
= section_headers
;
7890 i
< elf_header
.e_shnum
;
7892 if (strcmp (SECTION_NAME (sec
), ".debug_abbrev") == 0)
7895 if (i
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
7897 warn (_("Unable to locate .debug_abbrev section!\n"));
7901 begin
= ((unsigned char *)
7902 get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7903 _("debug_abbrev section data")));
7907 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
7908 begin
+ sec
->sh_size
);
7914 while (tags
< start
)
7917 unsigned long abbrev_number
;
7918 abbrev_entry
* entry
;
7921 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
7924 /* A null DIE marks the end of a list of children. */
7925 if (abbrev_number
== 0)
7931 /* Scan through the abbreviation list until we reach the
7933 for (entry
= first_abbrev
;
7934 entry
&& entry
->entry
!= abbrev_number
;
7935 entry
= entry
->next
)
7940 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
7945 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
7947 (unsigned long) (tags
- section_begin
- bytes_read
),
7949 get_TAG_name (entry
->tag
));
7951 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
7952 tags
= read_and_display_attr (attr
->attribute
,
7955 compunit
.cu_pointer_size
);
7957 if (entry
->children
)
7971 display_debug_aranges (section
, start
, file
)
7972 Elf32_Internal_Shdr
* section
;
7973 unsigned char * start
;
7974 FILE * file ATTRIBUTE_UNUSED
;
7976 unsigned char * end
= start
+ section
->sh_size
;
7978 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
7982 DWARF2_External_ARange
* external
;
7983 DWARF2_Internal_ARange arange
;
7984 unsigned char * ranges
;
7985 unsigned long length
;
7986 unsigned long address
;
7989 external
= (DWARF2_External_ARange
*) start
;
7991 arange
.ar_length
= BYTE_GET (external
->ar_length
);
7992 arange
.ar_version
= BYTE_GET (external
->ar_version
);
7993 arange
.ar_info_offset
= BYTE_GET (external
->ar_info_offset
);
7994 arange
.ar_pointer_size
= BYTE_GET (external
->ar_pointer_size
);
7995 arange
.ar_segment_size
= BYTE_GET (external
->ar_segment_size
);
7997 if (arange
.ar_length
== 0xffffffff)
7999 warn (_("64-bit DWARF aranges are not supported yet.\n"));
8003 if (arange
.ar_version
!= 2)
8005 warn (_("Only DWARF 2 aranges are currently supported.\n"));
8009 printf (_(" Length: %ld\n"), arange
.ar_length
);
8010 printf (_(" Version: %d\n"), arange
.ar_version
);
8011 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
8012 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
8013 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
8015 printf (_("\n Address Length\n"));
8017 ranges
= start
+ sizeof (* external
);
8019 /* Must pad to an alignment boundary that is twice the pointer size. */
8020 excess
= sizeof (* external
) % (2 * arange
.ar_pointer_size
);
8022 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
8026 address
= byte_get (ranges
, arange
.ar_pointer_size
);
8028 ranges
+= arange
.ar_pointer_size
;
8030 length
= byte_get (ranges
, arange
.ar_pointer_size
);
8032 ranges
+= arange
.ar_pointer_size
;
8034 /* A pair of zeros marks the end of the list. */
8035 if (address
== 0 && length
== 0)
8038 printf (" %8.8lx %lu\n", address
, length
);
8041 start
+= arange
.ar_length
+ sizeof (external
->ar_length
);
8049 typedef struct Frame_Chunk
8051 struct Frame_Chunk
* next
;
8052 unsigned char * chunk_start
;
8054 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
8055 short int * col_type
;
8057 char * augmentation
;
8058 unsigned int code_factor
;
8060 unsigned long pc_begin
;
8061 unsigned long pc_range
;
8065 unsigned char fde_encoding
;
8069 /* A marker for a col_type that means this column was never referenced
8070 in the frame info. */
8071 #define DW_CFA_unreferenced (-1)
8073 static void frame_need_space
PARAMS ((Frame_Chunk
*, int));
8074 static void frame_display_row
PARAMS ((Frame_Chunk
*, int *, int *));
8075 static int size_of_encoded_value
PARAMS ((int));
8078 frame_need_space (fc
, reg
)
8082 int prev
= fc
->ncols
;
8084 if (reg
< fc
->ncols
)
8087 fc
->ncols
= reg
+ 1;
8088 fc
->col_type
= (short int *) xrealloc (fc
->col_type
,
8089 fc
->ncols
* sizeof (short int));
8090 fc
->col_offset
= (int *) xrealloc (fc
->col_offset
,
8091 fc
->ncols
* sizeof (int));
8093 while (prev
< fc
->ncols
)
8095 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
8096 fc
->col_offset
[prev
] = 0;
8102 frame_display_row (fc
, need_col_headers
, max_regs
)
8104 int * need_col_headers
;
8110 if (* max_regs
< fc
->ncols
)
8111 * max_regs
= fc
->ncols
;
8113 if (* need_col_headers
)
8115 * need_col_headers
= 0;
8117 printf (" LOC CFA ");
8119 for (r
= 0; r
< * max_regs
; r
++)
8120 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8125 printf ("r%-4d", r
);
8131 printf ("%08lx ", fc
->pc_begin
);
8132 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
8133 printf ("%-8s ", tmp
);
8135 for (r
= 0; r
< fc
->ncols
; r
++)
8137 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8139 switch (fc
->col_type
[r
])
8141 case DW_CFA_undefined
:
8144 case DW_CFA_same_value
:
8148 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
8150 case DW_CFA_register
:
8151 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
8154 strcpy (tmp
, "n/a");
8157 printf ("%-5s", tmp
);
8164 size_of_encoded_value (encoding
)
8167 switch (encoding
& 0x7)
8170 case 0: return is_32bit_elf
? 4 : 8;
8177 #define GET(N) byte_get (start, N); start += N
8178 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
8179 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
8182 display_debug_frames (section
, start
, file
)
8183 Elf32_Internal_Shdr
* section
;
8184 unsigned char * start
;
8185 FILE * file ATTRIBUTE_UNUSED
;
8187 unsigned char * end
= start
+ section
->sh_size
;
8188 unsigned char * section_start
= start
;
8189 Frame_Chunk
* chunks
= 0;
8190 Frame_Chunk
* remembered_state
= 0;
8192 int is_eh
= (strcmp (SECTION_NAME (section
), ".eh_frame") == 0);
8195 int addr_size
= is_32bit_elf
? 4 : 8;
8197 printf (_("The section %s contains:\n"), SECTION_NAME (section
));
8201 unsigned char * saved_start
;
8202 unsigned char * block_end
;
8203 unsigned long length
;
8204 unsigned long cie_id
;
8207 int need_col_headers
= 1;
8208 unsigned char * augmentation_data
= NULL
;
8209 unsigned long augmentation_data_len
= 0;
8210 int encoded_ptr_size
= addr_size
;
8212 saved_start
= start
;
8213 length
= byte_get (start
, 4); start
+= 4;
8218 if (length
== 0xffffffff)
8220 warn (_("64-bit DWARF format frames are not supported yet.\n"));
8224 block_end
= saved_start
+ length
+ 4;
8225 cie_id
= byte_get (start
, 4); start
+= 4;
8227 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
8231 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8232 memset (fc
, 0, sizeof (Frame_Chunk
));
8236 fc
->chunk_start
= saved_start
;
8238 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8239 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8240 frame_need_space (fc
, max_regs
-1);
8244 fc
->augmentation
= start
;
8245 start
= strchr (start
, '\0') + 1;
8247 if (fc
->augmentation
[0] == 'z')
8249 fc
->code_factor
= LEB ();
8250 fc
->data_factor
= SLEB ();
8251 fc
->ra
= byte_get (start
, 1); start
+= 1;
8252 augmentation_data_len
= LEB ();
8253 augmentation_data
= start
;
8254 start
+= augmentation_data_len
;
8256 else if (strcmp (fc
->augmentation
, "eh") == 0)
8259 fc
->code_factor
= LEB ();
8260 fc
->data_factor
= SLEB ();
8261 fc
->ra
= byte_get (start
, 1); start
+= 1;
8265 fc
->code_factor
= LEB ();
8266 fc
->data_factor
= SLEB ();
8267 fc
->ra
= byte_get (start
, 1); start
+= 1;
8271 if (do_debug_frames_interp
)
8272 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
8273 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
8274 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
8278 printf ("\n%08lx %08lx %08lx CIE\n",
8279 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
8280 printf (" Version: %d\n", version
);
8281 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
8282 printf (" Code alignment factor: %u\n", fc
->code_factor
);
8283 printf (" Data alignment factor: %d\n", fc
->data_factor
);
8284 printf (" Return address column: %d\n", fc
->ra
);
8286 if (augmentation_data_len
)
8289 printf (" Augmentation data: ");
8290 for (i
= 0; i
< augmentation_data_len
; ++i
)
8291 printf (" %02x", augmentation_data
[i
]);
8297 if (augmentation_data_len
)
8299 unsigned char *p
, *q
;
8300 p
= fc
->augmentation
+ 1;
8301 q
= augmentation_data
;
8308 q
+= 1 + size_of_encoded_value (*q
);
8310 fc
->fde_encoding
= *q
++;
8316 if (fc
->fde_encoding
)
8317 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8320 frame_need_space (fc
, fc
->ra
);
8324 unsigned char * look_for
;
8325 static Frame_Chunk fde_fc
;
8328 memset (fc
, 0, sizeof (Frame_Chunk
));
8330 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
8332 for (cie
= chunks
; cie
; cie
= cie
->next
)
8333 if (cie
->chunk_start
== look_for
)
8338 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
8339 cie_id
, saved_start
);
8342 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8343 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8344 frame_need_space (fc
, max_regs
- 1);
8346 fc
->augmentation
= "";
8347 fc
->fde_encoding
= 0;
8351 fc
->ncols
= cie
->ncols
;
8352 fc
->col_type
= (short int *) xmalloc (fc
->ncols
* sizeof (short int));
8353 fc
->col_offset
= (int *) xmalloc (fc
->ncols
* sizeof (int));
8354 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
8355 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
8356 fc
->augmentation
= cie
->augmentation
;
8357 fc
->code_factor
= cie
->code_factor
;
8358 fc
->data_factor
= cie
->data_factor
;
8359 fc
->cfa_reg
= cie
->cfa_reg
;
8360 fc
->cfa_offset
= cie
->cfa_offset
;
8362 frame_need_space (fc
, max_regs
-1);
8363 fc
->fde_encoding
= cie
->fde_encoding
;
8366 if (fc
->fde_encoding
)
8367 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8369 fc
->pc_begin
= byte_get (start
, encoded_ptr_size
);
8370 start
+= encoded_ptr_size
;
8371 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
8372 start
+= encoded_ptr_size
;
8374 if (cie
->augmentation
[0] == 'z')
8376 augmentation_data_len
= LEB ();
8377 augmentation_data
= start
;
8378 start
+= augmentation_data_len
;
8381 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
8382 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
8383 (unsigned long)(cie
->chunk_start
- section_start
),
8384 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
8385 if (! do_debug_frames_interp
&& augmentation_data_len
)
8388 printf (" Augmentation data: ");
8389 for (i
= 0; i
< augmentation_data_len
; ++i
)
8390 printf (" %02x", augmentation_data
[i
]);
8396 /* At this point, fc is the current chunk, cie (if any) is set, and we're
8397 about to interpret instructions for the chunk. */
8399 if (do_debug_frames_interp
)
8401 /* Start by making a pass over the chunk, allocating storage
8402 and taking note of what registers are used. */
8403 unsigned char * tmp
= start
;
8405 while (start
< block_end
)
8415 /* Warning: if you add any more cases to this switch, be
8416 sure to add them to the corresponding switch below. */
8419 case DW_CFA_advance_loc
:
8423 frame_need_space (fc
, opa
);
8424 fc
->col_type
[opa
] = DW_CFA_undefined
;
8426 case DW_CFA_restore
:
8427 frame_need_space (fc
, opa
);
8428 fc
->col_type
[opa
] = DW_CFA_undefined
;
8430 case DW_CFA_set_loc
:
8431 start
+= encoded_ptr_size
;
8433 case DW_CFA_advance_loc1
:
8436 case DW_CFA_advance_loc2
:
8439 case DW_CFA_advance_loc4
:
8442 case DW_CFA_offset_extended
:
8443 reg
= LEB (); LEB ();
8444 frame_need_space (fc
, reg
);
8445 fc
->col_type
[reg
] = DW_CFA_undefined
;
8447 case DW_CFA_restore_extended
:
8449 frame_need_space (fc
, reg
);
8450 fc
->col_type
[reg
] = DW_CFA_undefined
;
8452 case DW_CFA_undefined
:
8454 frame_need_space (fc
, reg
);
8455 fc
->col_type
[reg
] = DW_CFA_undefined
;
8457 case DW_CFA_same_value
:
8459 frame_need_space (fc
, reg
);
8460 fc
->col_type
[reg
] = DW_CFA_undefined
;
8462 case DW_CFA_register
:
8463 reg
= LEB (); LEB ();
8464 frame_need_space (fc
, reg
);
8465 fc
->col_type
[reg
] = DW_CFA_undefined
;
8467 case DW_CFA_def_cfa
:
8470 case DW_CFA_def_cfa_register
:
8473 case DW_CFA_def_cfa_offset
:
8476 case DW_CFA_offset_extended_sf
:
8477 reg
= LEB (); SLEB ();
8478 frame_need_space (fc
, reg
);
8479 fc
->col_type
[reg
] = DW_CFA_undefined
;
8481 case DW_CFA_def_cfa_sf
:
8484 case DW_CFA_def_cfa_offset_sf
:
8487 case DW_CFA_GNU_args_size
:
8490 case DW_CFA_GNU_negative_offset_extended
:
8491 reg
= LEB (); LEB ();
8492 frame_need_space (fc
, reg
);
8493 fc
->col_type
[reg
] = DW_CFA_undefined
;
8502 /* Now we know what registers are used, make a second pass over
8503 the chunk, this time actually printing out the info. */
8505 while (start
< block_end
)
8508 unsigned long ul
, reg
, roffs
;
8517 /* Warning: if you add any more cases to this switch, be
8518 sure to add them to the corresponding switch above. */
8521 case DW_CFA_advance_loc
:
8522 if (do_debug_frames_interp
)
8523 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8525 printf (" DW_CFA_advance_loc: %d to %08lx\n",
8526 opa
* fc
->code_factor
,
8527 fc
->pc_begin
+ opa
* fc
->code_factor
);
8528 fc
->pc_begin
+= opa
* fc
->code_factor
;
8533 if (! do_debug_frames_interp
)
8534 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
8535 opa
, roffs
* fc
->data_factor
);
8536 fc
->col_type
[opa
] = DW_CFA_offset
;
8537 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
8540 case DW_CFA_restore
:
8541 if (! do_debug_frames_interp
)
8542 printf (" DW_CFA_restore: r%d\n", opa
);
8543 fc
->col_type
[opa
] = cie
->col_type
[opa
];
8544 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
8547 case DW_CFA_set_loc
:
8548 vma
= byte_get (start
, encoded_ptr_size
);
8549 start
+= encoded_ptr_size
;
8550 if (do_debug_frames_interp
)
8551 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8553 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
8557 case DW_CFA_advance_loc1
:
8558 ofs
= byte_get (start
, 1); start
+= 1;
8559 if (do_debug_frames_interp
)
8560 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8562 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
8563 ofs
* fc
->code_factor
,
8564 fc
->pc_begin
+ ofs
* fc
->code_factor
);
8565 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8568 case DW_CFA_advance_loc2
:
8569 ofs
= byte_get (start
, 2); start
+= 2;
8570 if (do_debug_frames_interp
)
8571 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8573 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
8574 ofs
* fc
->code_factor
,
8575 fc
->pc_begin
+ ofs
* fc
->code_factor
);
8576 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8579 case DW_CFA_advance_loc4
:
8580 ofs
= byte_get (start
, 4); start
+= 4;
8581 if (do_debug_frames_interp
)
8582 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8584 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
8585 ofs
* fc
->code_factor
,
8586 fc
->pc_begin
+ ofs
* fc
->code_factor
);
8587 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8590 case DW_CFA_offset_extended
:
8593 if (! do_debug_frames_interp
)
8594 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
8595 reg
, roffs
* fc
->data_factor
);
8596 fc
->col_type
[reg
] = DW_CFA_offset
;
8597 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
8600 case DW_CFA_restore_extended
:
8602 if (! do_debug_frames_interp
)
8603 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
8604 fc
->col_type
[reg
] = cie
->col_type
[reg
];
8605 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
8608 case DW_CFA_undefined
:
8610 if (! do_debug_frames_interp
)
8611 printf (" DW_CFA_undefined: r%ld\n", reg
);
8612 fc
->col_type
[reg
] = DW_CFA_undefined
;
8613 fc
->col_offset
[reg
] = 0;
8616 case DW_CFA_same_value
:
8618 if (! do_debug_frames_interp
)
8619 printf (" DW_CFA_same_value: r%ld\n", reg
);
8620 fc
->col_type
[reg
] = DW_CFA_same_value
;
8621 fc
->col_offset
[reg
] = 0;
8624 case DW_CFA_register
:
8627 if (! do_debug_frames_interp
)
8628 printf (" DW_CFA_register: r%ld\n", reg
);
8629 fc
->col_type
[reg
] = DW_CFA_register
;
8630 fc
->col_offset
[reg
] = roffs
;
8633 case DW_CFA_remember_state
:
8634 if (! do_debug_frames_interp
)
8635 printf (" DW_CFA_remember_state\n");
8636 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8637 rs
->ncols
= fc
->ncols
;
8638 rs
->col_type
= (short int *) xmalloc (rs
->ncols
* sizeof (short int));
8639 rs
->col_offset
= (int *) xmalloc (rs
->ncols
* sizeof (int));
8640 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
8641 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
8642 rs
->next
= remembered_state
;
8643 remembered_state
= rs
;
8646 case DW_CFA_restore_state
:
8647 if (! do_debug_frames_interp
)
8648 printf (" DW_CFA_restore_state\n");
8649 rs
= remembered_state
;
8650 remembered_state
= rs
->next
;
8651 frame_need_space (fc
, rs
->ncols
-1);
8652 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
8653 memcpy (fc
->col_offset
, rs
->col_offset
, rs
->ncols
* sizeof (int));
8654 free (rs
->col_type
);
8655 free (rs
->col_offset
);
8659 case DW_CFA_def_cfa
:
8660 fc
->cfa_reg
= LEB ();
8661 fc
->cfa_offset
= LEB ();
8662 if (! do_debug_frames_interp
)
8663 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
8664 fc
->cfa_reg
, fc
->cfa_offset
);
8667 case DW_CFA_def_cfa_register
:
8668 fc
->cfa_reg
= LEB ();
8669 if (! do_debug_frames_interp
)
8670 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
8673 case DW_CFA_def_cfa_offset
:
8674 fc
->cfa_offset
= LEB ();
8675 if (! do_debug_frames_interp
)
8676 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
8680 if (! do_debug_frames_interp
)
8681 printf (" DW_CFA_nop\n");
8684 case DW_CFA_offset_extended_sf
:
8687 frame_need_space (fc
, reg
);
8688 if (! do_debug_frames_interp
)
8689 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
8690 reg
, l
* fc
->data_factor
);
8691 fc
->col_type
[reg
] = DW_CFA_offset
;
8692 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8695 case DW_CFA_def_cfa_sf
:
8696 fc
->cfa_reg
= LEB ();
8697 fc
->cfa_offset
= SLEB ();
8698 if (! do_debug_frames_interp
)
8699 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
8700 fc
->cfa_reg
, fc
->cfa_offset
);
8703 case DW_CFA_def_cfa_offset_sf
:
8704 fc
->cfa_offset
= SLEB ();
8705 if (! do_debug_frames_interp
)
8706 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
8709 case DW_CFA_GNU_window_save
:
8710 if (! do_debug_frames_interp
)
8711 printf (" DW_CFA_GNU_window_save\n");
8714 case DW_CFA_GNU_args_size
:
8716 if (! do_debug_frames_interp
)
8717 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
8720 case DW_CFA_GNU_negative_offset_extended
:
8723 frame_need_space (fc
, reg
);
8724 if (! do_debug_frames_interp
)
8725 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
8726 reg
, l
* fc
->data_factor
);
8727 fc
->col_type
[reg
] = DW_CFA_offset
;
8728 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8731 /* FIXME: How do we handle these? */
8732 case DW_CFA_def_cfa_expression
:
8733 fprintf (stderr
, "unsupported DW_CFA_def_cfa_expression\n");
8737 case DW_CFA_expression
:
8738 fprintf (stderr
, "unsupported DW_CFA_expression\n");
8743 fprintf (stderr
, "unsupported or unknown DW_CFA_%d\n", op
);
8748 if (do_debug_frames_interp
)
8749 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8764 display_debug_not_supported (section
, start
, file
)
8765 Elf32_Internal_Shdr
* section
;
8766 unsigned char * start ATTRIBUTE_UNUSED
;
8767 FILE * file ATTRIBUTE_UNUSED
;
8769 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
8770 SECTION_NAME (section
));
8775 /* Pre-scan the .debug_info section to record the size of address.
8776 When dumping the .debug_line, we use that size information, assuming
8777 that all compilation units have the same address size. */
8779 prescan_debug_info (section
, start
, file
)
8780 Elf32_Internal_Shdr
* section ATTRIBUTE_UNUSED
;
8781 unsigned char * start
;
8782 FILE * file ATTRIBUTE_UNUSED
;
8784 DWARF2_External_CompUnit
* external
;
8786 external
= (DWARF2_External_CompUnit
*) start
;
8788 debug_line_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
8792 /* A structure containing the name of a debug section and a pointer
8793 to a function that can decode it. The third field is a prescan
8794 function to be run over the section before displaying any of the
8798 const char * const name
;
8799 int (* display
) PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
8800 int (* prescan
) PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
8804 { ".debug_abbrev", display_debug_abbrev
, NULL
},
8805 { ".debug_aranges", display_debug_aranges
, NULL
},
8806 { ".debug_frame", display_debug_frames
, NULL
},
8807 { ".debug_info", display_debug_info
, prescan_debug_info
},
8808 { ".debug_line", display_debug_lines
, NULL
},
8809 { ".debug_pubnames", display_debug_pubnames
, NULL
},
8810 { ".eh_frame", display_debug_frames
, NULL
},
8811 { ".debug_macinfo", display_debug_macinfo
, NULL
},
8812 { ".debug_str", display_debug_str
, NULL
},
8813 { ".debug_loc", display_debug_loc
, NULL
},
8814 { ".debug_pubtypes", display_debug_not_supported
, NULL
},
8815 { ".debug_ranges", display_debug_not_supported
, NULL
},
8816 { ".debug_static_func", display_debug_not_supported
, NULL
},
8817 { ".debug_static_vars", display_debug_not_supported
, NULL
},
8818 { ".debug_types", display_debug_not_supported
, NULL
},
8819 { ".debug_weaknames", display_debug_not_supported
, NULL
}
8823 display_debug_section (section
, file
)
8824 Elf32_Internal_Shdr
* section
;
8827 char * name
= SECTION_NAME (section
);
8828 bfd_size_type length
;
8829 unsigned char * start
;
8832 length
= section
->sh_size
;
8835 printf (_("\nSection '%s' has no debugging data.\n"), name
);
8839 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
, length
,
8840 _("debug section data"));
8844 /* See if we know how to display the contents of this section. */
8845 if (strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
8846 name
= ".debug_info";
8848 for (i
= NUM_ELEM (debug_displays
); i
--;)
8849 if (strcmp (debug_displays
[i
].name
, name
) == 0)
8851 debug_displays
[i
].display (section
, start
, file
);
8856 printf (_("Unrecognized debug section: %s\n"), name
);
8860 /* If we loaded in the abbrev section at some point,
8861 we must release it here. */
8868 process_section_contents (file
)
8871 Elf32_Internal_Shdr
* section
;
8877 /* Pre-scan the debug sections to find some debug information not
8878 present in some of them. For the .debug_line, we must find out the
8879 size of address (specified in .debug_info and .debug_aranges). */
8880 for (i
= 0, section
= section_headers
;
8881 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
8884 char * name
= SECTION_NAME (section
);
8887 if (section
->sh_size
== 0)
8890 /* See if there is some pre-scan operation for this section. */
8891 for (j
= NUM_ELEM (debug_displays
); j
--;)
8892 if (strcmp (debug_displays
[j
].name
, name
) == 0)
8894 if (debug_displays
[j
].prescan
!= NULL
)
8896 bfd_size_type length
;
8897 unsigned char * start
;
8899 length
= section
->sh_size
;
8900 start
= ((unsigned char *)
8901 get_data (NULL
, file
, section
->sh_offset
, length
,
8902 _("debug section data")));
8906 debug_displays
[j
].prescan (section
, start
, file
);
8914 for (i
= 0, section
= section_headers
;
8915 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
8918 #ifdef SUPPORT_DISASSEMBLY
8919 if (dump_sects
[i
] & DISASS_DUMP
)
8920 disassemble_section (section
, file
);
8922 if (dump_sects
[i
] & HEX_DUMP
)
8923 dump_section (section
, file
);
8925 if (dump_sects
[i
] & DEBUG_DUMP
)
8926 display_debug_section (section
, file
);
8929 if (i
< num_dump_sects
)
8930 warn (_("Some sections were not dumped because they do not exist!\n"));
8936 process_mips_fpe_exception (mask
)
8942 if (mask
& OEX_FPU_INEX
)
8943 fputs ("INEX", stdout
), first
= 0;
8944 if (mask
& OEX_FPU_UFLO
)
8945 printf ("%sUFLO", first
? "" : "|"), first
= 0;
8946 if (mask
& OEX_FPU_OFLO
)
8947 printf ("%sOFLO", first
? "" : "|"), first
= 0;
8948 if (mask
& OEX_FPU_DIV0
)
8949 printf ("%sDIV0", first
? "" : "|"), first
= 0;
8950 if (mask
& OEX_FPU_INVAL
)
8951 printf ("%sINVAL", first
? "" : "|");
8954 fputs ("0", stdout
);
8958 process_mips_specific (file
)
8961 Elf_Internal_Dyn
* entry
;
8962 size_t liblist_offset
= 0;
8963 size_t liblistno
= 0;
8964 size_t conflictsno
= 0;
8965 size_t options_offset
= 0;
8966 size_t conflicts_offset
= 0;
8968 /* We have a lot of special sections. Thanks SGI! */
8969 if (dynamic_segment
== NULL
)
8970 /* No information available. */
8973 for (entry
= dynamic_segment
; entry
->d_tag
!= DT_NULL
; ++entry
)
8974 switch (entry
->d_tag
)
8976 case DT_MIPS_LIBLIST
:
8977 liblist_offset
= entry
->d_un
.d_val
- loadaddr
;
8979 case DT_MIPS_LIBLISTNO
:
8980 liblistno
= entry
->d_un
.d_val
;
8982 case DT_MIPS_OPTIONS
:
8983 options_offset
= entry
->d_un
.d_val
- loadaddr
;
8985 case DT_MIPS_CONFLICT
:
8986 conflicts_offset
= entry
->d_un
.d_val
- loadaddr
;
8988 case DT_MIPS_CONFLICTNO
:
8989 conflictsno
= entry
->d_un
.d_val
;
8995 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
8997 Elf32_External_Lib
* elib
;
9000 elib
= ((Elf32_External_Lib
*)
9001 get_data (NULL
, file
, liblist_offset
,
9002 liblistno
* sizeof (Elf32_External_Lib
),
9006 printf ("\nSection '.liblist' contains %lu entries:\n",
9007 (unsigned long) liblistno
);
9008 fputs (" Library Time Stamp Checksum Version Flags\n",
9011 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
9018 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9019 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9020 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9021 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9022 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9024 tmp
= gmtime (&time
);
9025 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
9026 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9027 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9029 printf ("%3lu: ", (unsigned long) cnt
);
9030 print_symbol (20, dynamic_strings
+ liblist
.l_name
);
9031 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
9034 if (liblist
.l_flags
== 0)
9045 { " EXACT_MATCH", LL_EXACT_MATCH
},
9046 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
9047 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
9048 { " EXPORTS", LL_EXPORTS
},
9049 { " DELAY_LOAD", LL_DELAY_LOAD
},
9050 { " DELTA", LL_DELTA
}
9052 int flags
= liblist
.l_flags
;
9056 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
9058 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
9060 fputs (l_flags_vals
[fcnt
].name
, stdout
);
9061 flags
^= l_flags_vals
[fcnt
].bit
;
9064 printf (" %#x", (unsigned int) flags
);
9074 if (options_offset
!= 0)
9076 Elf_External_Options
* eopt
;
9077 Elf_Internal_Shdr
* sect
= section_headers
;
9078 Elf_Internal_Options
* iopt
;
9079 Elf_Internal_Options
* option
;
9083 /* Find the section header so that we get the size. */
9084 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
9087 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
,
9088 sect
->sh_size
, _("options"));
9091 iopt
= ((Elf_Internal_Options
*)
9092 malloc ((sect
->sh_size
/ sizeof (eopt
)) * sizeof (* iopt
)));
9095 error (_("Out of memory"));
9102 while (offset
< sect
->sh_size
)
9104 Elf_External_Options
* eoption
;
9106 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
9108 option
->kind
= BYTE_GET (eoption
->kind
);
9109 option
->size
= BYTE_GET (eoption
->size
);
9110 option
->section
= BYTE_GET (eoption
->section
);
9111 option
->info
= BYTE_GET (eoption
->info
);
9113 offset
+= option
->size
;
9119 printf (_("\nSection '%s' contains %d entries:\n"),
9120 SECTION_NAME (sect
), cnt
);
9128 switch (option
->kind
)
9131 /* This shouldn't happen. */
9132 printf (" NULL %d %lx", option
->section
, option
->info
);
9135 printf (" REGINFO ");
9136 if (elf_header
.e_machine
== EM_MIPS
)
9139 Elf32_External_RegInfo
* ereg
;
9140 Elf32_RegInfo reginfo
;
9142 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
9143 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9144 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9145 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9146 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9147 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9148 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9150 printf ("GPR %08lx GP 0x%lx\n",
9152 (unsigned long) reginfo
.ri_gp_value
);
9153 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9154 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9155 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9160 Elf64_External_RegInfo
* ereg
;
9161 Elf64_Internal_RegInfo reginfo
;
9163 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
9164 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9165 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9166 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9167 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9168 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9169 reginfo
.ri_gp_value
= BYTE_GET8 (ereg
->ri_gp_value
);
9171 printf ("GPR %08lx GP 0x",
9172 reginfo
.ri_gprmask
);
9173 printf_vma (reginfo
.ri_gp_value
);
9176 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9177 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9178 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9182 case ODK_EXCEPTIONS
:
9183 fputs (" EXCEPTIONS fpe_min(", stdout
);
9184 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
9185 fputs (") fpe_max(", stdout
);
9186 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
9187 fputs (")", stdout
);
9189 if (option
->info
& OEX_PAGE0
)
9190 fputs (" PAGE0", stdout
);
9191 if (option
->info
& OEX_SMM
)
9192 fputs (" SMM", stdout
);
9193 if (option
->info
& OEX_FPDBUG
)
9194 fputs (" FPDBUG", stdout
);
9195 if (option
->info
& OEX_DISMISS
)
9196 fputs (" DISMISS", stdout
);
9199 fputs (" PAD ", stdout
);
9200 if (option
->info
& OPAD_PREFIX
)
9201 fputs (" PREFIX", stdout
);
9202 if (option
->info
& OPAD_POSTFIX
)
9203 fputs (" POSTFIX", stdout
);
9204 if (option
->info
& OPAD_SYMBOL
)
9205 fputs (" SYMBOL", stdout
);
9208 fputs (" HWPATCH ", stdout
);
9209 if (option
->info
& OHW_R4KEOP
)
9210 fputs (" R4KEOP", stdout
);
9211 if (option
->info
& OHW_R8KPFETCH
)
9212 fputs (" R8KPFETCH", stdout
);
9213 if (option
->info
& OHW_R5KEOP
)
9214 fputs (" R5KEOP", stdout
);
9215 if (option
->info
& OHW_R5KCVTL
)
9216 fputs (" R5KCVTL", stdout
);
9219 fputs (" FILL ", stdout
);
9220 /* XXX Print content of info word? */
9223 fputs (" TAGS ", stdout
);
9224 /* XXX Print content of info word? */
9227 fputs (" HWAND ", stdout
);
9228 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9229 fputs (" R4KEOP_CHECKED", stdout
);
9230 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9231 fputs (" R4KEOP_CLEAN", stdout
);
9234 fputs (" HWOR ", stdout
);
9235 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9236 fputs (" R4KEOP_CHECKED", stdout
);
9237 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9238 fputs (" R4KEOP_CLEAN", stdout
);
9241 printf (" GP_GROUP %#06lx self-contained %#06lx",
9242 option
->info
& OGP_GROUP
,
9243 (option
->info
& OGP_SELF
) >> 16);
9246 printf (" IDENT %#06lx self-contained %#06lx",
9247 option
->info
& OGP_GROUP
,
9248 (option
->info
& OGP_SELF
) >> 16);
9251 /* This shouldn't happen. */
9252 printf (" %3d ??? %d %lx",
9253 option
->kind
, option
->section
, option
->info
);
9257 len
= sizeof (* eopt
);
9258 while (len
< option
->size
)
9259 if (((char *) option
)[len
] >= ' '
9260 && ((char *) option
)[len
] < 0x7f)
9261 printf ("%c", ((char *) option
)[len
++]);
9263 printf ("\\%03o", ((char *) option
)[len
++]);
9265 fputs ("\n", stdout
);
9273 if (conflicts_offset
!= 0 && conflictsno
!= 0)
9275 Elf32_Conflict
* iconf
;
9278 if (dynamic_symbols
== NULL
)
9280 error (_("conflict list found without a dynamic symbol table"));
9284 iconf
= (Elf32_Conflict
*) malloc (conflictsno
* sizeof (* iconf
));
9287 error (_("Out of memory"));
9293 Elf32_External_Conflict
* econf32
;
9295 econf32
= ((Elf32_External_Conflict
*)
9296 get_data (NULL
, file
, conflicts_offset
,
9297 conflictsno
* sizeof (* econf32
),
9302 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9303 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
9309 Elf64_External_Conflict
* econf64
;
9311 econf64
= ((Elf64_External_Conflict
*)
9312 get_data (NULL
, file
, conflicts_offset
,
9313 conflictsno
* sizeof (* econf64
),
9318 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9319 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
9324 printf (_("\nSection '.conflict' contains %ld entries:\n"),
9325 (long) conflictsno
);
9326 puts (_(" Num: Index Value Name"));
9328 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9330 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
9332 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
9333 print_vma (psym
->st_value
, FULL_HEX
);
9335 print_symbol (25, dynamic_strings
+ psym
->st_name
);
9346 get_note_type (e_type
)
9349 static char buff
[64];
9353 case NT_PRSTATUS
: return _("NT_PRSTATUS (prstatus structure)");
9354 case NT_FPREGSET
: return _("NT_FPREGSET (floating point registers)");
9355 case NT_PRPSINFO
: return _("NT_PRPSINFO (prpsinfo structure)");
9356 case NT_TASKSTRUCT
: return _("NT_TASKSTRUCT (task structure)");
9357 case NT_PRXFPREG
: return _("NT_PRXFPREG (user_xfpregs structure)");
9358 case NT_PSTATUS
: return _("NT_PSTATUS (pstatus structure)");
9359 case NT_FPREGS
: return _("NT_FPREGS (floating point registers)");
9360 case NT_PSINFO
: return _("NT_PSINFO (psinfo structure)");
9361 case NT_LWPSTATUS
: return _("NT_LWPSTATUS (lwpstatus_t structure)");
9362 case NT_LWPSINFO
: return _("NT_LWPSINFO (lwpsinfo_t structure)");
9363 case NT_WIN32PSTATUS
: return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9365 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
9371 get_netbsd_elfcore_note_type (e_type
)
9374 static char buff
[64];
9376 if (e_type
== NT_NETBSDCORE_PROCINFO
)
9378 /* NetBSD core "procinfo" structure. */
9379 return _("NetBSD procinfo structure");
9382 /* As of Jan 2002 there are no other machine-independent notes
9383 defined for NetBSD core files. If the note type is less
9384 than the start of the machine-dependent note types, we don't
9387 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
9389 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
9393 switch (elf_header
.e_machine
)
9395 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
9396 and PT_GETFPREGS == mach+2. */
9401 case EM_SPARC32PLUS
:
9405 case NT_NETBSDCORE_FIRSTMACH
+0:
9406 return _("PT_GETREGS (reg structure)");
9407 case NT_NETBSDCORE_FIRSTMACH
+2:
9408 return _("PT_GETFPREGS (fpreg structure)");
9414 /* On all other arch's, PT_GETREGS == mach+1 and
9415 PT_GETFPREGS == mach+3. */
9419 case NT_NETBSDCORE_FIRSTMACH
+1:
9420 return _("PT_GETREGS (reg structure)");
9421 case NT_NETBSDCORE_FIRSTMACH
+3:
9422 return _("PT_GETFPREGS (fpreg structure)");
9428 sprintf (buff
, _("PT_FIRSTMACH+%d"), e_type
- NT_NETBSDCORE_FIRSTMACH
);
9432 /* Note that by the ELF standard, the name field is already null byte
9433 terminated, and namesz includes the terminating null byte.
9434 I.E. the value of namesz for the name "FSF" is 4.
9436 If the value of namesz is zero, there is no name present. */
9438 process_note (pnote
)
9439 Elf32_Internal_Note
* pnote
;
9443 if (pnote
->namesz
== 0)
9445 /* If there is no note name, then use the default set of
9446 note type strings. */
9447 nt
= get_note_type (pnote
->type
);
9449 else if (strncmp (pnote
->namedata
, "NetBSD-CORE", 11) == 0)
9451 /* NetBSD-specific core file notes. */
9452 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
9456 /* Don't recognize this note name; just use the default set of
9457 note type strings. */
9458 nt
= get_note_type (pnote
->type
);
9461 printf (" %s\t\t0x%08lx\t%s\n",
9462 pnote
->namesz
? pnote
->namedata
: "(NONE)",
9469 process_corefile_note_segment (file
, offset
, length
)
9474 Elf_External_Note
* pnotes
;
9475 Elf_External_Note
* external
;
9481 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, length
,
9488 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
9489 (unsigned long) offset
, (unsigned long) length
);
9490 printf (_(" Owner\t\tData size\tDescription\n"));
9492 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
9494 Elf_External_Note
* next
;
9495 Elf32_Internal_Note inote
;
9498 inote
.type
= BYTE_GET (external
->type
);
9499 inote
.namesz
= BYTE_GET (external
->namesz
);
9500 inote
.namedata
= external
->name
;
9501 inote
.descsz
= BYTE_GET (external
->descsz
);
9502 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
9503 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
9505 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
9507 if (((char *) next
) > (((char *) pnotes
) + length
))
9509 warn (_("corrupt note found at offset %x into core notes\n"),
9510 ((char *) external
) - ((char *) pnotes
));
9511 warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
9512 inote
.type
, inote
.namesz
, inote
.descsz
);
9518 /* Verify that name is null terminated. It appears that at least
9519 one version of Linux (RedHat 6.0) generates corefiles that don't
9520 comply with the ELF spec by failing to include the null byte in
9522 if (inote
.namedata
[inote
.namesz
] != '\0')
9524 temp
= malloc (inote
.namesz
+ 1);
9528 error (_("Out of memory\n"));
9533 strncpy (temp
, inote
.namedata
, inote
.namesz
);
9534 temp
[inote
.namesz
] = 0;
9536 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
9537 inote
.namedata
= temp
;
9540 res
&= process_note (& inote
);
9555 process_corefile_note_segments (file
)
9558 Elf_Internal_Phdr
* program_headers
;
9559 Elf_Internal_Phdr
* segment
;
9563 program_headers
= (Elf_Internal_Phdr
*) malloc
9564 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
9566 if (program_headers
== NULL
)
9568 error (_("Out of memory\n"));
9573 i
= get_32bit_program_headers (file
, program_headers
);
9575 i
= get_64bit_program_headers (file
, program_headers
);
9579 free (program_headers
);
9583 for (i
= 0, segment
= program_headers
;
9584 i
< elf_header
.e_phnum
;
9587 if (segment
->p_type
== PT_NOTE
)
9588 res
&= process_corefile_note_segment (file
,
9589 (bfd_vma
) segment
->p_offset
,
9590 (bfd_vma
) segment
->p_filesz
);
9593 free (program_headers
);
9599 process_corefile_contents (file
)
9602 /* If we have not been asked to display the notes then do nothing. */
9606 /* If file is not a core file then exit. */
9607 if (elf_header
.e_type
!= ET_CORE
)
9610 /* No program headers means no NOTE segment. */
9611 if (elf_header
.e_phnum
== 0)
9613 printf (_("No note segments present in the core file.\n"));
9617 return process_corefile_note_segments (file
);
9621 process_arch_specific (file
)
9627 switch (elf_header
.e_machine
)
9630 case EM_MIPS_RS3_LE
:
9631 return process_mips_specific (file
);
9640 get_file_header (file
)
9643 /* Read in the identity array. */
9644 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
9647 /* Determine how to read the rest of the header. */
9648 switch (elf_header
.e_ident
[EI_DATA
])
9650 default: /* fall through */
9651 case ELFDATANONE
: /* fall through */
9652 case ELFDATA2LSB
: byte_get
= byte_get_little_endian
; break;
9653 case ELFDATA2MSB
: byte_get
= byte_get_big_endian
; break;
9656 /* For now we only support 32 bit and 64 bit ELF files. */
9657 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
9659 /* Read in the rest of the header. */
9662 Elf32_External_Ehdr ehdr32
;
9664 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
9667 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
9668 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
9669 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
9670 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
9671 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
9672 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
9673 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
9674 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
9675 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
9676 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
9677 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
9678 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
9679 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
9683 Elf64_External_Ehdr ehdr64
;
9685 /* If we have been compiled with sizeof (bfd_vma) == 4, then
9686 we will not be able to cope with the 64bit data found in
9687 64 ELF files. Detect this now and abort before we start
9688 overwritting things. */
9689 if (sizeof (bfd_vma
) < 8)
9691 error (_("This instance of readelf has been built without support for a\n\
9692 64 bit data type and so it cannot read 64 bit ELF files.\n"));
9696 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
9699 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
9700 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
9701 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
9702 elf_header
.e_entry
= BYTE_GET8 (ehdr64
.e_entry
);
9703 elf_header
.e_phoff
= BYTE_GET8 (ehdr64
.e_phoff
);
9704 elf_header
.e_shoff
= BYTE_GET8 (ehdr64
.e_shoff
);
9705 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
9706 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
9707 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
9708 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
9709 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
9710 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
9711 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
9714 if (elf_header
.e_shoff
)
9716 /* There may be some extensions in the first section header. Don't
9717 bomb if we can't read it. */
9719 get_32bit_section_headers (file
, 1);
9721 get_64bit_section_headers (file
, 1);
9728 process_file (file_name
)
9732 struct stat statbuf
;
9735 if (stat (file_name
, & statbuf
) < 0)
9737 error (_("Cannot stat input file %s.\n"), file_name
);
9741 file
= fopen (file_name
, "rb");
9744 error (_("Input file %s not found.\n"), file_name
);
9748 if (! get_file_header (file
))
9750 error (_("%s: Failed to read file header\n"), file_name
);
9755 /* Initialise per file variables. */
9756 for (i
= NUM_ELEM (version_info
); i
--;)
9757 version_info
[i
] = 0;
9759 for (i
= NUM_ELEM (dynamic_info
); i
--;)
9760 dynamic_info
[i
] = 0;
9762 /* Process the file. */
9764 printf (_("\nFile: %s\n"), file_name
);
9766 if (! process_file_header ())
9772 process_section_headers (file
);
9774 process_program_headers (file
);
9776 process_dynamic_segment (file
);
9778 process_relocs (file
);
9780 process_unwind (file
);
9782 process_symbol_table (file
);
9784 process_syminfo (file
);
9786 process_version_sections (file
);
9788 process_section_contents (file
);
9790 process_corefile_contents (file
);
9792 process_arch_specific (file
);
9796 if (section_headers
)
9798 free (section_headers
);
9799 section_headers
= NULL
;
9804 free (string_table
);
9805 string_table
= NULL
;
9806 string_table_length
= 0;
9809 if (dynamic_strings
)
9811 free (dynamic_strings
);
9812 dynamic_strings
= NULL
;
9815 if (dynamic_symbols
)
9817 free (dynamic_symbols
);
9818 dynamic_symbols
= NULL
;
9819 num_dynamic_syms
= 0;
9822 if (dynamic_syminfo
)
9824 free (dynamic_syminfo
);
9825 dynamic_syminfo
= NULL
;
9831 #ifdef SUPPORT_DISASSEMBLY
9832 /* Needed by the i386 disassembler. For extra credit, someone could
9833 fix this so that we insert symbolic addresses here, esp for GOT/PLT
9837 print_address (unsigned int addr
, FILE * outfile
)
9839 fprintf (outfile
,"0x%8.8x", addr
);
9842 /* Needed by the i386 disassembler. */
9844 db_task_printsym (unsigned int addr
)
9846 print_address (addr
, stderr
);
9850 int main
PARAMS ((int, char **));
9859 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
9860 setlocale (LC_MESSAGES
, "");
9862 #if defined (HAVE_SETLOCALE)
9863 setlocale (LC_CTYPE
, "");
9865 bindtextdomain (PACKAGE
, LOCALEDIR
);
9866 textdomain (PACKAGE
);
9868 parse_args (argc
, argv
);
9870 if (optind
< (argc
- 1))
9874 while (optind
< argc
)
9875 err
|= process_file (argv
[optind
++]);
9877 if (dump_sects
!= NULL
)