1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003 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 believe 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"
72 #include "elf/m68hc11.h"
73 #include "elf/mcore.h"
76 #include "elf/mn10200.h"
77 #include "elf/mn10300.h"
78 #include "elf/msp430.h"
82 #include "elf/ppc64.h"
85 #include "elf/sparc.h"
88 #include "elf/x86-64.h"
89 #include "elf/xstormy16.h"
90 #include "elf/iq2000.h"
91 #include "elf/xtensa.h"
95 #include "libiberty.h"
97 char *program_name
= "readelf";
98 unsigned long dynamic_addr
;
99 bfd_size_type dynamic_size
;
100 char *dynamic_strings
;
102 unsigned long string_table_length
;
103 unsigned long num_dynamic_syms
;
104 Elf_Internal_Sym
*dynamic_symbols
;
105 Elf_Internal_Syminfo
*dynamic_syminfo
;
106 unsigned long dynamic_syminfo_offset
;
107 unsigned int dynamic_syminfo_nent
;
108 char program_interpreter
[64];
109 bfd_vma dynamic_info
[DT_JMPREL
+ 1];
110 bfd_vma version_info
[16];
111 Elf_Internal_Ehdr elf_header
;
112 Elf_Internal_Shdr
*section_headers
;
113 Elf_Internal_Phdr
*program_headers
;
114 Elf_Internal_Dyn
*dynamic_segment
;
115 Elf_Internal_Shdr
*symtab_shndx_hdr
;
123 int do_using_dynamic
;
131 int do_debug_abbrevs
;
133 int do_debug_pubnames
;
134 int do_debug_aranges
;
136 int do_debug_frames_interp
;
137 int do_debug_macinfo
;
144 /* A dynamic array of flags indicating which sections require dumping. */
145 char *dump_sects
= NULL
;
146 unsigned int num_dump_sects
= 0;
148 #define HEX_DUMP (1 << 0)
149 #define DISASS_DUMP (1 << 1)
150 #define DEBUG_DUMP (1 << 2)
152 /* How to rpint a vma value. */
153 typedef enum print_mode
165 /* Forward declarations for dumb compilers. */
166 static void print_vma
167 PARAMS ((bfd_vma
, print_mode
));
168 static void print_symbol
169 PARAMS ((int, const char *));
170 static bfd_vma (*byte_get
)
171 PARAMS ((unsigned char *, int));
172 static bfd_vma byte_get_little_endian
173 PARAMS ((unsigned char *, int));
174 static bfd_vma byte_get_big_endian
175 PARAMS ((unsigned char *, int));
176 static bfd_vma byte_get_signed
177 PARAMS ((unsigned char *, int));
178 static void (*byte_put
)
179 PARAMS ((unsigned char *, bfd_vma
, int));
180 static void byte_put_little_endian
181 PARAMS ((unsigned char *, bfd_vma
, int));
182 static void byte_put_big_endian
183 PARAMS ((unsigned char *, bfd_vma
, int));
184 static const char *get_mips_dynamic_type
185 PARAMS ((unsigned long));
186 static const char *get_sparc64_dynamic_type
187 PARAMS ((unsigned long));
188 static const char *get_ppc64_dynamic_type
189 PARAMS ((unsigned long));
190 static const char *get_parisc_dynamic_type
191 PARAMS ((unsigned long));
192 static const char *get_ia64_dynamic_type
193 PARAMS ((unsigned long));
194 static const char *get_dynamic_type
195 PARAMS ((unsigned long));
196 static int slurp_rela_relocs
197 PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Rela
**,
199 static int slurp_rel_relocs
200 PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Rela
**,
202 static int dump_relocations
203 PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Sym
*,
204 unsigned long, char *, int));
205 static char *get_file_type
207 static char *get_machine_name
209 static void decode_ARM_machine_flags
210 PARAMS ((unsigned, char[]));
211 static char *get_machine_flags
212 PARAMS ((unsigned, unsigned));
213 static const char *get_mips_segment_type
214 PARAMS ((unsigned long));
215 static const char *get_parisc_segment_type
216 PARAMS ((unsigned long));
217 static const char *get_ia64_segment_type
218 PARAMS ((unsigned long));
219 static const char *get_segment_type
220 PARAMS ((unsigned long));
221 static const char *get_mips_section_type_name
222 PARAMS ((unsigned int));
223 static const char *get_parisc_section_type_name
224 PARAMS ((unsigned int));
225 static const char *get_ia64_section_type_name
226 PARAMS ((unsigned int));
227 static const char *get_section_type_name
228 PARAMS ((unsigned int));
229 static const char *get_symbol_binding
230 PARAMS ((unsigned int));
231 static const char *get_symbol_type
232 PARAMS ((unsigned int));
233 static const char *get_symbol_visibility
234 PARAMS ((unsigned int));
235 static const char *get_symbol_index_type
236 PARAMS ((unsigned int));
237 static const char *get_dynamic_flags
241 static void parse_args
242 PARAMS ((int, char **));
243 static int process_file_header
245 static int process_program_headers
247 static int process_section_headers
249 static int process_unwind
251 static void dynamic_segment_mips_val
252 PARAMS ((Elf_Internal_Dyn
*));
253 static void dynamic_segment_parisc_val
254 PARAMS ((Elf_Internal_Dyn
*));
255 static void dynamic_segment_ia64_val
256 PARAMS ((Elf_Internal_Dyn
*));
257 static int process_dynamic_segment
259 static int process_symbol_table
261 static int process_syminfo
263 static int process_section_contents
265 static void process_mips_fpe_exception
267 static int process_mips_specific
269 static int process_file
271 static int process_relocs
273 static int process_version_sections
275 static char *get_ver_flags
276 PARAMS ((unsigned int));
277 static int get_32bit_section_headers
278 PARAMS ((FILE *, unsigned int));
279 static int get_64bit_section_headers
280 PARAMS ((FILE *, unsigned int));
281 static int get_32bit_program_headers
282 PARAMS ((FILE *, Elf_Internal_Phdr
*));
283 static int get_64bit_program_headers
284 PARAMS ((FILE *, Elf_Internal_Phdr
*));
285 static int get_program_headers
287 static int get_file_header
289 static Elf_Internal_Sym
*get_32bit_elf_symbols
290 PARAMS ((FILE *, Elf_Internal_Shdr
*));
291 static Elf_Internal_Sym
*get_64bit_elf_symbols
292 PARAMS ((FILE *, Elf_Internal_Shdr
*));
293 static const char *get_elf_section_flags
295 static int *get_dynamic_data
296 PARAMS ((FILE *, unsigned int));
297 static int get_32bit_dynamic_segment
299 static int get_64bit_dynamic_segment
301 static long offset_from_vma
302 PARAMS ((FILE *, bfd_vma vma
, bfd_size_type size
));
303 #ifdef SUPPORT_DISASSEMBLY
304 static int disassemble_section
305 PARAMS ((Elf_Internal_Shdr
*, FILE *));
307 static int dump_section
308 PARAMS ((Elf_Internal_Shdr
*, FILE *));
309 static int display_debug_section
310 PARAMS ((Elf_Internal_Shdr
*, FILE *));
311 static int display_debug_info
312 PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
313 static int display_debug_not_supported
314 PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
315 static int prescan_debug_info
316 PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
317 static int display_debug_lines
318 PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
319 static int display_debug_pubnames
320 PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
321 static int display_debug_abbrev
322 PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
323 static int display_debug_aranges
324 PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
325 static int display_debug_frames
326 PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
327 static int display_debug_macinfo
328 PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
329 static int display_debug_str
330 PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
331 static int display_debug_loc
332 PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
333 static unsigned char *process_abbrev_section
334 PARAMS ((unsigned char *, unsigned char *));
335 static void load_debug_str
337 static void free_debug_str
339 static const char *fetch_indirect_string
340 PARAMS ((unsigned long));
341 static void load_debug_loc
343 static void free_debug_loc
345 static unsigned long read_leb128
346 PARAMS ((unsigned char *, int *, int));
347 static int process_extended_line_op
348 PARAMS ((unsigned char *, int, int));
349 static void reset_state_machine
351 static char *get_TAG_name
352 PARAMS ((unsigned long));
353 static char *get_AT_name
354 PARAMS ((unsigned long));
355 static char *get_FORM_name
356 PARAMS ((unsigned long));
357 static void free_abbrevs
359 static void add_abbrev
360 PARAMS ((unsigned long, unsigned long, int));
361 static void add_abbrev_attr
362 PARAMS ((unsigned long, unsigned long));
363 static unsigned char *read_and_display_attr
364 PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long,
365 unsigned long, unsigned long, int));
366 static unsigned char *read_and_display_attr_value
367 PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long,
368 unsigned long, unsigned long, int));
369 static unsigned char *display_block
370 PARAMS ((unsigned char *, unsigned long));
371 static void decode_location_expression
372 PARAMS ((unsigned char *, unsigned int, unsigned long));
373 static void request_dump
374 PARAMS ((unsigned int, int));
375 static const char *get_elf_class
376 PARAMS ((unsigned int));
377 static const char *get_data_encoding
378 PARAMS ((unsigned int));
379 static const char *get_osabi_name
380 PARAMS ((unsigned int));
381 static int guess_is_rela
382 PARAMS ((unsigned long));
383 static const char *get_note_type
384 PARAMS ((unsigned int));
385 static const char *get_netbsd_elfcore_note_type
386 PARAMS ((unsigned int));
387 static int process_note
388 PARAMS ((Elf_Internal_Note
*));
389 static int process_corefile_note_segment
390 PARAMS ((FILE *, bfd_vma
, bfd_vma
));
391 static int process_corefile_note_segments
393 static int process_corefile_contents
395 static int process_arch_specific
397 static int process_gnu_liblist
400 typedef int Elf32_Word
;
404 #define SECTION_NAME(X) ((X) == NULL ? "<none>" : \
405 ((X)->sh_name >= string_table_length \
406 ? "<corrupt>" : string_table + (X)->sh_name))
408 /* Given st_shndx I, map to section_headers index. */
409 #define SECTION_HEADER_INDEX(I) \
410 ((I) < SHN_LORESERVE \
412 : ((I) <= SHN_HIRESERVE \
414 : (I) - (SHN_HIRESERVE + 1 - SHN_LORESERVE)))
416 /* Reverse of the above. */
417 #define SECTION_HEADER_NUM(N) \
418 ((N) < SHN_LORESERVE \
420 : (N) + (SHN_HIRESERVE + 1 - SHN_LORESERVE))
422 #define SECTION_HEADER(I) (section_headers + SECTION_HEADER_INDEX (I))
424 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
426 #define BYTE_GET(field) byte_get (field, sizeof (field))
428 /* If we can support a 64 bit data type then BFD64 should be defined
429 and sizeof (bfd_vma) == 8. In this case when translating from an
430 external 8 byte field to an internal field, we can assume that the
431 internal field is also 8 bytes wide and so we can extract all the data.
432 If, however, BFD64 is not defined, then we must assume that the
433 internal data structure only has 4 byte wide fields that are the
434 equivalent of the 8 byte wide external counterparts, and so we must
435 truncate the data. */
437 #define BYTE_GET8(field) byte_get (field, -8)
439 #define BYTE_GET8(field) byte_get (field, 8)
442 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
444 #define GET_ELF_SYMBOLS(file, section) \
445 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
446 : get_64bit_elf_symbols (file, section))
450 error
VPARAMS ((const char *message
, ...))
452 VA_OPEN (args
, message
);
453 VA_FIXEDARG (args
, const char *, message
);
455 fprintf (stderr
, _("%s: Error: "), program_name
);
456 vfprintf (stderr
, message
, args
);
461 warn
VPARAMS ((const char *message
, ...))
463 VA_OPEN (args
, message
);
464 VA_FIXEDARG (args
, const char *, message
);
466 fprintf (stderr
, _("%s: Warning: "), program_name
);
467 vfprintf (stderr
, message
, args
);
471 static PTR get_data
PARAMS ((PTR
, FILE *, long, size_t, const char *));
474 get_data (var
, file
, offset
, size
, reason
)
486 if (fseek (file
, offset
, SEEK_SET
))
488 error (_("Unable to seek to %x for %s\n"), offset
, reason
);
495 mvar
= (PTR
) malloc (size
);
499 error (_("Out of memory allocating %d bytes for %s\n"),
505 if (fread (mvar
, size
, 1, file
) != 1)
507 error (_("Unable to read in %d bytes of %s\n"), size
, reason
);
517 byte_get_little_endian (field
, size
)
518 unsigned char *field
;
527 return ((unsigned int) (field
[0]))
528 | (((unsigned int) (field
[1])) << 8);
532 /* We want to extract data from an 8 byte wide field and
533 place it into a 4 byte wide field. Since this is a little
534 endian source we can just use the 4 byte extraction code. */
538 return ((unsigned long) (field
[0]))
539 | (((unsigned long) (field
[1])) << 8)
540 | (((unsigned long) (field
[2])) << 16)
541 | (((unsigned long) (field
[3])) << 24);
546 /* This is a special case, generated by the BYTE_GET8 macro.
547 It means that we are loading an 8 byte value from a field
548 in an external structure into an 8 byte value in a field
549 in an internal strcuture. */
550 return ((bfd_vma
) (field
[0]))
551 | (((bfd_vma
) (field
[1])) << 8)
552 | (((bfd_vma
) (field
[2])) << 16)
553 | (((bfd_vma
) (field
[3])) << 24)
554 | (((bfd_vma
) (field
[4])) << 32)
555 | (((bfd_vma
) (field
[5])) << 40)
556 | (((bfd_vma
) (field
[6])) << 48)
557 | (((bfd_vma
) (field
[7])) << 56);
560 error (_("Unhandled data length: %d\n"), size
);
566 byte_get_signed (field
, size
)
567 unsigned char *field
;
570 bfd_vma x
= byte_get (field
, size
);
575 return (x
^ 0x80) - 0x80;
577 return (x
^ 0x8000) - 0x8000;
579 return (x
^ 0x80000000) - 0x80000000;
589 byte_put_little_endian (field
, value
, size
)
590 unsigned char * field
;
597 field
[7] = (((value
>> 24) >> 24) >> 8) & 0xff;
598 field
[6] = ((value
>> 24) >> 24) & 0xff;
599 field
[5] = ((value
>> 24) >> 16) & 0xff;
600 field
[4] = ((value
>> 24) >> 8) & 0xff;
603 field
[3] = (value
>> 24) & 0xff;
604 field
[2] = (value
>> 16) & 0xff;
607 field
[1] = (value
>> 8) & 0xff;
610 field
[0] = value
& 0xff;
614 error (_("Unhandled data length: %d\n"), size
);
619 /* Print a VMA value. */
621 print_vma (vma
, mode
)
635 printf ("%8.8lx", (unsigned long) vma
);
641 printf ("%5ld", (long) vma
);
649 printf ("%lx", (unsigned long) vma
);
653 printf ("%ld", (unsigned long) vma
);
657 printf ("%lu", (unsigned long) vma
);
679 #if BFD_HOST_64BIT_LONG
682 if (_bfd_int64_high (vma
))
683 printf ("%lx%8.8lx", _bfd_int64_high (vma
), _bfd_int64_low (vma
));
685 printf ("%lx", _bfd_int64_low (vma
));
690 #if BFD_HOST_64BIT_LONG
693 if (_bfd_int64_high (vma
))
695 printf ("++%ld", _bfd_int64_low (vma
));
697 printf ("%ld", _bfd_int64_low (vma
));
702 #if BFD_HOST_64BIT_LONG
704 printf ("%5ld", vma
);
706 printf ("%#lx", vma
);
708 if (_bfd_int64_high (vma
))
710 printf ("++%ld", _bfd_int64_low (vma
));
711 else if (vma
<= 99999)
712 printf ("%5ld", _bfd_int64_low (vma
));
714 printf ("%#lx", _bfd_int64_low (vma
));
719 #if BFD_HOST_64BIT_LONG
722 if (_bfd_int64_high (vma
))
724 printf ("++%lu", _bfd_int64_low (vma
));
726 printf ("%lu", _bfd_int64_low (vma
));
734 /* Display a symbol on stdout. If do_wide is not true then
735 format the symbol to be at most WIDTH characters,
736 truncating as necessary. If WIDTH is negative then
737 format the string to be exactly - WIDTH characters,
738 truncating or padding as necessary. */
741 print_symbol (width
, symbol
)
746 printf ("%s", symbol
);
748 printf ("%-*.*s", width
, width
, symbol
);
750 printf ("%-.*s", width
, symbol
);
754 byte_get_big_endian (field
, size
)
755 unsigned char *field
;
764 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
767 return ((unsigned long) (field
[3]))
768 | (((unsigned long) (field
[2])) << 8)
769 | (((unsigned long) (field
[1])) << 16)
770 | (((unsigned long) (field
[0])) << 24);
774 /* Although we are extracing data from an 8 byte wide field, we
775 are returning only 4 bytes of data. */
776 return ((unsigned long) (field
[7]))
777 | (((unsigned long) (field
[6])) << 8)
778 | (((unsigned long) (field
[5])) << 16)
779 | (((unsigned long) (field
[4])) << 24);
783 /* This is a special case, generated by the BYTE_GET8 macro.
784 It means that we are loading an 8 byte value from a field
785 in an external structure into an 8 byte value in a field
786 in an internal strcuture. */
787 return ((bfd_vma
) (field
[7]))
788 | (((bfd_vma
) (field
[6])) << 8)
789 | (((bfd_vma
) (field
[5])) << 16)
790 | (((bfd_vma
) (field
[4])) << 24)
791 | (((bfd_vma
) (field
[3])) << 32)
792 | (((bfd_vma
) (field
[2])) << 40)
793 | (((bfd_vma
) (field
[1])) << 48)
794 | (((bfd_vma
) (field
[0])) << 56);
798 error (_("Unhandled data length: %d\n"), size
);
804 byte_put_big_endian (field
, value
, size
)
805 unsigned char * field
;
812 field
[7] = value
& 0xff;
813 field
[6] = (value
>> 8) & 0xff;
814 field
[5] = (value
>> 16) & 0xff;
815 field
[4] = (value
>> 24) & 0xff;
820 field
[3] = value
& 0xff;
821 field
[2] = (value
>> 8) & 0xff;
825 field
[1] = value
& 0xff;
829 field
[0] = value
& 0xff;
833 error (_("Unhandled data length: %d\n"), size
);
838 /* Guess the relocation size commonly used by the specific machines. */
841 guess_is_rela (e_machine
)
842 unsigned long e_machine
;
846 /* Targets that use REL relocations. */
862 /* Targets that use RELA relocations. */
877 case EM_CYGNUS_MN10200
:
879 case EM_CYGNUS_MN10300
:
924 warn (_("Don't know about relocations on this machine architecture\n"));
930 slurp_rela_relocs (file
, rel_offset
, rel_size
, relasp
, nrelasp
)
932 unsigned long rel_offset
;
933 unsigned long rel_size
;
934 Elf_Internal_Rela
**relasp
;
935 unsigned long *nrelasp
;
937 Elf_Internal_Rela
*relas
;
938 unsigned long nrelas
;
943 Elf32_External_Rela
*erelas
;
945 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
,
946 rel_size
, _("relocs"));
950 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
952 relas
= (Elf_Internal_Rela
*)
953 malloc (nrelas
* sizeof (Elf_Internal_Rela
));
957 error(_("out of memory parsing relocs"));
961 for (i
= 0; i
< nrelas
; i
++)
963 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
964 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
965 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
972 Elf64_External_Rela
*erelas
;
974 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
,
975 rel_size
, _("relocs"));
979 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
981 relas
= (Elf_Internal_Rela
*)
982 malloc (nrelas
* sizeof (Elf_Internal_Rela
));
986 error(_("out of memory parsing relocs"));
990 for (i
= 0; i
< nrelas
; i
++)
992 relas
[i
].r_offset
= BYTE_GET8 (erelas
[i
].r_offset
);
993 relas
[i
].r_info
= BYTE_GET8 (erelas
[i
].r_info
);
994 relas
[i
].r_addend
= BYTE_GET8 (erelas
[i
].r_addend
);
1005 slurp_rel_relocs (file
, rel_offset
, rel_size
, relsp
, nrelsp
)
1007 unsigned long rel_offset
;
1008 unsigned long rel_size
;
1009 Elf_Internal_Rela
**relsp
;
1010 unsigned long *nrelsp
;
1012 Elf_Internal_Rela
*rels
;
1013 unsigned long nrels
;
1018 Elf32_External_Rel
*erels
;
1020 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
,
1021 rel_size
, _("relocs"));
1025 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
1027 rels
= (Elf_Internal_Rela
*) malloc (nrels
* sizeof (Elf_Internal_Rela
));
1031 error(_("out of memory parsing relocs"));
1035 for (i
= 0; i
< nrels
; i
++)
1037 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1038 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1039 rels
[i
].r_addend
= 0;
1046 Elf64_External_Rel
*erels
;
1048 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
,
1049 rel_size
, _("relocs"));
1053 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
1055 rels
= (Elf_Internal_Rela
*) malloc (nrels
* sizeof (Elf_Internal_Rela
));
1059 error(_("out of memory parsing relocs"));
1063 for (i
= 0; i
< nrels
; i
++)
1065 rels
[i
].r_offset
= BYTE_GET8 (erels
[i
].r_offset
);
1066 rels
[i
].r_info
= BYTE_GET8 (erels
[i
].r_info
);
1067 rels
[i
].r_addend
= 0;
1077 /* Display the contents of the relocation data found at the specified offset. */
1080 dump_relocations (file
, rel_offset
, rel_size
, symtab
, nsyms
, strtab
, is_rela
)
1082 unsigned long rel_offset
;
1083 unsigned long rel_size
;
1084 Elf_Internal_Sym
*symtab
;
1085 unsigned long nsyms
;
1090 Elf_Internal_Rela
*rels
;
1093 if (is_rela
== UNKNOWN
)
1094 is_rela
= guess_is_rela (elf_header
.e_machine
);
1098 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1103 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1112 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1114 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1119 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1121 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1129 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1131 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1136 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1138 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1142 for (i
= 0; i
< rel_size
; i
++)
1145 const char *rtype2
= NULL
;
1146 const char *rtype3
= NULL
;
1149 bfd_vma symtab_index
;
1151 bfd_vma type2
= (bfd_vma
) NULL
;
1152 bfd_vma type3
= (bfd_vma
) NULL
;
1154 offset
= rels
[i
].r_offset
;
1155 info
= rels
[i
].r_info
;
1159 type
= ELF32_R_TYPE (info
);
1160 symtab_index
= ELF32_R_SYM (info
);
1164 /* The #ifdef BFD64 below is to prevent a compile time warning.
1165 We know that if we do not have a 64 bit data type that we
1166 will never execute this code anyway. */
1168 if (elf_header
.e_machine
== EM_MIPS
)
1170 /* In little-endian objects, r_info isn't really a 64-bit
1171 little-endian value: it has a 32-bit little-endian
1172 symbol index followed by four individual byte fields.
1173 Reorder INFO accordingly. */
1174 if (elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1175 info
= (((info
& 0xffffffff) << 32)
1176 | ((info
>> 56) & 0xff)
1177 | ((info
>> 40) & 0xff00)
1178 | ((info
>> 24) & 0xff0000)
1179 | ((info
>> 8) & 0xff000000));
1180 type
= ELF64_MIPS_R_TYPE (info
);
1181 type2
= ELF64_MIPS_R_TYPE2 (info
);
1182 type3
= ELF64_MIPS_R_TYPE3 (info
);
1184 else if (elf_header
.e_machine
== EM_SPARCV9
)
1185 type
= ELF64_R_TYPE_ID (info
);
1187 type
= ELF64_R_TYPE (info
);
1189 symtab_index
= ELF64_R_SYM (info
);
1195 #ifdef _bfd_int64_low
1196 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset
), _bfd_int64_low (info
));
1198 printf ("%8.8lx %8.8lx ", offset
, info
);
1203 #ifdef _bfd_int64_low
1205 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1206 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1207 _bfd_int64_high (offset
),
1208 _bfd_int64_low (offset
),
1209 _bfd_int64_high (info
),
1210 _bfd_int64_low (info
));
1213 ? "%16.16lx %16.16lx "
1214 : "%12.12lx %12.12lx ",
1219 switch (elf_header
.e_machine
)
1226 case EM_CYGNUS_M32R
:
1227 rtype
= elf_m32r_reloc_type (type
);
1232 rtype
= elf_i386_reloc_type (type
);
1237 rtype
= elf_m68hc11_reloc_type (type
);
1241 rtype
= elf_m68k_reloc_type (type
);
1245 rtype
= elf_i960_reloc_type (type
);
1250 rtype
= elf_avr_reloc_type (type
);
1253 case EM_OLD_SPARCV9
:
1254 case EM_SPARC32PLUS
:
1257 rtype
= elf_sparc_reloc_type (type
);
1261 case EM_CYGNUS_V850
:
1262 rtype
= v850_reloc_type (type
);
1266 case EM_CYGNUS_D10V
:
1267 rtype
= elf_d10v_reloc_type (type
);
1271 case EM_CYGNUS_D30V
:
1272 rtype
= elf_d30v_reloc_type (type
);
1276 rtype
= elf_dlx_reloc_type (type
);
1280 rtype
= elf_sh_reloc_type (type
);
1284 case EM_CYGNUS_MN10300
:
1285 rtype
= elf_mn10300_reloc_type (type
);
1289 case EM_CYGNUS_MN10200
:
1290 rtype
= elf_mn10200_reloc_type (type
);
1294 case EM_CYGNUS_FR30
:
1295 rtype
= elf_fr30_reloc_type (type
);
1299 rtype
= elf_frv_reloc_type (type
);
1303 rtype
= elf_mcore_reloc_type (type
);
1307 rtype
= elf_mmix_reloc_type (type
);
1312 rtype
= elf_msp430_reloc_type (type
);
1316 rtype
= elf_ppc_reloc_type (type
);
1320 rtype
= elf_ppc64_reloc_type (type
);
1324 case EM_MIPS_RS3_LE
:
1325 rtype
= elf_mips_reloc_type (type
);
1328 rtype2
= elf_mips_reloc_type (type2
);
1329 rtype3
= elf_mips_reloc_type (type3
);
1334 rtype
= elf_alpha_reloc_type (type
);
1338 rtype
= elf_arm_reloc_type (type
);
1342 rtype
= elf_arc_reloc_type (type
);
1346 rtype
= elf_hppa_reloc_type (type
);
1352 rtype
= elf_h8_reloc_type (type
);
1357 rtype
= elf_or32_reloc_type (type
);
1362 rtype
= elf_pj_reloc_type (type
);
1365 rtype
= elf_ia64_reloc_type (type
);
1369 rtype
= elf_cris_reloc_type (type
);
1373 rtype
= elf_i860_reloc_type (type
);
1377 rtype
= elf_x86_64_reloc_type (type
);
1381 rtype
= i370_reloc_type (type
);
1386 rtype
= elf_s390_reloc_type (type
);
1390 rtype
= elf_xstormy16_reloc_type (type
);
1394 rtype
= elf_vax_reloc_type (type
);
1399 rtype
= elf_ip2k_reloc_type (type
);
1403 rtype
= elf_iq2000_reloc_type (type
);
1408 rtype
= elf_xtensa_reloc_type (type
);
1413 #ifdef _bfd_int64_low
1414 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type
));
1416 printf (_("unrecognized: %-7lx"), type
);
1419 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1423 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1424 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1427 Elf_Internal_Sym
*psym
;
1429 psym
= symtab
+ symtab_index
;
1432 print_vma (psym
->st_value
, LONG_HEX
);
1433 printf (is_32bit_elf
? " " : " ");
1435 if (psym
->st_name
== 0)
1437 const char *sec_name
= "<null>";
1440 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1442 bfd_vma sec_index
= (bfd_vma
) -1;
1444 if (psym
->st_shndx
< SHN_LORESERVE
)
1445 sec_index
= psym
->st_shndx
;
1446 else if (psym
->st_shndx
> SHN_LORESERVE
)
1447 sec_index
= psym
->st_shndx
- (SHN_HIRESERVE
+ 1
1450 if (sec_index
!= (bfd_vma
) -1)
1451 sec_name
= SECTION_NAME (section_headers
+ sec_index
);
1452 else if (psym
->st_shndx
== SHN_ABS
)
1454 else if (psym
->st_shndx
== SHN_COMMON
)
1455 sec_name
= "COMMON";
1458 sprintf (name_buf
, "<section 0x%x>",
1459 (unsigned int) psym
->st_shndx
);
1460 sec_name
= name_buf
;
1463 print_symbol (22, sec_name
);
1465 else if (strtab
== NULL
)
1466 printf (_("<string table index %3ld>"), psym
->st_name
);
1468 print_symbol (22, strtab
+ psym
->st_name
);
1471 printf (" + %lx", (unsigned long) rels
[i
].r_addend
);
1476 printf ("%*c", is_32bit_elf
? (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1477 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1480 if (elf_header
.e_machine
== EM_SPARCV9
1481 && !strcmp (rtype
, "R_SPARC_OLO10"))
1482 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1486 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1488 printf (" Type2: ");
1491 #ifdef _bfd_int64_low
1492 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2
));
1494 printf (_("unrecognized: %-7lx"), type2
);
1497 printf ("%-17.17s", rtype2
);
1499 printf("\n Type3: ");
1502 #ifdef _bfd_int64_low
1503 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3
));
1505 printf (_("unrecognized: %-7lx"), type3
);
1508 printf ("%-17.17s", rtype3
);
1520 get_mips_dynamic_type (type
)
1525 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1526 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1527 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1528 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1529 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1530 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1531 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1532 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1533 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1534 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1535 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1536 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1537 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1538 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1539 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1540 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1541 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1542 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1543 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1544 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1545 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1546 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1547 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1548 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1549 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1550 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1551 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1552 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1553 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1554 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1555 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1556 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1557 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1558 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1559 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1560 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1561 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1562 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1563 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1564 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1565 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1566 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1567 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1574 get_sparc64_dynamic_type (type
)
1579 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1586 get_ppc64_dynamic_type (type
)
1591 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1592 case DT_PPC64_OPD
: return "PPC64_OPD";
1593 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1600 get_parisc_dynamic_type (type
)
1605 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1606 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1607 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1608 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1609 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1610 case DT_HP_PREINIT
: return "HP_PREINIT";
1611 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1612 case DT_HP_NEEDED
: return "HP_NEEDED";
1613 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1614 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1615 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1616 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1617 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1624 get_ia64_dynamic_type (type
)
1629 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1636 get_dynamic_type (type
)
1639 static char buff
[32];
1643 case DT_NULL
: return "NULL";
1644 case DT_NEEDED
: return "NEEDED";
1645 case DT_PLTRELSZ
: return "PLTRELSZ";
1646 case DT_PLTGOT
: return "PLTGOT";
1647 case DT_HASH
: return "HASH";
1648 case DT_STRTAB
: return "STRTAB";
1649 case DT_SYMTAB
: return "SYMTAB";
1650 case DT_RELA
: return "RELA";
1651 case DT_RELASZ
: return "RELASZ";
1652 case DT_RELAENT
: return "RELAENT";
1653 case DT_STRSZ
: return "STRSZ";
1654 case DT_SYMENT
: return "SYMENT";
1655 case DT_INIT
: return "INIT";
1656 case DT_FINI
: return "FINI";
1657 case DT_SONAME
: return "SONAME";
1658 case DT_RPATH
: return "RPATH";
1659 case DT_SYMBOLIC
: return "SYMBOLIC";
1660 case DT_REL
: return "REL";
1661 case DT_RELSZ
: return "RELSZ";
1662 case DT_RELENT
: return "RELENT";
1663 case DT_PLTREL
: return "PLTREL";
1664 case DT_DEBUG
: return "DEBUG";
1665 case DT_TEXTREL
: return "TEXTREL";
1666 case DT_JMPREL
: return "JMPREL";
1667 case DT_BIND_NOW
: return "BIND_NOW";
1668 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1669 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1670 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1671 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1672 case DT_RUNPATH
: return "RUNPATH";
1673 case DT_FLAGS
: return "FLAGS";
1675 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1676 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1678 case DT_CHECKSUM
: return "CHECKSUM";
1679 case DT_PLTPADSZ
: return "PLTPADSZ";
1680 case DT_MOVEENT
: return "MOVEENT";
1681 case DT_MOVESZ
: return "MOVESZ";
1682 case DT_FEATURE
: return "FEATURE";
1683 case DT_POSFLAG_1
: return "POSFLAG_1";
1684 case DT_SYMINSZ
: return "SYMINSZ";
1685 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1687 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1688 case DT_CONFIG
: return "CONFIG";
1689 case DT_DEPAUDIT
: return "DEPAUDIT";
1690 case DT_AUDIT
: return "AUDIT";
1691 case DT_PLTPAD
: return "PLTPAD";
1692 case DT_MOVETAB
: return "MOVETAB";
1693 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1695 case DT_VERSYM
: return "VERSYM";
1697 case DT_RELACOUNT
: return "RELACOUNT";
1698 case DT_RELCOUNT
: return "RELCOUNT";
1699 case DT_FLAGS_1
: return "FLAGS_1";
1700 case DT_VERDEF
: return "VERDEF";
1701 case DT_VERDEFNUM
: return "VERDEFNUM";
1702 case DT_VERNEED
: return "VERNEED";
1703 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1705 case DT_AUXILIARY
: return "AUXILIARY";
1706 case DT_USED
: return "USED";
1707 case DT_FILTER
: return "FILTER";
1709 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1710 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1711 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1712 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1713 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1716 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1720 switch (elf_header
.e_machine
)
1723 case EM_MIPS_RS3_LE
:
1724 result
= get_mips_dynamic_type (type
);
1727 result
= get_sparc64_dynamic_type (type
);
1730 result
= get_ppc64_dynamic_type (type
);
1733 result
= get_ia64_dynamic_type (type
);
1743 sprintf (buff
, _("Processor Specific: %lx"), type
);
1745 else if ((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1749 switch (elf_header
.e_machine
)
1752 result
= get_parisc_dynamic_type (type
);
1762 sprintf (buff
, _("Operating System specific: %lx"), type
);
1765 sprintf (buff
, _("<unknown>: %lx"), type
);
1772 get_file_type (e_type
)
1775 static char buff
[32];
1779 case ET_NONE
: return _("NONE (None)");
1780 case ET_REL
: return _("REL (Relocatable file)");
1781 case ET_EXEC
: return _("EXEC (Executable file)");
1782 case ET_DYN
: return _("DYN (Shared object file)");
1783 case ET_CORE
: return _("CORE (Core file)");
1786 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1787 sprintf (buff
, _("Processor Specific: (%x)"), e_type
);
1788 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1789 sprintf (buff
, _("OS Specific: (%x)"), e_type
);
1791 sprintf (buff
, _("<unknown>: %x"), e_type
);
1797 get_machine_name (e_machine
)
1800 static char buff
[64]; /* XXX */
1804 case EM_NONE
: return _("None");
1805 case EM_M32
: return "WE32100";
1806 case EM_SPARC
: return "Sparc";
1807 case EM_386
: return "Intel 80386";
1808 case EM_68K
: return "MC68000";
1809 case EM_88K
: return "MC88000";
1810 case EM_486
: return "Intel 80486";
1811 case EM_860
: return "Intel 80860";
1812 case EM_MIPS
: return "MIPS R3000";
1813 case EM_S370
: return "IBM System/370";
1814 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1815 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1816 case EM_PARISC
: return "HPPA";
1817 case EM_PPC_OLD
: return "Power PC (old)";
1818 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1819 case EM_960
: return "Intel 90860";
1820 case EM_PPC
: return "PowerPC";
1821 case EM_PPC64
: return "PowerPC64";
1822 case EM_V800
: return "NEC V800";
1823 case EM_FR20
: return "Fujitsu FR20";
1824 case EM_RH32
: return "TRW RH32";
1825 case EM_MCORE
: return "MCORE";
1826 case EM_ARM
: return "ARM";
1827 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1828 case EM_SH
: return "Renesas / SuperH SH";
1829 case EM_SPARCV9
: return "Sparc v9";
1830 case EM_TRICORE
: return "Siemens Tricore";
1831 case EM_ARC
: return "ARC";
1832 case EM_H8_300
: return "Renesas H8/300";
1833 case EM_H8_300H
: return "Renesas H8/300H";
1834 case EM_H8S
: return "Renesas H8S";
1835 case EM_H8_500
: return "Renesas H8/500";
1836 case EM_IA_64
: return "Intel IA-64";
1837 case EM_MIPS_X
: return "Stanford MIPS-X";
1838 case EM_COLDFIRE
: return "Motorola Coldfire";
1839 case EM_68HC12
: return "Motorola M68HC12";
1840 case EM_ALPHA
: return "Alpha";
1841 case EM_CYGNUS_D10V
:
1842 case EM_D10V
: return "d10v";
1843 case EM_CYGNUS_D30V
:
1844 case EM_D30V
: return "d30v";
1845 case EM_CYGNUS_M32R
:
1846 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1847 case EM_CYGNUS_V850
:
1848 case EM_V850
: return "NEC v850";
1849 case EM_CYGNUS_MN10300
:
1850 case EM_MN10300
: return "mn10300";
1851 case EM_CYGNUS_MN10200
:
1852 case EM_MN10200
: return "mn10200";
1853 case EM_CYGNUS_FR30
:
1854 case EM_FR30
: return "Fujitsu FR30";
1855 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1857 case EM_PJ
: return "picoJava";
1858 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1859 case EM_PCP
: return "Siemens PCP";
1860 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1861 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1862 case EM_STARCORE
: return "Motorola Star*Core processor";
1863 case EM_ME16
: return "Toyota ME16 processor";
1864 case EM_ST100
: return "STMicroelectronics ST100 processor";
1865 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1866 case EM_FX66
: return "Siemens FX66 microcontroller";
1867 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1868 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1869 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1870 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1871 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1872 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1873 case EM_SVX
: return "Silicon Graphics SVx";
1874 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1875 case EM_VAX
: return "Digital VAX";
1877 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1878 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1879 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1880 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1881 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1882 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1883 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1884 case EM_PRISM
: return "Vitesse Prism";
1885 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1887 case EM_S390
: return "IBM S/390";
1888 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1890 case EM_OR32
: return "OpenRISC";
1891 case EM_DLX
: return "OpenDLX";
1893 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1894 case EM_IQ2000
: return "Vitesse IQ2000";
1896 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1898 sprintf (buff
, _("<unknown>: %x"), e_machine
);
1904 decode_ARM_machine_flags (e_flags
, buf
)
1911 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1912 e_flags
&= ~ EF_ARM_EABIMASK
;
1914 /* Handle "generic" ARM flags. */
1915 if (e_flags
& EF_ARM_RELEXEC
)
1917 strcat (buf
, ", relocatable executable");
1918 e_flags
&= ~ EF_ARM_RELEXEC
;
1921 if (e_flags
& EF_ARM_HASENTRY
)
1923 strcat (buf
, ", has entry point");
1924 e_flags
&= ~ EF_ARM_HASENTRY
;
1927 /* Now handle EABI specific flags. */
1931 strcat (buf
, ", <unrecognized EABI>");
1936 case EF_ARM_EABI_VER1
:
1937 strcat (buf
, ", Version1 EABI");
1942 /* Process flags one bit at a time. */
1943 flag
= e_flags
& - e_flags
;
1948 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1949 strcat (buf
, ", sorted symbol tables");
1959 case EF_ARM_EABI_VER2
:
1960 strcat (buf
, ", Version2 EABI");
1965 /* Process flags one bit at a time. */
1966 flag
= e_flags
& - e_flags
;
1971 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1972 strcat (buf
, ", sorted symbol tables");
1975 case EF_ARM_DYNSYMSUSESEGIDX
:
1976 strcat (buf
, ", dynamic symbols use segment index");
1979 case EF_ARM_MAPSYMSFIRST
:
1980 strcat (buf
, ", mapping symbols precede others");
1990 case EF_ARM_EABI_UNKNOWN
:
1991 strcat (buf
, ", GNU EABI");
1996 /* Process flags one bit at a time. */
1997 flag
= e_flags
& - e_flags
;
2002 case EF_ARM_INTERWORK
:
2003 strcat (buf
, ", interworking enabled");
2006 case EF_ARM_APCS_26
:
2007 strcat (buf
, ", uses APCS/26");
2010 case EF_ARM_APCS_FLOAT
:
2011 strcat (buf
, ", uses APCS/float");
2015 strcat (buf
, ", position independent");
2019 strcat (buf
, ", 8 bit structure alignment");
2022 case EF_ARM_NEW_ABI
:
2023 strcat (buf
, ", uses new ABI");
2026 case EF_ARM_OLD_ABI
:
2027 strcat (buf
, ", uses old ABI");
2030 case EF_ARM_SOFT_FLOAT
:
2031 strcat (buf
, ", software FP");
2034 case EF_ARM_MAVERICK_FLOAT
:
2035 strcat (buf
, ", Maverick FP");
2046 strcat (buf
,", <unknown>");
2050 get_machine_flags (e_flags
, e_machine
)
2054 static char buf
[1024];
2066 decode_ARM_machine_flags (e_flags
, buf
);
2070 if (e_flags
& EF_CPU32
)
2071 strcat (buf
, ", cpu32");
2072 if (e_flags
& EF_M68000
)
2073 strcat (buf
, ", m68000");
2077 if (e_flags
& EF_PPC_EMB
)
2078 strcat (buf
, ", emb");
2080 if (e_flags
& EF_PPC_RELOCATABLE
)
2081 strcat (buf
, ", relocatable");
2083 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2084 strcat (buf
, ", relocatable-lib");
2088 case EM_CYGNUS_V850
:
2089 switch (e_flags
& EF_V850_ARCH
)
2092 strcat (buf
, ", v850e");
2095 strcat (buf
, ", v850");
2098 strcat (buf
, ", unknown v850 architecture variant");
2104 case EM_CYGNUS_M32R
:
2105 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2106 strcat (buf
, ", m32r");
2111 case EM_MIPS_RS3_LE
:
2112 if (e_flags
& EF_MIPS_NOREORDER
)
2113 strcat (buf
, ", noreorder");
2115 if (e_flags
& EF_MIPS_PIC
)
2116 strcat (buf
, ", pic");
2118 if (e_flags
& EF_MIPS_CPIC
)
2119 strcat (buf
, ", cpic");
2121 if (e_flags
& EF_MIPS_UCODE
)
2122 strcat (buf
, ", ugen_reserved");
2124 if (e_flags
& EF_MIPS_ABI2
)
2125 strcat (buf
, ", abi2");
2127 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2128 strcat (buf
, ", odk first");
2130 if (e_flags
& EF_MIPS_32BITMODE
)
2131 strcat (buf
, ", 32bitmode");
2133 switch ((e_flags
& EF_MIPS_MACH
))
2135 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2136 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2137 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2138 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2139 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2140 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2141 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2142 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2143 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2145 /* We simply ignore the field in this case to avoid confusion:
2146 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2149 default: strcat (buf
, ", unknown CPU"); break;
2152 switch ((e_flags
& EF_MIPS_ABI
))
2154 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2155 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2156 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2157 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2159 /* We simply ignore the field in this case to avoid confusion:
2160 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2161 This means it is likely to be an o32 file, but not for
2164 default: strcat (buf
, ", unknown ABI"); break;
2167 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2168 strcat (buf
, ", mdmx");
2170 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2171 strcat (buf
, ", mips16");
2173 switch ((e_flags
& EF_MIPS_ARCH
))
2175 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2176 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2177 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2178 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2179 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2180 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2181 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2182 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2183 default: strcat (buf
, ", unknown ISA"); break;
2189 if (e_flags
& EF_SPARC_32PLUS
)
2190 strcat (buf
, ", v8+");
2192 if (e_flags
& EF_SPARC_SUN_US1
)
2193 strcat (buf
, ", ultrasparcI");
2195 if (e_flags
& EF_SPARC_SUN_US3
)
2196 strcat (buf
, ", ultrasparcIII");
2198 if (e_flags
& EF_SPARC_HAL_R1
)
2199 strcat (buf
, ", halr1");
2201 if (e_flags
& EF_SPARC_LEDATA
)
2202 strcat (buf
, ", ledata");
2204 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2205 strcat (buf
, ", tso");
2207 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2208 strcat (buf
, ", pso");
2210 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2211 strcat (buf
, ", rmo");
2215 switch (e_flags
& EF_PARISC_ARCH
)
2217 case EFA_PARISC_1_0
:
2218 strcpy (buf
, ", PA-RISC 1.0");
2220 case EFA_PARISC_1_1
:
2221 strcpy (buf
, ", PA-RISC 1.1");
2223 case EFA_PARISC_2_0
:
2224 strcpy (buf
, ", PA-RISC 2.0");
2229 if (e_flags
& EF_PARISC_TRAPNIL
)
2230 strcat (buf
, ", trapnil");
2231 if (e_flags
& EF_PARISC_EXT
)
2232 strcat (buf
, ", ext");
2233 if (e_flags
& EF_PARISC_LSB
)
2234 strcat (buf
, ", lsb");
2235 if (e_flags
& EF_PARISC_WIDE
)
2236 strcat (buf
, ", wide");
2237 if (e_flags
& EF_PARISC_NO_KABP
)
2238 strcat (buf
, ", no kabp");
2239 if (e_flags
& EF_PARISC_LAZYSWAP
)
2240 strcat (buf
, ", lazyswap");
2245 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2246 strcat (buf
, ", new calling convention");
2248 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2249 strcat (buf
, ", gnu calling convention");
2253 if ((e_flags
& EF_IA_64_ABI64
))
2254 strcat (buf
, ", 64-bit");
2256 strcat (buf
, ", 32-bit");
2257 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2258 strcat (buf
, ", reduced fp model");
2259 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2260 strcat (buf
, ", no function descriptors, constant gp");
2261 else if ((e_flags
& EF_IA_64_CONS_GP
))
2262 strcat (buf
, ", constant gp");
2263 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2264 strcat (buf
, ", absolute");
2268 if ((e_flags
& EF_VAX_NONPIC
))
2269 strcat (buf
, ", non-PIC");
2270 if ((e_flags
& EF_VAX_DFLOAT
))
2271 strcat (buf
, ", D-Float");
2272 if ((e_flags
& EF_VAX_GFLOAT
))
2273 strcat (buf
, ", G-Float");
2282 get_mips_segment_type (type
)
2287 case PT_MIPS_REGINFO
:
2289 case PT_MIPS_RTPROC
:
2291 case PT_MIPS_OPTIONS
:
2301 get_parisc_segment_type (type
)
2306 case PT_HP_TLS
: return "HP_TLS";
2307 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2308 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2309 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2310 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2311 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2312 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2313 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2314 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2315 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2316 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2317 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2318 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2319 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2328 get_ia64_segment_type (type
)
2333 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2334 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2335 case PT_HP_TLS
: return "HP_TLS";
2336 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2337 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2338 case PT_IA_64_HP_STACK
: return "HP_STACK";
2347 get_segment_type (p_type
)
2348 unsigned long p_type
;
2350 static char buff
[32];
2354 case PT_NULL
: return "NULL";
2355 case PT_LOAD
: return "LOAD";
2356 case PT_DYNAMIC
: return "DYNAMIC";
2357 case PT_INTERP
: return "INTERP";
2358 case PT_NOTE
: return "NOTE";
2359 case PT_SHLIB
: return "SHLIB";
2360 case PT_PHDR
: return "PHDR";
2361 case PT_TLS
: return "TLS";
2363 case PT_GNU_EH_FRAME
:
2364 return "GNU_EH_FRAME";
2365 case PT_GNU_STACK
: return "STACK";
2368 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2372 switch (elf_header
.e_machine
)
2375 case EM_MIPS_RS3_LE
:
2376 result
= get_mips_segment_type (p_type
);
2379 result
= get_parisc_segment_type (p_type
);
2382 result
= get_ia64_segment_type (p_type
);
2392 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2394 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2398 switch (elf_header
.e_machine
)
2401 result
= get_parisc_segment_type (p_type
);
2404 result
= get_ia64_segment_type (p_type
);
2414 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2417 sprintf (buff
, _("<unknown>: %lx"), p_type
);
2424 get_mips_section_type_name (sh_type
)
2425 unsigned int sh_type
;
2429 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2430 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2431 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2432 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2433 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2434 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2435 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2436 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2437 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2438 case SHT_MIPS_RELD
: return "MIPS_RELD";
2439 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2440 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2441 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2442 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2443 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2444 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2445 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2446 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2447 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2448 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2449 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2450 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2451 case SHT_MIPS_LINE
: return "MIPS_LINE";
2452 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2453 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2454 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2455 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2456 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2457 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2458 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2459 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2460 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2461 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2462 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2463 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2464 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2465 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2466 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2467 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2475 get_parisc_section_type_name (sh_type
)
2476 unsigned int sh_type
;
2480 case SHT_PARISC_EXT
: return "PARISC_EXT";
2481 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2482 case SHT_PARISC_DOC
: return "PARISC_DOC";
2490 get_ia64_section_type_name (sh_type
)
2491 unsigned int sh_type
;
2493 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2494 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2495 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2499 case SHT_IA_64_EXT
: return "IA_64_EXT";
2500 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2501 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2509 get_section_type_name (sh_type
)
2510 unsigned int sh_type
;
2512 static char buff
[32];
2516 case SHT_NULL
: return "NULL";
2517 case SHT_PROGBITS
: return "PROGBITS";
2518 case SHT_SYMTAB
: return "SYMTAB";
2519 case SHT_STRTAB
: return "STRTAB";
2520 case SHT_RELA
: return "RELA";
2521 case SHT_HASH
: return "HASH";
2522 case SHT_DYNAMIC
: return "DYNAMIC";
2523 case SHT_NOTE
: return "NOTE";
2524 case SHT_NOBITS
: return "NOBITS";
2525 case SHT_REL
: return "REL";
2526 case SHT_SHLIB
: return "SHLIB";
2527 case SHT_DYNSYM
: return "DYNSYM";
2528 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2529 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2530 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2531 case SHT_GROUP
: return "GROUP";
2532 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2533 case SHT_GNU_verdef
: return "VERDEF";
2534 case SHT_GNU_verneed
: return "VERNEED";
2535 case SHT_GNU_versym
: return "VERSYM";
2536 case 0x6ffffff0: return "VERSYM";
2537 case 0x6ffffffc: return "VERDEF";
2538 case 0x7ffffffd: return "AUXILIARY";
2539 case 0x7fffffff: return "FILTER";
2540 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2543 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2547 switch (elf_header
.e_machine
)
2550 case EM_MIPS_RS3_LE
:
2551 result
= get_mips_section_type_name (sh_type
);
2554 result
= get_parisc_section_type_name (sh_type
);
2557 result
= get_ia64_section_type_name (sh_type
);
2567 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2569 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2570 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2571 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2572 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2574 sprintf (buff
, _("<unknown>: %x"), sh_type
);
2580 #define OPTION_DEBUG_DUMP 512
2582 struct option options
[] =
2584 {"all", no_argument
, 0, 'a'},
2585 {"file-header", no_argument
, 0, 'h'},
2586 {"program-headers", no_argument
, 0, 'l'},
2587 {"headers", no_argument
, 0, 'e'},
2588 {"histogram", no_argument
, 0, 'I'},
2589 {"segments", no_argument
, 0, 'l'},
2590 {"sections", no_argument
, 0, 'S'},
2591 {"section-headers", no_argument
, 0, 'S'},
2592 {"symbols", no_argument
, 0, 's'},
2593 {"syms", no_argument
, 0, 's'},
2594 {"relocs", no_argument
, 0, 'r'},
2595 {"notes", no_argument
, 0, 'n'},
2596 {"dynamic", no_argument
, 0, 'd'},
2597 {"arch-specific", no_argument
, 0, 'A'},
2598 {"version-info", no_argument
, 0, 'V'},
2599 {"use-dynamic", no_argument
, 0, 'D'},
2600 {"hex-dump", required_argument
, 0, 'x'},
2601 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2602 {"unwind", no_argument
, 0, 'u'},
2603 #ifdef SUPPORT_DISASSEMBLY
2604 {"instruction-dump", required_argument
, 0, 'i'},
2607 {"version", no_argument
, 0, 'v'},
2608 {"wide", no_argument
, 0, 'W'},
2609 {"help", no_argument
, 0, 'H'},
2610 {0, no_argument
, 0, 0}
2616 fprintf (stdout
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2617 fprintf (stdout
, _(" Display information about the contents of ELF format files\n"));
2618 fprintf (stdout
, _(" Options are:\n\
2619 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2620 -h --file-header Display the ELF file header\n\
2621 -l --program-headers Display the program headers\n\
2622 --segments An alias for --program-headers\n\
2623 -S --section-headers Display the sections' header\n\
2624 --sections An alias for --section-headers\n\
2625 -e --headers Equivalent to: -h -l -S\n\
2626 -s --syms Display the symbol table\n\
2627 --symbols An alias for --syms\n\
2628 -n --notes Display the core notes (if present)\n\
2629 -r --relocs Display the relocations (if present)\n\
2630 -u --unwind Display the unwind info (if present)\n\
2631 -d --dynamic Display the dynamic segment (if present)\n\
2632 -V --version-info Display the version sections (if present)\n\
2633 -A --arch-specific Display architecture specific information (if any).\n\
2634 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2635 -x --hex-dump=<number> Dump the contents of section <number>\n\
2636 -w[liaprmfFso] or\n\
2637 --debug-dump[=line,=info,=abbrev,=pubnames,=ranges,=macro,=frames,=str,=loc]\n\
2638 Display the contents of DWARF2 debug sections\n"));
2639 #ifdef SUPPORT_DISASSEMBLY
2640 fprintf (stdout
, _("\
2641 -i --instruction-dump=<number>\n\
2642 Disassemble the contents of section <number>\n"));
2644 fprintf (stdout
, _("\
2645 -I --histogram Display histogram of bucket list lengths\n\
2646 -W --wide Allow output width to exceed 80 characters\n\
2647 -H --help Display this information\n\
2648 -v --version Display the version number of readelf\n"));
2649 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2655 request_dump (section
, type
)
2656 unsigned int section
;
2659 if (section
>= num_dump_sects
)
2661 char *new_dump_sects
;
2663 new_dump_sects
= (char *) calloc (section
+ 1, 1);
2665 if (new_dump_sects
== NULL
)
2666 error (_("Out of memory allocating dump request table."));
2669 /* Copy current flag settings. */
2670 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2674 dump_sects
= new_dump_sects
;
2675 num_dump_sects
= section
+ 1;
2680 dump_sects
[section
] |= type
;
2686 parse_args (argc
, argv
)
2695 while ((c
= getopt_long
2696 (argc
, argv
, "ersuahnldSDAIw::x:i:vVWH", options
, NULL
)) != EOF
)
2763 section
= strtoul (optarg
, & cp
, 0);
2764 if (! *cp
&& section
>= 0)
2766 request_dump (section
, HEX_DUMP
);
2776 unsigned int index
= 0;
2780 while (optarg
[index
])
2781 switch (optarg
[index
++])
2790 do_debug_abbrevs
= 1;
2800 do_debug_pubnames
= 1;
2805 do_debug_aranges
= 1;
2809 do_debug_frames_interp
= 1;
2811 do_debug_frames
= 1;
2816 do_debug_macinfo
= 1;
2830 warn (_("Unrecognized debug option '%s'\n"), optarg
);
2835 case OPTION_DEBUG_DUMP
:
2841 static const char *debug_dump_opt
[]
2842 = { "line", "info", "abbrev", "pubnames", "ranges",
2843 "macro", "frames", "frames-interp", "str", "loc", NULL
};
2852 for (index
= 0; debug_dump_opt
[index
]; index
++)
2854 size_t len
= strlen (debug_dump_opt
[index
]);
2856 if (strncmp (p
, debug_dump_opt
[index
], len
) == 0
2857 && (p
[len
] == ',' || p
[len
] == '\0'))
2866 do_debug_abbrevs
= 1;
2877 do_debug_pubnames
= 1;
2881 do_debug_aranges
= 1;
2886 do_debug_frames_interp
= 1;
2887 do_debug_frames
= 1;
2891 do_debug_macinfo
= 1;
2904 if (debug_dump_opt
[index
] == NULL
)
2906 warn (_("Unrecognized debug option '%s'\n"), p
);
2907 p
= strchr (p
, ',');
2917 #ifdef SUPPORT_DISASSEMBLY
2920 section
= strtoul (optarg
, & cp
, 0);
2921 if (! *cp
&& section
>= 0)
2923 request_dump (section
, DISASS_DUMP
);
2929 print_version (program_name
);
2939 /* xgettext:c-format */
2940 error (_("Invalid option '-%c'\n"), c
);
2947 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
2948 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
2949 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
)
2953 warn (_("Nothing to do.\n"));
2959 get_elf_class (elf_class
)
2960 unsigned int elf_class
;
2962 static char buff
[32];
2966 case ELFCLASSNONE
: return _("none");
2967 case ELFCLASS32
: return "ELF32";
2968 case ELFCLASS64
: return "ELF64";
2970 sprintf (buff
, _("<unknown: %x>"), elf_class
);
2976 get_data_encoding (encoding
)
2977 unsigned int encoding
;
2979 static char buff
[32];
2983 case ELFDATANONE
: return _("none");
2984 case ELFDATA2LSB
: return _("2's complement, little endian");
2985 case ELFDATA2MSB
: return _("2's complement, big endian");
2987 sprintf (buff
, _("<unknown: %x>"), encoding
);
2993 get_osabi_name (osabi
)
2996 static char buff
[32];
3000 case ELFOSABI_NONE
: return "UNIX - System V";
3001 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3002 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3003 case ELFOSABI_LINUX
: return "UNIX - Linux";
3004 case ELFOSABI_HURD
: return "GNU/Hurd";
3005 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3006 case ELFOSABI_AIX
: return "UNIX - AIX";
3007 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3008 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3009 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3010 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3011 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3012 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3013 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3014 case ELFOSABI_AROS
: return "Amiga Research OS";
3015 case ELFOSABI_STANDALONE
: return _("Standalone App");
3016 case ELFOSABI_ARM
: return "ARM";
3018 sprintf (buff
, _("<unknown: %x>"), osabi
);
3023 /* Decode the data held in 'elf_header'. */
3026 process_file_header ()
3028 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3029 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3030 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3031 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3034 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3042 printf (_("ELF Header:\n"));
3043 printf (_(" Magic: "));
3044 for (i
= 0; i
< EI_NIDENT
; i
++)
3045 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3047 printf (_(" Class: %s\n"),
3048 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3049 printf (_(" Data: %s\n"),
3050 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3051 printf (_(" Version: %d %s\n"),
3052 elf_header
.e_ident
[EI_VERSION
],
3053 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3055 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3058 printf (_(" OS/ABI: %s\n"),
3059 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3060 printf (_(" ABI Version: %d\n"),
3061 elf_header
.e_ident
[EI_ABIVERSION
]);
3062 printf (_(" Type: %s\n"),
3063 get_file_type (elf_header
.e_type
));
3064 printf (_(" Machine: %s\n"),
3065 get_machine_name (elf_header
.e_machine
));
3066 printf (_(" Version: 0x%lx\n"),
3067 (unsigned long) elf_header
.e_version
);
3069 printf (_(" Entry point address: "));
3070 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3071 printf (_("\n Start of program headers: "));
3072 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3073 printf (_(" (bytes into file)\n Start of section headers: "));
3074 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3075 printf (_(" (bytes into file)\n"));
3077 printf (_(" Flags: 0x%lx%s\n"),
3078 (unsigned long) elf_header
.e_flags
,
3079 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3080 printf (_(" Size of this header: %ld (bytes)\n"),
3081 (long) elf_header
.e_ehsize
);
3082 printf (_(" Size of program headers: %ld (bytes)\n"),
3083 (long) elf_header
.e_phentsize
);
3084 printf (_(" Number of program headers: %ld\n"),
3085 (long) elf_header
.e_phnum
);
3086 printf (_(" Size of section headers: %ld (bytes)\n"),
3087 (long) elf_header
.e_shentsize
);
3088 printf (_(" Number of section headers: %ld"),
3089 (long) elf_header
.e_shnum
);
3090 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
3091 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3092 putc ('\n', stdout
);
3093 printf (_(" Section header string table index: %ld"),
3094 (long) elf_header
.e_shstrndx
);
3095 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
3096 printf (" (%ld)", (long) section_headers
[0].sh_link
);
3097 putc ('\n', stdout
);
3100 if (section_headers
!= NULL
)
3102 if (elf_header
.e_shnum
== 0)
3103 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3104 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
3105 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3106 free (section_headers
);
3107 section_headers
= NULL
;
3115 get_32bit_program_headers (file
, program_headers
)
3117 Elf_Internal_Phdr
*program_headers
;
3119 Elf32_External_Phdr
*phdrs
;
3120 Elf32_External_Phdr
*external
;
3121 Elf_Internal_Phdr
*internal
;
3124 phdrs
= ((Elf32_External_Phdr
*)
3125 get_data (NULL
, file
, elf_header
.e_phoff
,
3126 elf_header
.e_phentsize
* elf_header
.e_phnum
,
3127 _("program headers")));
3131 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3132 i
< elf_header
.e_phnum
;
3133 i
++, internal
++, external
++)
3135 internal
->p_type
= BYTE_GET (external
->p_type
);
3136 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3137 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3138 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3139 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3140 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3141 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3142 internal
->p_align
= BYTE_GET (external
->p_align
);
3151 get_64bit_program_headers (file
, program_headers
)
3153 Elf_Internal_Phdr
*program_headers
;
3155 Elf64_External_Phdr
*phdrs
;
3156 Elf64_External_Phdr
*external
;
3157 Elf_Internal_Phdr
*internal
;
3160 phdrs
= ((Elf64_External_Phdr
*)
3161 get_data (NULL
, file
, elf_header
.e_phoff
,
3162 elf_header
.e_phentsize
* elf_header
.e_phnum
,
3163 _("program headers")));
3167 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3168 i
< elf_header
.e_phnum
;
3169 i
++, internal
++, external
++)
3171 internal
->p_type
= BYTE_GET (external
->p_type
);
3172 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3173 internal
->p_offset
= BYTE_GET8 (external
->p_offset
);
3174 internal
->p_vaddr
= BYTE_GET8 (external
->p_vaddr
);
3175 internal
->p_paddr
= BYTE_GET8 (external
->p_paddr
);
3176 internal
->p_filesz
= BYTE_GET8 (external
->p_filesz
);
3177 internal
->p_memsz
= BYTE_GET8 (external
->p_memsz
);
3178 internal
->p_align
= BYTE_GET8 (external
->p_align
);
3186 /* Returns 1 if the program headers were read into `program_headers'. */
3189 get_program_headers (file
)
3192 Elf_Internal_Phdr
*phdrs
;
3194 /* Check cache of prior read. */
3195 if (program_headers
!= NULL
)
3198 phdrs
= (Elf_Internal_Phdr
*) malloc
3199 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
3203 error (_("Out of memory\n"));
3208 ? get_32bit_program_headers (file
, phdrs
)
3209 : get_64bit_program_headers (file
, phdrs
))
3211 program_headers
= phdrs
;
3219 /* Returns 1 if the program headers were loaded. */
3222 process_program_headers (file
)
3225 Elf_Internal_Phdr
*segment
;
3228 if (elf_header
.e_phnum
== 0)
3231 printf (_("\nThere are no program headers in this file.\n"));
3235 if (do_segments
&& !do_header
)
3237 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3238 printf (_("Entry point "));
3239 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3240 printf (_("\nThere are %d program headers, starting at offset "),
3241 elf_header
.e_phnum
);
3242 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3246 if (! get_program_headers (file
))
3251 if (elf_header
.e_phnum
> 1)
3252 printf (_("\nProgram Headers:\n"));
3254 printf (_("\nProgram Headers:\n"));
3258 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3261 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3265 (_(" Type Offset VirtAddr PhysAddr\n"));
3267 (_(" FileSiz MemSiz Flags Align\n"));
3274 for (i
= 0, segment
= program_headers
;
3275 i
< elf_header
.e_phnum
;
3280 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3284 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3285 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3286 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3287 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3288 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3290 (segment
->p_flags
& PF_R
? 'R' : ' '),
3291 (segment
->p_flags
& PF_W
? 'W' : ' '),
3292 (segment
->p_flags
& PF_X
? 'E' : ' '));
3293 printf ("%#lx", (unsigned long) segment
->p_align
);
3297 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3298 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3301 print_vma (segment
->p_offset
, FULL_HEX
);
3305 print_vma (segment
->p_vaddr
, FULL_HEX
);
3307 print_vma (segment
->p_paddr
, FULL_HEX
);
3310 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3311 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3314 print_vma (segment
->p_filesz
, FULL_HEX
);
3318 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3319 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3322 print_vma (segment
->p_offset
, FULL_HEX
);
3326 (segment
->p_flags
& PF_R
? 'R' : ' '),
3327 (segment
->p_flags
& PF_W
? 'W' : ' '),
3328 (segment
->p_flags
& PF_X
? 'E' : ' '));
3330 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3331 printf ("%#lx", (unsigned long) segment
->p_align
);
3334 print_vma (segment
->p_align
, PREFIX_HEX
);
3339 print_vma (segment
->p_offset
, FULL_HEX
);
3341 print_vma (segment
->p_vaddr
, FULL_HEX
);
3343 print_vma (segment
->p_paddr
, FULL_HEX
);
3345 print_vma (segment
->p_filesz
, FULL_HEX
);
3347 print_vma (segment
->p_memsz
, FULL_HEX
);
3349 (segment
->p_flags
& PF_R
? 'R' : ' '),
3350 (segment
->p_flags
& PF_W
? 'W' : ' '),
3351 (segment
->p_flags
& PF_X
? 'E' : ' '));
3352 print_vma (segment
->p_align
, HEX
);
3356 switch (segment
->p_type
)
3360 error (_("more than one dynamic segment\n"));
3362 dynamic_addr
= segment
->p_offset
;
3363 dynamic_size
= segment
->p_filesz
;
3367 if (fseek (file
, (long) segment
->p_offset
, SEEK_SET
))
3368 error (_("Unable to find program interpreter name\n"));
3371 program_interpreter
[0] = 0;
3372 fscanf (file
, "%63s", program_interpreter
);
3375 printf (_("\n [Requesting program interpreter: %s]"),
3376 program_interpreter
);
3382 putc ('\n', stdout
);
3385 if (do_segments
&& section_headers
!= NULL
)
3387 printf (_("\n Section to Segment mapping:\n"));
3388 printf (_(" Segment Sections...\n"));
3390 assert (string_table
!= NULL
);
3392 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3395 Elf_Internal_Shdr
*section
;
3397 segment
= program_headers
+ i
;
3398 section
= section_headers
;
3400 printf (" %2.2d ", i
);
3402 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3404 if (section
->sh_size
> 0
3405 /* Compare allocated sections by VMA, unallocated
3406 sections by file offset. */
3407 && (section
->sh_flags
& SHF_ALLOC
3408 ? (section
->sh_addr
>= segment
->p_vaddr
3409 && section
->sh_addr
+ section
->sh_size
3410 <= segment
->p_vaddr
+ segment
->p_memsz
)
3411 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
3412 && (section
->sh_offset
+ section
->sh_size
3413 <= segment
->p_offset
+ segment
->p_filesz
))))
3414 printf ("%s ", SECTION_NAME (section
));
3425 /* Find the file offset corresponding to VMA by using the program headers. */
3428 offset_from_vma (file
, vma
, size
)
3433 Elf_Internal_Phdr
*seg
;
3435 if (! get_program_headers (file
))
3437 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3441 for (seg
= program_headers
;
3442 seg
< program_headers
+ elf_header
.e_phnum
;
3445 if (seg
->p_type
!= PT_LOAD
)
3448 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3449 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3450 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3453 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3460 get_32bit_section_headers (file
, num
)
3464 Elf32_External_Shdr
*shdrs
;
3465 Elf_Internal_Shdr
*internal
;
3468 shdrs
= ((Elf32_External_Shdr
*)
3469 get_data (NULL
, file
, elf_header
.e_shoff
,
3470 elf_header
.e_shentsize
* num
,
3471 _("section headers")));
3475 section_headers
= ((Elf_Internal_Shdr
*)
3476 malloc (num
* sizeof (Elf_Internal_Shdr
)));
3478 if (section_headers
== NULL
)
3480 error (_("Out of memory\n"));
3484 for (i
= 0, internal
= section_headers
;
3488 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3489 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3490 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3491 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3492 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3493 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3494 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3495 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3496 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3497 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3506 get_64bit_section_headers (file
, num
)
3510 Elf64_External_Shdr
*shdrs
;
3511 Elf_Internal_Shdr
*internal
;
3514 shdrs
= ((Elf64_External_Shdr
*)
3515 get_data (NULL
, file
, elf_header
.e_shoff
,
3516 elf_header
.e_shentsize
* num
,
3517 _("section headers")));
3521 section_headers
= ((Elf_Internal_Shdr
*)
3522 malloc (num
* sizeof (Elf_Internal_Shdr
)));
3524 if (section_headers
== NULL
)
3526 error (_("Out of memory\n"));
3530 for (i
= 0, internal
= section_headers
;
3534 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3535 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3536 internal
->sh_flags
= BYTE_GET8 (shdrs
[i
].sh_flags
);
3537 internal
->sh_addr
= BYTE_GET8 (shdrs
[i
].sh_addr
);
3538 internal
->sh_size
= BYTE_GET8 (shdrs
[i
].sh_size
);
3539 internal
->sh_entsize
= BYTE_GET8 (shdrs
[i
].sh_entsize
);
3540 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3541 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3542 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3543 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3551 static Elf_Internal_Sym
*
3552 get_32bit_elf_symbols (file
, section
)
3554 Elf_Internal_Shdr
*section
;
3556 unsigned long number
;
3557 Elf32_External_Sym
*esyms
;
3558 Elf_External_Sym_Shndx
*shndx
;
3559 Elf_Internal_Sym
*isyms
;
3560 Elf_Internal_Sym
*psym
;
3563 esyms
= ((Elf32_External_Sym
*)
3564 get_data (NULL
, file
, section
->sh_offset
,
3565 section
->sh_size
, _("symbols")));
3570 if (symtab_shndx_hdr
!= NULL
3571 && (symtab_shndx_hdr
->sh_link
3572 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3574 shndx
= ((Elf_External_Sym_Shndx
*)
3575 get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3576 symtab_shndx_hdr
->sh_size
, _("symtab shndx")));
3584 number
= section
->sh_size
/ section
->sh_entsize
;
3585 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
3589 error (_("Out of memory\n"));
3596 for (j
= 0, psym
= isyms
;
3600 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3601 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3602 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3603 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3604 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3606 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3607 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3608 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3618 static Elf_Internal_Sym
*
3619 get_64bit_elf_symbols (file
, section
)
3621 Elf_Internal_Shdr
*section
;
3623 unsigned long number
;
3624 Elf64_External_Sym
*esyms
;
3625 Elf_External_Sym_Shndx
*shndx
;
3626 Elf_Internal_Sym
*isyms
;
3627 Elf_Internal_Sym
*psym
;
3630 esyms
= ((Elf64_External_Sym
*)
3631 get_data (NULL
, file
, section
->sh_offset
,
3632 section
->sh_size
, _("symbols")));
3637 if (symtab_shndx_hdr
!= NULL
3638 && (symtab_shndx_hdr
->sh_link
3639 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3641 shndx
= ((Elf_External_Sym_Shndx
*)
3642 get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3643 symtab_shndx_hdr
->sh_size
, _("symtab shndx")));
3651 number
= section
->sh_size
/ section
->sh_entsize
;
3652 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
3656 error (_("Out of memory\n"));
3663 for (j
= 0, psym
= isyms
;
3667 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3668 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3669 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3670 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3671 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3673 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3674 psym
->st_value
= BYTE_GET8 (esyms
[j
].st_value
);
3675 psym
->st_size
= BYTE_GET8 (esyms
[j
].st_size
);
3686 get_elf_section_flags (sh_flags
)
3689 static char buff
[32];
3697 flag
= sh_flags
& - sh_flags
;
3702 case SHF_WRITE
: strcat (buff
, "W"); break;
3703 case SHF_ALLOC
: strcat (buff
, "A"); break;
3704 case SHF_EXECINSTR
: strcat (buff
, "X"); break;
3705 case SHF_MERGE
: strcat (buff
, "M"); break;
3706 case SHF_STRINGS
: strcat (buff
, "S"); break;
3707 case SHF_INFO_LINK
: strcat (buff
, "I"); break;
3708 case SHF_LINK_ORDER
: strcat (buff
, "L"); break;
3709 case SHF_OS_NONCONFORMING
: strcat (buff
, "O"); break;
3710 case SHF_GROUP
: strcat (buff
, "G"); break;
3711 case SHF_TLS
: strcat (buff
, "T"); break;
3714 if (flag
& SHF_MASKOS
)
3717 sh_flags
&= ~ SHF_MASKOS
;
3719 else if (flag
& SHF_MASKPROC
)
3722 sh_flags
&= ~ SHF_MASKPROC
;
3734 process_section_headers (file
)
3737 Elf_Internal_Shdr
*section
;
3740 section_headers
= NULL
;
3742 if (elf_header
.e_shnum
== 0)
3745 printf (_("\nThere are no sections in this file.\n"));
3750 if (do_sections
&& !do_header
)
3751 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3752 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
3756 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
3759 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
3762 /* Read in the string table, so that we have names to display. */
3763 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
3765 if (section
->sh_size
!= 0)
3767 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
3768 section
->sh_size
, _("string table"));
3770 string_table_length
= section
->sh_size
;
3773 /* Scan the sections for the dynamic symbol table
3774 and dynamic string table and debug sections. */
3775 dynamic_symbols
= NULL
;
3776 dynamic_strings
= NULL
;
3777 dynamic_syminfo
= NULL
;
3778 symtab_shndx_hdr
= NULL
;
3780 for (i
= 0, section
= section_headers
;
3781 i
< elf_header
.e_shnum
;
3784 char *name
= SECTION_NAME (section
);
3786 if (section
->sh_type
== SHT_DYNSYM
)
3788 if (dynamic_symbols
!= NULL
)
3790 error (_("File contains multiple dynamic symbol tables\n"));
3794 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
3795 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
3797 else if (section
->sh_type
== SHT_STRTAB
3798 && strcmp (name
, ".dynstr") == 0)
3800 if (dynamic_strings
!= NULL
)
3802 error (_("File contains multiple dynamic string tables\n"));
3806 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
3808 _("dynamic strings"));
3810 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
3812 if (symtab_shndx_hdr
!= NULL
)
3814 error (_("File contains multiple symtab shndx tables\n"));
3817 symtab_shndx_hdr
= section
;
3819 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
3820 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
3821 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
3823 && strncmp (name
, ".debug_", 7) == 0)
3828 || (do_debug_info
&& (strcmp (name
, "info") == 0))
3829 || (do_debug_abbrevs
&& (strcmp (name
, "abbrev") == 0))
3830 || (do_debug_lines
&& (strcmp (name
, "line") == 0))
3831 || (do_debug_pubnames
&& (strcmp (name
, "pubnames") == 0))
3832 || (do_debug_aranges
&& (strcmp (name
, "aranges") == 0))
3833 || (do_debug_frames
&& (strcmp (name
, "frame") == 0))
3834 || (do_debug_macinfo
&& (strcmp (name
, "macinfo") == 0))
3835 || (do_debug_str
&& (strcmp (name
, "str") == 0))
3836 || (do_debug_loc
&& (strcmp (name
, "loc") == 0))
3838 request_dump (i
, DEBUG_DUMP
);
3840 /* linkonce section to be combined with .debug_info at link time. */
3841 else if ((do_debugging
|| do_debug_info
)
3842 && strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
3843 request_dump (i
, DEBUG_DUMP
);
3844 else if (do_debug_frames
&& strcmp (name
, ".eh_frame") == 0)
3845 request_dump (i
, DEBUG_DUMP
);
3851 if (elf_header
.e_shnum
> 1)
3852 printf (_("\nSection Headers:\n"));
3854 printf (_("\nSection Header:\n"));
3858 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
3861 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
3864 printf (_(" [Nr] Name Type Address Offset\n"));
3865 printf (_(" Size EntSize Flags Link Info Align\n"));
3868 for (i
= 0, section
= section_headers
;
3869 i
< elf_header
.e_shnum
;
3872 printf (" [%2u] %-17.17s %-15.15s ",
3873 SECTION_HEADER_NUM (i
),
3874 SECTION_NAME (section
),
3875 get_section_type_name (section
->sh_type
));
3879 print_vma (section
->sh_addr
, LONG_HEX
);
3881 printf ( " %6.6lx %6.6lx %2.2lx",
3882 (unsigned long) section
->sh_offset
,
3883 (unsigned long) section
->sh_size
,
3884 (unsigned long) section
->sh_entsize
);
3886 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3888 printf ("%2ld %3lx %2ld\n",
3889 (unsigned long) section
->sh_link
,
3890 (unsigned long) section
->sh_info
,
3891 (unsigned long) section
->sh_addralign
);
3895 print_vma (section
->sh_addr
, LONG_HEX
);
3897 if ((long) section
->sh_offset
== section
->sh_offset
)
3898 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
3902 print_vma (section
->sh_offset
, LONG_HEX
);
3905 if ((unsigned long) section
->sh_size
== section
->sh_size
)
3906 printf (" %6.6lx", (unsigned long) section
->sh_size
);
3910 print_vma (section
->sh_size
, LONG_HEX
);
3913 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
3914 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
3918 print_vma (section
->sh_entsize
, LONG_HEX
);
3921 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3923 printf ("%2ld %3lx ",
3924 (unsigned long) section
->sh_link
,
3925 (unsigned long) section
->sh_info
);
3927 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
3928 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
3931 print_vma (section
->sh_addralign
, DEC
);
3938 print_vma (section
->sh_addr
, LONG_HEX
);
3939 if ((long) section
->sh_offset
== section
->sh_offset
)
3940 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
3944 print_vma (section
->sh_offset
, LONG_HEX
);
3947 print_vma (section
->sh_size
, LONG_HEX
);
3949 print_vma (section
->sh_entsize
, LONG_HEX
);
3951 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3953 printf (" %2ld %3lx %ld\n",
3954 (unsigned long) section
->sh_link
,
3955 (unsigned long) section
->sh_info
,
3956 (unsigned long) section
->sh_addralign
);
3960 printf (_("Key to Flags:\n\
3961 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
3962 I (info), L (link order), G (group), x (unknown)\n\
3963 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3974 } dynamic_relocations
[] =
3976 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
3977 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
3978 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
3981 /* Process the reloc section. */
3983 process_relocs (file
)
3986 unsigned long rel_size
;
3987 unsigned long rel_offset
;
3993 if (do_using_dynamic
)
3997 int has_dynamic_reloc
;
4000 has_dynamic_reloc
= 0;
4002 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4004 is_rela
= dynamic_relocations
[i
].rela
;
4005 name
= dynamic_relocations
[i
].name
;
4006 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4007 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4009 has_dynamic_reloc
|= rel_size
;
4011 if (is_rela
== UNKNOWN
)
4013 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4014 switch (dynamic_info
[DT_PLTREL
])
4028 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4029 name
, rel_offset
, rel_size
);
4031 dump_relocations (file
,
4032 offset_from_vma (file
, rel_offset
, rel_size
),
4034 dynamic_symbols
, num_dynamic_syms
,
4035 dynamic_strings
, is_rela
);
4039 if (! has_dynamic_reloc
)
4040 printf (_("\nThere are no dynamic relocations in this file.\n"));
4044 Elf_Internal_Shdr
*section
;
4048 for (i
= 0, section
= section_headers
;
4049 i
< elf_header
.e_shnum
;
4052 if ( section
->sh_type
!= SHT_RELA
4053 && section
->sh_type
!= SHT_REL
)
4056 rel_offset
= section
->sh_offset
;
4057 rel_size
= section
->sh_size
;
4061 Elf_Internal_Shdr
*strsec
;
4062 Elf_Internal_Sym
*symtab
;
4065 unsigned long nsyms
;
4067 printf (_("\nRelocation section "));
4069 if (string_table
== NULL
)
4070 printf ("%d", section
->sh_name
);
4072 printf (_("'%s'"), SECTION_NAME (section
));
4074 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4075 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4080 if (section
->sh_link
)
4082 Elf_Internal_Shdr
*symsec
;
4084 symsec
= SECTION_HEADER (section
->sh_link
);
4085 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4086 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4091 strsec
= SECTION_HEADER (symsec
->sh_link
);
4093 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
4097 is_rela
= section
->sh_type
== SHT_RELA
;
4099 dump_relocations (file
, rel_offset
, rel_size
,
4100 symtab
, nsyms
, strtab
, is_rela
);
4112 printf (_("\nThere are no relocations in this file.\n"));
4118 #include "unwind-ia64.h"
4120 /* An absolute address consists of a section and an offset. If the
4121 section is NULL, the offset itself is the address, otherwise, the
4122 address equals to LOAD_ADDRESS(section) + offset. */
4126 unsigned short section
;
4132 struct unw_table_entry
4134 struct absaddr start
;
4136 struct absaddr info
;
4138 *table
; /* Unwind table. */
4139 unsigned long table_len
; /* Length of unwind table. */
4140 unsigned char *info
; /* Unwind info. */
4141 unsigned long info_size
; /* Size of unwind info. */
4142 bfd_vma info_addr
; /* starting address of unwind info. */
4143 bfd_vma seg_base
; /* Starting address of segment. */
4144 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4145 unsigned long nsyms
; /* Number of symbols. */
4146 char *strtab
; /* The string table. */
4147 unsigned long strtab_size
; /* Size of string table. */
4150 static void find_symbol_for_address
4151 PARAMS ((struct unw_aux_info
*, struct absaddr
, const char **, bfd_vma
*));
4152 static void dump_ia64_unwind
4153 PARAMS ((struct unw_aux_info
*));
4154 static int slurp_ia64_unwind_table
4155 PARAMS ((FILE *, struct unw_aux_info
*, Elf_Internal_Shdr
*));
4158 find_symbol_for_address (aux
, addr
, symname
, offset
)
4159 struct unw_aux_info
*aux
;
4160 struct absaddr addr
;
4161 const char **symname
;
4164 bfd_vma dist
= (bfd_vma
) 0x100000;
4165 Elf_Internal_Sym
*sym
, *best
= NULL
;
4168 for (i
= 0, sym
= aux
->symtab
; i
< aux
->nsyms
; ++i
, ++sym
)
4170 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4171 && sym
->st_name
!= 0
4172 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4173 && addr
.offset
>= sym
->st_value
4174 && addr
.offset
- sym
->st_value
< dist
)
4177 dist
= addr
.offset
- sym
->st_value
;
4184 *symname
= (best
->st_name
>= aux
->strtab_size
4185 ? "<corrupt>" : aux
->strtab
+ best
->st_name
);
4190 *offset
= addr
.offset
;
4194 dump_ia64_unwind (aux
)
4195 struct unw_aux_info
*aux
;
4198 struct unw_table_entry
*tp
;
4201 addr_size
= is_32bit_elf
? 4 : 8;
4203 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4207 const unsigned char *dp
;
4208 const unsigned char *head
;
4209 const char *procname
;
4211 find_symbol_for_address (aux
, tp
->start
, &procname
, &offset
);
4213 fputs ("\n<", stdout
);
4217 fputs (procname
, stdout
);
4220 printf ("+%lx", (unsigned long) offset
);
4223 fputs (">: [", stdout
);
4224 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4225 fputc ('-', stdout
);
4226 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4227 printf ("], info at +0x%lx\n",
4228 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4230 head
= aux
->info
+ (tp
->info
.offset
- aux
->info_addr
);
4231 stamp
= BYTE_GET8 ((unsigned char *) head
);
4233 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4234 (unsigned) UNW_VER (stamp
),
4235 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4236 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4237 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4238 (unsigned long) (addr_size
* UNW_LENGTH (stamp
)));
4240 if (UNW_VER (stamp
) != 1)
4242 printf ("\tUnknown version.\n");
4247 for (dp
= head
+ 8; dp
< head
+ 8 + addr_size
* UNW_LENGTH (stamp
);)
4248 dp
= unw_decode (dp
, in_body
, & in_body
);
4253 slurp_ia64_unwind_table (file
, aux
, sec
)
4255 struct unw_aux_info
*aux
;
4256 Elf_Internal_Shdr
*sec
;
4258 unsigned long size
, addr_size
, nrelas
, i
;
4259 Elf_Internal_Phdr
*seg
;
4260 struct unw_table_entry
*tep
;
4261 Elf_Internal_Shdr
*relsec
;
4262 Elf_Internal_Rela
*rela
, *rp
;
4263 unsigned char *table
, *tp
;
4264 Elf_Internal_Sym
*sym
;
4265 const char *relname
;
4267 addr_size
= is_32bit_elf
? 4 : 8;
4269 /* First, find the starting address of the segment that includes
4272 if (elf_header
.e_phnum
)
4274 if (! get_program_headers (file
))
4277 for (seg
= program_headers
;
4278 seg
< program_headers
+ elf_header
.e_phnum
;
4281 if (seg
->p_type
!= PT_LOAD
)
4284 if (sec
->sh_addr
>= seg
->p_vaddr
4285 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4287 aux
->seg_base
= seg
->p_vaddr
;
4293 /* Second, build the unwind table from the contents of the unwind section: */
4294 size
= sec
->sh_size
;
4295 table
= (char *) get_data (NULL
, file
, sec
->sh_offset
,
4296 size
, _("unwind table"));
4300 tep
= aux
->table
= xmalloc (size
/ (3 * addr_size
) * sizeof (aux
->table
[0]));
4301 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * addr_size
, ++tep
)
4303 tep
->start
.section
= SHN_UNDEF
;
4304 tep
->end
.section
= SHN_UNDEF
;
4305 tep
->info
.section
= SHN_UNDEF
;
4308 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4309 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4310 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
4314 tep
->start
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 0);
4315 tep
->end
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 8);
4316 tep
->info
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 16);
4318 tep
->start
.offset
+= aux
->seg_base
;
4319 tep
->end
.offset
+= aux
->seg_base
;
4320 tep
->info
.offset
+= aux
->seg_base
;
4324 /* Third, apply any relocations to the unwind table: */
4326 for (relsec
= section_headers
;
4327 relsec
< section_headers
+ elf_header
.e_shnum
;
4330 if (relsec
->sh_type
!= SHT_RELA
4331 || SECTION_HEADER (relsec
->sh_info
) != sec
)
4334 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
4338 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4342 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4343 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4345 if (ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
4347 warn (_("Skipping unexpected symbol type %u\n"),
4348 ELF32_ST_TYPE (sym
->st_info
));
4354 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4355 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4357 if (ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
4359 warn (_("Skipping unexpected symbol type %u\n"),
4360 ELF64_ST_TYPE (sym
->st_info
));
4365 if (strncmp (relname
, "R_IA64_SEGREL", 13) != 0)
4367 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4371 i
= rp
->r_offset
/ (3 * addr_size
);
4373 switch (rp
->r_offset
/addr_size
% 3)
4376 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4377 aux
->table
[i
].start
.offset
+= rp
->r_addend
;
4380 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4381 aux
->table
[i
].end
.offset
+= rp
->r_addend
;
4384 aux
->table
[i
].info
.section
= sym
->st_shndx
;
4385 aux
->table
[i
].info
.offset
+= rp
->r_addend
;
4395 aux
->table_len
= size
/ (3 * addr_size
);
4400 process_unwind (file
)
4403 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
4404 unsigned long i
, addr_size
, unwcount
= 0, unwstart
= 0;
4405 struct unw_aux_info aux
;
4410 if (elf_header
.e_machine
!= EM_IA_64
)
4412 printf (_("\nThere are no unwind sections in this file.\n"));
4416 memset (& aux
, 0, sizeof (aux
));
4418 addr_size
= is_32bit_elf
? 4 : 8;
4420 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4422 if (sec
->sh_type
== SHT_SYMTAB
)
4424 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
4425 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
4427 strsec
= SECTION_HEADER (sec
->sh_link
);
4428 aux
.strtab_size
= strsec
->sh_size
;
4429 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
4430 aux
.strtab_size
, _("string table"));
4432 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4437 printf (_("\nThere are no unwind sections in this file.\n"));
4439 while (unwcount
-- > 0)
4444 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
4445 i
< elf_header
.e_shnum
; ++i
, ++sec
)
4446 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4453 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
4455 if (strncmp (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
,
4458 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO */
4459 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
4460 suffix
= SECTION_NAME (unwsec
) + len
;
4461 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4463 if (strncmp (SECTION_NAME (sec
),
4464 ELF_STRING_ia64_unwind_info_once
, len2
) == 0
4465 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
4470 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
4471 .IA_64.unwind or BAR -> .IA_64.unwind_info */
4472 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
4473 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
4475 if (strncmp (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
,
4477 suffix
= SECTION_NAME (unwsec
) + len
;
4478 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4480 if (strncmp (SECTION_NAME (sec
),
4481 ELF_STRING_ia64_unwind_info
, len2
) == 0
4482 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
4486 if (i
== elf_header
.e_shnum
)
4488 printf (_("\nCould not find unwind info section for "));
4490 if (string_table
== NULL
)
4491 printf ("%d", unwsec
->sh_name
);
4493 printf (_("'%s'"), SECTION_NAME (unwsec
));
4497 aux
.info_size
= sec
->sh_size
;
4498 aux
.info_addr
= sec
->sh_addr
;
4499 aux
.info
= (char *) get_data (NULL
, file
, sec
->sh_offset
,
4500 aux
.info_size
, _("unwind info"));
4502 printf (_("\nUnwind section "));
4504 if (string_table
== NULL
)
4505 printf ("%d", unwsec
->sh_name
);
4507 printf (_("'%s'"), SECTION_NAME (unwsec
));
4509 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4510 (unsigned long) unwsec
->sh_offset
,
4511 (unsigned long) (unwsec
->sh_size
/ (3 * addr_size
)));
4513 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
4515 if (aux
.table_len
> 0)
4516 dump_ia64_unwind (& aux
);
4519 free ((char *) aux
.table
);
4521 free ((char *) aux
.info
);
4530 free ((char *) aux
.strtab
);
4536 dynamic_segment_mips_val (entry
)
4537 Elf_Internal_Dyn
*entry
;
4539 switch (entry
->d_tag
)
4542 if (entry
->d_un
.d_val
== 0)
4546 static const char * opts
[] =
4548 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
4549 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
4550 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
4551 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
4556 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++cnt
)
4557 if (entry
->d_un
.d_val
& (1 << cnt
))
4559 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
4566 case DT_MIPS_IVERSION
:
4567 if (dynamic_strings
!= NULL
)
4568 printf ("Interface Version: %s\n",
4569 dynamic_strings
+ entry
->d_un
.d_val
);
4571 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
4574 case DT_MIPS_TIME_STAMP
:
4579 time_t time
= entry
->d_un
.d_val
;
4580 tmp
= gmtime (&time
);
4581 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
4582 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
4583 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
4584 printf ("Time Stamp: %s\n", timebuf
);
4588 case DT_MIPS_RLD_VERSION
:
4589 case DT_MIPS_LOCAL_GOTNO
:
4590 case DT_MIPS_CONFLICTNO
:
4591 case DT_MIPS_LIBLISTNO
:
4592 case DT_MIPS_SYMTABNO
:
4593 case DT_MIPS_UNREFEXTNO
:
4594 case DT_MIPS_HIPAGENO
:
4595 case DT_MIPS_DELTA_CLASS_NO
:
4596 case DT_MIPS_DELTA_INSTANCE_NO
:
4597 case DT_MIPS_DELTA_RELOC_NO
:
4598 case DT_MIPS_DELTA_SYM_NO
:
4599 case DT_MIPS_DELTA_CLASSSYM_NO
:
4600 case DT_MIPS_COMPACT_SIZE
:
4601 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
4605 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
4611 dynamic_segment_parisc_val (entry
)
4612 Elf_Internal_Dyn
*entry
;
4614 switch (entry
->d_tag
)
4616 case DT_HP_DLD_FLAGS
:
4625 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
4626 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
4627 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
4628 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
4629 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
4630 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
4631 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
4632 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
4633 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
4634 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
4635 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
4639 bfd_vma val
= entry
->d_un
.d_val
;
4641 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
4642 if (val
& flags
[cnt
].bit
)
4646 fputs (flags
[cnt
].str
, stdout
);
4648 val
^= flags
[cnt
].bit
;
4651 if (val
!= 0 || first
)
4655 print_vma (val
, HEX
);
4661 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
4668 dynamic_segment_ia64_val (entry
)
4669 Elf_Internal_Dyn
*entry
;
4671 switch (entry
->d_tag
)
4673 case DT_IA_64_PLT_RESERVE
:
4674 /* First 3 bytes reserved. */
4675 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
4677 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
4683 get_32bit_dynamic_segment (file
)
4686 Elf32_External_Dyn
*edyn
;
4687 Elf_Internal_Dyn
*entry
;
4690 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
,
4691 dynamic_size
, _("dynamic segment"));
4695 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
4696 how large this .dynamic is now. We can do this even before the byte
4697 swapping since the DT_NULL tag is recognizable. */
4699 while (*(Elf32_Word
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
4702 dynamic_segment
= (Elf_Internal_Dyn
*)
4703 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
4705 if (dynamic_segment
== NULL
)
4707 error (_("Out of memory\n"));
4712 for (i
= 0, entry
= dynamic_segment
;
4716 entry
->d_tag
= BYTE_GET (edyn
[i
].d_tag
);
4717 entry
->d_un
.d_val
= BYTE_GET (edyn
[i
].d_un
.d_val
);
4726 get_64bit_dynamic_segment (file
)
4729 Elf64_External_Dyn
*edyn
;
4730 Elf_Internal_Dyn
*entry
;
4733 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
,
4734 dynamic_size
, _("dynamic segment"));
4738 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
4739 how large this .dynamic is now. We can do this even before the byte
4740 swapping since the DT_NULL tag is recognizable. */
4742 while (*(bfd_vma
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
4745 dynamic_segment
= (Elf_Internal_Dyn
*)
4746 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
4748 if (dynamic_segment
== NULL
)
4750 error (_("Out of memory\n"));
4755 for (i
= 0, entry
= dynamic_segment
;
4759 entry
->d_tag
= BYTE_GET8 (edyn
[i
].d_tag
);
4760 entry
->d_un
.d_val
= BYTE_GET8 (edyn
[i
].d_un
.d_val
);
4769 get_dynamic_flags (flags
)
4772 static char buff
[128];
4780 flag
= flags
& - flags
;
4788 case DF_ORIGIN
: strcpy (p
, "ORIGIN"); break;
4789 case DF_SYMBOLIC
: strcpy (p
, "SYMBOLIC"); break;
4790 case DF_TEXTREL
: strcpy (p
, "TEXTREL"); break;
4791 case DF_BIND_NOW
: strcpy (p
, "BIND_NOW"); break;
4792 case DF_STATIC_TLS
: strcpy (p
, "STATIC_TLS"); break;
4793 default: strcpy (p
, "unknown"); break;
4796 p
= strchr (p
, '\0');
4801 /* Parse and display the contents of the dynamic segment. */
4803 process_dynamic_segment (file
)
4806 Elf_Internal_Dyn
*entry
;
4809 if (dynamic_size
== 0)
4812 printf (_("\nThere is no dynamic segment in this file.\n"));
4819 if (! get_32bit_dynamic_segment (file
))
4822 else if (! get_64bit_dynamic_segment (file
))
4825 /* Find the appropriate symbol table. */
4826 if (dynamic_symbols
== NULL
)
4828 for (i
= 0, entry
= dynamic_segment
;
4832 Elf_Internal_Shdr section
;
4834 if (entry
->d_tag
!= DT_SYMTAB
)
4837 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
4839 /* Since we do not know how big the symbol table is,
4840 we default to reading in the entire file (!) and
4841 processing that. This is overkill, I know, but it
4843 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
4845 if (fseek (file
, 0, SEEK_END
))
4846 error (_("Unable to seek to end of file!"));
4848 section
.sh_size
= ftell (file
) - section
.sh_offset
;
4850 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
4852 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
4854 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
4855 if (num_dynamic_syms
< 1)
4857 error (_("Unable to determine the number of symbols to load\n"));
4861 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
4865 /* Similarly find a string table. */
4866 if (dynamic_strings
== NULL
)
4868 for (i
= 0, entry
= dynamic_segment
;
4872 unsigned long offset
;
4875 if (entry
->d_tag
!= DT_STRTAB
)
4878 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
4880 /* Since we do not know how big the string table is,
4881 we default to reading in the entire file (!) and
4882 processing that. This is overkill, I know, but it
4885 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
4886 if (fseek (file
, 0, SEEK_END
))
4887 error (_("Unable to seek to end of file\n"));
4888 str_tab_len
= ftell (file
) - offset
;
4890 if (str_tab_len
< 1)
4893 (_("Unable to determine the length of the dynamic string table\n"));
4897 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, str_tab_len
,
4898 _("dynamic string table"));
4903 /* And find the syminfo section if available. */
4904 if (dynamic_syminfo
== NULL
)
4906 unsigned long syminsz
= 0;
4908 for (i
= 0, entry
= dynamic_segment
;
4912 if (entry
->d_tag
== DT_SYMINENT
)
4914 /* Note: these braces are necessary to avoid a syntax
4915 error from the SunOS4 C compiler. */
4916 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
4918 else if (entry
->d_tag
== DT_SYMINSZ
)
4919 syminsz
= entry
->d_un
.d_val
;
4920 else if (entry
->d_tag
== DT_SYMINFO
)
4921 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
4925 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
4927 Elf_External_Syminfo
*extsyminfo
;
4928 Elf_Internal_Syminfo
*syminfo
;
4930 /* There is a syminfo section. Read the data. */
4931 extsyminfo
= ((Elf_External_Syminfo
*)
4932 get_data (NULL
, file
, dynamic_syminfo_offset
,
4933 syminsz
, _("symbol information")));
4937 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
4938 if (dynamic_syminfo
== NULL
)
4940 error (_("Out of memory\n"));
4944 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
4945 for (i
= 0, syminfo
= dynamic_syminfo
; i
< dynamic_syminfo_nent
;
4948 syminfo
->si_boundto
= BYTE_GET (extsyminfo
[i
].si_boundto
);
4949 syminfo
->si_flags
= BYTE_GET (extsyminfo
[i
].si_flags
);
4956 if (do_dynamic
&& dynamic_addr
)
4957 printf (_("\nDynamic segment at offset 0x%lx contains %ld entries:\n"),
4958 dynamic_addr
, (long) dynamic_size
);
4960 printf (_(" Tag Type Name/Value\n"));
4962 for (i
= 0, entry
= dynamic_segment
;
4971 print_vma (entry
->d_tag
, FULL_HEX
);
4972 dtype
= get_dynamic_type (entry
->d_tag
);
4973 printf (" (%s)%*s", dtype
,
4974 ((is_32bit_elf
? 27 : 19)
4975 - (int) strlen (dtype
)),
4979 switch (entry
->d_tag
)
4983 puts (get_dynamic_flags (entry
->d_un
.d_val
));
4993 switch (entry
->d_tag
)
4996 printf (_("Auxiliary library"));
5000 printf (_("Filter library"));
5004 printf (_("Configuration file"));
5008 printf (_("Dependency audit library"));
5012 printf (_("Audit library"));
5016 if (dynamic_strings
)
5017 printf (": [%s]\n", dynamic_strings
+ entry
->d_un
.d_val
);
5021 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5030 printf (_("Flags:"));
5032 if (entry
->d_un
.d_val
== 0)
5033 printf (_(" None\n"));
5036 unsigned long int val
= entry
->d_un
.d_val
;
5038 if (val
& DTF_1_PARINIT
)
5040 printf (" PARINIT");
5041 val
^= DTF_1_PARINIT
;
5043 if (val
& DTF_1_CONFEXP
)
5045 printf (" CONFEXP");
5046 val
^= DTF_1_CONFEXP
;
5049 printf (" %lx", val
);
5058 printf (_("Flags:"));
5060 if (entry
->d_un
.d_val
== 0)
5061 printf (_(" None\n"));
5064 unsigned long int val
= entry
->d_un
.d_val
;
5066 if (val
& DF_P1_LAZYLOAD
)
5068 printf (" LAZYLOAD");
5069 val
^= DF_P1_LAZYLOAD
;
5071 if (val
& DF_P1_GROUPPERM
)
5073 printf (" GROUPPERM");
5074 val
^= DF_P1_GROUPPERM
;
5077 printf (" %lx", val
);
5086 printf (_("Flags:"));
5087 if (entry
->d_un
.d_val
== 0)
5088 printf (_(" None\n"));
5091 unsigned long int val
= entry
->d_un
.d_val
;
5098 if (val
& DF_1_GLOBAL
)
5103 if (val
& DF_1_GROUP
)
5108 if (val
& DF_1_NODELETE
)
5110 printf (" NODELETE");
5111 val
^= DF_1_NODELETE
;
5113 if (val
& DF_1_LOADFLTR
)
5115 printf (" LOADFLTR");
5116 val
^= DF_1_LOADFLTR
;
5118 if (val
& DF_1_INITFIRST
)
5120 printf (" INITFIRST");
5121 val
^= DF_1_INITFIRST
;
5123 if (val
& DF_1_NOOPEN
)
5128 if (val
& DF_1_ORIGIN
)
5133 if (val
& DF_1_DIRECT
)
5138 if (val
& DF_1_TRANS
)
5143 if (val
& DF_1_INTERPOSE
)
5145 printf (" INTERPOSE");
5146 val
^= DF_1_INTERPOSE
;
5148 if (val
& DF_1_NODEFLIB
)
5150 printf (" NODEFLIB");
5151 val
^= DF_1_NODEFLIB
;
5153 if (val
& DF_1_NODUMP
)
5158 if (val
& DF_1_CONLFAT
)
5160 printf (" CONLFAT");
5161 val
^= DF_1_CONLFAT
;
5164 printf (" %lx", val
);
5171 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5173 puts (get_dynamic_type (entry
->d_un
.d_val
));
5193 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5199 if (dynamic_strings
== NULL
)
5202 name
= dynamic_strings
+ entry
->d_un
.d_val
;
5206 switch (entry
->d_tag
)
5209 printf (_("Shared library: [%s]"), name
);
5211 if (strcmp (name
, program_interpreter
) == 0)
5212 printf (_(" program interpreter"));
5216 printf (_("Library soname: [%s]"), name
);
5220 printf (_("Library rpath: [%s]"), name
);
5224 printf (_("Library runpath: [%s]"), name
);
5228 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5233 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5246 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5250 case DT_INIT_ARRAYSZ
:
5251 case DT_FINI_ARRAYSZ
:
5252 case DT_GNU_CONFLICTSZ
:
5253 case DT_GNU_LIBLISTSZ
:
5256 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5257 printf (" (bytes)\n");
5267 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5280 if (dynamic_strings
!= NULL
&& entry
->d_tag
== DT_USED
)
5284 name
= dynamic_strings
+ entry
->d_un
.d_val
;
5288 printf (_("Not needed object: [%s]\n"), name
);
5293 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5299 /* The value of this entry is ignored. */
5304 case DT_GNU_PRELINKED
:
5308 time_t time
= entry
->d_un
.d_val
;
5310 tmp
= gmtime (&time
);
5311 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
5312 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5313 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5319 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
5320 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
5325 switch (elf_header
.e_machine
)
5328 case EM_MIPS_RS3_LE
:
5329 dynamic_segment_mips_val (entry
);
5332 dynamic_segment_parisc_val (entry
);
5335 dynamic_segment_ia64_val (entry
);
5338 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5350 get_ver_flags (flags
)
5353 static char buff
[32];
5360 if (flags
& VER_FLG_BASE
)
5361 strcat (buff
, "BASE ");
5363 if (flags
& VER_FLG_WEAK
)
5365 if (flags
& VER_FLG_BASE
)
5366 strcat (buff
, "| ");
5368 strcat (buff
, "WEAK ");
5371 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
5372 strcat (buff
, "| <unknown>");
5377 /* Display the contents of the version sections. */
5379 process_version_sections (file
)
5382 Elf_Internal_Shdr
*section
;
5389 for (i
= 0, section
= section_headers
;
5390 i
< elf_header
.e_shnum
;
5393 switch (section
->sh_type
)
5395 case SHT_GNU_verdef
:
5397 Elf_External_Verdef
*edefs
;
5404 (_("\nVersion definition section '%s' contains %ld entries:\n"),
5405 SECTION_NAME (section
), section
->sh_info
);
5407 printf (_(" Addr: 0x"));
5408 printf_vma (section
->sh_addr
);
5409 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5410 (unsigned long) section
->sh_offset
, section
->sh_link
,
5411 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
5413 edefs
= ((Elf_External_Verdef
*)
5414 get_data (NULL
, file
, section
->sh_offset
,
5416 _("version definition section")));
5420 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
5423 Elf_External_Verdef
*edef
;
5424 Elf_Internal_Verdef ent
;
5425 Elf_External_Verdaux
*eaux
;
5426 Elf_Internal_Verdaux aux
;
5430 vstart
= ((char *) edefs
) + idx
;
5432 edef
= (Elf_External_Verdef
*) vstart
;
5434 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
5435 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
5436 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
5437 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
5438 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
5439 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
5440 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
5442 printf (_(" %#06x: Rev: %d Flags: %s"),
5443 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
5445 printf (_(" Index: %d Cnt: %d "),
5446 ent
.vd_ndx
, ent
.vd_cnt
);
5448 vstart
+= ent
.vd_aux
;
5450 eaux
= (Elf_External_Verdaux
*) vstart
;
5452 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
5453 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
5455 if (dynamic_strings
)
5456 printf (_("Name: %s\n"), dynamic_strings
+ aux
.vda_name
);
5458 printf (_("Name index: %ld\n"), aux
.vda_name
);
5460 isum
= idx
+ ent
.vd_aux
;
5462 for (j
= 1; j
< ent
.vd_cnt
; j
++)
5464 isum
+= aux
.vda_next
;
5465 vstart
+= aux
.vda_next
;
5467 eaux
= (Elf_External_Verdaux
*) vstart
;
5469 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
5470 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
5472 if (dynamic_strings
)
5473 printf (_(" %#06x: Parent %d: %s\n"),
5474 isum
, j
, dynamic_strings
+ aux
.vda_name
);
5476 printf (_(" %#06x: Parent %d, name index: %ld\n"),
5477 isum
, j
, aux
.vda_name
);
5487 case SHT_GNU_verneed
:
5489 Elf_External_Verneed
*eneed
;
5495 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
5496 SECTION_NAME (section
), section
->sh_info
);
5498 printf (_(" Addr: 0x"));
5499 printf_vma (section
->sh_addr
);
5500 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
5501 (unsigned long) section
->sh_offset
, section
->sh_link
,
5502 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
5504 eneed
= ((Elf_External_Verneed
*)
5505 get_data (NULL
, file
, section
->sh_offset
,
5506 section
->sh_size
, _("version need section")));
5510 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
5512 Elf_External_Verneed
*entry
;
5513 Elf_Internal_Verneed ent
;
5518 vstart
= ((char *) eneed
) + idx
;
5520 entry
= (Elf_External_Verneed
*) vstart
;
5522 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
5523 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
5524 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
5525 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
5526 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
5528 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
5530 if (dynamic_strings
)
5531 printf (_(" File: %s"), dynamic_strings
+ ent
.vn_file
);
5533 printf (_(" File: %lx"), ent
.vn_file
);
5535 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
5537 vstart
+= ent
.vn_aux
;
5539 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
5541 Elf_External_Vernaux
*eaux
;
5542 Elf_Internal_Vernaux aux
;
5544 eaux
= (Elf_External_Vernaux
*) vstart
;
5546 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
5547 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
5548 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
5549 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
5550 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
5552 if (dynamic_strings
)
5553 printf (_(" %#06x: Name: %s"),
5554 isum
, dynamic_strings
+ aux
.vna_name
);
5556 printf (_(" %#06x: Name index: %lx"),
5557 isum
, aux
.vna_name
);
5559 printf (_(" Flags: %s Version: %d\n"),
5560 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
5562 isum
+= aux
.vna_next
;
5563 vstart
+= aux
.vna_next
;
5573 case SHT_GNU_versym
:
5575 Elf_Internal_Shdr
*link_section
;
5578 unsigned char *edata
;
5579 unsigned short *data
;
5581 Elf_Internal_Sym
*symbols
;
5582 Elf_Internal_Shdr
*string_sec
;
5584 link_section
= SECTION_HEADER (section
->sh_link
);
5585 total
= section
->sh_size
/ section
->sh_entsize
;
5589 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
5591 string_sec
= SECTION_HEADER (link_section
->sh_link
);
5593 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
5594 string_sec
->sh_size
,
5595 _("version string table"));
5599 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
5600 SECTION_NAME (section
), total
);
5602 printf (_(" Addr: "));
5603 printf_vma (section
->sh_addr
);
5604 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5605 (unsigned long) section
->sh_offset
, section
->sh_link
,
5606 SECTION_NAME (link_section
));
5610 get_data (NULL
, file
,
5612 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
5613 total
* sizeof (short)),
5614 total
* sizeof (short), _("version symbol data")));
5621 data
= (unsigned short *) malloc (total
* sizeof (short));
5623 for (cnt
= total
; cnt
--;)
5624 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
5629 for (cnt
= 0; cnt
< total
; cnt
+= 4)
5632 int check_def
, check_need
;
5635 printf (" %03x:", cnt
);
5637 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
5638 switch (data
[cnt
+ j
])
5641 fputs (_(" 0 (*local*) "), stdout
);
5645 fputs (_(" 1 (*global*) "), stdout
);
5649 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
5650 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
5654 if (SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
5657 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
5664 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
5666 Elf_Internal_Verneed ivn
;
5667 unsigned long offset
;
5669 offset
= offset_from_vma
5670 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
5671 sizeof (Elf_External_Verneed
));
5675 Elf_Internal_Vernaux ivna
;
5676 Elf_External_Verneed evn
;
5677 Elf_External_Vernaux evna
;
5678 unsigned long a_off
;
5680 get_data (&evn
, file
, offset
, sizeof (evn
),
5683 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
5684 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
5686 a_off
= offset
+ ivn
.vn_aux
;
5690 get_data (&evna
, file
, a_off
, sizeof (evna
),
5691 _("version need aux (2)"));
5693 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
5694 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
5696 a_off
+= ivna
.vna_next
;
5698 while (ivna
.vna_other
!= data
[cnt
+ j
]
5699 && ivna
.vna_next
!= 0);
5701 if (ivna
.vna_other
== data
[cnt
+ j
])
5703 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
5705 name
= strtab
+ ivna
.vna_name
;
5706 nn
+= printf ("(%s%-*s",
5708 12 - (int) strlen (name
),
5714 offset
+= ivn
.vn_next
;
5716 while (ivn
.vn_next
);
5719 if (check_def
&& data
[cnt
+ j
] != 0x8001
5720 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
5722 Elf_Internal_Verdef ivd
;
5723 Elf_External_Verdef evd
;
5724 unsigned long offset
;
5726 offset
= offset_from_vma
5727 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
5732 get_data (&evd
, file
, offset
, sizeof (evd
),
5735 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
5736 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
5738 offset
+= ivd
.vd_next
;
5740 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
5741 && ivd
.vd_next
!= 0);
5743 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
5745 Elf_External_Verdaux evda
;
5746 Elf_Internal_Verdaux ivda
;
5748 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
5750 get_data (&evda
, file
,
5751 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
5752 sizeof (evda
), _("version def aux"));
5754 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
5756 name
= strtab
+ ivda
.vda_name
;
5757 nn
+= printf ("(%s%-*s",
5759 12 - (int) strlen (name
),
5765 printf ("%*c", 18 - nn
, ' ');
5783 printf (_("\nNo version information found in this file.\n"));
5789 get_symbol_binding (binding
)
5790 unsigned int binding
;
5792 static char buff
[32];
5796 case STB_LOCAL
: return "LOCAL";
5797 case STB_GLOBAL
: return "GLOBAL";
5798 case STB_WEAK
: return "WEAK";
5800 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
5801 sprintf (buff
, _("<processor specific>: %d"), binding
);
5802 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
5803 sprintf (buff
, _("<OS specific>: %d"), binding
);
5805 sprintf (buff
, _("<unknown>: %d"), binding
);
5811 get_symbol_type (type
)
5814 static char buff
[32];
5818 case STT_NOTYPE
: return "NOTYPE";
5819 case STT_OBJECT
: return "OBJECT";
5820 case STT_FUNC
: return "FUNC";
5821 case STT_SECTION
: return "SECTION";
5822 case STT_FILE
: return "FILE";
5823 case STT_COMMON
: return "COMMON";
5824 case STT_TLS
: return "TLS";
5826 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
5828 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
5829 return "THUMB_FUNC";
5831 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
5834 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
5835 return "PARISC_MILLI";
5837 sprintf (buff
, _("<processor specific>: %d"), type
);
5839 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
5841 if (elf_header
.e_machine
== EM_PARISC
)
5843 if (type
== STT_HP_OPAQUE
)
5845 if (type
== STT_HP_STUB
)
5849 sprintf (buff
, _("<OS specific>: %d"), type
);
5852 sprintf (buff
, _("<unknown>: %d"), type
);
5858 get_symbol_visibility (visibility
)
5859 unsigned int visibility
;
5863 case STV_DEFAULT
: return "DEFAULT";
5864 case STV_INTERNAL
: return "INTERNAL";
5865 case STV_HIDDEN
: return "HIDDEN";
5866 case STV_PROTECTED
: return "PROTECTED";
5872 get_symbol_index_type (type
)
5875 static char buff
[32];
5879 case SHN_UNDEF
: return "UND";
5880 case SHN_ABS
: return "ABS";
5881 case SHN_COMMON
: return "COM";
5883 if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
5884 sprintf (buff
, "PRC[0x%04x]", type
);
5885 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
5886 sprintf (buff
, "OS [0x%04x]", type
);
5887 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
5888 sprintf (buff
, "RSV[0x%04x]", type
);
5890 sprintf (buff
, "%3d", type
);
5898 get_dynamic_data (file
, number
)
5900 unsigned int number
;
5902 unsigned char *e_data
;
5905 e_data
= (unsigned char *) malloc (number
* 4);
5909 error (_("Out of memory\n"));
5913 if (fread (e_data
, 4, number
, file
) != number
)
5915 error (_("Unable to read in dynamic data\n"));
5919 i_data
= (int *) malloc (number
* sizeof (*i_data
));
5923 error (_("Out of memory\n"));
5929 i_data
[number
] = byte_get (e_data
+ number
* 4, 4);
5936 /* Dump the symbol table. */
5938 process_symbol_table (file
)
5941 Elf_Internal_Shdr
*section
;
5942 unsigned char nb
[4];
5943 unsigned char nc
[4];
5946 int *buckets
= NULL
;
5949 if (! do_syms
&& !do_histogram
)
5952 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
5955 if (fseek (file
, offset_from_vma (file
, dynamic_info
[DT_HASH
],
5956 sizeof nb
+ sizeof nc
),
5959 error (_("Unable to seek to start of dynamic information"));
5963 if (fread (nb
, sizeof (nb
), 1, file
) != 1)
5965 error (_("Failed to read in number of buckets\n"));
5969 if (fread (nc
, sizeof (nc
), 1, file
) != 1)
5971 error (_("Failed to read in number of chains\n"));
5975 nbuckets
= byte_get (nb
, 4);
5976 nchains
= byte_get (nc
, 4);
5978 buckets
= get_dynamic_data (file
, nbuckets
);
5979 chains
= get_dynamic_data (file
, nchains
);
5981 if (buckets
== NULL
|| chains
== NULL
)
5986 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
5991 printf (_("\nSymbol table for image:\n"));
5993 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5995 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5997 for (hn
= 0; hn
< nbuckets
; hn
++)
6002 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
6004 Elf_Internal_Sym
*psym
;
6006 psym
= dynamic_symbols
+ si
;
6008 printf (" %3d %3d: ", si
, hn
);
6009 print_vma (psym
->st_value
, LONG_HEX
);
6011 print_vma (psym
->st_size
, DEC_5
);
6013 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6014 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6015 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6016 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
6017 print_symbol (25, dynamic_strings
+ psym
->st_name
);
6022 else if (do_syms
&& !do_using_dynamic
)
6026 for (i
= 0, section
= section_headers
;
6027 i
< elf_header
.e_shnum
;
6032 Elf_Internal_Sym
*symtab
;
6033 Elf_Internal_Sym
*psym
;
6036 if ( section
->sh_type
!= SHT_SYMTAB
6037 && section
->sh_type
!= SHT_DYNSYM
)
6040 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
6041 SECTION_NAME (section
),
6042 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
6044 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6046 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6048 symtab
= GET_ELF_SYMBOLS (file
, section
);
6052 if (section
->sh_link
== elf_header
.e_shstrndx
)
6053 strtab
= string_table
;
6056 Elf_Internal_Shdr
*string_sec
;
6058 string_sec
= SECTION_HEADER (section
->sh_link
);
6060 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
6061 string_sec
->sh_size
,
6065 for (si
= 0, psym
= symtab
;
6066 si
< section
->sh_size
/ section
->sh_entsize
;
6069 printf ("%6d: ", si
);
6070 print_vma (psym
->st_value
, LONG_HEX
);
6072 print_vma (psym
->st_size
, DEC_5
);
6073 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6074 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6075 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6076 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
6077 print_symbol (25, strtab
+ psym
->st_name
);
6079 if (section
->sh_type
== SHT_DYNSYM
&&
6080 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
6082 unsigned char data
[2];
6083 unsigned short vers_data
;
6084 unsigned long offset
;
6088 offset
= offset_from_vma
6089 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6090 sizeof data
+ si
* sizeof (vers_data
));
6092 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
6093 sizeof (data
), _("version data"));
6095 vers_data
= byte_get (data
, 2);
6097 is_nobits
= (SECTION_HEADER (psym
->st_shndx
)->sh_type
6100 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
6102 if ((vers_data
& 0x8000) || vers_data
> 1)
6104 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
6105 && (is_nobits
|| ! check_def
))
6107 Elf_External_Verneed evn
;
6108 Elf_Internal_Verneed ivn
;
6109 Elf_Internal_Vernaux ivna
;
6111 /* We must test both. */
6112 offset
= offset_from_vma
6113 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6118 unsigned long vna_off
;
6120 get_data (&evn
, file
, offset
, sizeof (evn
),
6123 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6124 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6126 vna_off
= offset
+ ivn
.vn_aux
;
6130 Elf_External_Vernaux evna
;
6132 get_data (&evna
, file
, vna_off
,
6134 _("version need aux (3)"));
6136 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6137 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6138 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6140 vna_off
+= ivna
.vna_next
;
6142 while (ivna
.vna_other
!= vers_data
6143 && ivna
.vna_next
!= 0);
6145 if (ivna
.vna_other
== vers_data
)
6148 offset
+= ivn
.vn_next
;
6150 while (ivn
.vn_next
!= 0);
6152 if (ivna
.vna_other
== vers_data
)
6155 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
6158 else if (! is_nobits
)
6159 error (_("bad dynamic symbol"));
6166 if (vers_data
!= 0x8001
6167 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6169 Elf_Internal_Verdef ivd
;
6170 Elf_Internal_Verdaux ivda
;
6171 Elf_External_Verdaux evda
;
6172 unsigned long offset
;
6174 offset
= offset_from_vma
6176 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6177 sizeof (Elf_External_Verdef
));
6181 Elf_External_Verdef evd
;
6183 get_data (&evd
, file
, offset
, sizeof (evd
),
6186 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6187 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6188 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6190 offset
+= ivd
.vd_next
;
6192 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
6193 && ivd
.vd_next
!= 0);
6195 offset
-= ivd
.vd_next
;
6196 offset
+= ivd
.vd_aux
;
6198 get_data (&evda
, file
, offset
, sizeof (evda
),
6199 _("version def aux"));
6201 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6203 if (psym
->st_name
!= ivda
.vda_name
)
6204 printf ((vers_data
& 0x8000)
6206 strtab
+ ivda
.vda_name
);
6216 if (strtab
!= string_table
)
6222 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
6224 if (do_histogram
&& buckets
!= NULL
)
6231 int nzero_counts
= 0;
6234 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
6236 printf (_(" Length Number %% of total Coverage\n"));
6238 lengths
= (int *) calloc (nbuckets
, sizeof (int));
6239 if (lengths
== NULL
)
6241 error (_("Out of memory"));
6244 for (hn
= 0; hn
< nbuckets
; ++hn
)
6249 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
6252 if (maxlength
< ++lengths
[hn
])
6257 counts
= (int *) calloc (maxlength
+ 1, sizeof (int));
6260 error (_("Out of memory"));
6264 for (hn
= 0; hn
< nbuckets
; ++hn
)
6265 ++counts
[lengths
[hn
]];
6269 printf (" 0 %-10d (%5.1f%%)\n",
6270 counts
[0], (counts
[0] * 100.0) / nbuckets
);
6271 for (si
= 1; si
<= maxlength
; ++si
)
6273 nzero_counts
+= counts
[si
] * si
;
6274 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
6275 si
, counts
[si
], (counts
[si
] * 100.0) / nbuckets
,
6276 (nzero_counts
* 100.0) / nsyms
);
6284 if (buckets
!= NULL
)
6294 process_syminfo (file
)
6295 FILE *file ATTRIBUTE_UNUSED
;
6299 if (dynamic_syminfo
== NULL
6301 /* No syminfo, this is ok. */
6304 /* There better should be a dynamic symbol section. */
6305 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
6309 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
6310 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
6312 printf (_(" Num: Name BoundTo Flags\n"));
6313 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
6315 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
6317 printf ("%4d: ", i
);
6318 print_symbol (30, dynamic_strings
+ dynamic_symbols
[i
].st_name
);
6321 switch (dynamic_syminfo
[i
].si_boundto
)
6323 case SYMINFO_BT_SELF
:
6324 fputs ("SELF ", stdout
);
6326 case SYMINFO_BT_PARENT
:
6327 fputs ("PARENT ", stdout
);
6330 if (dynamic_syminfo
[i
].si_boundto
> 0
6331 && dynamic_syminfo
[i
].si_boundto
< dynamic_size
)
6336 [dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
6340 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
6344 if (flags
& SYMINFO_FLG_DIRECT
)
6346 if (flags
& SYMINFO_FLG_PASSTHRU
)
6347 printf (" PASSTHRU");
6348 if (flags
& SYMINFO_FLG_COPY
)
6350 if (flags
& SYMINFO_FLG_LAZYLOAD
)
6351 printf (" LAZYLOAD");
6359 #ifdef SUPPORT_DISASSEMBLY
6361 disassemble_section (section
, file
)
6362 Elf_Internal_Shdr
*section
;
6365 printf (_("\nAssembly dump of section %s\n"),
6366 SECTION_NAME (section
));
6368 /* XXX -- to be done --- XXX */
6375 dump_section (section
, file
)
6376 Elf_Internal_Shdr
*section
;
6379 bfd_size_type bytes
;
6381 unsigned char *data
;
6382 unsigned char *start
;
6384 bytes
= section
->sh_size
;
6388 printf (_("\nSection '%s' has no data to dump.\n"),
6389 SECTION_NAME (section
));
6393 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
6395 addr
= section
->sh_addr
;
6397 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
, bytes
,
6410 lbytes
= (bytes
> 16 ? 16 : bytes
);
6412 printf (" 0x%8.8lx ", (unsigned long) addr
);
6414 switch (elf_header
.e_ident
[EI_DATA
])
6418 for (j
= 15; j
>= 0; j
--)
6421 printf ("%2.2x", data
[j
]);
6431 for (j
= 0; j
< 16; j
++)
6434 printf ("%2.2x", data
[j
]);
6444 for (j
= 0; j
< lbytes
; j
++)
6447 if (k
>= ' ' && k
< 0x80)
6466 static unsigned long int
6467 read_leb128 (data
, length_return
, sign
)
6468 unsigned char *data
;
6472 unsigned long int result
= 0;
6473 unsigned int num_read
= 0;
6482 result
|= (byte
& 0x7f) << shift
;
6487 while (byte
& 0x80);
6489 if (length_return
!= NULL
)
6490 *length_return
= num_read
;
6492 if (sign
&& (shift
< 32) && (byte
& 0x40))
6493 result
|= -1 << shift
;
6498 typedef struct State_Machine_Registers
6500 unsigned long address
;
6503 unsigned int column
;
6507 /* This variable hold the number of the last entry seen
6508 in the File Table. */
6509 unsigned int last_file_entry
;
6512 static SMR state_machine_regs
;
6515 reset_state_machine (is_stmt
)
6518 state_machine_regs
.address
= 0;
6519 state_machine_regs
.file
= 1;
6520 state_machine_regs
.line
= 1;
6521 state_machine_regs
.column
= 0;
6522 state_machine_regs
.is_stmt
= is_stmt
;
6523 state_machine_regs
.basic_block
= 0;
6524 state_machine_regs
.end_sequence
= 0;
6525 state_machine_regs
.last_file_entry
= 0;
6528 /* Handled an extend line op. Returns true if this is the end
6531 process_extended_line_op (data
, is_stmt
, pointer_size
)
6532 unsigned char *data
;
6536 unsigned char op_code
;
6539 unsigned char *name
;
6542 len
= read_leb128 (data
, & bytes_read
, 0);
6547 warn (_("badly formed extended line op encountered!\n"));
6554 printf (_(" Extended opcode %d: "), op_code
);
6558 case DW_LNE_end_sequence
:
6559 printf (_("End of Sequence\n\n"));
6560 reset_state_machine (is_stmt
);
6563 case DW_LNE_set_address
:
6564 adr
= byte_get (data
, pointer_size
);
6565 printf (_("set Address to 0x%lx\n"), adr
);
6566 state_machine_regs
.address
= adr
;
6569 case DW_LNE_define_file
:
6570 printf (_(" define new File Table entry\n"));
6571 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6573 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
6575 data
+= strlen ((char *) data
) + 1;
6576 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6578 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6580 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6581 printf (_("%s\n\n"), name
);
6585 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
6592 /* Size of pointers in the .debug_line section. This information is not
6593 really present in that section. It's obtained before dumping the debug
6594 sections by doing some pre-scan of the .debug_info section. */
6595 static int debug_line_pointer_size
= 4;
6598 display_debug_lines (section
, start
, file
)
6599 Elf_Internal_Shdr
*section
;
6600 unsigned char * start
;
6601 FILE *file ATTRIBUTE_UNUSED
;
6603 unsigned char *hdrptr
;
6604 DWARF2_Internal_LineInfo info
;
6605 unsigned char *standard_opcodes
;
6606 unsigned char *data
= start
;
6607 unsigned char *end
= start
+ section
->sh_size
;
6608 unsigned char *end_of_sequence
;
6611 int initial_length_size
;
6613 printf (_("\nDump of debug contents of section %s:\n\n"),
6614 SECTION_NAME (section
));
6620 /* Check the length of the block. */
6621 info
.li_length
= byte_get (hdrptr
, 4);
6624 if (info
.li_length
== 0xffffffff)
6626 /* This section is 64-bit DWARF 3. */
6627 info
.li_length
= byte_get (hdrptr
, 8);
6630 initial_length_size
= 12;
6635 initial_length_size
= 4;
6638 if (info
.li_length
+ initial_length_size
> section
->sh_size
)
6641 (_("The line info appears to be corrupt - the section is too small\n"));
6645 /* Check its version number. */
6646 info
.li_version
= byte_get (hdrptr
, 2);
6648 if (info
.li_version
!= 2 && info
.li_version
!= 3)
6650 warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
6654 info
.li_prologue_length
= byte_get (hdrptr
, offset_size
);
6655 hdrptr
+= offset_size
;
6656 info
.li_min_insn_length
= byte_get (hdrptr
, 1);
6658 info
.li_default_is_stmt
= byte_get (hdrptr
, 1);
6660 info
.li_line_base
= byte_get (hdrptr
, 1);
6662 info
.li_line_range
= byte_get (hdrptr
, 1);
6664 info
.li_opcode_base
= byte_get (hdrptr
, 1);
6667 /* Sign extend the line base field. */
6668 info
.li_line_base
<<= 24;
6669 info
.li_line_base
>>= 24;
6671 printf (_(" Length: %ld\n"), info
.li_length
);
6672 printf (_(" DWARF Version: %d\n"), info
.li_version
);
6673 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
6674 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
6675 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
6676 printf (_(" Line Base: %d\n"), info
.li_line_base
);
6677 printf (_(" Line Range: %d\n"), info
.li_line_range
);
6678 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
6680 end_of_sequence
= data
+ info
.li_length
+ initial_length_size
;
6682 reset_state_machine (info
.li_default_is_stmt
);
6684 /* Display the contents of the Opcodes table. */
6685 standard_opcodes
= hdrptr
;
6687 printf (_("\n Opcodes:\n"));
6689 for (i
= 1; i
< info
.li_opcode_base
; i
++)
6690 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
6692 /* Display the contents of the Directory table. */
6693 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
6696 printf (_("\n The Directory Table is empty.\n"));
6699 printf (_("\n The Directory Table:\n"));
6703 printf (_(" %s\n"), data
);
6705 data
+= strlen ((char *) data
) + 1;
6709 /* Skip the NUL at the end of the table. */
6712 /* Display the contents of the File Name table. */
6714 printf (_("\n The File Name Table is empty.\n"));
6717 printf (_("\n The File Name Table:\n"));
6718 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6722 unsigned char *name
;
6725 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
6728 data
+= strlen ((char *) data
) + 1;
6730 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6732 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6734 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6736 printf (_("%s\n"), name
);
6740 /* Skip the NUL at the end of the table. */
6743 /* Now display the statements. */
6744 printf (_("\n Line Number Statements:\n"));
6747 while (data
< end_of_sequence
)
6749 unsigned char op_code
;
6755 if (op_code
>= info
.li_opcode_base
)
6757 op_code
-= info
.li_opcode_base
;
6758 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
6759 state_machine_regs
.address
+= adv
;
6760 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
6761 op_code
, adv
, state_machine_regs
.address
);
6762 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
6763 state_machine_regs
.line
+= adv
;
6764 printf (_(" and Line by %d to %d\n"),
6765 adv
, state_machine_regs
.line
);
6767 else switch (op_code
)
6769 case DW_LNS_extended_op
:
6770 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
6771 debug_line_pointer_size
);
6775 printf (_(" Copy\n"));
6778 case DW_LNS_advance_pc
:
6779 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
6781 state_machine_regs
.address
+= adv
;
6782 printf (_(" Advance PC by %d to %lx\n"), adv
,
6783 state_machine_regs
.address
);
6786 case DW_LNS_advance_line
:
6787 adv
= read_leb128 (data
, & bytes_read
, 1);
6789 state_machine_regs
.line
+= adv
;
6790 printf (_(" Advance Line by %d to %d\n"), adv
,
6791 state_machine_regs
.line
);
6794 case DW_LNS_set_file
:
6795 adv
= read_leb128 (data
, & bytes_read
, 0);
6797 printf (_(" Set File Name to entry %d in the File Name Table\n"),
6799 state_machine_regs
.file
= adv
;
6802 case DW_LNS_set_column
:
6803 adv
= read_leb128 (data
, & bytes_read
, 0);
6805 printf (_(" Set column to %d\n"), adv
);
6806 state_machine_regs
.column
= adv
;
6809 case DW_LNS_negate_stmt
:
6810 adv
= state_machine_regs
.is_stmt
;
6812 printf (_(" Set is_stmt to %d\n"), adv
);
6813 state_machine_regs
.is_stmt
= adv
;
6816 case DW_LNS_set_basic_block
:
6817 printf (_(" Set basic block\n"));
6818 state_machine_regs
.basic_block
= 1;
6821 case DW_LNS_const_add_pc
:
6822 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
6823 * info
.li_min_insn_length
);
6824 state_machine_regs
.address
+= adv
;
6825 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
6826 state_machine_regs
.address
);
6829 case DW_LNS_fixed_advance_pc
:
6830 adv
= byte_get (data
, 2);
6832 state_machine_regs
.address
+= adv
;
6833 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
6834 adv
, state_machine_regs
.address
);
6837 case DW_LNS_set_prologue_end
:
6838 printf (_(" Set prologue_end to true\n"));
6841 case DW_LNS_set_epilogue_begin
:
6842 printf (_(" Set epilogue_begin to true\n"));
6845 case DW_LNS_set_isa
:
6846 adv
= read_leb128 (data
, & bytes_read
, 0);
6848 printf (_(" Set ISA to %d\n"), adv
);
6852 printf (_(" Unknown opcode %d with operands: "), op_code
);
6855 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
6857 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
6858 i
== 1 ? "" : ", ");
6873 display_debug_pubnames (section
, start
, file
)
6874 Elf_Internal_Shdr
*section
;
6875 unsigned char *start
;
6876 FILE *file ATTRIBUTE_UNUSED
;
6878 DWARF2_Internal_PubNames pubnames
;
6881 end
= start
+ section
->sh_size
;
6883 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
6887 unsigned char *data
;
6888 unsigned long offset
;
6889 int offset_size
, initial_length_size
;
6893 pubnames
.pn_length
= byte_get (data
, 4);
6895 if (pubnames
.pn_length
== 0xffffffff)
6897 pubnames
.pn_length
= byte_get (data
, 8);
6900 initial_length_size
= 12;
6905 initial_length_size
= 4;
6908 pubnames
.pn_version
= byte_get (data
, 2);
6910 pubnames
.pn_offset
= byte_get (data
, offset_size
);
6911 data
+= offset_size
;
6912 pubnames
.pn_size
= byte_get (data
, offset_size
);
6913 data
+= offset_size
;
6915 start
+= pubnames
.pn_length
+ initial_length_size
;
6917 if (pubnames
.pn_version
!= 2 && pubnames
.pn_version
!= 3)
6919 static int warned
= 0;
6923 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
6930 printf (_(" Length: %ld\n"),
6931 pubnames
.pn_length
);
6932 printf (_(" Version: %d\n"),
6933 pubnames
.pn_version
);
6934 printf (_(" Offset into .debug_info section: %ld\n"),
6935 pubnames
.pn_offset
);
6936 printf (_(" Size of area in .debug_info section: %ld\n"),
6939 printf (_("\n Offset\tName\n"));
6943 offset
= byte_get (data
, offset_size
);
6947 data
+= offset_size
;
6948 printf (" %ld\t\t%s\n", offset
, data
);
6949 data
+= strlen ((char *) data
) + 1;
6952 while (offset
!= 0);
6965 case DW_TAG_padding
: return "DW_TAG_padding";
6966 case DW_TAG_array_type
: return "DW_TAG_array_type";
6967 case DW_TAG_class_type
: return "DW_TAG_class_type";
6968 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
6969 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
6970 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
6971 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
6972 case DW_TAG_label
: return "DW_TAG_label";
6973 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
6974 case DW_TAG_member
: return "DW_TAG_member";
6975 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
6976 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
6977 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
6978 case DW_TAG_string_type
: return "DW_TAG_string_type";
6979 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
6980 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
6981 case DW_TAG_typedef
: return "DW_TAG_typedef";
6982 case DW_TAG_union_type
: return "DW_TAG_union_type";
6983 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
6984 case DW_TAG_variant
: return "DW_TAG_variant";
6985 case DW_TAG_common_block
: return "DW_TAG_common_block";
6986 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
6987 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
6988 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
6989 case DW_TAG_module
: return "DW_TAG_module";
6990 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
6991 case DW_TAG_set_type
: return "DW_TAG_set_type";
6992 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
6993 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
6994 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
6995 case DW_TAG_base_type
: return "DW_TAG_base_type";
6996 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
6997 case DW_TAG_const_type
: return "DW_TAG_const_type";
6998 case DW_TAG_constant
: return "DW_TAG_constant";
6999 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
7000 case DW_TAG_file_type
: return "DW_TAG_file_type";
7001 case DW_TAG_friend
: return "DW_TAG_friend";
7002 case DW_TAG_namelist
: return "DW_TAG_namelist";
7003 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
7004 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
7005 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
7006 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
7007 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
7008 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
7009 case DW_TAG_try_block
: return "DW_TAG_try_block";
7010 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
7011 case DW_TAG_variable
: return "DW_TAG_variable";
7012 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
7013 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
7014 case DW_TAG_format_label
: return "DW_TAG_format_label";
7015 case DW_TAG_function_template
: return "DW_TAG_function_template";
7016 case DW_TAG_class_template
: return "DW_TAG_class_template";
7017 /* DWARF 2.1 values. */
7018 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
7019 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
7020 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
7021 case DW_TAG_namespace
: return "DW_TAG_namespace";
7022 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
7023 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
7024 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
7025 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
7027 case DW_TAG_upc_shared_type
: return "DW_TAG_upc_shared_type";
7028 case DW_TAG_upc_strict_type
: return "DW_TAG_upc_strict_type";
7029 case DW_TAG_upc_relaxed_type
: return "DW_TAG_upc_relaxed_type";
7032 static char buffer
[100];
7034 sprintf (buffer
, _("Unknown TAG value: %lx"), tag
);
7041 get_AT_name (attribute
)
7042 unsigned long attribute
;
7046 case DW_AT_sibling
: return "DW_AT_sibling";
7047 case DW_AT_location
: return "DW_AT_location";
7048 case DW_AT_name
: return "DW_AT_name";
7049 case DW_AT_ordering
: return "DW_AT_ordering";
7050 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
7051 case DW_AT_byte_size
: return "DW_AT_byte_size";
7052 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
7053 case DW_AT_bit_size
: return "DW_AT_bit_size";
7054 case DW_AT_element_list
: return "DW_AT_element_list";
7055 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
7056 case DW_AT_low_pc
: return "DW_AT_low_pc";
7057 case DW_AT_high_pc
: return "DW_AT_high_pc";
7058 case DW_AT_language
: return "DW_AT_language";
7059 case DW_AT_member
: return "DW_AT_member";
7060 case DW_AT_discr
: return "DW_AT_discr";
7061 case DW_AT_discr_value
: return "DW_AT_discr_value";
7062 case DW_AT_visibility
: return "DW_AT_visibility";
7063 case DW_AT_import
: return "DW_AT_import";
7064 case DW_AT_string_length
: return "DW_AT_string_length";
7065 case DW_AT_common_reference
: return "DW_AT_common_reference";
7066 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
7067 case DW_AT_const_value
: return "DW_AT_const_value";
7068 case DW_AT_containing_type
: return "DW_AT_containing_type";
7069 case DW_AT_default_value
: return "DW_AT_default_value";
7070 case DW_AT_inline
: return "DW_AT_inline";
7071 case DW_AT_is_optional
: return "DW_AT_is_optional";
7072 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
7073 case DW_AT_producer
: return "DW_AT_producer";
7074 case DW_AT_prototyped
: return "DW_AT_prototyped";
7075 case DW_AT_return_addr
: return "DW_AT_return_addr";
7076 case DW_AT_start_scope
: return "DW_AT_start_scope";
7077 case DW_AT_stride_size
: return "DW_AT_stride_size";
7078 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
7079 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
7080 case DW_AT_accessibility
: return "DW_AT_accessibility";
7081 case DW_AT_address_class
: return "DW_AT_address_class";
7082 case DW_AT_artificial
: return "DW_AT_artificial";
7083 case DW_AT_base_types
: return "DW_AT_base_types";
7084 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
7085 case DW_AT_count
: return "DW_AT_count";
7086 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
7087 case DW_AT_decl_column
: return "DW_AT_decl_column";
7088 case DW_AT_decl_file
: return "DW_AT_decl_file";
7089 case DW_AT_decl_line
: return "DW_AT_decl_line";
7090 case DW_AT_declaration
: return "DW_AT_declaration";
7091 case DW_AT_discr_list
: return "DW_AT_discr_list";
7092 case DW_AT_encoding
: return "DW_AT_encoding";
7093 case DW_AT_external
: return "DW_AT_external";
7094 case DW_AT_frame_base
: return "DW_AT_frame_base";
7095 case DW_AT_friend
: return "DW_AT_friend";
7096 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
7097 case DW_AT_macro_info
: return "DW_AT_macro_info";
7098 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
7099 case DW_AT_priority
: return "DW_AT_priority";
7100 case DW_AT_segment
: return "DW_AT_segment";
7101 case DW_AT_specification
: return "DW_AT_specification";
7102 case DW_AT_static_link
: return "DW_AT_static_link";
7103 case DW_AT_type
: return "DW_AT_type";
7104 case DW_AT_use_location
: return "DW_AT_use_location";
7105 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
7106 case DW_AT_virtuality
: return "DW_AT_virtuality";
7107 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
7108 /* DWARF 2.1 values. */
7109 case DW_AT_allocated
: return "DW_AT_allocated";
7110 case DW_AT_associated
: return "DW_AT_associated";
7111 case DW_AT_data_location
: return "DW_AT_data_location";
7112 case DW_AT_stride
: return "DW_AT_stride";
7113 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
7114 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
7115 case DW_AT_extension
: return "DW_AT_extension";
7116 case DW_AT_ranges
: return "DW_AT_ranges";
7117 case DW_AT_trampoline
: return "DW_AT_trampoline";
7118 case DW_AT_call_column
: return "DW_AT_call_column";
7119 case DW_AT_call_file
: return "DW_AT_call_file";
7120 case DW_AT_call_line
: return "DW_AT_call_line";
7121 /* SGI/MIPS extensions. */
7122 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
7123 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
7124 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
7125 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
7126 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
7127 case DW_AT_MIPS_software_pipeline_depth
:
7128 return "DW_AT_MIPS_software_pipeline_depth";
7129 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
7130 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
7131 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
7132 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
7133 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
7134 /* GNU extensions. */
7135 case DW_AT_sf_names
: return "DW_AT_sf_names";
7136 case DW_AT_src_info
: return "DW_AT_src_info";
7137 case DW_AT_mac_info
: return "DW_AT_mac_info";
7138 case DW_AT_src_coords
: return "DW_AT_src_coords";
7139 case DW_AT_body_begin
: return "DW_AT_body_begin";
7140 case DW_AT_body_end
: return "DW_AT_body_end";
7141 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
7142 /* UPC extension. */
7143 case DW_AT_upc_threads_scaled
: return "DW_AT_upc_threads_scaled";
7146 static char buffer
[100];
7148 sprintf (buffer
, _("Unknown AT value: %lx"), attribute
);
7155 get_FORM_name (form
)
7160 case DW_FORM_addr
: return "DW_FORM_addr";
7161 case DW_FORM_block2
: return "DW_FORM_block2";
7162 case DW_FORM_block4
: return "DW_FORM_block4";
7163 case DW_FORM_data2
: return "DW_FORM_data2";
7164 case DW_FORM_data4
: return "DW_FORM_data4";
7165 case DW_FORM_data8
: return "DW_FORM_data8";
7166 case DW_FORM_string
: return "DW_FORM_string";
7167 case DW_FORM_block
: return "DW_FORM_block";
7168 case DW_FORM_block1
: return "DW_FORM_block1";
7169 case DW_FORM_data1
: return "DW_FORM_data1";
7170 case DW_FORM_flag
: return "DW_FORM_flag";
7171 case DW_FORM_sdata
: return "DW_FORM_sdata";
7172 case DW_FORM_strp
: return "DW_FORM_strp";
7173 case DW_FORM_udata
: return "DW_FORM_udata";
7174 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
7175 case DW_FORM_ref1
: return "DW_FORM_ref1";
7176 case DW_FORM_ref2
: return "DW_FORM_ref2";
7177 case DW_FORM_ref4
: return "DW_FORM_ref4";
7178 case DW_FORM_ref8
: return "DW_FORM_ref8";
7179 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
7180 case DW_FORM_indirect
: return "DW_FORM_indirect";
7183 static char buffer
[100];
7185 sprintf (buffer
, _("Unknown FORM value: %lx"), form
);
7191 /* FIXME: There are better and more effiecint ways to handle
7192 these structures. For now though, I just want something that
7193 is simple to implement. */
7194 typedef struct abbrev_attr
7196 unsigned long attribute
;
7198 struct abbrev_attr
*next
;
7202 typedef struct abbrev_entry
7204 unsigned long entry
;
7207 struct abbrev_attr
*first_attr
;
7208 struct abbrev_attr
*last_attr
;
7209 struct abbrev_entry
*next
;
7213 static abbrev_entry
*first_abbrev
= NULL
;
7214 static abbrev_entry
*last_abbrev
= NULL
;
7219 abbrev_entry
*abbrev
;
7221 for (abbrev
= first_abbrev
; abbrev
;)
7223 abbrev_entry
*next
= abbrev
->next
;
7226 for (attr
= abbrev
->first_attr
; attr
;)
7228 abbrev_attr
*next
= attr
->next
;
7238 last_abbrev
= first_abbrev
= NULL
;
7242 add_abbrev (number
, tag
, children
)
7243 unsigned long number
;
7247 abbrev_entry
*entry
;
7249 entry
= (abbrev_entry
*) malloc (sizeof (*entry
));
7255 entry
->entry
= number
;
7257 entry
->children
= children
;
7258 entry
->first_attr
= NULL
;
7259 entry
->last_attr
= NULL
;
7262 if (first_abbrev
== NULL
)
7263 first_abbrev
= entry
;
7265 last_abbrev
->next
= entry
;
7267 last_abbrev
= entry
;
7271 add_abbrev_attr (attribute
, form
)
7272 unsigned long attribute
;
7277 attr
= (abbrev_attr
*) malloc (sizeof (*attr
));
7283 attr
->attribute
= attribute
;
7287 if (last_abbrev
->first_attr
== NULL
)
7288 last_abbrev
->first_attr
= attr
;
7290 last_abbrev
->last_attr
->next
= attr
;
7292 last_abbrev
->last_attr
= attr
;
7295 /* Processes the (partial) contents of a .debug_abbrev section.
7296 Returns NULL if the end of the section was encountered.
7297 Returns the address after the last byte read if the end of
7298 an abbreviation set was found. */
7300 static unsigned char *
7301 process_abbrev_section (start
, end
)
7302 unsigned char *start
;
7305 if (first_abbrev
!= NULL
)
7311 unsigned long entry
;
7313 unsigned long attribute
;
7316 entry
= read_leb128 (start
, & bytes_read
, 0);
7317 start
+= bytes_read
;
7319 /* A single zero is supposed to end the section according
7320 to the standard. If there's more, then signal that to
7323 return start
== end
? NULL
: start
;
7325 tag
= read_leb128 (start
, & bytes_read
, 0);
7326 start
+= bytes_read
;
7328 children
= *start
++;
7330 add_abbrev (entry
, tag
, children
);
7336 attribute
= read_leb128 (start
, & bytes_read
, 0);
7337 start
+= bytes_read
;
7339 form
= read_leb128 (start
, & bytes_read
, 0);
7340 start
+= bytes_read
;
7343 add_abbrev_attr (attribute
, form
);
7345 while (attribute
!= 0);
7353 display_debug_macinfo (section
, start
, file
)
7354 Elf_Internal_Shdr
*section
;
7355 unsigned char *start
;
7356 FILE *file ATTRIBUTE_UNUSED
;
7358 unsigned char *end
= start
+ section
->sh_size
;
7359 unsigned char *curr
= start
;
7360 unsigned int bytes_read
;
7361 enum dwarf_macinfo_record_type op
;
7363 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
7367 unsigned int lineno
;
7375 case DW_MACINFO_start_file
:
7377 unsigned int filenum
;
7379 lineno
= read_leb128 (curr
, & bytes_read
, 0);
7381 filenum
= read_leb128 (curr
, & bytes_read
, 0);
7384 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"), lineno
, filenum
);
7388 case DW_MACINFO_end_file
:
7389 printf (_(" DW_MACINFO_end_file\n"));
7392 case DW_MACINFO_define
:
7393 lineno
= read_leb128 (curr
, & bytes_read
, 0);
7396 curr
+= strlen (string
) + 1;
7397 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"), lineno
, string
);
7400 case DW_MACINFO_undef
:
7401 lineno
= read_leb128 (curr
, & bytes_read
, 0);
7404 curr
+= strlen (string
) + 1;
7405 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"), lineno
, string
);
7408 case DW_MACINFO_vendor_ext
:
7410 unsigned int constant
;
7412 constant
= read_leb128 (curr
, & bytes_read
, 0);
7415 curr
+= strlen (string
) + 1;
7416 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"), constant
, string
);
7427 display_debug_abbrev (section
, start
, file
)
7428 Elf_Internal_Shdr
*section
;
7429 unsigned char *start
;
7430 FILE *file ATTRIBUTE_UNUSED
;
7432 abbrev_entry
*entry
;
7433 unsigned char *end
= start
+ section
->sh_size
;
7435 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
7439 start
= process_abbrev_section (start
, end
);
7441 if (first_abbrev
== NULL
)
7444 printf (_(" Number TAG\n"));
7446 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
7450 printf (_(" %ld %s [%s]\n"),
7452 get_TAG_name (entry
->tag
),
7453 entry
->children
? _("has children") : _("no children"));
7455 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
7457 printf (_(" %-18s %s\n"),
7458 get_AT_name (attr
->attribute
),
7459 get_FORM_name (attr
->form
));
7473 static unsigned char *
7474 display_block (data
, length
)
7475 unsigned char *data
;
7476 unsigned long length
;
7478 printf (_(" %lu byte block: "), length
);
7481 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
7487 decode_location_expression (data
, pointer_size
, length
)
7488 unsigned char * data
;
7489 unsigned int pointer_size
;
7490 unsigned long length
;
7494 unsigned long uvalue
;
7495 unsigned char *end
= data
+ length
;
7504 printf ("DW_OP_addr: %lx",
7505 (unsigned long) byte_get (data
, pointer_size
));
7506 data
+= pointer_size
;
7509 printf ("DW_OP_deref");
7512 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
7515 printf ("DW_OP_const1s: %ld", (long) byte_get (data
++, 1));
7518 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
7522 printf ("DW_OP_const2s: %ld", (long) byte_get (data
, 2));
7526 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
7530 printf ("DW_OP_const4s: %ld", (long) byte_get (data
, 4));
7534 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
7535 (unsigned long) byte_get (data
+ 4, 4));
7539 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
7540 (long) byte_get (data
+ 4, 4));
7544 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
7548 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
7552 printf ("DW_OP_dup");
7555 printf ("DW_OP_drop");
7558 printf ("DW_OP_over");
7561 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
7564 printf ("DW_OP_swap");
7567 printf ("DW_OP_rot");
7570 printf ("DW_OP_xderef");
7573 printf ("DW_OP_abs");
7576 printf ("DW_OP_and");
7579 printf ("DW_OP_div");
7582 printf ("DW_OP_minus");
7585 printf ("DW_OP_mod");
7588 printf ("DW_OP_mul");
7591 printf ("DW_OP_neg");
7594 printf ("DW_OP_not");
7597 printf ("DW_OP_or");
7600 printf ("DW_OP_plus");
7602 case DW_OP_plus_uconst
:
7603 printf ("DW_OP_plus_uconst: %lu",
7604 read_leb128 (data
, &bytes_read
, 0));
7608 printf ("DW_OP_shl");
7611 printf ("DW_OP_shr");
7614 printf ("DW_OP_shra");
7617 printf ("DW_OP_xor");
7620 printf ("DW_OP_bra: %ld", (long) byte_get (data
, 2));
7624 printf ("DW_OP_eq");
7627 printf ("DW_OP_ge");
7630 printf ("DW_OP_gt");
7633 printf ("DW_OP_le");
7636 printf ("DW_OP_lt");
7639 printf ("DW_OP_ne");
7642 printf ("DW_OP_skip: %ld", (long) byte_get (data
, 2));
7678 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
7713 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
7748 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
7749 read_leb128 (data
, &bytes_read
, 1));
7754 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
7758 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
7762 uvalue
= read_leb128 (data
, &bytes_read
, 0);
7764 printf ("DW_OP_bregx: %lu %ld", uvalue
,
7765 read_leb128 (data
, &bytes_read
, 1));
7769 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
7772 case DW_OP_deref_size
:
7773 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
7775 case DW_OP_xderef_size
:
7776 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
7779 printf ("DW_OP_nop");
7782 /* DWARF 3 extensions. */
7783 case DW_OP_push_object_address
:
7784 printf ("DW_OP_push_object_address");
7787 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2));
7791 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4));
7794 case DW_OP_call_ref
:
7795 printf ("DW_OP_call_ref");
7798 /* GNU extensions. */
7799 case DW_OP_GNU_push_tls_address
:
7800 printf ("DW_OP_GNU_push_tls_address");
7804 if (op
>= DW_OP_lo_user
7805 && op
<= DW_OP_hi_user
)
7806 printf (_("(User defined location op)"));
7808 printf (_("(Unknown location op)"));
7809 /* No way to tell where the next op is, so just bail. */
7813 /* Separate the ops. */
7819 static const char *debug_loc_contents
;
7820 static bfd_vma debug_loc_size
;
7823 load_debug_loc (file
)
7826 Elf_Internal_Shdr
*sec
;
7829 /* If it is already loaded, do nothing. */
7830 if (debug_loc_contents
!= NULL
)
7833 /* Locate the .debug_loc section. */
7834 for (i
= 0, sec
= section_headers
;
7835 i
< elf_header
.e_shnum
;
7837 if (strcmp (SECTION_NAME (sec
), ".debug_loc") == 0)
7840 if (i
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
7843 debug_loc_size
= sec
->sh_size
;
7845 debug_loc_contents
= ((char *)
7846 get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7847 _("debug_loc section data")));
7853 if (debug_loc_contents
== NULL
)
7856 free ((char *) debug_loc_contents
);
7857 debug_loc_contents
= NULL
;
7863 display_debug_loc (section
, start
, file
)
7864 Elf_Internal_Shdr
*section
;
7865 unsigned char *start
;
7866 FILE *file ATTRIBUTE_UNUSED
;
7868 unsigned char *section_end
;
7869 unsigned long bytes
;
7870 unsigned char *section_begin
= start
;
7873 addr
= section
->sh_addr
;
7874 bytes
= section
->sh_size
;
7875 section_end
= start
+ bytes
;
7879 printf (_("\nThe .debug_loc section is empty.\n"));
7883 printf (_("Contents of the .debug_loc section:\n\n"));
7884 printf (_("\n Offset Begin End Expression\n"));
7886 while (start
< section_end
)
7888 unsigned long begin
;
7890 unsigned short length
;
7891 unsigned long offset
;
7893 offset
= start
- section_begin
;
7897 /* Normally, the lists in the debug_loc section are related to a
7898 given compilation unit, and thus, we would use the pointer size
7899 of that compilation unit. However, since we are displaying it
7900 seperately here, we either have to store pointer sizes of all
7901 compilation units, or assume they don't change. We assume,
7902 like the debug_line display, that it doesn't change. */
7903 begin
= byte_get (start
, debug_line_pointer_size
);
7904 start
+= debug_line_pointer_size
;
7905 end
= byte_get (start
, debug_line_pointer_size
);
7906 start
+= debug_line_pointer_size
;
7908 if (begin
== 0 && end
== 0)
7911 /* For now, skip any base address specifiers. */
7912 if (begin
== 0xffffffff)
7918 length
= byte_get (start
, 2);
7921 printf (" %8.8lx %8.8lx %8.8lx (", offset
, begin
, end
);
7922 decode_location_expression (start
, debug_line_pointer_size
, length
);
7932 static const char *debug_str_contents
;
7933 static bfd_vma debug_str_size
;
7936 load_debug_str (file
)
7939 Elf_Internal_Shdr
*sec
;
7942 /* If it is already loaded, do nothing. */
7943 if (debug_str_contents
!= NULL
)
7946 /* Locate the .debug_str section. */
7947 for (i
= 0, sec
= section_headers
;
7948 i
< elf_header
.e_shnum
;
7950 if (strcmp (SECTION_NAME (sec
), ".debug_str") == 0)
7953 if (i
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
7956 debug_str_size
= sec
->sh_size
;
7958 debug_str_contents
= ((char *)
7959 get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7960 _("debug_str section data")));
7966 if (debug_str_contents
== NULL
)
7969 free ((char *) debug_str_contents
);
7970 debug_str_contents
= NULL
;
7975 fetch_indirect_string (offset
)
7976 unsigned long offset
;
7978 if (debug_str_contents
== NULL
)
7979 return _("<no .debug_str section>");
7981 if (offset
> debug_str_size
)
7982 return _("<offset is too big>");
7984 return debug_str_contents
+ offset
;
7988 display_debug_str (section
, start
, file
)
7989 Elf_Internal_Shdr
*section
;
7990 unsigned char *start
;
7991 FILE *file ATTRIBUTE_UNUSED
;
7993 unsigned long bytes
;
7996 addr
= section
->sh_addr
;
7997 bytes
= section
->sh_size
;
8001 printf (_("\nThe .debug_str section is empty.\n"));
8005 printf (_("Contents of the .debug_str section:\n\n"));
8013 lbytes
= (bytes
> 16 ? 16 : bytes
);
8015 printf (" 0x%8.8lx ", (unsigned long) addr
);
8017 for (j
= 0; j
< 16; j
++)
8020 printf ("%2.2x", start
[j
]);
8028 for (j
= 0; j
< lbytes
; j
++)
8031 if (k
>= ' ' && k
< 0x80)
8047 static unsigned char *
8048 read_and_display_attr_value (attribute
, form
, data
, cu_offset
, pointer_size
,
8049 offset_size
, dwarf_version
)
8050 unsigned long attribute
;
8052 unsigned char *data
;
8053 unsigned long cu_offset
;
8054 unsigned long pointer_size
;
8055 unsigned long offset_size
;
8058 unsigned long uvalue
= 0;
8059 unsigned char *block_start
= NULL
;
8067 case DW_FORM_ref_addr
:
8068 if (dwarf_version
== 2)
8070 uvalue
= byte_get (data
, pointer_size
);
8071 data
+= pointer_size
;
8073 else if (dwarf_version
== 3)
8075 uvalue
= byte_get (data
, offset_size
);
8076 data
+= offset_size
;
8080 error (_("Internal error: DWARF version is not 2 or 3.\n"));
8085 uvalue
= byte_get (data
, pointer_size
);
8086 data
+= pointer_size
;
8090 uvalue
= byte_get (data
, offset_size
);
8091 data
+= offset_size
;
8097 uvalue
= byte_get (data
++, 1);
8102 uvalue
= byte_get (data
, 2);
8108 uvalue
= byte_get (data
, 4);
8113 uvalue
= read_leb128 (data
, & bytes_read
, 1);
8117 case DW_FORM_ref_udata
:
8119 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8123 case DW_FORM_indirect
:
8124 form
= read_leb128 (data
, & bytes_read
, 0);
8126 printf (" %s", get_FORM_name (form
));
8127 return read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
8128 pointer_size
, offset_size
,
8134 case DW_FORM_ref_addr
:
8135 printf (" <#%lx>", uvalue
);
8141 case DW_FORM_ref_udata
:
8142 printf (" <%lx>", uvalue
+ cu_offset
);
8146 printf (" %#lx", uvalue
);
8154 printf (" %ld", uvalue
);
8159 uvalue
= byte_get (data
, 4);
8160 printf (" %lx", uvalue
);
8161 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
8165 case DW_FORM_string
:
8166 printf (" %s", data
);
8167 data
+= strlen ((char *) data
) + 1;
8171 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8172 block_start
= data
+ bytes_read
;
8173 data
= display_block (block_start
, uvalue
);
8176 case DW_FORM_block1
:
8177 uvalue
= byte_get (data
, 1);
8178 block_start
= data
+ 1;
8179 data
= display_block (block_start
, uvalue
);
8182 case DW_FORM_block2
:
8183 uvalue
= byte_get (data
, 2);
8184 block_start
= data
+ 2;
8185 data
= display_block (block_start
, uvalue
);
8188 case DW_FORM_block4
:
8189 uvalue
= byte_get (data
, 4);
8190 block_start
= data
+ 4;
8191 data
= display_block (block_start
, uvalue
);
8195 printf (_(" (indirect string, offset: 0x%lx): %s"),
8196 uvalue
, fetch_indirect_string (uvalue
));
8199 case DW_FORM_indirect
:
8200 /* Handled above. */
8204 warn (_("Unrecognized form: %d\n"), form
);
8208 /* For some attributes we can display futher information. */
8217 case DW_INL_not_inlined
:
8218 printf (_("(not inlined)"));
8220 case DW_INL_inlined
:
8221 printf (_("(inlined)"));
8223 case DW_INL_declared_not_inlined
:
8224 printf (_("(declared as inline but ignored)"));
8226 case DW_INL_declared_inlined
:
8227 printf (_("(declared as inline and inlined)"));
8230 printf (_(" (Unknown inline attribute value: %lx)"), uvalue
);
8235 case DW_AT_language
:
8238 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
8239 case DW_LANG_C89
: printf ("(ANSI C)"); break;
8240 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
8241 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
8242 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
8243 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
8244 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
8245 case DW_LANG_Ada83
: printf ("(Ada)"); break;
8246 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
8247 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
8248 /* DWARF 2.1 values. */
8249 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
8250 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
8251 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
8252 /* MIPS extension. */
8253 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
8254 /* UPC extension. */
8255 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
8257 printf ("(Unknown: %lx)", uvalue
);
8262 case DW_AT_encoding
:
8265 case DW_ATE_void
: printf ("(void)"); break;
8266 case DW_ATE_address
: printf ("(machine address)"); break;
8267 case DW_ATE_boolean
: printf ("(boolean)"); break;
8268 case DW_ATE_complex_float
: printf ("(complex float)"); break;
8269 case DW_ATE_float
: printf ("(float)"); break;
8270 case DW_ATE_signed
: printf ("(signed)"); break;
8271 case DW_ATE_signed_char
: printf ("(signed char)"); break;
8272 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
8273 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
8274 /* DWARF 2.1 value. */
8275 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
8277 if (uvalue
>= DW_ATE_lo_user
8278 && uvalue
<= DW_ATE_hi_user
)
8279 printf ("(user defined type)");
8281 printf ("(unknown type)");
8286 case DW_AT_accessibility
:
8289 case DW_ACCESS_public
: printf ("(public)"); break;
8290 case DW_ACCESS_protected
: printf ("(protected)"); break;
8291 case DW_ACCESS_private
: printf ("(private)"); break;
8293 printf ("(unknown accessibility)");
8298 case DW_AT_visibility
:
8301 case DW_VIS_local
: printf ("(local)"); break;
8302 case DW_VIS_exported
: printf ("(exported)"); break;
8303 case DW_VIS_qualified
: printf ("(qualified)"); break;
8304 default: printf ("(unknown visibility)"); break;
8308 case DW_AT_virtuality
:
8311 case DW_VIRTUALITY_none
: printf ("(none)"); break;
8312 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
8313 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
8314 default: printf ("(unknown virtuality)"); break;
8318 case DW_AT_identifier_case
:
8321 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
8322 case DW_ID_up_case
: printf ("(up_case)"); break;
8323 case DW_ID_down_case
: printf ("(down_case)"); break;
8324 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
8325 default: printf ("(unknown case)"); break;
8329 case DW_AT_calling_convention
:
8332 case DW_CC_normal
: printf ("(normal)"); break;
8333 case DW_CC_program
: printf ("(program)"); break;
8334 case DW_CC_nocall
: printf ("(nocall)"); break;
8336 if (uvalue
>= DW_CC_lo_user
8337 && uvalue
<= DW_CC_hi_user
)
8338 printf ("(user defined)");
8340 printf ("(unknown convention)");
8344 case DW_AT_ordering
:
8347 case -1: printf ("(undefined)"); break;
8348 case 0: printf ("(row major)"); break;
8349 case 1: printf ("(column major)"); break;
8353 case DW_AT_frame_base
:
8354 case DW_AT_location
:
8355 case DW_AT_data_member_location
:
8356 case DW_AT_vtable_elem_location
:
8357 case DW_AT_allocated
:
8358 case DW_AT_associated
:
8359 case DW_AT_data_location
:
8361 case DW_AT_upper_bound
:
8362 case DW_AT_lower_bound
:
8366 decode_location_expression (block_start
, pointer_size
, uvalue
);
8369 else if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8372 printf ("location list");
8384 static unsigned char *
8385 read_and_display_attr (attribute
, form
, data
, cu_offset
, pointer_size
,
8386 offset_size
, dwarf_version
)
8387 unsigned long attribute
;
8389 unsigned char *data
;
8390 unsigned long cu_offset
;
8391 unsigned long pointer_size
;
8392 unsigned long offset_size
;
8395 printf (" %-18s:", get_AT_name (attribute
));
8396 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
8397 pointer_size
, offset_size
, dwarf_version
);
8403 display_debug_info (section
, start
, file
)
8404 Elf_Internal_Shdr
*section
;
8405 unsigned char *start
;
8408 unsigned char *end
= start
+ section
->sh_size
;
8409 unsigned char *section_begin
= start
;
8411 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
8413 load_debug_str (file
);
8414 load_debug_loc (file
);
8418 DWARF2_Internal_CompUnit compunit
;
8419 Elf_Internal_Shdr
*relsec
;
8420 unsigned char *hdrptr
;
8421 unsigned char *cu_abbrev_offset_ptr
;
8422 unsigned char *tags
;
8425 unsigned long cu_offset
;
8427 int initial_length_size
;
8431 compunit
.cu_length
= byte_get (hdrptr
, 4);
8434 if (compunit
.cu_length
== 0xffffffff)
8436 compunit
.cu_length
= byte_get (hdrptr
, 8);
8439 initial_length_size
= 12;
8444 initial_length_size
= 4;
8447 compunit
.cu_version
= byte_get (hdrptr
, 2);
8450 /* Apply addends of RELA relocations. */
8451 for (relsec
= section_headers
;
8452 relsec
< section_headers
+ elf_header
.e_shnum
;
8455 unsigned long nrelas
;
8456 Elf_Internal_Rela
*rela
, *rp
;
8457 Elf_Internal_Shdr
*symsec
;
8458 Elf_Internal_Sym
*symtab
;
8459 Elf_Internal_Sym
*sym
;
8461 if (relsec
->sh_type
!= SHT_RELA
8462 || SECTION_HEADER (relsec
->sh_info
) != section
8463 || relsec
->sh_size
== 0)
8466 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8470 symsec
= SECTION_HEADER (relsec
->sh_link
);
8471 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
8473 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8477 if (rp
->r_offset
>= (bfd_vma
) (hdrptr
- section_begin
)
8478 && section
->sh_size
> (bfd_vma
) offset_size
8479 && rp
->r_offset
<= section
->sh_size
- offset_size
)
8480 loc
= section_begin
+ rp
->r_offset
;
8486 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
8488 if (ELF32_R_SYM (rp
->r_info
) != 0
8489 && ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
8491 warn (_("Skipping unexpected symbol type %u\n"),
8492 ELF32_ST_TYPE (sym
->st_info
));
8498 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
8500 if (ELF64_R_SYM (rp
->r_info
) != 0
8501 && ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
8503 warn (_("Skipping unexpected symbol type %u\n"),
8504 ELF64_ST_TYPE (sym
->st_info
));
8509 byte_put (loc
, rp
->r_addend
, offset_size
);
8516 cu_abbrev_offset_ptr
= hdrptr
;
8517 compunit
.cu_abbrev_offset
= byte_get (hdrptr
, offset_size
);
8518 hdrptr
+= offset_size
;
8520 compunit
.cu_pointer_size
= byte_get (hdrptr
, 1);
8524 cu_offset
= start
- section_begin
;
8525 start
+= compunit
.cu_length
+ initial_length_size
;
8527 printf (_(" Compilation Unit @ %lx:\n"), cu_offset
);
8528 printf (_(" Length: %ld\n"), compunit
.cu_length
);
8529 printf (_(" Version: %d\n"), compunit
.cu_version
);
8530 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
8531 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
8533 if (compunit
.cu_version
!= 2 && compunit
.cu_version
!= 3)
8535 warn (_("Only version 2 and 3 DWARF debug information is currently supported.\n"));
8541 /* Read in the abbrevs used by this compilation unit. */
8543 Elf_Internal_Shdr
*sec
;
8544 unsigned char *begin
;
8546 /* Locate the .debug_abbrev section and process it. */
8547 for (i
= 0, sec
= section_headers
;
8548 i
< elf_header
.e_shnum
;
8550 if (strcmp (SECTION_NAME (sec
), ".debug_abbrev") == 0)
8553 if (i
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
8555 warn (_("Unable to locate .debug_abbrev section!\n"));
8559 begin
= ((unsigned char *)
8560 get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
8561 _("debug_abbrev section data")));
8565 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
8566 begin
+ sec
->sh_size
);
8572 while (tags
< start
)
8575 unsigned long abbrev_number
;
8576 abbrev_entry
*entry
;
8579 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
8582 /* A null DIE marks the end of a list of children. */
8583 if (abbrev_number
== 0)
8589 /* Scan through the abbreviation list until we reach the
8591 for (entry
= first_abbrev
;
8592 entry
&& entry
->entry
!= abbrev_number
;
8593 entry
= entry
->next
)
8598 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
8603 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
8605 (unsigned long) (tags
- section_begin
- bytes_read
),
8607 get_TAG_name (entry
->tag
));
8609 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
8610 tags
= read_and_display_attr (attr
->attribute
,
8613 compunit
.cu_pointer_size
,
8615 compunit
.cu_version
);
8617 if (entry
->children
)
8631 display_debug_aranges (section
, start
, file
)
8632 Elf_Internal_Shdr
*section
;
8633 unsigned char *start
;
8634 FILE *file ATTRIBUTE_UNUSED
;
8636 unsigned char *end
= start
+ section
->sh_size
;
8638 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
8642 unsigned char *hdrptr
;
8643 DWARF2_Internal_ARange arange
;
8644 unsigned char *ranges
;
8645 unsigned long length
;
8646 unsigned long address
;
8649 int initial_length_size
;
8653 arange
.ar_length
= byte_get (hdrptr
, 4);
8656 if (arange
.ar_length
== 0xffffffff)
8658 arange
.ar_length
= byte_get (hdrptr
, 8);
8661 initial_length_size
= 12;
8666 initial_length_size
= 4;
8669 arange
.ar_version
= byte_get (hdrptr
, 2);
8672 arange
.ar_info_offset
= byte_get (hdrptr
, offset_size
);
8673 hdrptr
+= offset_size
;
8675 arange
.ar_pointer_size
= byte_get (hdrptr
, 1);
8678 arange
.ar_segment_size
= byte_get (hdrptr
, 1);
8681 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
8683 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
8687 printf (_(" Length: %ld\n"), arange
.ar_length
);
8688 printf (_(" Version: %d\n"), arange
.ar_version
);
8689 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
8690 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
8691 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
8693 printf (_("\n Address Length\n"));
8697 /* Must pad to an alignment boundary that is twice the pointer size. */
8698 excess
= (hdrptr
- start
) % (2 * arange
.ar_pointer_size
);
8700 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
8704 address
= byte_get (ranges
, arange
.ar_pointer_size
);
8706 ranges
+= arange
.ar_pointer_size
;
8708 length
= byte_get (ranges
, arange
.ar_pointer_size
);
8710 ranges
+= arange
.ar_pointer_size
;
8712 /* A pair of zeros marks the end of the list. */
8713 if (address
== 0 && length
== 0)
8716 printf (" %8.8lx %lu\n", address
, length
);
8719 start
+= arange
.ar_length
+ initial_length_size
;
8727 typedef struct Frame_Chunk
8729 struct Frame_Chunk
*next
;
8730 unsigned char *chunk_start
;
8732 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
8733 short int *col_type
;
8736 unsigned int code_factor
;
8738 unsigned long pc_begin
;
8739 unsigned long pc_range
;
8743 unsigned char fde_encoding
;
8744 unsigned char cfa_exp
;
8748 /* A marker for a col_type that means this column was never referenced
8749 in the frame info. */
8750 #define DW_CFA_unreferenced (-1)
8752 static void frame_need_space
PARAMS ((Frame_Chunk
*, int));
8753 static void frame_display_row
PARAMS ((Frame_Chunk
*, int *, int *));
8754 static int size_of_encoded_value
PARAMS ((int));
8755 static bfd_vma get_encoded_value
PARAMS ((unsigned char *, int));
8758 frame_need_space (fc
, reg
)
8762 int prev
= fc
->ncols
;
8764 if (reg
< fc
->ncols
)
8767 fc
->ncols
= reg
+ 1;
8768 fc
->col_type
= (short int *) xrealloc (fc
->col_type
,
8769 fc
->ncols
* sizeof (short int));
8770 fc
->col_offset
= (int *) xrealloc (fc
->col_offset
,
8771 fc
->ncols
* sizeof (int));
8773 while (prev
< fc
->ncols
)
8775 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
8776 fc
->col_offset
[prev
] = 0;
8782 frame_display_row (fc
, need_col_headers
, max_regs
)
8784 int *need_col_headers
;
8790 if (*max_regs
< fc
->ncols
)
8791 *max_regs
= fc
->ncols
;
8793 if (*need_col_headers
)
8795 *need_col_headers
= 0;
8797 printf (" LOC CFA ");
8799 for (r
= 0; r
< *max_regs
; r
++)
8800 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8805 printf ("r%-4d", r
);
8811 printf ("%08lx ", fc
->pc_begin
);
8813 strcpy (tmp
, "exp");
8815 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
8816 printf ("%-8s ", tmp
);
8818 for (r
= 0; r
< fc
->ncols
; r
++)
8820 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8822 switch (fc
->col_type
[r
])
8824 case DW_CFA_undefined
:
8827 case DW_CFA_same_value
:
8831 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
8833 case DW_CFA_register
:
8834 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
8836 case DW_CFA_expression
:
8837 strcpy (tmp
, "exp");
8840 strcpy (tmp
, "n/a");
8843 printf ("%-5s", tmp
);
8850 size_of_encoded_value (encoding
)
8853 switch (encoding
& 0x7)
8856 case 0: return is_32bit_elf
? 4 : 8;
8864 get_encoded_value (data
, encoding
)
8865 unsigned char *data
;
8868 int size
= size_of_encoded_value (encoding
);
8869 if (encoding
& DW_EH_PE_signed
)
8870 return byte_get_signed (data
, size
);
8872 return byte_get (data
, size
);
8875 #define GET(N) byte_get (start, N); start += N
8876 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
8877 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
8880 display_debug_frames (section
, start
, file
)
8881 Elf_Internal_Shdr
*section
;
8882 unsigned char *start
;
8883 FILE *file ATTRIBUTE_UNUSED
;
8885 unsigned char *end
= start
+ section
->sh_size
;
8886 unsigned char *section_start
= start
;
8887 Frame_Chunk
*chunks
= 0;
8888 Frame_Chunk
*remembered_state
= 0;
8890 int is_eh
= (strcmp (SECTION_NAME (section
), ".eh_frame") == 0);
8893 int addr_size
= is_32bit_elf
? 4 : 8;
8895 printf (_("The section %s contains:\n"), SECTION_NAME (section
));
8899 unsigned char *saved_start
;
8900 unsigned char *block_end
;
8901 unsigned long length
;
8902 unsigned long cie_id
;
8905 int need_col_headers
= 1;
8906 unsigned char *augmentation_data
= NULL
;
8907 unsigned long augmentation_data_len
= 0;
8908 int encoded_ptr_size
= addr_size
;
8910 int initial_length_size
;
8912 saved_start
= start
;
8913 length
= byte_get (start
, 4); start
+= 4;
8917 printf ("\n%08lx ZERO terminator\n\n",
8918 (unsigned long)(saved_start
- section_start
));
8922 if (length
== 0xffffffff)
8924 length
= byte_get (start
, 8);
8927 initial_length_size
= 12;
8932 initial_length_size
= 4;
8935 block_end
= saved_start
+ length
+ initial_length_size
;
8936 cie_id
= byte_get (start
, offset_size
); start
+= offset_size
;
8938 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
8942 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8943 memset (fc
, 0, sizeof (Frame_Chunk
));
8947 fc
->chunk_start
= saved_start
;
8949 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8950 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8951 frame_need_space (fc
, max_regs
-1);
8955 fc
->augmentation
= start
;
8956 start
= strchr (start
, '\0') + 1;
8958 if (fc
->augmentation
[0] == 'z')
8960 fc
->code_factor
= LEB ();
8961 fc
->data_factor
= SLEB ();
8962 fc
->ra
= byte_get (start
, 1); start
+= 1;
8963 augmentation_data_len
= LEB ();
8964 augmentation_data
= start
;
8965 start
+= augmentation_data_len
;
8967 else if (strcmp (fc
->augmentation
, "eh") == 0)
8970 fc
->code_factor
= LEB ();
8971 fc
->data_factor
= SLEB ();
8972 fc
->ra
= byte_get (start
, 1); start
+= 1;
8976 fc
->code_factor
= LEB ();
8977 fc
->data_factor
= SLEB ();
8978 fc
->ra
= byte_get (start
, 1); start
+= 1;
8982 if (do_debug_frames_interp
)
8983 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
8984 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
8985 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
8989 printf ("\n%08lx %08lx %08lx CIE\n",
8990 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
8991 printf (" Version: %d\n", version
);
8992 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
8993 printf (" Code alignment factor: %u\n", fc
->code_factor
);
8994 printf (" Data alignment factor: %d\n", fc
->data_factor
);
8995 printf (" Return address column: %d\n", fc
->ra
);
8997 if (augmentation_data_len
)
9000 printf (" Augmentation data: ");
9001 for (i
= 0; i
< augmentation_data_len
; ++i
)
9002 printf (" %02x", augmentation_data
[i
]);
9008 if (augmentation_data_len
)
9010 unsigned char *p
, *q
;
9011 p
= fc
->augmentation
+ 1;
9012 q
= augmentation_data
;
9019 q
+= 1 + size_of_encoded_value (*q
);
9021 fc
->fde_encoding
= *q
++;
9027 if (fc
->fde_encoding
)
9028 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
9031 frame_need_space (fc
, fc
->ra
);
9035 unsigned char *look_for
;
9036 static Frame_Chunk fde_fc
;
9039 memset (fc
, 0, sizeof (Frame_Chunk
));
9041 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
9043 for (cie
= chunks
; cie
; cie
= cie
->next
)
9044 if (cie
->chunk_start
== look_for
)
9049 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
9050 cie_id
, saved_start
);
9053 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
9054 fc
->col_offset
= (int *) xmalloc (sizeof (int));
9055 frame_need_space (fc
, max_regs
- 1);
9057 fc
->augmentation
= "";
9058 fc
->fde_encoding
= 0;
9062 fc
->ncols
= cie
->ncols
;
9063 fc
->col_type
= (short int *) xmalloc (fc
->ncols
* sizeof (short int));
9064 fc
->col_offset
= (int *) xmalloc (fc
->ncols
* sizeof (int));
9065 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
9066 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
9067 fc
->augmentation
= cie
->augmentation
;
9068 fc
->code_factor
= cie
->code_factor
;
9069 fc
->data_factor
= cie
->data_factor
;
9070 fc
->cfa_reg
= cie
->cfa_reg
;
9071 fc
->cfa_offset
= cie
->cfa_offset
;
9073 frame_need_space (fc
, max_regs
-1);
9074 fc
->fde_encoding
= cie
->fde_encoding
;
9077 if (fc
->fde_encoding
)
9078 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
9080 fc
->pc_begin
= get_encoded_value (start
, fc
->fde_encoding
);
9081 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
)
9082 fc
->pc_begin
+= section
->sh_addr
+ (start
- section_start
);
9083 start
+= encoded_ptr_size
;
9084 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
9085 start
+= encoded_ptr_size
;
9087 if (cie
->augmentation
[0] == 'z')
9089 augmentation_data_len
= LEB ();
9090 augmentation_data
= start
;
9091 start
+= augmentation_data_len
;
9094 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
9095 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
9096 (unsigned long)(cie
->chunk_start
- section_start
),
9097 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
9098 if (! do_debug_frames_interp
&& augmentation_data_len
)
9101 printf (" Augmentation data: ");
9102 for (i
= 0; i
< augmentation_data_len
; ++i
)
9103 printf (" %02x", augmentation_data
[i
]);
9109 /* At this point, fc is the current chunk, cie (if any) is set, and we're
9110 about to interpret instructions for the chunk. */
9111 /* ??? At present we need to do this always, since this sizes the
9112 fc->col_type and fc->col_offset arrays, which we write into always.
9113 We should probably split the interpreted and non-interpreted bits
9114 into two different routines, since there's so much that doesn't
9115 really overlap between them. */
9116 if (1 || do_debug_frames_interp
)
9118 /* Start by making a pass over the chunk, allocating storage
9119 and taking note of what registers are used. */
9120 unsigned char *tmp
= start
;
9122 while (start
< block_end
)
9125 unsigned long reg
, tmp
;
9132 /* Warning: if you add any more cases to this switch, be
9133 sure to add them to the corresponding switch below. */
9136 case DW_CFA_advance_loc
:
9140 frame_need_space (fc
, opa
);
9141 fc
->col_type
[opa
] = DW_CFA_undefined
;
9143 case DW_CFA_restore
:
9144 frame_need_space (fc
, opa
);
9145 fc
->col_type
[opa
] = DW_CFA_undefined
;
9147 case DW_CFA_set_loc
:
9148 start
+= encoded_ptr_size
;
9150 case DW_CFA_advance_loc1
:
9153 case DW_CFA_advance_loc2
:
9156 case DW_CFA_advance_loc4
:
9159 case DW_CFA_offset_extended
:
9160 reg
= LEB (); LEB ();
9161 frame_need_space (fc
, reg
);
9162 fc
->col_type
[reg
] = DW_CFA_undefined
;
9164 case DW_CFA_restore_extended
:
9166 frame_need_space (fc
, reg
);
9167 fc
->col_type
[reg
] = DW_CFA_undefined
;
9169 case DW_CFA_undefined
:
9171 frame_need_space (fc
, reg
);
9172 fc
->col_type
[reg
] = DW_CFA_undefined
;
9174 case DW_CFA_same_value
:
9176 frame_need_space (fc
, reg
);
9177 fc
->col_type
[reg
] = DW_CFA_undefined
;
9179 case DW_CFA_register
:
9180 reg
= LEB (); LEB ();
9181 frame_need_space (fc
, reg
);
9182 fc
->col_type
[reg
] = DW_CFA_undefined
;
9184 case DW_CFA_def_cfa
:
9187 case DW_CFA_def_cfa_register
:
9190 case DW_CFA_def_cfa_offset
:
9193 case DW_CFA_def_cfa_expression
:
9197 case DW_CFA_expression
:
9201 frame_need_space (fc
, reg
);
9202 fc
->col_type
[reg
] = DW_CFA_undefined
;
9204 case DW_CFA_offset_extended_sf
:
9205 reg
= LEB (); SLEB ();
9206 frame_need_space (fc
, reg
);
9207 fc
->col_type
[reg
] = DW_CFA_undefined
;
9209 case DW_CFA_def_cfa_sf
:
9212 case DW_CFA_def_cfa_offset_sf
:
9215 case DW_CFA_MIPS_advance_loc8
:
9218 case DW_CFA_GNU_args_size
:
9221 case DW_CFA_GNU_negative_offset_extended
:
9222 reg
= LEB (); LEB ();
9223 frame_need_space (fc
, reg
);
9224 fc
->col_type
[reg
] = DW_CFA_undefined
;
9233 /* Now we know what registers are used, make a second pass over
9234 the chunk, this time actually printing out the info. */
9236 while (start
< block_end
)
9239 unsigned long ul
, reg
, roffs
;
9248 /* Warning: if you add any more cases to this switch, be
9249 sure to add them to the corresponding switch above. */
9252 case DW_CFA_advance_loc
:
9253 if (do_debug_frames_interp
)
9254 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9256 printf (" DW_CFA_advance_loc: %d to %08lx\n",
9257 opa
* fc
->code_factor
,
9258 fc
->pc_begin
+ opa
* fc
->code_factor
);
9259 fc
->pc_begin
+= opa
* fc
->code_factor
;
9264 if (! do_debug_frames_interp
)
9265 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
9266 opa
, roffs
* fc
->data_factor
);
9267 fc
->col_type
[opa
] = DW_CFA_offset
;
9268 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
9271 case DW_CFA_restore
:
9272 if (! do_debug_frames_interp
)
9273 printf (" DW_CFA_restore: r%d\n", opa
);
9274 fc
->col_type
[opa
] = cie
->col_type
[opa
];
9275 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
9278 case DW_CFA_set_loc
:
9279 vma
= get_encoded_value (start
, fc
->fde_encoding
);
9280 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
)
9281 vma
+= section
->sh_addr
+ (start
- section_start
);
9282 start
+= encoded_ptr_size
;
9283 if (do_debug_frames_interp
)
9284 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9286 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
9290 case DW_CFA_advance_loc1
:
9291 ofs
= byte_get (start
, 1); start
+= 1;
9292 if (do_debug_frames_interp
)
9293 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9295 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
9296 ofs
* fc
->code_factor
,
9297 fc
->pc_begin
+ ofs
* fc
->code_factor
);
9298 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9301 case DW_CFA_advance_loc2
:
9302 ofs
= byte_get (start
, 2); start
+= 2;
9303 if (do_debug_frames_interp
)
9304 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9306 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
9307 ofs
* fc
->code_factor
,
9308 fc
->pc_begin
+ ofs
* fc
->code_factor
);
9309 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9312 case DW_CFA_advance_loc4
:
9313 ofs
= byte_get (start
, 4); start
+= 4;
9314 if (do_debug_frames_interp
)
9315 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9317 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
9318 ofs
* fc
->code_factor
,
9319 fc
->pc_begin
+ ofs
* fc
->code_factor
);
9320 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9323 case DW_CFA_offset_extended
:
9326 if (! do_debug_frames_interp
)
9327 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
9328 reg
, roffs
* fc
->data_factor
);
9329 fc
->col_type
[reg
] = DW_CFA_offset
;
9330 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
9333 case DW_CFA_restore_extended
:
9335 if (! do_debug_frames_interp
)
9336 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
9337 fc
->col_type
[reg
] = cie
->col_type
[reg
];
9338 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
9341 case DW_CFA_undefined
:
9343 if (! do_debug_frames_interp
)
9344 printf (" DW_CFA_undefined: r%ld\n", reg
);
9345 fc
->col_type
[reg
] = DW_CFA_undefined
;
9346 fc
->col_offset
[reg
] = 0;
9349 case DW_CFA_same_value
:
9351 if (! do_debug_frames_interp
)
9352 printf (" DW_CFA_same_value: r%ld\n", reg
);
9353 fc
->col_type
[reg
] = DW_CFA_same_value
;
9354 fc
->col_offset
[reg
] = 0;
9357 case DW_CFA_register
:
9360 if (! do_debug_frames_interp
)
9361 printf (" DW_CFA_register: r%ld in r%ld\n", reg
, roffs
);
9362 fc
->col_type
[reg
] = DW_CFA_register
;
9363 fc
->col_offset
[reg
] = roffs
;
9366 case DW_CFA_remember_state
:
9367 if (! do_debug_frames_interp
)
9368 printf (" DW_CFA_remember_state\n");
9369 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
9370 rs
->ncols
= fc
->ncols
;
9371 rs
->col_type
= (short int *) xmalloc (rs
->ncols
* sizeof (short int));
9372 rs
->col_offset
= (int *) xmalloc (rs
->ncols
* sizeof (int));
9373 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
9374 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
9375 rs
->next
= remembered_state
;
9376 remembered_state
= rs
;
9379 case DW_CFA_restore_state
:
9380 if (! do_debug_frames_interp
)
9381 printf (" DW_CFA_restore_state\n");
9382 rs
= remembered_state
;
9383 remembered_state
= rs
->next
;
9384 frame_need_space (fc
, rs
->ncols
-1);
9385 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
9386 memcpy (fc
->col_offset
, rs
->col_offset
, rs
->ncols
* sizeof (int));
9387 free (rs
->col_type
);
9388 free (rs
->col_offset
);
9392 case DW_CFA_def_cfa
:
9393 fc
->cfa_reg
= LEB ();
9394 fc
->cfa_offset
= LEB ();
9396 if (! do_debug_frames_interp
)
9397 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
9398 fc
->cfa_reg
, fc
->cfa_offset
);
9401 case DW_CFA_def_cfa_register
:
9402 fc
->cfa_reg
= LEB ();
9404 if (! do_debug_frames_interp
)
9405 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
9408 case DW_CFA_def_cfa_offset
:
9409 fc
->cfa_offset
= LEB ();
9410 if (! do_debug_frames_interp
)
9411 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
9415 if (! do_debug_frames_interp
)
9416 printf (" DW_CFA_nop\n");
9419 case DW_CFA_def_cfa_expression
:
9421 if (! do_debug_frames_interp
)
9423 printf (" DW_CFA_def_cfa_expression (");
9424 decode_location_expression (start
, addr_size
, ul
);
9431 case DW_CFA_expression
:
9434 if (! do_debug_frames_interp
)
9436 printf (" DW_CFA_expression: r%ld (", reg
);
9437 decode_location_expression (start
, addr_size
, ul
);
9440 fc
->col_type
[reg
] = DW_CFA_expression
;
9444 case DW_CFA_offset_extended_sf
:
9447 frame_need_space (fc
, reg
);
9448 if (! do_debug_frames_interp
)
9449 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
9450 reg
, l
* fc
->data_factor
);
9451 fc
->col_type
[reg
] = DW_CFA_offset
;
9452 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9455 case DW_CFA_def_cfa_sf
:
9456 fc
->cfa_reg
= LEB ();
9457 fc
->cfa_offset
= SLEB ();
9459 if (! do_debug_frames_interp
)
9460 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
9461 fc
->cfa_reg
, fc
->cfa_offset
);
9464 case DW_CFA_def_cfa_offset_sf
:
9465 fc
->cfa_offset
= SLEB ();
9466 if (! do_debug_frames_interp
)
9467 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
9470 case DW_CFA_MIPS_advance_loc8
:
9471 ofs
= byte_get (start
, 8); start
+= 8;
9472 if (do_debug_frames_interp
)
9473 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9475 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
9476 ofs
* fc
->code_factor
,
9477 fc
->pc_begin
+ ofs
* fc
->code_factor
);
9478 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9481 case DW_CFA_GNU_window_save
:
9482 if (! do_debug_frames_interp
)
9483 printf (" DW_CFA_GNU_window_save\n");
9486 case DW_CFA_GNU_args_size
:
9488 if (! do_debug_frames_interp
)
9489 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
9492 case DW_CFA_GNU_negative_offset_extended
:
9495 frame_need_space (fc
, reg
);
9496 if (! do_debug_frames_interp
)
9497 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
9498 reg
, l
* fc
->data_factor
);
9499 fc
->col_type
[reg
] = DW_CFA_offset
;
9500 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9504 fprintf (stderr
, "unsupported or unknown DW_CFA_%d\n", op
);
9509 if (do_debug_frames_interp
)
9510 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9525 display_debug_not_supported (section
, start
, file
)
9526 Elf_Internal_Shdr
*section
;
9527 unsigned char *start ATTRIBUTE_UNUSED
;
9528 FILE *file ATTRIBUTE_UNUSED
;
9530 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
9531 SECTION_NAME (section
));
9536 /* Pre-scan the .debug_info section to record the size of address.
9537 When dumping the .debug_line, we use that size information, assuming
9538 that all compilation units have the same address size. */
9540 prescan_debug_info (section
, start
, file
)
9541 Elf_Internal_Shdr
*section ATTRIBUTE_UNUSED
;
9542 unsigned char *start
;
9543 FILE *file ATTRIBUTE_UNUSED
;
9545 unsigned long length
;
9547 /* Read the first 4 bytes. For a 32-bit DWARF section, this will
9548 be the length. For a 64-bit DWARF section, it'll be the escape
9549 code 0xffffffff followed by an 8 byte length. For the purposes
9550 of this prescan, we don't care about the actual length, but the
9551 presence of the escape bytes does affect the location of the byte
9552 which describes the address size. */
9553 length
= byte_get (start
, 4);
9555 if (length
== 0xffffffff)
9557 /* For 64-bit DWARF, the 1-byte address_size field is 22 bytes
9558 from the start of the section. This is computed as follows:
9560 unit_length: 12 bytes
9562 debug_abbrev_offset: 8 bytes
9563 -----------------------------
9566 debug_line_pointer_size
= byte_get (start
+ 22, 1);
9570 /* For 32-bit DWARF, the 1-byte address_size field is 10 bytes from
9571 the start of the section:
9572 unit_length: 4 bytes
9574 debug_abbrev_offset: 4 bytes
9575 -----------------------------
9578 debug_line_pointer_size
= byte_get (start
+ 10, 1);
9583 /* A structure containing the name of a debug section and a pointer
9584 to a function that can decode it. The third field is a prescan
9585 function to be run over the section before displaying any of the
9589 const char *const name
;
9590 int (*display
) PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
9591 int (*prescan
) PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
9595 { ".debug_abbrev", display_debug_abbrev
, NULL
},
9596 { ".debug_aranges", display_debug_aranges
, NULL
},
9597 { ".debug_frame", display_debug_frames
, NULL
},
9598 { ".debug_info", display_debug_info
, prescan_debug_info
},
9599 { ".debug_line", display_debug_lines
, NULL
},
9600 { ".debug_pubnames", display_debug_pubnames
, NULL
},
9601 { ".eh_frame", display_debug_frames
, NULL
},
9602 { ".debug_macinfo", display_debug_macinfo
, NULL
},
9603 { ".debug_str", display_debug_str
, NULL
},
9604 { ".debug_loc", display_debug_loc
, NULL
},
9605 { ".debug_pubtypes", display_debug_not_supported
, NULL
},
9606 { ".debug_ranges", display_debug_not_supported
, NULL
},
9607 { ".debug_static_func", display_debug_not_supported
, NULL
},
9608 { ".debug_static_vars", display_debug_not_supported
, NULL
},
9609 { ".debug_types", display_debug_not_supported
, NULL
},
9610 { ".debug_weaknames", display_debug_not_supported
, NULL
}
9614 display_debug_section (section
, file
)
9615 Elf_Internal_Shdr
*section
;
9618 char *name
= SECTION_NAME (section
);
9619 bfd_size_type length
;
9620 unsigned char *start
;
9623 length
= section
->sh_size
;
9626 printf (_("\nSection '%s' has no debugging data.\n"), name
);
9630 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
, length
,
9631 _("debug section data"));
9635 /* See if we know how to display the contents of this section. */
9636 if (strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
9637 name
= ".debug_info";
9639 for (i
= NUM_ELEM (debug_displays
); i
--;)
9640 if (strcmp (debug_displays
[i
].name
, name
) == 0)
9642 debug_displays
[i
].display (section
, start
, file
);
9647 printf (_("Unrecognized debug section: %s\n"), name
);
9651 /* If we loaded in the abbrev section at some point,
9652 we must release it here. */
9659 process_section_contents (file
)
9662 Elf_Internal_Shdr
*section
;
9668 /* Pre-scan the debug sections to find some debug information not
9669 present in some of them. For the .debug_line, we must find out the
9670 size of address (specified in .debug_info and .debug_aranges). */
9671 for (i
= 0, section
= section_headers
;
9672 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
9675 char *name
= SECTION_NAME (section
);
9678 if (section
->sh_size
== 0)
9681 /* See if there is some pre-scan operation for this section. */
9682 for (j
= NUM_ELEM (debug_displays
); j
--;)
9683 if (strcmp (debug_displays
[j
].name
, name
) == 0)
9685 if (debug_displays
[j
].prescan
!= NULL
)
9687 bfd_size_type length
;
9688 unsigned char *start
;
9690 length
= section
->sh_size
;
9691 start
= ((unsigned char *)
9692 get_data (NULL
, file
, section
->sh_offset
, length
,
9693 _("debug section data")));
9697 debug_displays
[j
].prescan (section
, start
, file
);
9705 for (i
= 0, section
= section_headers
;
9706 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
9709 #ifdef SUPPORT_DISASSEMBLY
9710 if (dump_sects
[i
] & DISASS_DUMP
)
9711 disassemble_section (section
, file
);
9713 if (dump_sects
[i
] & HEX_DUMP
)
9714 dump_section (section
, file
);
9716 if (dump_sects
[i
] & DEBUG_DUMP
)
9717 display_debug_section (section
, file
);
9720 if (i
< num_dump_sects
)
9721 warn (_("Some sections were not dumped because they do not exist!\n"));
9727 process_mips_fpe_exception (mask
)
9733 if (mask
& OEX_FPU_INEX
)
9734 fputs ("INEX", stdout
), first
= 0;
9735 if (mask
& OEX_FPU_UFLO
)
9736 printf ("%sUFLO", first
? "" : "|"), first
= 0;
9737 if (mask
& OEX_FPU_OFLO
)
9738 printf ("%sOFLO", first
? "" : "|"), first
= 0;
9739 if (mask
& OEX_FPU_DIV0
)
9740 printf ("%sDIV0", first
? "" : "|"), first
= 0;
9741 if (mask
& OEX_FPU_INVAL
)
9742 printf ("%sINVAL", first
? "" : "|");
9745 fputs ("0", stdout
);
9749 process_mips_specific (file
)
9752 Elf_Internal_Dyn
*entry
;
9753 size_t liblist_offset
= 0;
9754 size_t liblistno
= 0;
9755 size_t conflictsno
= 0;
9756 size_t options_offset
= 0;
9757 size_t conflicts_offset
= 0;
9759 /* We have a lot of special sections. Thanks SGI! */
9760 if (dynamic_segment
== NULL
)
9761 /* No information available. */
9764 for (entry
= dynamic_segment
; entry
->d_tag
!= DT_NULL
; ++entry
)
9765 switch (entry
->d_tag
)
9767 case DT_MIPS_LIBLIST
:
9769 = offset_from_vma (file
, entry
->d_un
.d_val
,
9770 liblistno
* sizeof (Elf32_External_Lib
));
9772 case DT_MIPS_LIBLISTNO
:
9773 liblistno
= entry
->d_un
.d_val
;
9775 case DT_MIPS_OPTIONS
:
9776 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9778 case DT_MIPS_CONFLICT
:
9780 = offset_from_vma (file
, entry
->d_un
.d_val
,
9781 conflictsno
* sizeof (Elf32_External_Conflict
));
9783 case DT_MIPS_CONFLICTNO
:
9784 conflictsno
= entry
->d_un
.d_val
;
9790 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
9792 Elf32_External_Lib
*elib
;
9795 elib
= ((Elf32_External_Lib
*)
9796 get_data (NULL
, file
, liblist_offset
,
9797 liblistno
* sizeof (Elf32_External_Lib
),
9801 printf ("\nSection '.liblist' contains %lu entries:\n",
9802 (unsigned long) liblistno
);
9803 fputs (" Library Time Stamp Checksum Version Flags\n",
9806 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
9813 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9814 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9815 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9816 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9817 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9819 tmp
= gmtime (&time
);
9820 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
9821 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9822 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9824 printf ("%3lu: ", (unsigned long) cnt
);
9825 print_symbol (20, dynamic_strings
+ liblist
.l_name
);
9826 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
9829 if (liblist
.l_flags
== 0)
9840 { " EXACT_MATCH", LL_EXACT_MATCH
},
9841 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
9842 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
9843 { " EXPORTS", LL_EXPORTS
},
9844 { " DELAY_LOAD", LL_DELAY_LOAD
},
9845 { " DELTA", LL_DELTA
}
9847 int flags
= liblist
.l_flags
;
9851 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
9853 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
9855 fputs (l_flags_vals
[fcnt
].name
, stdout
);
9856 flags
^= l_flags_vals
[fcnt
].bit
;
9859 printf (" %#x", (unsigned int) flags
);
9869 if (options_offset
!= 0)
9871 Elf_External_Options
*eopt
;
9872 Elf_Internal_Shdr
*sect
= section_headers
;
9873 Elf_Internal_Options
*iopt
;
9874 Elf_Internal_Options
*option
;
9878 /* Find the section header so that we get the size. */
9879 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
9882 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
,
9883 sect
->sh_size
, _("options"));
9886 iopt
= ((Elf_Internal_Options
*)
9887 malloc ((sect
->sh_size
/ sizeof (eopt
)) * sizeof (*iopt
)));
9890 error (_("Out of memory"));
9897 while (offset
< sect
->sh_size
)
9899 Elf_External_Options
*eoption
;
9901 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
9903 option
->kind
= BYTE_GET (eoption
->kind
);
9904 option
->size
= BYTE_GET (eoption
->size
);
9905 option
->section
= BYTE_GET (eoption
->section
);
9906 option
->info
= BYTE_GET (eoption
->info
);
9908 offset
+= option
->size
;
9914 printf (_("\nSection '%s' contains %d entries:\n"),
9915 SECTION_NAME (sect
), cnt
);
9923 switch (option
->kind
)
9926 /* This shouldn't happen. */
9927 printf (" NULL %d %lx", option
->section
, option
->info
);
9930 printf (" REGINFO ");
9931 if (elf_header
.e_machine
== EM_MIPS
)
9934 Elf32_External_RegInfo
*ereg
;
9935 Elf32_RegInfo reginfo
;
9937 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
9938 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9939 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9940 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9941 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9942 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9943 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9945 printf ("GPR %08lx GP 0x%lx\n",
9947 (unsigned long) reginfo
.ri_gp_value
);
9948 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9949 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9950 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9955 Elf64_External_RegInfo
*ereg
;
9956 Elf64_Internal_RegInfo reginfo
;
9958 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
9959 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9960 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9961 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9962 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9963 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9964 reginfo
.ri_gp_value
= BYTE_GET8 (ereg
->ri_gp_value
);
9966 printf ("GPR %08lx GP 0x",
9967 reginfo
.ri_gprmask
);
9968 printf_vma (reginfo
.ri_gp_value
);
9971 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9972 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9973 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9977 case ODK_EXCEPTIONS
:
9978 fputs (" EXCEPTIONS fpe_min(", stdout
);
9979 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
9980 fputs (") fpe_max(", stdout
);
9981 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
9982 fputs (")", stdout
);
9984 if (option
->info
& OEX_PAGE0
)
9985 fputs (" PAGE0", stdout
);
9986 if (option
->info
& OEX_SMM
)
9987 fputs (" SMM", stdout
);
9988 if (option
->info
& OEX_FPDBUG
)
9989 fputs (" FPDBUG", stdout
);
9990 if (option
->info
& OEX_DISMISS
)
9991 fputs (" DISMISS", stdout
);
9994 fputs (" PAD ", stdout
);
9995 if (option
->info
& OPAD_PREFIX
)
9996 fputs (" PREFIX", stdout
);
9997 if (option
->info
& OPAD_POSTFIX
)
9998 fputs (" POSTFIX", stdout
);
9999 if (option
->info
& OPAD_SYMBOL
)
10000 fputs (" SYMBOL", stdout
);
10003 fputs (" HWPATCH ", stdout
);
10004 if (option
->info
& OHW_R4KEOP
)
10005 fputs (" R4KEOP", stdout
);
10006 if (option
->info
& OHW_R8KPFETCH
)
10007 fputs (" R8KPFETCH", stdout
);
10008 if (option
->info
& OHW_R5KEOP
)
10009 fputs (" R5KEOP", stdout
);
10010 if (option
->info
& OHW_R5KCVTL
)
10011 fputs (" R5KCVTL", stdout
);
10014 fputs (" FILL ", stdout
);
10015 /* XXX Print content of info word? */
10018 fputs (" TAGS ", stdout
);
10019 /* XXX Print content of info word? */
10022 fputs (" HWAND ", stdout
);
10023 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
10024 fputs (" R4KEOP_CHECKED", stdout
);
10025 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
10026 fputs (" R4KEOP_CLEAN", stdout
);
10029 fputs (" HWOR ", stdout
);
10030 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
10031 fputs (" R4KEOP_CHECKED", stdout
);
10032 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
10033 fputs (" R4KEOP_CLEAN", stdout
);
10036 printf (" GP_GROUP %#06lx self-contained %#06lx",
10037 option
->info
& OGP_GROUP
,
10038 (option
->info
& OGP_SELF
) >> 16);
10041 printf (" IDENT %#06lx self-contained %#06lx",
10042 option
->info
& OGP_GROUP
,
10043 (option
->info
& OGP_SELF
) >> 16);
10046 /* This shouldn't happen. */
10047 printf (" %3d ??? %d %lx",
10048 option
->kind
, option
->section
, option
->info
);
10052 len
= sizeof (*eopt
);
10053 while (len
< option
->size
)
10054 if (((char *) option
)[len
] >= ' '
10055 && ((char *) option
)[len
] < 0x7f)
10056 printf ("%c", ((char *) option
)[len
++]);
10058 printf ("\\%03o", ((char *) option
)[len
++]);
10060 fputs ("\n", stdout
);
10068 if (conflicts_offset
!= 0 && conflictsno
!= 0)
10070 Elf32_Conflict
*iconf
;
10073 if (dynamic_symbols
== NULL
)
10075 error (_("conflict list found without a dynamic symbol table"));
10079 iconf
= (Elf32_Conflict
*) malloc (conflictsno
* sizeof (*iconf
));
10082 error (_("Out of memory"));
10088 Elf32_External_Conflict
*econf32
;
10090 econf32
= ((Elf32_External_Conflict
*)
10091 get_data (NULL
, file
, conflicts_offset
,
10092 conflictsno
* sizeof (*econf32
),
10097 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10098 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
10104 Elf64_External_Conflict
*econf64
;
10106 econf64
= ((Elf64_External_Conflict
*)
10107 get_data (NULL
, file
, conflicts_offset
,
10108 conflictsno
* sizeof (*econf64
),
10113 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10114 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
10119 printf (_("\nSection '.conflict' contains %ld entries:\n"),
10120 (long) conflictsno
);
10121 puts (_(" Num: Index Value Name"));
10123 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10125 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
10127 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
10128 print_vma (psym
->st_value
, FULL_HEX
);
10130 print_symbol (25, dynamic_strings
+ psym
->st_name
);
10141 process_gnu_liblist (file
)
10144 Elf_Internal_Shdr
*section
, *string_sec
;
10145 Elf32_External_Lib
*elib
;
10153 for (i
= 0, section
= section_headers
;
10154 i
< elf_header
.e_shnum
;
10157 switch (section
->sh_type
)
10159 case SHT_GNU_LIBLIST
:
10160 elib
= ((Elf32_External_Lib
*)
10161 get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
10166 string_sec
= SECTION_HEADER (section
->sh_link
);
10168 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
10169 string_sec
->sh_size
,
10170 _("liblist string table"));
10173 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
10179 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
10180 SECTION_NAME (section
),
10181 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
10183 puts (" Library Time Stamp Checksum Version Flags");
10185 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
10193 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
10194 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
10195 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
10196 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
10197 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
10199 tmp
= gmtime (&time
);
10200 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
10201 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10202 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10204 printf ("%3lu: ", (unsigned long) cnt
);
10206 printf ("%-20s", strtab
+ liblist
.l_name
);
10208 printf ("%-20.20s", strtab
+ liblist
.l_name
);
10209 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
10210 liblist
.l_version
, liblist
.l_flags
);
10220 static const char *
10221 get_note_type (e_type
)
10224 static char buff
[64];
10228 case NT_PRSTATUS
: return _("NT_PRSTATUS (prstatus structure)");
10229 case NT_FPREGSET
: return _("NT_FPREGSET (floating point registers)");
10230 case NT_PRPSINFO
: return _("NT_PRPSINFO (prpsinfo structure)");
10231 case NT_TASKSTRUCT
: return _("NT_TASKSTRUCT (task structure)");
10232 case NT_PRXFPREG
: return _("NT_PRXFPREG (user_xfpregs structure)");
10233 case NT_PSTATUS
: return _("NT_PSTATUS (pstatus structure)");
10234 case NT_FPREGS
: return _("NT_FPREGS (floating point registers)");
10235 case NT_PSINFO
: return _("NT_PSINFO (psinfo structure)");
10236 case NT_LWPSTATUS
: return _("NT_LWPSTATUS (lwpstatus_t structure)");
10237 case NT_LWPSINFO
: return _("NT_LWPSINFO (lwpsinfo_t structure)");
10238 case NT_WIN32PSTATUS
: return _("NT_WIN32PSTATUS (win32_pstatus structure)");
10240 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
10245 static const char *
10246 get_netbsd_elfcore_note_type (e_type
)
10249 static char buff
[64];
10251 if (e_type
== NT_NETBSDCORE_PROCINFO
)
10253 /* NetBSD core "procinfo" structure. */
10254 return _("NetBSD procinfo structure");
10257 /* As of Jan 2002 there are no other machine-independent notes
10258 defined for NetBSD core files. If the note type is less
10259 than the start of the machine-dependent note types, we don't
10262 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
10264 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
10268 switch (elf_header
.e_machine
)
10270 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
10271 and PT_GETFPREGS == mach+2. */
10276 case EM_SPARC32PLUS
:
10280 case NT_NETBSDCORE_FIRSTMACH
+0:
10281 return _("PT_GETREGS (reg structure)");
10282 case NT_NETBSDCORE_FIRSTMACH
+2:
10283 return _("PT_GETFPREGS (fpreg structure)");
10289 /* On all other arch's, PT_GETREGS == mach+1 and
10290 PT_GETFPREGS == mach+3. */
10294 case NT_NETBSDCORE_FIRSTMACH
+1:
10295 return _("PT_GETREGS (reg structure)");
10296 case NT_NETBSDCORE_FIRSTMACH
+3:
10297 return _("PT_GETFPREGS (fpreg structure)");
10303 sprintf (buff
, _("PT_FIRSTMACH+%d"), e_type
- NT_NETBSDCORE_FIRSTMACH
);
10307 /* Note that by the ELF standard, the name field is already null byte
10308 terminated, and namesz includes the terminating null byte.
10309 I.E. the value of namesz for the name "FSF" is 4.
10311 If the value of namesz is zero, there is no name present. */
10313 process_note (pnote
)
10314 Elf_Internal_Note
*pnote
;
10318 if (pnote
->namesz
== 0)
10320 /* If there is no note name, then use the default set of
10321 note type strings. */
10322 nt
= get_note_type (pnote
->type
);
10324 else if (strncmp (pnote
->namedata
, "NetBSD-CORE", 11) == 0)
10326 /* NetBSD-specific core file notes. */
10327 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
10331 /* Don't recognize this note name; just use the default set of
10332 note type strings. */
10333 nt
= get_note_type (pnote
->type
);
10336 printf (" %s\t\t0x%08lx\t%s\n",
10337 pnote
->namesz
? pnote
->namedata
: "(NONE)",
10338 pnote
->descsz
, nt
);
10344 process_corefile_note_segment (file
, offset
, length
)
10349 Elf_External_Note
*pnotes
;
10350 Elf_External_Note
*external
;
10356 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, length
,
10363 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
10364 (unsigned long) offset
, (unsigned long) length
);
10365 printf (_(" Owner\t\tData size\tDescription\n"));
10367 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
10369 Elf_External_Note
*next
;
10370 Elf_Internal_Note inote
;
10373 inote
.type
= BYTE_GET (external
->type
);
10374 inote
.namesz
= BYTE_GET (external
->namesz
);
10375 inote
.namedata
= external
->name
;
10376 inote
.descsz
= BYTE_GET (external
->descsz
);
10377 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
10378 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
10380 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
10382 if (((char *) next
) > (((char *) pnotes
) + length
))
10384 warn (_("corrupt note found at offset %x into core notes\n"),
10385 ((char *) external
) - ((char *) pnotes
));
10386 warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
10387 inote
.type
, inote
.namesz
, inote
.descsz
);
10393 /* Verify that name is null terminated. It appears that at least
10394 one version of Linux (RedHat 6.0) generates corefiles that don't
10395 comply with the ELF spec by failing to include the null byte in
10397 if (inote
.namedata
[inote
.namesz
] != '\0')
10399 temp
= malloc (inote
.namesz
+ 1);
10403 error (_("Out of memory\n"));
10408 strncpy (temp
, inote
.namedata
, inote
.namesz
);
10409 temp
[inote
.namesz
] = 0;
10411 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
10412 inote
.namedata
= temp
;
10415 res
&= process_note (& inote
);
10430 process_corefile_note_segments (file
)
10433 Elf_Internal_Phdr
*segment
;
10437 if (! get_program_headers (file
))
10440 for (i
= 0, segment
= program_headers
;
10441 i
< elf_header
.e_phnum
;
10444 if (segment
->p_type
== PT_NOTE
)
10445 res
&= process_corefile_note_segment (file
,
10446 (bfd_vma
) segment
->p_offset
,
10447 (bfd_vma
) segment
->p_filesz
);
10454 process_corefile_contents (file
)
10457 /* If we have not been asked to display the notes then do nothing. */
10461 /* If file is not a core file then exit. */
10462 if (elf_header
.e_type
!= ET_CORE
)
10465 /* No program headers means no NOTE segment. */
10466 if (elf_header
.e_phnum
== 0)
10468 printf (_("No note segments present in the core file.\n"));
10472 return process_corefile_note_segments (file
);
10476 process_arch_specific (file
)
10482 switch (elf_header
.e_machine
)
10485 case EM_MIPS_RS3_LE
:
10486 return process_mips_specific (file
);
10495 get_file_header (file
)
10498 /* Read in the identity array. */
10499 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
10502 /* Determine how to read the rest of the header. */
10503 switch (elf_header
.e_ident
[EI_DATA
])
10505 default: /* fall through */
10506 case ELFDATANONE
: /* fall through */
10508 byte_get
= byte_get_little_endian
;
10509 byte_put
= byte_put_little_endian
;
10512 byte_get
= byte_get_big_endian
;
10513 byte_put
= byte_put_big_endian
;
10517 /* For now we only support 32 bit and 64 bit ELF files. */
10518 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
10520 /* Read in the rest of the header. */
10523 Elf32_External_Ehdr ehdr32
;
10525 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
10528 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
10529 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
10530 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
10531 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
10532 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
10533 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
10534 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
10535 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
10536 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
10537 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
10538 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
10539 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
10540 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
10544 Elf64_External_Ehdr ehdr64
;
10546 /* If we have been compiled with sizeof (bfd_vma) == 4, then
10547 we will not be able to cope with the 64bit data found in
10548 64 ELF files. Detect this now and abort before we start
10549 overwritting things. */
10550 if (sizeof (bfd_vma
) < 8)
10552 error (_("This instance of readelf has been built without support for a\n\
10553 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10557 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
10560 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
10561 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
10562 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
10563 elf_header
.e_entry
= BYTE_GET8 (ehdr64
.e_entry
);
10564 elf_header
.e_phoff
= BYTE_GET8 (ehdr64
.e_phoff
);
10565 elf_header
.e_shoff
= BYTE_GET8 (ehdr64
.e_shoff
);
10566 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
10567 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
10568 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
10569 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
10570 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
10571 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
10572 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
10575 if (elf_header
.e_shoff
)
10577 /* There may be some extensions in the first section header. Don't
10578 bomb if we can't read it. */
10580 get_32bit_section_headers (file
, 1);
10582 get_64bit_section_headers (file
, 1);
10589 process_file (file_name
)
10593 struct stat statbuf
;
10596 if (stat (file_name
, & statbuf
) < 0)
10598 error (_("Cannot stat input file %s.\n"), file_name
);
10602 file
= fopen (file_name
, "rb");
10605 error (_("Input file %s not found.\n"), file_name
);
10609 if (! get_file_header (file
))
10611 error (_("%s: Failed to read file header\n"), file_name
);
10616 /* Initialise per file variables. */
10617 for (i
= NUM_ELEM (version_info
); i
--;)
10618 version_info
[i
] = 0;
10620 for (i
= NUM_ELEM (dynamic_info
); i
--;)
10621 dynamic_info
[i
] = 0;
10623 /* Process the file. */
10625 printf (_("\nFile: %s\n"), file_name
);
10627 if (! process_file_header ())
10633 if (! process_section_headers (file
))
10635 /* Without loaded section headers we
10636 cannot process lots of things. */
10637 do_unwind
= do_version
= do_dump
= do_arch
= 0;
10639 if (! do_using_dynamic
)
10640 do_syms
= do_reloc
= 0;
10643 if (process_program_headers (file
))
10644 process_dynamic_segment (file
);
10646 process_relocs (file
);
10648 process_unwind (file
);
10650 process_symbol_table (file
);
10652 process_syminfo (file
);
10654 process_version_sections (file
);
10656 process_section_contents (file
);
10658 process_corefile_contents (file
);
10660 process_gnu_liblist (file
);
10662 process_arch_specific (file
);
10666 if (program_headers
)
10668 free (program_headers
);
10669 program_headers
= NULL
;
10672 if (section_headers
)
10674 free (section_headers
);
10675 section_headers
= NULL
;
10680 free (string_table
);
10681 string_table
= NULL
;
10682 string_table_length
= 0;
10685 if (dynamic_strings
)
10687 free (dynamic_strings
);
10688 dynamic_strings
= NULL
;
10691 if (dynamic_symbols
)
10693 free (dynamic_symbols
);
10694 dynamic_symbols
= NULL
;
10695 num_dynamic_syms
= 0;
10698 if (dynamic_syminfo
)
10700 free (dynamic_syminfo
);
10701 dynamic_syminfo
= NULL
;
10707 #ifdef SUPPORT_DISASSEMBLY
10708 /* Needed by the i386 disassembler. For extra credit, someone could
10709 fix this so that we insert symbolic addresses here, esp for GOT/PLT
10713 print_address (unsigned int addr
, FILE *outfile
)
10715 fprintf (outfile
,"0x%8.8x", addr
);
10718 /* Needed by the i386 disassembler. */
10720 db_task_printsym (unsigned int addr
)
10722 print_address (addr
, stderr
);
10726 int main
PARAMS ((int, char **));
10734 char *cmdline_dump_sects
= NULL
;
10735 unsigned num_cmdline_dump_sects
= 0;
10737 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
10738 setlocale (LC_MESSAGES
, "");
10740 #if defined (HAVE_SETLOCALE)
10741 setlocale (LC_CTYPE
, "");
10743 bindtextdomain (PACKAGE
, LOCALEDIR
);
10744 textdomain (PACKAGE
);
10746 parse_args (argc
, argv
);
10748 if (optind
< (argc
- 1))
10751 /* When processing more than one file remember the dump requests
10752 issued on command line to reset them after each file. */
10753 if (optind
+ 1 < argc
&& dump_sects
!= NULL
)
10755 cmdline_dump_sects
= malloc (num_dump_sects
);
10756 if (cmdline_dump_sects
== NULL
)
10757 error (_("Out of memory allocating dump request table."));
10760 memcpy (cmdline_dump_sects
, dump_sects
, num_dump_sects
);
10761 num_cmdline_dump_sects
= num_dump_sects
;
10766 while (optind
< argc
)
10768 err
|= process_file (argv
[optind
++]);
10770 /* Reset dump requests. */
10771 if (optind
< argc
&& dump_sects
!= NULL
)
10773 num_dump_sects
= num_cmdline_dump_sects
;
10774 if (num_cmdline_dump_sects
> 0)
10775 memcpy (dump_sects
, cmdline_dump_sects
, num_cmdline_dump_sects
);
10779 if (dump_sects
!= NULL
)
10781 if (cmdline_dump_sects
!= NULL
)
10782 free (cmdline_dump_sects
);