1 /* dwarf.c -- display DWARF contents of a BFD binary file
2 Copyright 2005, 2006, 2007, 2008, 2009, 2010
3 Free Software Foundation, Inc.
5 This file is part of GNU Binutils.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
23 #include "libiberty.h"
26 #include "elf/common.h"
30 static const char *regname (unsigned int regno
, int row
);
32 static int have_frame_base
;
33 static int need_base_address
;
35 static unsigned int last_pointer_size
= 0;
36 static int warned_about_missing_comp_units
= FALSE
;
38 static unsigned int num_debug_info_entries
= 0;
39 static debug_info
*debug_information
= NULL
;
40 /* Special value for num_debug_info_entries to indicate
41 that the .debug_info section could not be loaded/parsed. */
42 #define DEBUG_INFO_UNAVAILABLE (unsigned int) -1
49 int do_debug_pubnames
;
50 int do_debug_pubtypes
;
54 int do_debug_frames_interp
;
63 /* Values for do_debug_lines. */
64 #define FLAG_DEBUG_LINES_RAW 1
65 #define FLAG_DEBUG_LINES_DECODED 2
67 dwarf_vma (*byte_get
) (unsigned char *, int);
70 byte_get_little_endian (unsigned char *field
, int size
)
78 return ((unsigned int) (field
[0]))
79 | (((unsigned int) (field
[1])) << 8);
82 return ((unsigned long) (field
[0]))
83 | (((unsigned long) (field
[1])) << 8)
84 | (((unsigned long) (field
[2])) << 16);
87 return ((unsigned long) (field
[0]))
88 | (((unsigned long) (field
[1])) << 8)
89 | (((unsigned long) (field
[2])) << 16)
90 | (((unsigned long) (field
[3])) << 24);
93 if (sizeof (dwarf_vma
) == 8)
94 return ((dwarf_vma
) (field
[0]))
95 | (((dwarf_vma
) (field
[1])) << 8)
96 | (((dwarf_vma
) (field
[2])) << 16)
97 | (((dwarf_vma
) (field
[3])) << 24)
98 | (((dwarf_vma
) (field
[4])) << 32)
99 | (((dwarf_vma
) (field
[5])) << 40)
100 | (((dwarf_vma
) (field
[6])) << 48)
101 | (((dwarf_vma
) (field
[7])) << 56);
102 else if (sizeof (dwarf_vma
) == 4)
103 /* We want to extract data from an 8 byte wide field and
104 place it into a 4 byte wide field. Since this is a little
105 endian source we can just use the 4 byte extraction code. */
106 return ((unsigned long) (field
[0]))
107 | (((unsigned long) (field
[1])) << 8)
108 | (((unsigned long) (field
[2])) << 16)
109 | (((unsigned long) (field
[3])) << 24);
112 error (_("Unhandled data length: %d\n"), size
);
118 byte_get_big_endian (unsigned char *field
, int size
)
126 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
129 return ((unsigned long) (field
[2]))
130 | (((unsigned long) (field
[1])) << 8)
131 | (((unsigned long) (field
[0])) << 16);
134 return ((unsigned long) (field
[3]))
135 | (((unsigned long) (field
[2])) << 8)
136 | (((unsigned long) (field
[1])) << 16)
137 | (((unsigned long) (field
[0])) << 24);
140 if (sizeof (dwarf_vma
) == 8)
141 return ((dwarf_vma
) (field
[7]))
142 | (((dwarf_vma
) (field
[6])) << 8)
143 | (((dwarf_vma
) (field
[5])) << 16)
144 | (((dwarf_vma
) (field
[4])) << 24)
145 | (((dwarf_vma
) (field
[3])) << 32)
146 | (((dwarf_vma
) (field
[2])) << 40)
147 | (((dwarf_vma
) (field
[1])) << 48)
148 | (((dwarf_vma
) (field
[0])) << 56);
149 else if (sizeof (dwarf_vma
) == 4)
151 /* Although we are extracing data from an 8 byte wide field,
152 we are returning only 4 bytes of data. */
154 return ((unsigned long) (field
[3]))
155 | (((unsigned long) (field
[2])) << 8)
156 | (((unsigned long) (field
[1])) << 16)
157 | (((unsigned long) (field
[0])) << 24);
161 error (_("Unhandled data length: %d\n"), size
);
167 byte_get_signed (unsigned char *field
, int size
)
169 dwarf_vma x
= byte_get (field
, size
);
174 return (x
^ 0x80) - 0x80;
176 return (x
^ 0x8000) - 0x8000;
178 return (x
^ 0x80000000) - 0x80000000;
187 size_of_encoded_value (int encoding
)
189 switch (encoding
& 0x7)
192 case 0: return eh_addr_size
;
200 get_encoded_value (unsigned char *data
, int encoding
)
202 int size
= size_of_encoded_value (encoding
);
204 if (encoding
& DW_EH_PE_signed
)
205 return byte_get_signed (data
, size
);
207 return byte_get (data
, size
);
210 /* Print a dwarf_vma value (typically an address, offset or length) in
211 hexadecimal format, followed by a space. The length of the value (and
212 hence the precision displayed) is determined by the byte_size parameter. */
215 print_dwarf_vma (dwarf_vma val
, unsigned byte_size
)
217 static char buff
[18];
219 /* Printf does not have a way of specifiying a maximum field width for an
220 integer value, so we print the full value into a buffer and then select
221 the precision we need. */
222 #if __STDC_VERSION__ >= 199901L || (defined(__GNUC__) && __GNUC__ >= 2)
224 snprintf (buff
, sizeof (buff
), "%16.16llx ", val
);
226 snprintf (buff
, sizeof (buff
), "%016I64x ", val
);
229 snprintf (buff
, sizeof (buff
), "%16.16lx ", val
);
232 fputs (buff
+ (byte_size
== 4 ? 8 : 0), stdout
);
236 read_leb128 (unsigned char *data
, unsigned int *length_return
, int sign
)
238 unsigned long int result
= 0;
239 unsigned int num_read
= 0;
240 unsigned int shift
= 0;
248 result
|= ((unsigned long int) (byte
& 0x7f)) << shift
;
255 if (length_return
!= NULL
)
256 *length_return
= num_read
;
258 if (sign
&& (shift
< 8 * sizeof (result
)) && (byte
& 0x40))
259 result
|= -1L << shift
;
264 typedef struct State_Machine_Registers
266 unsigned long address
;
272 unsigned char op_index
;
273 unsigned char end_sequence
;
274 /* This variable hold the number of the last entry seen
275 in the File Table. */
276 unsigned int last_file_entry
;
279 static SMR state_machine_regs
;
282 reset_state_machine (int is_stmt
)
284 state_machine_regs
.address
= 0;
285 state_machine_regs
.op_index
= 0;
286 state_machine_regs
.file
= 1;
287 state_machine_regs
.line
= 1;
288 state_machine_regs
.column
= 0;
289 state_machine_regs
.is_stmt
= is_stmt
;
290 state_machine_regs
.basic_block
= 0;
291 state_machine_regs
.end_sequence
= 0;
292 state_machine_regs
.last_file_entry
= 0;
295 /* Handled an extend line op.
296 Returns the number of bytes read. */
299 process_extended_line_op (unsigned char *data
, int is_stmt
)
301 unsigned char op_code
;
302 unsigned int bytes_read
;
307 len
= read_leb128 (data
, & bytes_read
, 0);
312 warn (_("badly formed extended line op encountered!\n"));
319 printf (_(" Extended opcode %d: "), op_code
);
323 case DW_LNE_end_sequence
:
324 printf (_("End of Sequence\n\n"));
325 reset_state_machine (is_stmt
);
328 case DW_LNE_set_address
:
329 adr
= byte_get (data
, len
- bytes_read
- 1);
330 printf (_("set Address to 0x%lx\n"), adr
);
331 state_machine_regs
.address
= adr
;
332 state_machine_regs
.op_index
= 0;
335 case DW_LNE_define_file
:
336 printf (_(" define new File Table entry\n"));
337 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
339 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
341 data
+= strlen ((char *) data
) + 1;
342 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
344 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
346 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
347 printf (_("%s\n\n"), name
);
350 case DW_LNE_set_discriminator
:
351 printf (_("set Discriminator to %lu\n"),
352 read_leb128 (data
, & bytes_read
, 0));
356 case DW_LNE_HP_negate_is_UV_update
:
357 printf ("DW_LNE_HP_negate_is_UV_update\n");
359 case DW_LNE_HP_push_context
:
360 printf ("DW_LNE_HP_push_context\n");
362 case DW_LNE_HP_pop_context
:
363 printf ("DW_LNE_HP_pop_context\n");
365 case DW_LNE_HP_set_file_line_column
:
366 printf ("DW_LNE_HP_set_file_line_column\n");
368 case DW_LNE_HP_set_routine_name
:
369 printf ("DW_LNE_HP_set_routine_name\n");
371 case DW_LNE_HP_set_sequence
:
372 printf ("DW_LNE_HP_set_sequence\n");
374 case DW_LNE_HP_negate_post_semantics
:
375 printf ("DW_LNE_HP_negate_post_semantics\n");
377 case DW_LNE_HP_negate_function_exit
:
378 printf ("DW_LNE_HP_negate_function_exit\n");
380 case DW_LNE_HP_negate_front_end_logical
:
381 printf ("DW_LNE_HP_negate_front_end_logical\n");
383 case DW_LNE_HP_define_proc
:
384 printf ("DW_LNE_HP_define_proc\n");
388 if (op_code
>= DW_LNE_lo_user
389 /* The test against DW_LNW_hi_user is redundant due to
390 the limited range of the unsigned char data type used
392 /*&& op_code <= DW_LNE_hi_user*/)
393 printf (_("user defined: length %d\n"), len
- bytes_read
);
395 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
403 fetch_indirect_string (unsigned long offset
)
405 struct dwarf_section
*section
= &debug_displays
[str
].section
;
407 if (section
->start
== NULL
)
408 return _("<no .debug_str section>");
410 /* DWARF sections under Mach-O have non-zero addresses. */
411 offset
-= section
->address
;
412 if (offset
> section
->size
)
414 warn (_("DW_FORM_strp offset too big: %lx\n"), offset
);
415 return _("<offset is too big>");
418 return (const char *) section
->start
+ offset
;
421 /* FIXME: There are better and more efficient ways to handle
422 these structures. For now though, I just want something that
423 is simple to implement. */
424 typedef struct abbrev_attr
426 unsigned long attribute
;
428 struct abbrev_attr
*next
;
432 typedef struct abbrev_entry
437 struct abbrev_attr
*first_attr
;
438 struct abbrev_attr
*last_attr
;
439 struct abbrev_entry
*next
;
443 static abbrev_entry
*first_abbrev
= NULL
;
444 static abbrev_entry
*last_abbrev
= NULL
;
451 for (abbrv
= first_abbrev
; abbrv
;)
453 abbrev_entry
*next_abbrev
= abbrv
->next
;
456 for (attr
= abbrv
->first_attr
; attr
;)
458 abbrev_attr
*next_attr
= attr
->next
;
468 last_abbrev
= first_abbrev
= NULL
;
472 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
476 entry
= (abbrev_entry
*) malloc (sizeof (*entry
));
482 entry
->entry
= number
;
484 entry
->children
= children
;
485 entry
->first_attr
= NULL
;
486 entry
->last_attr
= NULL
;
489 if (first_abbrev
== NULL
)
490 first_abbrev
= entry
;
492 last_abbrev
->next
= entry
;
498 add_abbrev_attr (unsigned long attribute
, unsigned long form
)
502 attr
= (abbrev_attr
*) malloc (sizeof (*attr
));
508 attr
->attribute
= attribute
;
512 if (last_abbrev
->first_attr
== NULL
)
513 last_abbrev
->first_attr
= attr
;
515 last_abbrev
->last_attr
->next
= attr
;
517 last_abbrev
->last_attr
= attr
;
520 /* Processes the (partial) contents of a .debug_abbrev section.
521 Returns NULL if the end of the section was encountered.
522 Returns the address after the last byte read if the end of
523 an abbreviation set was found. */
525 static unsigned char *
526 process_abbrev_section (unsigned char *start
, unsigned char *end
)
528 if (first_abbrev
!= NULL
)
533 unsigned int bytes_read
;
536 unsigned long attribute
;
539 entry
= read_leb128 (start
, & bytes_read
, 0);
542 /* A single zero is supposed to end the section according
543 to the standard. If there's more, then signal that to
546 return start
== end
? NULL
: start
;
548 tag
= read_leb128 (start
, & bytes_read
, 0);
553 add_abbrev (entry
, tag
, children
);
559 attribute
= read_leb128 (start
, & bytes_read
, 0);
562 form
= read_leb128 (start
, & bytes_read
, 0);
566 add_abbrev_attr (attribute
, form
);
568 while (attribute
!= 0);
575 get_TAG_name (unsigned long tag
)
579 case DW_TAG_padding
: return "DW_TAG_padding";
580 case DW_TAG_array_type
: return "DW_TAG_array_type";
581 case DW_TAG_class_type
: return "DW_TAG_class_type";
582 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
583 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
584 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
585 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
586 case DW_TAG_label
: return "DW_TAG_label";
587 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
588 case DW_TAG_member
: return "DW_TAG_member";
589 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
590 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
591 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
592 case DW_TAG_string_type
: return "DW_TAG_string_type";
593 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
594 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
595 case DW_TAG_typedef
: return "DW_TAG_typedef";
596 case DW_TAG_union_type
: return "DW_TAG_union_type";
597 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
598 case DW_TAG_variant
: return "DW_TAG_variant";
599 case DW_TAG_common_block
: return "DW_TAG_common_block";
600 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
601 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
602 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
603 case DW_TAG_module
: return "DW_TAG_module";
604 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
605 case DW_TAG_set_type
: return "DW_TAG_set_type";
606 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
607 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
608 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
609 case DW_TAG_base_type
: return "DW_TAG_base_type";
610 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
611 case DW_TAG_const_type
: return "DW_TAG_const_type";
612 case DW_TAG_constant
: return "DW_TAG_constant";
613 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
614 case DW_TAG_file_type
: return "DW_TAG_file_type";
615 case DW_TAG_friend
: return "DW_TAG_friend";
616 case DW_TAG_namelist
: return "DW_TAG_namelist";
617 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
618 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
619 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
620 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
621 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
622 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
623 case DW_TAG_try_block
: return "DW_TAG_try_block";
624 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
625 case DW_TAG_variable
: return "DW_TAG_variable";
626 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
627 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
628 case DW_TAG_format_label
: return "DW_TAG_format_label";
629 case DW_TAG_function_template
: return "DW_TAG_function_template";
630 case DW_TAG_class_template
: return "DW_TAG_class_template";
631 /* DWARF 2.1 values. */
632 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
633 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
634 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
635 case DW_TAG_namespace
: return "DW_TAG_namespace";
636 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
637 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
638 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
639 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
640 case DW_TAG_condition
: return "DW_TAG_condition";
641 case DW_TAG_shared_type
: return "DW_TAG_shared_type";
642 /* DWARF 4 values. */
643 case DW_TAG_type_unit
: return "DW_TAG_type_unit";
644 case DW_TAG_rvalue_reference_type
: return "DW_TAG_rvalue_reference_type";
645 case DW_TAG_template_alias
: return "DW_TAG_template_alias";
647 case DW_TAG_upc_shared_type
: return "DW_TAG_upc_shared_type";
648 case DW_TAG_upc_strict_type
: return "DW_TAG_upc_strict_type";
649 case DW_TAG_upc_relaxed_type
: return "DW_TAG_upc_relaxed_type";
652 static char buffer
[100];
654 snprintf (buffer
, sizeof (buffer
), _("Unknown TAG value: %lx"), tag
);
661 get_FORM_name (unsigned long form
)
665 case DW_FORM_addr
: return "DW_FORM_addr";
666 case DW_FORM_block2
: return "DW_FORM_block2";
667 case DW_FORM_block4
: return "DW_FORM_block4";
668 case DW_FORM_data2
: return "DW_FORM_data2";
669 case DW_FORM_data4
: return "DW_FORM_data4";
670 case DW_FORM_data8
: return "DW_FORM_data8";
671 case DW_FORM_string
: return "DW_FORM_string";
672 case DW_FORM_block
: return "DW_FORM_block";
673 case DW_FORM_block1
: return "DW_FORM_block1";
674 case DW_FORM_data1
: return "DW_FORM_data1";
675 case DW_FORM_flag
: return "DW_FORM_flag";
676 case DW_FORM_sdata
: return "DW_FORM_sdata";
677 case DW_FORM_strp
: return "DW_FORM_strp";
678 case DW_FORM_udata
: return "DW_FORM_udata";
679 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
680 case DW_FORM_ref1
: return "DW_FORM_ref1";
681 case DW_FORM_ref2
: return "DW_FORM_ref2";
682 case DW_FORM_ref4
: return "DW_FORM_ref4";
683 case DW_FORM_ref8
: return "DW_FORM_ref8";
684 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
685 case DW_FORM_indirect
: return "DW_FORM_indirect";
686 /* DWARF 4 values. */
687 case DW_FORM_sec_offset
: return "DW_FORM_sec_offset";
688 case DW_FORM_exprloc
: return "DW_FORM_exprloc";
689 case DW_FORM_flag_present
: return "DW_FORM_flag_present";
690 case DW_FORM_ref_sig8
: return "DW_FORM_ref_sig8";
693 static char buffer
[100];
695 snprintf (buffer
, sizeof (buffer
), _("Unknown FORM value: %lx"), form
);
701 static unsigned char *
702 display_block (unsigned char *data
, unsigned long length
)
704 printf (_(" %lu byte block: "), length
);
707 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
713 decode_location_expression (unsigned char * data
,
714 unsigned int pointer_size
,
715 unsigned long length
,
716 unsigned long cu_offset
,
717 struct dwarf_section
* section
)
720 unsigned int bytes_read
;
721 unsigned long uvalue
;
722 unsigned char *end
= data
+ length
;
723 int need_frame_base
= 0;
732 printf ("DW_OP_addr: %lx",
733 (unsigned long) byte_get (data
, pointer_size
));
734 data
+= pointer_size
;
737 printf ("DW_OP_deref");
740 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
743 printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data
++, 1));
746 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
750 printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data
, 2));
754 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
758 printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data
, 4));
762 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
763 (unsigned long) byte_get (data
+ 4, 4));
767 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
768 (long) byte_get (data
+ 4, 4));
772 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
776 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
780 printf ("DW_OP_dup");
783 printf ("DW_OP_drop");
786 printf ("DW_OP_over");
789 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
792 printf ("DW_OP_swap");
795 printf ("DW_OP_rot");
798 printf ("DW_OP_xderef");
801 printf ("DW_OP_abs");
804 printf ("DW_OP_and");
807 printf ("DW_OP_div");
810 printf ("DW_OP_minus");
813 printf ("DW_OP_mod");
816 printf ("DW_OP_mul");
819 printf ("DW_OP_neg");
822 printf ("DW_OP_not");
828 printf ("DW_OP_plus");
830 case DW_OP_plus_uconst
:
831 printf ("DW_OP_plus_uconst: %lu",
832 read_leb128 (data
, &bytes_read
, 0));
836 printf ("DW_OP_shl");
839 printf ("DW_OP_shr");
842 printf ("DW_OP_shra");
845 printf ("DW_OP_xor");
848 printf ("DW_OP_bra: %ld", (long) byte_get_signed (data
, 2));
870 printf ("DW_OP_skip: %ld", (long) byte_get_signed (data
, 2));
906 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
941 printf ("DW_OP_reg%d (%s)", op
- DW_OP_reg0
,
942 regname (op
- DW_OP_reg0
, 1));
977 printf ("DW_OP_breg%d (%s): %ld", op
- DW_OP_breg0
,
978 regname (op
- DW_OP_breg0
, 1),
979 read_leb128 (data
, &bytes_read
, 1));
984 uvalue
= read_leb128 (data
, &bytes_read
, 0);
986 printf ("DW_OP_regx: %lu (%s)", uvalue
, regname (uvalue
, 1));
990 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
994 uvalue
= read_leb128 (data
, &bytes_read
, 0);
996 printf ("DW_OP_bregx: %lu (%s) %ld", uvalue
, regname (uvalue
, 1),
997 read_leb128 (data
, &bytes_read
, 1));
1001 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
1004 case DW_OP_deref_size
:
1005 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
1007 case DW_OP_xderef_size
:
1008 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
1011 printf ("DW_OP_nop");
1014 /* DWARF 3 extensions. */
1015 case DW_OP_push_object_address
:
1016 printf ("DW_OP_push_object_address");
1019 /* XXX: Strictly speaking for 64-bit DWARF3 files
1020 this ought to be an 8-byte wide computation. */
1021 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2) + cu_offset
);
1025 /* XXX: Strictly speaking for 64-bit DWARF3 files
1026 this ought to be an 8-byte wide computation. */
1027 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4) + cu_offset
);
1030 case DW_OP_call_ref
:
1031 /* XXX: Strictly speaking for 64-bit DWARF3 files
1032 this ought to be an 8-byte wide computation. */
1033 printf ("DW_OP_call_ref: <%lx>", (long) byte_get (data
, 4) + cu_offset
);
1036 case DW_OP_form_tls_address
:
1037 printf ("DW_OP_form_tls_address");
1039 case DW_OP_call_frame_cfa
:
1040 printf ("DW_OP_call_frame_cfa");
1042 case DW_OP_bit_piece
:
1043 printf ("DW_OP_bit_piece: ");
1044 printf ("size: %lu ", read_leb128 (data
, &bytes_read
, 0));
1046 printf ("offset: %lu ", read_leb128 (data
, &bytes_read
, 0));
1050 /* DWARF 4 extensions. */
1051 case DW_OP_stack_value
:
1052 printf ("DW_OP_stack_value");
1055 case DW_OP_implicit_value
:
1056 printf ("DW_OP_implicit_value");
1057 uvalue
= read_leb128 (data
, &bytes_read
, 0);
1059 display_block (data
, uvalue
);
1063 /* GNU extensions. */
1064 case DW_OP_GNU_push_tls_address
:
1065 printf ("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown");
1067 case DW_OP_GNU_uninit
:
1068 printf ("DW_OP_GNU_uninit");
1069 /* FIXME: Is there data associated with this OP ? */
1071 case DW_OP_GNU_encoded_addr
:
1077 addr
= get_encoded_value (data
, encoding
);
1078 if ((encoding
& 0x70) == DW_EH_PE_pcrel
)
1079 addr
+= section
->address
+ (data
- section
->start
);
1080 data
+= size_of_encoded_value (encoding
);
1082 printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding
);
1083 print_dwarf_vma (addr
, pointer_size
);
1087 /* HP extensions. */
1088 case DW_OP_HP_is_value
:
1089 printf ("DW_OP_HP_is_value");
1090 /* FIXME: Is there data associated with this OP ? */
1092 case DW_OP_HP_fltconst4
:
1093 printf ("DW_OP_HP_fltconst4");
1094 /* FIXME: Is there data associated with this OP ? */
1096 case DW_OP_HP_fltconst8
:
1097 printf ("DW_OP_HP_fltconst8");
1098 /* FIXME: Is there data associated with this OP ? */
1100 case DW_OP_HP_mod_range
:
1101 printf ("DW_OP_HP_mod_range");
1102 /* FIXME: Is there data associated with this OP ? */
1104 case DW_OP_HP_unmod_range
:
1105 printf ("DW_OP_HP_unmod_range");
1106 /* FIXME: Is there data associated with this OP ? */
1109 printf ("DW_OP_HP_tls");
1110 /* FIXME: Is there data associated with this OP ? */
1113 /* PGI (STMicroelectronics) extensions. */
1114 case DW_OP_PGI_omp_thread_num
:
1115 /* Pushes the thread number for the current thread as it would be
1116 returned by the standard OpenMP library function:
1117 omp_get_thread_num(). The "current thread" is the thread for
1118 which the expression is being evaluated. */
1119 printf ("DW_OP_PGI_omp_thread_num");
1123 if (op
>= DW_OP_lo_user
1124 && op
<= DW_OP_hi_user
)
1125 printf (_("(User defined location op)"));
1127 printf (_("(Unknown location op)"));
1128 /* No way to tell where the next op is, so just bail. */
1129 return need_frame_base
;
1132 /* Separate the ops. */
1137 return need_frame_base
;
1140 static unsigned char *
1141 read_and_display_attr_value (unsigned long attribute
,
1143 unsigned char * data
,
1144 unsigned long cu_offset
,
1145 unsigned long pointer_size
,
1146 unsigned long offset_size
,
1148 debug_info
* debug_info_p
,
1150 struct dwarf_section
* section
)
1152 unsigned long uvalue
= 0;
1153 unsigned char *block_start
= NULL
;
1154 unsigned char * orig_data
= data
;
1155 unsigned int bytes_read
;
1162 case DW_FORM_ref_addr
:
1163 if (dwarf_version
== 2)
1165 uvalue
= byte_get (data
, pointer_size
);
1166 data
+= pointer_size
;
1168 else if (dwarf_version
== 3 || dwarf_version
== 4)
1170 uvalue
= byte_get (data
, offset_size
);
1171 data
+= offset_size
;
1175 error (_("Internal error: DWARF version is not 2, 3 or 4.\n"));
1180 uvalue
= byte_get (data
, pointer_size
);
1181 data
+= pointer_size
;
1185 case DW_FORM_sec_offset
:
1186 uvalue
= byte_get (data
, offset_size
);
1187 data
+= offset_size
;
1190 case DW_FORM_flag_present
:
1197 uvalue
= byte_get (data
++, 1);
1202 uvalue
= byte_get (data
, 2);
1208 uvalue
= byte_get (data
, 4);
1213 uvalue
= read_leb128 (data
, & bytes_read
, 1);
1217 case DW_FORM_ref_udata
:
1219 uvalue
= read_leb128 (data
, & bytes_read
, 0);
1223 case DW_FORM_indirect
:
1224 form
= read_leb128 (data
, & bytes_read
, 0);
1227 printf (" %s", get_FORM_name (form
));
1228 return read_and_display_attr_value (attribute
, form
, data
,
1229 cu_offset
, pointer_size
,
1230 offset_size
, dwarf_version
,
1231 debug_info_p
, do_loc
,
1237 case DW_FORM_ref_addr
:
1239 printf (" <0x%lx>", uvalue
);
1245 case DW_FORM_ref_udata
:
1247 printf (" <0x%lx>", uvalue
+ cu_offset
);
1252 case DW_FORM_sec_offset
:
1254 printf (" 0x%lx", uvalue
);
1257 case DW_FORM_flag_present
:
1264 printf (" %ld", uvalue
);
1271 uvalue
= byte_get (data
, 4);
1272 printf (" 0x%lx", uvalue
);
1273 printf (" 0x%lx", (unsigned long) byte_get (data
+ 4, 4));
1275 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1276 && num_debug_info_entries
== 0)
1278 if (sizeof (uvalue
) == 8)
1279 uvalue
= byte_get (data
, 8);
1281 error (_("DW_FORM_data8 is unsupported when sizeof (unsigned long) != 8\n"));
1286 case DW_FORM_string
:
1288 printf (" %s", data
);
1289 data
+= strlen ((char *) data
) + 1;
1293 case DW_FORM_exprloc
:
1294 uvalue
= read_leb128 (data
, & bytes_read
, 0);
1295 block_start
= data
+ bytes_read
;
1297 data
= block_start
+ uvalue
;
1299 data
= display_block (block_start
, uvalue
);
1302 case DW_FORM_block1
:
1303 uvalue
= byte_get (data
, 1);
1304 block_start
= data
+ 1;
1306 data
= block_start
+ uvalue
;
1308 data
= display_block (block_start
, uvalue
);
1311 case DW_FORM_block2
:
1312 uvalue
= byte_get (data
, 2);
1313 block_start
= data
+ 2;
1315 data
= block_start
+ uvalue
;
1317 data
= display_block (block_start
, uvalue
);
1320 case DW_FORM_block4
:
1321 uvalue
= byte_get (data
, 4);
1322 block_start
= data
+ 4;
1324 data
= block_start
+ uvalue
;
1326 data
= display_block (block_start
, uvalue
);
1331 printf (_(" (indirect string, offset: 0x%lx): %s"),
1332 uvalue
, fetch_indirect_string (uvalue
));
1335 case DW_FORM_indirect
:
1336 /* Handled above. */
1339 case DW_FORM_ref_sig8
:
1343 printf (" signature: ");
1344 for (i
= 0; i
< 8; i
++)
1346 printf ("%02x", (unsigned) byte_get (data
, 1));
1355 warn (_("Unrecognized form: %lu\n"), form
);
1359 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1360 && num_debug_info_entries
== 0)
1364 case DW_AT_frame_base
:
1365 have_frame_base
= 1;
1366 case DW_AT_location
:
1367 case DW_AT_string_length
:
1368 case DW_AT_return_addr
:
1369 case DW_AT_data_member_location
:
1370 case DW_AT_vtable_elem_location
:
1372 case DW_AT_static_link
:
1373 case DW_AT_use_location
:
1374 if (form
== DW_FORM_data4
1375 || form
== DW_FORM_data8
1376 || form
== DW_FORM_sec_offset
)
1378 /* Process location list. */
1379 unsigned int lmax
= debug_info_p
->max_loc_offsets
;
1380 unsigned int num
= debug_info_p
->num_loc_offsets
;
1382 if (lmax
== 0 || num
>= lmax
)
1385 debug_info_p
->loc_offsets
= (long unsigned int *)
1386 xcrealloc (debug_info_p
->loc_offsets
,
1387 lmax
, sizeof (*debug_info_p
->loc_offsets
));
1388 debug_info_p
->have_frame_base
= (int *)
1389 xcrealloc (debug_info_p
->have_frame_base
,
1390 lmax
, sizeof (*debug_info_p
->have_frame_base
));
1391 debug_info_p
->max_loc_offsets
= lmax
;
1393 debug_info_p
->loc_offsets
[num
] = uvalue
;
1394 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
1395 debug_info_p
->num_loc_offsets
++;
1400 if (need_base_address
)
1401 debug_info_p
->base_address
= uvalue
;
1405 if (form
== DW_FORM_data4
1406 || form
== DW_FORM_data8
1407 || form
== DW_FORM_sec_offset
)
1409 /* Process range list. */
1410 unsigned int lmax
= debug_info_p
->max_range_lists
;
1411 unsigned int num
= debug_info_p
->num_range_lists
;
1413 if (lmax
== 0 || num
>= lmax
)
1416 debug_info_p
->range_lists
= (long unsigned int *)
1417 xcrealloc (debug_info_p
->range_lists
,
1418 lmax
, sizeof (*debug_info_p
->range_lists
));
1419 debug_info_p
->max_range_lists
= lmax
;
1421 debug_info_p
->range_lists
[num
] = uvalue
;
1422 debug_info_p
->num_range_lists
++;
1434 /* For some attributes we can display further information. */
1442 case DW_INL_not_inlined
:
1443 printf (_("(not inlined)"));
1445 case DW_INL_inlined
:
1446 printf (_("(inlined)"));
1448 case DW_INL_declared_not_inlined
:
1449 printf (_("(declared as inline but ignored)"));
1451 case DW_INL_declared_inlined
:
1452 printf (_("(declared as inline and inlined)"));
1455 printf (_(" (Unknown inline attribute value: %lx)"), uvalue
);
1460 case DW_AT_language
:
1463 /* Ordered by the numeric value of these constants. */
1464 case DW_LANG_C89
: printf ("(ANSI C)"); break;
1465 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
1466 case DW_LANG_Ada83
: printf ("(Ada)"); break;
1467 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
1468 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
1469 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
1470 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
1471 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
1472 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
1473 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
1474 /* DWARF 2.1 values. */
1475 case DW_LANG_Java
: printf ("(Java)"); break;
1476 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
1477 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
1478 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
1479 /* DWARF 3 values. */
1480 case DW_LANG_PLI
: printf ("(PLI)"); break;
1481 case DW_LANG_ObjC
: printf ("(Objective C)"); break;
1482 case DW_LANG_ObjC_plus_plus
: printf ("(Objective C++)"); break;
1483 case DW_LANG_UPC
: printf ("(Unified Parallel C)"); break;
1484 case DW_LANG_D
: printf ("(D)"); break;
1485 /* DWARF 4 values. */
1486 case DW_LANG_Python
: printf ("(Python)"); break;
1487 /* MIPS extension. */
1488 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
1489 /* UPC extension. */
1490 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
1492 if (uvalue
>= DW_LANG_lo_user
&& uvalue
<= DW_LANG_hi_user
)
1493 printf ("(implementation defined: %lx)", uvalue
);
1495 printf ("(Unknown: %lx)", uvalue
);
1500 case DW_AT_encoding
:
1503 case DW_ATE_void
: printf ("(void)"); break;
1504 case DW_ATE_address
: printf ("(machine address)"); break;
1505 case DW_ATE_boolean
: printf ("(boolean)"); break;
1506 case DW_ATE_complex_float
: printf ("(complex float)"); break;
1507 case DW_ATE_float
: printf ("(float)"); break;
1508 case DW_ATE_signed
: printf ("(signed)"); break;
1509 case DW_ATE_signed_char
: printf ("(signed char)"); break;
1510 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
1511 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
1512 /* DWARF 2.1 values: */
1513 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
1514 case DW_ATE_decimal_float
: printf ("(decimal float)"); break;
1515 /* DWARF 3 values: */
1516 case DW_ATE_packed_decimal
: printf ("(packed_decimal)"); break;
1517 case DW_ATE_numeric_string
: printf ("(numeric_string)"); break;
1518 case DW_ATE_edited
: printf ("(edited)"); break;
1519 case DW_ATE_signed_fixed
: printf ("(signed_fixed)"); break;
1520 case DW_ATE_unsigned_fixed
: printf ("(unsigned_fixed)"); break;
1521 /* HP extensions: */
1522 case DW_ATE_HP_float80
: printf ("(HP_float80)"); break;
1523 case DW_ATE_HP_complex_float80
: printf ("(HP_complex_float80)"); break;
1524 case DW_ATE_HP_float128
: printf ("(HP_float128)"); break;
1525 case DW_ATE_HP_complex_float128
:printf ("(HP_complex_float128)"); break;
1526 case DW_ATE_HP_floathpintel
: printf ("(HP_floathpintel)"); break;
1527 case DW_ATE_HP_imaginary_float80
: printf ("(HP_imaginary_float80)"); break;
1528 case DW_ATE_HP_imaginary_float128
: printf ("(HP_imaginary_float128)"); break;
1531 if (uvalue
>= DW_ATE_lo_user
1532 && uvalue
<= DW_ATE_hi_user
)
1533 printf ("(user defined type)");
1535 printf ("(unknown type)");
1540 case DW_AT_accessibility
:
1543 case DW_ACCESS_public
: printf ("(public)"); break;
1544 case DW_ACCESS_protected
: printf ("(protected)"); break;
1545 case DW_ACCESS_private
: printf ("(private)"); break;
1547 printf ("(unknown accessibility)");
1552 case DW_AT_visibility
:
1555 case DW_VIS_local
: printf ("(local)"); break;
1556 case DW_VIS_exported
: printf ("(exported)"); break;
1557 case DW_VIS_qualified
: printf ("(qualified)"); break;
1558 default: printf ("(unknown visibility)"); break;
1562 case DW_AT_virtuality
:
1565 case DW_VIRTUALITY_none
: printf ("(none)"); break;
1566 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
1567 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
1568 default: printf ("(unknown virtuality)"); break;
1572 case DW_AT_identifier_case
:
1575 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
1576 case DW_ID_up_case
: printf ("(up_case)"); break;
1577 case DW_ID_down_case
: printf ("(down_case)"); break;
1578 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
1579 default: printf ("(unknown case)"); break;
1583 case DW_AT_calling_convention
:
1586 case DW_CC_normal
: printf ("(normal)"); break;
1587 case DW_CC_program
: printf ("(program)"); break;
1588 case DW_CC_nocall
: printf ("(nocall)"); break;
1590 if (uvalue
>= DW_CC_lo_user
1591 && uvalue
<= DW_CC_hi_user
)
1592 printf ("(user defined)");
1594 printf ("(unknown convention)");
1598 case DW_AT_ordering
:
1601 case -1: printf ("(undefined)"); break;
1602 case 0: printf ("(row major)"); break;
1603 case 1: printf ("(column major)"); break;
1607 case DW_AT_frame_base
:
1608 have_frame_base
= 1;
1609 case DW_AT_location
:
1610 case DW_AT_string_length
:
1611 case DW_AT_return_addr
:
1612 case DW_AT_data_member_location
:
1613 case DW_AT_vtable_elem_location
:
1615 case DW_AT_static_link
:
1616 case DW_AT_use_location
:
1617 if (form
== DW_FORM_data4
1618 || form
== DW_FORM_data8
1619 || form
== DW_FORM_sec_offset
)
1620 printf (_("(location list)"));
1622 case DW_AT_allocated
:
1623 case DW_AT_associated
:
1624 case DW_AT_data_location
:
1626 case DW_AT_upper_bound
:
1627 case DW_AT_lower_bound
:
1630 int need_frame_base
;
1633 need_frame_base
= decode_location_expression (block_start
,
1636 cu_offset
, section
);
1638 if (need_frame_base
&& !have_frame_base
)
1639 printf (_(" [without DW_AT_frame_base]"));
1645 if (form
== DW_FORM_ref_sig8
)
1648 if (form
== DW_FORM_ref1
1649 || form
== DW_FORM_ref2
1650 || form
== DW_FORM_ref4
)
1651 uvalue
+= cu_offset
;
1653 if (uvalue
>= section
->size
)
1654 warn (_("Offset %lx used as value for DW_AT_import attribute of DIE at offset %lx is too big.\n"),
1655 uvalue
, (unsigned long) (orig_data
- section
->start
));
1658 unsigned long abbrev_number
;
1659 abbrev_entry
* entry
;
1661 abbrev_number
= read_leb128 (section
->start
+ uvalue
, NULL
, 0);
1663 printf ("[Abbrev Number: %ld", abbrev_number
);
1664 for (entry
= first_abbrev
; entry
!= NULL
; entry
= entry
->next
)
1665 if (entry
->entry
== abbrev_number
)
1668 printf (" (%s)", get_TAG_name (entry
->tag
));
1682 get_AT_name (unsigned long attribute
)
1686 case DW_AT_sibling
: return "DW_AT_sibling";
1687 case DW_AT_location
: return "DW_AT_location";
1688 case DW_AT_name
: return "DW_AT_name";
1689 case DW_AT_ordering
: return "DW_AT_ordering";
1690 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
1691 case DW_AT_byte_size
: return "DW_AT_byte_size";
1692 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
1693 case DW_AT_bit_size
: return "DW_AT_bit_size";
1694 case DW_AT_element_list
: return "DW_AT_element_list";
1695 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
1696 case DW_AT_low_pc
: return "DW_AT_low_pc";
1697 case DW_AT_high_pc
: return "DW_AT_high_pc";
1698 case DW_AT_language
: return "DW_AT_language";
1699 case DW_AT_member
: return "DW_AT_member";
1700 case DW_AT_discr
: return "DW_AT_discr";
1701 case DW_AT_discr_value
: return "DW_AT_discr_value";
1702 case DW_AT_visibility
: return "DW_AT_visibility";
1703 case DW_AT_import
: return "DW_AT_import";
1704 case DW_AT_string_length
: return "DW_AT_string_length";
1705 case DW_AT_common_reference
: return "DW_AT_common_reference";
1706 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
1707 case DW_AT_const_value
: return "DW_AT_const_value";
1708 case DW_AT_containing_type
: return "DW_AT_containing_type";
1709 case DW_AT_default_value
: return "DW_AT_default_value";
1710 case DW_AT_inline
: return "DW_AT_inline";
1711 case DW_AT_is_optional
: return "DW_AT_is_optional";
1712 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
1713 case DW_AT_producer
: return "DW_AT_producer";
1714 case DW_AT_prototyped
: return "DW_AT_prototyped";
1715 case DW_AT_return_addr
: return "DW_AT_return_addr";
1716 case DW_AT_start_scope
: return "DW_AT_start_scope";
1717 case DW_AT_stride_size
: return "DW_AT_stride_size";
1718 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
1719 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
1720 case DW_AT_accessibility
: return "DW_AT_accessibility";
1721 case DW_AT_address_class
: return "DW_AT_address_class";
1722 case DW_AT_artificial
: return "DW_AT_artificial";
1723 case DW_AT_base_types
: return "DW_AT_base_types";
1724 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
1725 case DW_AT_count
: return "DW_AT_count";
1726 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
1727 case DW_AT_decl_column
: return "DW_AT_decl_column";
1728 case DW_AT_decl_file
: return "DW_AT_decl_file";
1729 case DW_AT_decl_line
: return "DW_AT_decl_line";
1730 case DW_AT_declaration
: return "DW_AT_declaration";
1731 case DW_AT_discr_list
: return "DW_AT_discr_list";
1732 case DW_AT_encoding
: return "DW_AT_encoding";
1733 case DW_AT_external
: return "DW_AT_external";
1734 case DW_AT_frame_base
: return "DW_AT_frame_base";
1735 case DW_AT_friend
: return "DW_AT_friend";
1736 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
1737 case DW_AT_macro_info
: return "DW_AT_macro_info";
1738 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
1739 case DW_AT_priority
: return "DW_AT_priority";
1740 case DW_AT_segment
: return "DW_AT_segment";
1741 case DW_AT_specification
: return "DW_AT_specification";
1742 case DW_AT_static_link
: return "DW_AT_static_link";
1743 case DW_AT_type
: return "DW_AT_type";
1744 case DW_AT_use_location
: return "DW_AT_use_location";
1745 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
1746 case DW_AT_virtuality
: return "DW_AT_virtuality";
1747 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
1748 /* DWARF 2.1 values. */
1749 case DW_AT_allocated
: return "DW_AT_allocated";
1750 case DW_AT_associated
: return "DW_AT_associated";
1751 case DW_AT_data_location
: return "DW_AT_data_location";
1752 case DW_AT_stride
: return "DW_AT_stride";
1753 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
1754 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
1755 case DW_AT_extension
: return "DW_AT_extension";
1756 case DW_AT_ranges
: return "DW_AT_ranges";
1757 case DW_AT_trampoline
: return "DW_AT_trampoline";
1758 case DW_AT_call_column
: return "DW_AT_call_column";
1759 case DW_AT_call_file
: return "DW_AT_call_file";
1760 case DW_AT_call_line
: return "DW_AT_call_line";
1761 case DW_AT_description
: return "DW_AT_description";
1762 case DW_AT_binary_scale
: return "DW_AT_binary_scale";
1763 case DW_AT_decimal_scale
: return "DW_AT_decimal_scale";
1764 case DW_AT_small
: return "DW_AT_small";
1765 case DW_AT_decimal_sign
: return "DW_AT_decimal_sign";
1766 case DW_AT_digit_count
: return "DW_AT_digit_count";
1767 case DW_AT_picture_string
: return "DW_AT_picture_string";
1768 case DW_AT_mutable
: return "DW_AT_mutable";
1769 case DW_AT_threads_scaled
: return "DW_AT_threads_scaled";
1770 case DW_AT_explicit
: return "DW_AT_explicit";
1771 case DW_AT_object_pointer
: return "DW_AT_object_pointer";
1772 case DW_AT_endianity
: return "DW_AT_endianity";
1773 case DW_AT_elemental
: return "DW_AT_elemental";
1774 case DW_AT_pure
: return "DW_AT_pure";
1775 case DW_AT_recursive
: return "DW_AT_recursive";
1776 /* DWARF 4 values. */
1777 case DW_AT_signature
: return "DW_AT_signature";
1778 case DW_AT_main_subprogram
: return "DW_AT_main_subprogram";
1779 case DW_AT_data_bit_offset
: return "DW_AT_data_bit_offset";
1780 case DW_AT_const_expr
: return "DW_AT_const_expr";
1781 case DW_AT_enum_class
: return "DW_AT_enum_class";
1782 case DW_AT_linkage_name
: return "DW_AT_linkage_name";
1784 /* HP and SGI/MIPS extensions. */
1785 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
1786 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
1787 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
1788 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
1789 case DW_AT_MIPS_software_pipeline_depth
: return "DW_AT_MIPS_software_pipeline_depth";
1790 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
1791 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
1792 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
1793 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
1794 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
1796 /* HP Extensions. */
1797 case DW_AT_HP_block_index
: return "DW_AT_HP_block_index";
1798 case DW_AT_HP_actuals_stmt_list
: return "DW_AT_HP_actuals_stmt_list";
1799 case DW_AT_HP_proc_per_section
: return "DW_AT_HP_proc_per_section";
1800 case DW_AT_HP_raw_data_ptr
: return "DW_AT_HP_raw_data_ptr";
1801 case DW_AT_HP_pass_by_reference
: return "DW_AT_HP_pass_by_reference";
1802 case DW_AT_HP_opt_level
: return "DW_AT_HP_opt_level";
1803 case DW_AT_HP_prof_version_id
: return "DW_AT_HP_prof_version_id";
1804 case DW_AT_HP_opt_flags
: return "DW_AT_HP_opt_flags";
1805 case DW_AT_HP_cold_region_low_pc
: return "DW_AT_HP_cold_region_low_pc";
1806 case DW_AT_HP_cold_region_high_pc
: return "DW_AT_HP_cold_region_high_pc";
1807 case DW_AT_HP_all_variables_modifiable
: return "DW_AT_HP_all_variables_modifiable";
1808 case DW_AT_HP_linkage_name
: return "DW_AT_HP_linkage_name";
1809 case DW_AT_HP_prof_flags
: return "DW_AT_HP_prof_flags";
1811 /* One value is shared by the MIPS and HP extensions: */
1812 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
1814 /* GNU extensions. */
1815 case DW_AT_sf_names
: return "DW_AT_sf_names";
1816 case DW_AT_src_info
: return "DW_AT_src_info";
1817 case DW_AT_mac_info
: return "DW_AT_mac_info";
1818 case DW_AT_src_coords
: return "DW_AT_src_coords";
1819 case DW_AT_body_begin
: return "DW_AT_body_begin";
1820 case DW_AT_body_end
: return "DW_AT_body_end";
1821 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
1822 case DW_AT_GNU_guarded_by
: return "DW_AT_GNU_guarded_by";
1823 case DW_AT_GNU_pt_guarded_by
: return "DW_AT_GNU_pt_guarded_by";
1824 case DW_AT_GNU_guarded
: return "DW_AT_GNU_guarded";
1825 case DW_AT_GNU_pt_guarded
: return "DW_AT_GNU_pt_guarded";
1826 case DW_AT_GNU_locks_excluded
: return "DW_AT_GNU_locks_excluded";
1827 case DW_AT_GNU_exclusive_locks_required
: return "DW_AT_GNU_exclusive_locks_required";
1828 case DW_AT_GNU_shared_locks_required
: return "DW_AT_GNU_shared_locks_required";
1829 case DW_AT_GNU_odr_signature
: return "DW_AT_GNU_odr_signature";
1830 case DW_AT_use_GNAT_descriptive_type
: return "DW_AT_use_GNAT_descriptive_type";
1831 case DW_AT_GNAT_descriptive_type
: return "DW_AT_GNAT_descriptive_type";
1833 /* UPC extension. */
1834 case DW_AT_upc_threads_scaled
: return "DW_AT_upc_threads_scaled";
1836 /* PGI (STMicroelectronics) extensions. */
1837 case DW_AT_PGI_lbase
: return "DW_AT_PGI_lbase";
1838 case DW_AT_PGI_soffset
: return "DW_AT_PGI_soffset";
1839 case DW_AT_PGI_lstride
: return "DW_AT_PGI_lstride";
1843 static char buffer
[100];
1845 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
1852 static unsigned char *
1853 read_and_display_attr (unsigned long attribute
,
1855 unsigned char * data
,
1856 unsigned long cu_offset
,
1857 unsigned long pointer_size
,
1858 unsigned long offset_size
,
1860 debug_info
* debug_info_p
,
1862 struct dwarf_section
* section
)
1865 printf (" %-18s:", get_AT_name (attribute
));
1866 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
1867 pointer_size
, offset_size
,
1868 dwarf_version
, debug_info_p
,
1876 /* Process the contents of a .debug_info section. If do_loc is non-zero
1877 then we are scanning for location lists and we do not want to display
1878 anything to the user. If do_types is non-zero, we are processing
1879 a .debug_types section instead of a .debug_info section. */
1882 process_debug_info (struct dwarf_section
*section
,
1884 enum dwarf_section_display_enum abbrev_sec
,
1888 unsigned char *start
= section
->start
;
1889 unsigned char *end
= start
+ section
->size
;
1890 unsigned char *section_begin
;
1892 unsigned int num_units
= 0;
1894 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1895 && num_debug_info_entries
== 0
1898 unsigned long length
;
1900 /* First scan the section to get the number of comp units. */
1901 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
1904 /* Read the first 4 bytes. For a 32-bit DWARF section, this
1905 will be the length. For a 64-bit DWARF section, it'll be
1906 the escape code 0xffffffff followed by an 8 byte length. */
1907 length
= byte_get (section_begin
, 4);
1909 if (length
== 0xffffffff)
1911 length
= byte_get (section_begin
+ 4, 8);
1912 section_begin
+= length
+ 12;
1914 else if (length
>= 0xfffffff0 && length
< 0xffffffff)
1916 warn (_("Reserved length value (%lx) found in section %s\n"), length
, section
->name
);
1920 section_begin
+= length
+ 4;
1922 /* Negative values are illegal, they may even cause infinite
1923 looping. This can happen if we can't accurately apply
1924 relocations to an object file. */
1925 if ((signed long) length
<= 0)
1927 warn (_("Corrupt unit length (%lx) found in section %s\n"), length
, section
->name
);
1934 error (_("No comp units in %s section ?"), section
->name
);
1938 /* Then allocate an array to hold the information. */
1939 debug_information
= (debug_info
*) cmalloc (num_units
,
1940 sizeof (* debug_information
));
1941 if (debug_information
== NULL
)
1943 error (_("Not enough memory for a debug info array of %u entries"),
1951 printf (_("Contents of the %s section:\n\n"), section
->name
);
1953 load_debug_section (str
, file
);
1956 load_debug_section (abbrev_sec
, file
);
1957 if (debug_displays
[abbrev_sec
].section
.start
== NULL
)
1959 warn (_("Unable to locate %s section!\n"),
1960 debug_displays
[abbrev_sec
].section
.name
);
1964 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
1966 DWARF2_Internal_CompUnit compunit
;
1967 unsigned char *hdrptr
;
1968 unsigned char *tags
;
1970 unsigned long cu_offset
;
1972 int initial_length_size
;
1973 unsigned char signature
[8] = { 0 };
1974 unsigned long type_offset
= 0;
1978 compunit
.cu_length
= byte_get (hdrptr
, 4);
1981 if (compunit
.cu_length
== 0xffffffff)
1983 compunit
.cu_length
= byte_get (hdrptr
, 8);
1986 initial_length_size
= 12;
1991 initial_length_size
= 4;
1994 compunit
.cu_version
= byte_get (hdrptr
, 2);
1997 cu_offset
= start
- section_begin
;
1999 compunit
.cu_abbrev_offset
= byte_get (hdrptr
, offset_size
);
2000 hdrptr
+= offset_size
;
2002 compunit
.cu_pointer_size
= byte_get (hdrptr
, 1);
2009 for (i
= 0; i
< 8; i
++)
2011 signature
[i
] = byte_get (hdrptr
, 1);
2015 type_offset
= byte_get (hdrptr
, offset_size
);
2016 hdrptr
+= offset_size
;
2019 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2020 && num_debug_info_entries
== 0
2023 debug_information
[unit
].cu_offset
= cu_offset
;
2024 debug_information
[unit
].pointer_size
2025 = compunit
.cu_pointer_size
;
2026 debug_information
[unit
].base_address
= 0;
2027 debug_information
[unit
].loc_offsets
= NULL
;
2028 debug_information
[unit
].have_frame_base
= NULL
;
2029 debug_information
[unit
].max_loc_offsets
= 0;
2030 debug_information
[unit
].num_loc_offsets
= 0;
2031 debug_information
[unit
].range_lists
= NULL
;
2032 debug_information
[unit
].max_range_lists
= 0;
2033 debug_information
[unit
].num_range_lists
= 0;
2038 printf (_(" Compilation Unit @ offset 0x%lx:\n"), cu_offset
);
2039 printf (_(" Length: 0x%lx (%s)\n"), compunit
.cu_length
,
2040 initial_length_size
== 8 ? "64-bit" : "32-bit");
2041 printf (_(" Version: %d\n"), compunit
.cu_version
);
2042 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
2043 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
2047 printf (_(" Signature: "));
2048 for (i
= 0; i
< 8; i
++)
2049 printf ("%02x", signature
[i
]);
2051 printf (_(" Type Offset: 0x%lx\n"), type_offset
);
2055 if (cu_offset
+ compunit
.cu_length
+ initial_length_size
2058 warn (_("Debug info is corrupted, length of CU at %lx extends beyond end of section (length = %lx)\n"),
2059 cu_offset
, compunit
.cu_length
);
2063 start
+= compunit
.cu_length
+ initial_length_size
;
2065 if (compunit
.cu_version
!= 2
2066 && compunit
.cu_version
!= 3
2067 && compunit
.cu_version
!= 4)
2069 warn (_("CU at offset %lx contains corrupt or unsupported version number: %d.\n"),
2070 cu_offset
, compunit
.cu_version
);
2076 /* Process the abbrevs used by this compilation unit. DWARF
2077 sections under Mach-O have non-zero addresses. */
2078 if (compunit
.cu_abbrev_offset
>= debug_displays
[abbrev_sec
].section
.size
)
2079 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
2080 (unsigned long) compunit
.cu_abbrev_offset
,
2081 (unsigned long) debug_displays
[abbrev_sec
].section
.size
);
2083 process_abbrev_section
2084 ((unsigned char *) debug_displays
[abbrev_sec
].section
.start
2085 + compunit
.cu_abbrev_offset
,
2086 (unsigned char *) debug_displays
[abbrev_sec
].section
.start
2087 + debug_displays
[abbrev_sec
].section
.size
);
2090 while (tags
< start
)
2092 unsigned int bytes_read
;
2093 unsigned long abbrev_number
;
2094 unsigned long die_offset
;
2095 abbrev_entry
*entry
;
2098 die_offset
= tags
- section_begin
;
2100 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
2103 /* A null DIE marks the end of a list of siblings or it may also be
2104 a section padding. */
2105 if (abbrev_number
== 0)
2107 /* Check if it can be a section padding for the last CU. */
2108 if (level
== 0 && start
== end
)
2112 for (chk
= tags
; chk
< start
; chk
++)
2122 static unsigned num_bogus_warns
= 0;
2124 if (num_bogus_warns
< 3)
2126 warn (_("Bogus end-of-siblings marker detected at offset %lx in .debug_info section\n"),
2129 if (num_bogus_warns
== 3)
2130 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
2137 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
2138 level
, die_offset
, abbrev_number
);
2140 /* Scan through the abbreviation list until we reach the
2142 for (entry
= first_abbrev
;
2143 entry
&& entry
->entry
!= abbrev_number
;
2144 entry
= entry
->next
)
2154 warn (_("DIE at offset %lx refers to abbreviation number %lu which does not exist\n"),
2155 die_offset
, abbrev_number
);
2160 printf (_(" (%s)\n"), get_TAG_name (entry
->tag
));
2165 need_base_address
= 0;
2167 case DW_TAG_compile_unit
:
2168 need_base_address
= 1;
2170 case DW_TAG_entry_point
:
2171 case DW_TAG_subprogram
:
2172 need_base_address
= 0;
2173 /* Assuming that there is no DW_AT_frame_base. */
2174 have_frame_base
= 0;
2178 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
2181 /* Show the offset from where the tag was extracted. */
2182 printf (" <%2lx>", (unsigned long)(tags
- section_begin
));
2184 tags
= read_and_display_attr (attr
->attribute
,
2187 compunit
.cu_pointer_size
,
2189 compunit
.cu_version
,
2190 debug_information
+ unit
,
2194 if (entry
->children
)
2199 /* Set num_debug_info_entries here so that it can be used to check if
2200 we need to process .debug_loc and .debug_ranges sections. */
2201 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2202 && num_debug_info_entries
== 0
2204 num_debug_info_entries
= num_units
;
2214 /* Locate and scan the .debug_info section in the file and record the pointer
2215 sizes and offsets for the compilation units in it. Usually an executable
2216 will have just one pointer size, but this is not guaranteed, and so we try
2217 not to make any assumptions. Returns zero upon failure, or the number of
2218 compilation units upon success. */
2221 load_debug_info (void * file
)
2223 /* Reset the last pointer size so that we can issue correct error
2224 messages if we are displaying the contents of more than one section. */
2225 last_pointer_size
= 0;
2226 warned_about_missing_comp_units
= FALSE
;
2228 /* If we have already tried and failed to load the .debug_info
2229 section then do not bother to repear the task. */
2230 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
2233 /* If we already have the information there is nothing else to do. */
2234 if (num_debug_info_entries
> 0)
2235 return num_debug_info_entries
;
2237 if (load_debug_section (info
, file
)
2238 && process_debug_info (&debug_displays
[info
].section
, file
, abbrev
, 1, 0))
2239 return num_debug_info_entries
;
2241 num_debug_info_entries
= DEBUG_INFO_UNAVAILABLE
;
2246 display_debug_lines_raw (struct dwarf_section
*section
,
2247 unsigned char *data
,
2250 unsigned char *start
= section
->start
;
2252 printf (_("Raw dump of debug contents of section %s:\n\n"),
2257 DWARF2_Internal_LineInfo linfo
;
2258 unsigned char *standard_opcodes
;
2259 unsigned char *end_of_sequence
;
2260 unsigned char *hdrptr
;
2261 unsigned long hdroff
;
2262 int initial_length_size
;
2267 hdroff
= hdrptr
- start
;
2269 /* Check the length of the block. */
2270 linfo
.li_length
= byte_get (hdrptr
, 4);
2273 if (linfo
.li_length
== 0xffffffff)
2275 /* This section is 64-bit DWARF 3. */
2276 linfo
.li_length
= byte_get (hdrptr
, 8);
2279 initial_length_size
= 12;
2284 initial_length_size
= 4;
2287 if (linfo
.li_length
+ initial_length_size
> section
->size
)
2290 (_("The information in section %s appears to be corrupt - the section is too small\n"),
2295 /* Check its version number. */
2296 linfo
.li_version
= byte_get (hdrptr
, 2);
2298 if (linfo
.li_version
!= 2
2299 && linfo
.li_version
!= 3
2300 && linfo
.li_version
!= 4)
2302 warn (_("Only DWARF version 2, 3 and 4 line info is currently supported.\n"));
2306 linfo
.li_prologue_length
= byte_get (hdrptr
, offset_size
);
2307 hdrptr
+= offset_size
;
2308 linfo
.li_min_insn_length
= byte_get (hdrptr
, 1);
2310 if (linfo
.li_version
>= 4)
2312 linfo
.li_max_ops_per_insn
= byte_get (hdrptr
, 1);
2314 if (linfo
.li_max_ops_per_insn
== 0)
2316 warn (_("Invalid maximum operations per insn.\n"));
2321 linfo
.li_max_ops_per_insn
= 1;
2322 linfo
.li_default_is_stmt
= byte_get (hdrptr
, 1);
2324 linfo
.li_line_base
= byte_get (hdrptr
, 1);
2326 linfo
.li_line_range
= byte_get (hdrptr
, 1);
2328 linfo
.li_opcode_base
= byte_get (hdrptr
, 1);
2331 /* Sign extend the line base field. */
2332 linfo
.li_line_base
<<= 24;
2333 linfo
.li_line_base
>>= 24;
2335 printf (_(" Offset: 0x%lx\n"), hdroff
);
2336 printf (_(" Length: %ld\n"), linfo
.li_length
);
2337 printf (_(" DWARF Version: %d\n"), linfo
.li_version
);
2338 printf (_(" Prologue Length: %d\n"), linfo
.li_prologue_length
);
2339 printf (_(" Minimum Instruction Length: %d\n"), linfo
.li_min_insn_length
);
2340 if (linfo
.li_version
>= 4)
2341 printf (_(" Maximum Ops per Instruction: %d\n"), linfo
.li_max_ops_per_insn
);
2342 printf (_(" Initial value of 'is_stmt': %d\n"), linfo
.li_default_is_stmt
);
2343 printf (_(" Line Base: %d\n"), linfo
.li_line_base
);
2344 printf (_(" Line Range: %d\n"), linfo
.li_line_range
);
2345 printf (_(" Opcode Base: %d\n"), linfo
.li_opcode_base
);
2347 end_of_sequence
= data
+ linfo
.li_length
+ initial_length_size
;
2349 reset_state_machine (linfo
.li_default_is_stmt
);
2351 /* Display the contents of the Opcodes table. */
2352 standard_opcodes
= hdrptr
;
2354 printf (_("\n Opcodes:\n"));
2356 for (i
= 1; i
< linfo
.li_opcode_base
; i
++)
2357 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
2359 /* Display the contents of the Directory table. */
2360 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
2363 printf (_("\n The Directory Table is empty.\n"));
2366 printf (_("\n The Directory Table:\n"));
2370 printf (_(" %s\n"), data
);
2372 data
+= strlen ((char *) data
) + 1;
2376 /* Skip the NUL at the end of the table. */
2379 /* Display the contents of the File Name table. */
2381 printf (_("\n The File Name Table is empty.\n"));
2384 printf (_("\n The File Name Table:\n"));
2385 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
2389 unsigned char *name
;
2390 unsigned int bytes_read
;
2392 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
2395 data
+= strlen ((char *) data
) + 1;
2397 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
2399 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
2401 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
2403 printf (_("%s\n"), name
);
2407 /* Skip the NUL at the end of the table. */
2410 /* Now display the statements. */
2411 printf (_("\n Line Number Statements:\n"));
2413 while (data
< end_of_sequence
)
2415 unsigned char op_code
;
2417 unsigned long int uladv
;
2418 unsigned int bytes_read
;
2422 if (op_code
>= linfo
.li_opcode_base
)
2424 op_code
-= linfo
.li_opcode_base
;
2425 uladv
= (op_code
/ linfo
.li_line_range
);
2426 if (linfo
.li_max_ops_per_insn
== 1)
2428 uladv
*= linfo
.li_min_insn_length
;
2429 state_machine_regs
.address
+= uladv
;
2430 printf (_(" Special opcode %d: advance Address by %lu to 0x%lx"),
2431 op_code
, uladv
, state_machine_regs
.address
);
2435 state_machine_regs
.address
2436 += ((state_machine_regs
.op_index
+ uladv
)
2437 / linfo
.li_max_ops_per_insn
)
2438 * linfo
.li_min_insn_length
;
2439 state_machine_regs
.op_index
2440 = (state_machine_regs
.op_index
+ uladv
)
2441 % linfo
.li_max_ops_per_insn
;
2442 printf (_(" Special opcode %d: advance Address by %lu to 0x%lx[%d]"),
2443 op_code
, uladv
, state_machine_regs
.address
,
2444 state_machine_regs
.op_index
);
2446 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
2447 state_machine_regs
.line
+= adv
;
2448 printf (_(" and Line by %d to %d\n"),
2449 adv
, state_machine_regs
.line
);
2451 else switch (op_code
)
2453 case DW_LNS_extended_op
:
2454 data
+= process_extended_line_op (data
, linfo
.li_default_is_stmt
);
2458 printf (_(" Copy\n"));
2461 case DW_LNS_advance_pc
:
2462 uladv
= read_leb128 (data
, & bytes_read
, 0);
2464 if (linfo
.li_max_ops_per_insn
== 1)
2466 uladv
*= linfo
.li_min_insn_length
;
2467 state_machine_regs
.address
+= uladv
;
2468 printf (_(" Advance PC by %lu to 0x%lx\n"), uladv
,
2469 state_machine_regs
.address
);
2473 state_machine_regs
.address
2474 += ((state_machine_regs
.op_index
+ uladv
)
2475 / linfo
.li_max_ops_per_insn
)
2476 * linfo
.li_min_insn_length
;
2477 state_machine_regs
.op_index
2478 = (state_machine_regs
.op_index
+ uladv
)
2479 % linfo
.li_max_ops_per_insn
;
2480 printf (_(" Advance PC by %lu to 0x%lx[%d]\n"), uladv
,
2481 state_machine_regs
.address
,
2482 state_machine_regs
.op_index
);
2486 case DW_LNS_advance_line
:
2487 adv
= read_leb128 (data
, & bytes_read
, 1);
2489 state_machine_regs
.line
+= adv
;
2490 printf (_(" Advance Line by %d to %d\n"), adv
,
2491 state_machine_regs
.line
);
2494 case DW_LNS_set_file
:
2495 adv
= read_leb128 (data
, & bytes_read
, 0);
2497 printf (_(" Set File Name to entry %d in the File Name Table\n"),
2499 state_machine_regs
.file
= adv
;
2502 case DW_LNS_set_column
:
2503 uladv
= read_leb128 (data
, & bytes_read
, 0);
2505 printf (_(" Set column to %lu\n"), uladv
);
2506 state_machine_regs
.column
= uladv
;
2509 case DW_LNS_negate_stmt
:
2510 adv
= state_machine_regs
.is_stmt
;
2512 printf (_(" Set is_stmt to %d\n"), adv
);
2513 state_machine_regs
.is_stmt
= adv
;
2516 case DW_LNS_set_basic_block
:
2517 printf (_(" Set basic block\n"));
2518 state_machine_regs
.basic_block
= 1;
2521 case DW_LNS_const_add_pc
:
2522 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
2523 if (linfo
.li_max_ops_per_insn
)
2525 uladv
*= linfo
.li_min_insn_length
;
2526 state_machine_regs
.address
+= uladv
;
2527 printf (_(" Advance PC by constant %lu to 0x%lx\n"), uladv
,
2528 state_machine_regs
.address
);
2532 state_machine_regs
.address
2533 += ((state_machine_regs
.op_index
+ uladv
)
2534 / linfo
.li_max_ops_per_insn
)
2535 * linfo
.li_min_insn_length
;
2536 state_machine_regs
.op_index
2537 = (state_machine_regs
.op_index
+ uladv
)
2538 % linfo
.li_max_ops_per_insn
;
2539 printf (_(" Advance PC by constant %lu to 0x%lx[%d]\n"),
2540 uladv
, state_machine_regs
.address
,
2541 state_machine_regs
.op_index
);
2545 case DW_LNS_fixed_advance_pc
:
2546 uladv
= byte_get (data
, 2);
2548 state_machine_regs
.address
+= uladv
;
2549 state_machine_regs
.op_index
= 0;
2550 printf (_(" Advance PC by fixed size amount %lu to 0x%lx\n"),
2551 uladv
, state_machine_regs
.address
);
2554 case DW_LNS_set_prologue_end
:
2555 printf (_(" Set prologue_end to true\n"));
2558 case DW_LNS_set_epilogue_begin
:
2559 printf (_(" Set epilogue_begin to true\n"));
2562 case DW_LNS_set_isa
:
2563 uladv
= read_leb128 (data
, & bytes_read
, 0);
2565 printf (_(" Set ISA to %lu\n"), uladv
);
2569 printf (_(" Unknown opcode %d with operands: "), op_code
);
2571 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
2573 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
2574 i
== 1 ? "" : ", ");
2589 unsigned char *name
;
2590 unsigned int directory_index
;
2591 unsigned int modification_date
;
2592 unsigned int length
;
2595 /* Output a decoded representation of the .debug_line section. */
2598 display_debug_lines_decoded (struct dwarf_section
*section
,
2599 unsigned char *data
,
2602 printf (_("Decoded dump of debug contents of section %s:\n\n"),
2607 /* This loop amounts to one iteration per compilation unit. */
2608 DWARF2_Internal_LineInfo linfo
;
2609 unsigned char *standard_opcodes
;
2610 unsigned char *end_of_sequence
;
2611 unsigned char *hdrptr
;
2612 int initial_length_size
;
2615 File_Entry
*file_table
= NULL
;
2616 unsigned char **directory_table
= NULL
;
2620 /* Extract information from the Line Number Program Header.
2621 (section 6.2.4 in the Dwarf3 doc). */
2623 /* Get the length of this CU's line number information block. */
2624 linfo
.li_length
= byte_get (hdrptr
, 4);
2627 if (linfo
.li_length
== 0xffffffff)
2629 /* This section is 64-bit DWARF 3. */
2630 linfo
.li_length
= byte_get (hdrptr
, 8);
2633 initial_length_size
= 12;
2638 initial_length_size
= 4;
2641 if (linfo
.li_length
+ initial_length_size
> section
->size
)
2643 warn (_("The line info appears to be corrupt - "
2644 "the section is too small\n"));
2648 /* Get this CU's Line Number Block version number. */
2649 linfo
.li_version
= byte_get (hdrptr
, 2);
2651 if (linfo
.li_version
!= 2
2652 && linfo
.li_version
!= 3
2653 && linfo
.li_version
!= 4)
2655 warn (_("Only DWARF version 2, 3 and 4 line info is currently "
2660 linfo
.li_prologue_length
= byte_get (hdrptr
, offset_size
);
2661 hdrptr
+= offset_size
;
2662 linfo
.li_min_insn_length
= byte_get (hdrptr
, 1);
2664 if (linfo
.li_version
>= 4)
2666 linfo
.li_max_ops_per_insn
= byte_get (hdrptr
, 1);
2668 if (linfo
.li_max_ops_per_insn
== 0)
2670 warn (_("Invalid maximum operations per insn.\n"));
2675 linfo
.li_max_ops_per_insn
= 1;
2676 linfo
.li_default_is_stmt
= byte_get (hdrptr
, 1);
2678 linfo
.li_line_base
= byte_get (hdrptr
, 1);
2680 linfo
.li_line_range
= byte_get (hdrptr
, 1);
2682 linfo
.li_opcode_base
= byte_get (hdrptr
, 1);
2685 /* Sign extend the line base field. */
2686 linfo
.li_line_base
<<= 24;
2687 linfo
.li_line_base
>>= 24;
2689 /* Find the end of this CU's Line Number Information Block. */
2690 end_of_sequence
= data
+ linfo
.li_length
+ initial_length_size
;
2692 reset_state_machine (linfo
.li_default_is_stmt
);
2694 /* Save a pointer to the contents of the Opcodes table. */
2695 standard_opcodes
= hdrptr
;
2697 /* Traverse the Directory table just to count entries. */
2698 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
2701 unsigned int n_directories
= 0;
2702 unsigned char *ptr_directory_table
= data
;
2706 data
+= strlen ((char *) data
) + 1;
2710 /* Go through the directory table again to save the directories. */
2711 directory_table
= (unsigned char **)
2712 xmalloc (n_directories
* sizeof (unsigned char *));
2715 while (*ptr_directory_table
!= 0)
2717 directory_table
[i
] = ptr_directory_table
;
2718 ptr_directory_table
+= strlen ((char *) ptr_directory_table
) + 1;
2722 /* Skip the NUL at the end of the table. */
2725 /* Traverse the File Name table just to count the entries. */
2728 unsigned int n_files
= 0;
2729 unsigned char *ptr_file_name_table
= data
;
2733 unsigned int bytes_read
;
2735 /* Skip Name, directory index, last modification time and length
2737 data
+= strlen ((char *) data
) + 1;
2738 read_leb128 (data
, & bytes_read
, 0);
2740 read_leb128 (data
, & bytes_read
, 0);
2742 read_leb128 (data
, & bytes_read
, 0);
2748 /* Go through the file table again to save the strings. */
2749 file_table
= (File_Entry
*) xmalloc (n_files
* sizeof (File_Entry
));
2752 while (*ptr_file_name_table
!= 0)
2754 unsigned int bytes_read
;
2756 file_table
[i
].name
= ptr_file_name_table
;
2757 ptr_file_name_table
+= strlen ((char *) ptr_file_name_table
) + 1;
2759 /* We are not interested in directory, time or size. */
2760 file_table
[i
].directory_index
= read_leb128 (ptr_file_name_table
,
2762 ptr_file_name_table
+= bytes_read
;
2763 file_table
[i
].modification_date
= read_leb128 (ptr_file_name_table
,
2765 ptr_file_name_table
+= bytes_read
;
2766 file_table
[i
].length
= read_leb128 (ptr_file_name_table
, & bytes_read
, 0);
2767 ptr_file_name_table
+= bytes_read
;
2772 /* Print the Compilation Unit's name and a header. */
2773 if (directory_table
== NULL
)
2775 printf (_("CU: %s:\n"), file_table
[0].name
);
2776 printf (_("File name Line number Starting address\n"));
2780 if (do_wide
|| strlen ((char *) directory_table
[0]) < 76)
2782 printf (_("CU: %s/%s:\n"), directory_table
[0],
2783 file_table
[0].name
);
2787 printf (_("%s:\n"), file_table
[0].name
);
2789 printf (_("File name Line number Starting address\n"));
2793 /* Skip the NUL at the end of the table. */
2796 /* This loop iterates through the Dwarf Line Number Program. */
2797 while (data
< end_of_sequence
)
2799 unsigned char op_code
;
2801 unsigned long int uladv
;
2802 unsigned int bytes_read
;
2803 int is_special_opcode
= 0;
2807 if (op_code
>= linfo
.li_opcode_base
)
2809 op_code
-= linfo
.li_opcode_base
;
2810 uladv
= (op_code
/ linfo
.li_line_range
);
2811 if (linfo
.li_max_ops_per_insn
== 1)
2813 uladv
*= linfo
.li_min_insn_length
;
2814 state_machine_regs
.address
+= uladv
;
2818 state_machine_regs
.address
2819 += ((state_machine_regs
.op_index
+ uladv
)
2820 / linfo
.li_max_ops_per_insn
)
2821 * linfo
.li_min_insn_length
;
2822 state_machine_regs
.op_index
2823 = (state_machine_regs
.op_index
+ uladv
)
2824 % linfo
.li_max_ops_per_insn
;
2827 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
2828 state_machine_regs
.line
+= adv
;
2829 is_special_opcode
= 1;
2831 else switch (op_code
)
2833 case DW_LNS_extended_op
:
2835 unsigned int ext_op_code_len
;
2836 unsigned char ext_op_code
;
2837 unsigned char *op_code_data
= data
;
2839 ext_op_code_len
= read_leb128 (op_code_data
, &bytes_read
, 0);
2840 op_code_data
+= bytes_read
;
2842 if (ext_op_code_len
== 0)
2844 warn (_("badly formed extended line op encountered!\n"));
2847 ext_op_code_len
+= bytes_read
;
2848 ext_op_code
= *op_code_data
++;
2850 switch (ext_op_code
)
2852 case DW_LNE_end_sequence
:
2853 reset_state_machine (linfo
.li_default_is_stmt
);
2855 case DW_LNE_set_address
:
2856 state_machine_regs
.address
=
2857 byte_get (op_code_data
, ext_op_code_len
- bytes_read
- 1);
2858 state_machine_regs
.op_index
= 0;
2860 case DW_LNE_define_file
:
2862 unsigned int dir_index
= 0;
2864 ++state_machine_regs
.last_file_entry
;
2865 op_code_data
+= strlen ((char *) op_code_data
) + 1;
2866 dir_index
= read_leb128 (op_code_data
, & bytes_read
, 0);
2867 op_code_data
+= bytes_read
;
2868 read_leb128 (op_code_data
, & bytes_read
, 0);
2869 op_code_data
+= bytes_read
;
2870 read_leb128 (op_code_data
, & bytes_read
, 0);
2872 printf (_("%s:\n"), directory_table
[dir_index
]);
2876 printf (_("UNKNOWN: length %d\n"), ext_op_code_len
- bytes_read
);
2879 data
+= ext_op_code_len
;
2885 case DW_LNS_advance_pc
:
2886 uladv
= read_leb128 (data
, & bytes_read
, 0);
2888 if (linfo
.li_max_ops_per_insn
== 1)
2890 uladv
*= linfo
.li_min_insn_length
;
2891 state_machine_regs
.address
+= uladv
;
2895 state_machine_regs
.address
2896 += ((state_machine_regs
.op_index
+ uladv
)
2897 / linfo
.li_max_ops_per_insn
)
2898 * linfo
.li_min_insn_length
;
2899 state_machine_regs
.op_index
2900 = (state_machine_regs
.op_index
+ uladv
)
2901 % linfo
.li_max_ops_per_insn
;
2905 case DW_LNS_advance_line
:
2906 adv
= read_leb128 (data
, & bytes_read
, 1);
2908 state_machine_regs
.line
+= adv
;
2911 case DW_LNS_set_file
:
2912 adv
= read_leb128 (data
, & bytes_read
, 0);
2914 state_machine_regs
.file
= adv
;
2915 if (file_table
[state_machine_regs
.file
- 1].directory_index
== 0)
2917 /* If directory index is 0, that means current directory. */
2918 printf (_("\n./%s:[++]\n"),
2919 file_table
[state_machine_regs
.file
- 1].name
);
2923 /* The directory index starts counting at 1. */
2924 printf (_("\n%s/%s:\n"),
2925 directory_table
[file_table
[state_machine_regs
.file
- 1].directory_index
- 1],
2926 file_table
[state_machine_regs
.file
- 1].name
);
2930 case DW_LNS_set_column
:
2931 uladv
= read_leb128 (data
, & bytes_read
, 0);
2933 state_machine_regs
.column
= uladv
;
2936 case DW_LNS_negate_stmt
:
2937 adv
= state_machine_regs
.is_stmt
;
2939 state_machine_regs
.is_stmt
= adv
;
2942 case DW_LNS_set_basic_block
:
2943 state_machine_regs
.basic_block
= 1;
2946 case DW_LNS_const_add_pc
:
2947 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
2948 if (linfo
.li_max_ops_per_insn
== 1)
2950 uladv
*= linfo
.li_min_insn_length
;
2951 state_machine_regs
.address
+= uladv
;
2955 state_machine_regs
.address
2956 += ((state_machine_regs
.op_index
+ uladv
)
2957 / linfo
.li_max_ops_per_insn
)
2958 * linfo
.li_min_insn_length
;
2959 state_machine_regs
.op_index
2960 = (state_machine_regs
.op_index
+ uladv
)
2961 % linfo
.li_max_ops_per_insn
;
2965 case DW_LNS_fixed_advance_pc
:
2966 uladv
= byte_get (data
, 2);
2968 state_machine_regs
.address
+= uladv
;
2969 state_machine_regs
.op_index
= 0;
2972 case DW_LNS_set_prologue_end
:
2975 case DW_LNS_set_epilogue_begin
:
2978 case DW_LNS_set_isa
:
2979 uladv
= read_leb128 (data
, & bytes_read
, 0);
2981 printf (_(" Set ISA to %lu\n"), uladv
);
2985 printf (_(" Unknown opcode %d with operands: "), op_code
);
2987 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
2989 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
2990 i
== 1 ? "" : ", ");
2997 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
2998 to the DWARF address/line matrix. */
2999 if ((is_special_opcode
) || (op_code
== DW_LNE_end_sequence
)
3000 || (op_code
== DW_LNS_copy
))
3002 const unsigned int MAX_FILENAME_LENGTH
= 35;
3003 char *fileName
= (char *)file_table
[state_machine_regs
.file
- 1].name
;
3004 char *newFileName
= NULL
;
3005 size_t fileNameLength
= strlen (fileName
);
3007 if ((fileNameLength
> MAX_FILENAME_LENGTH
) && (!do_wide
))
3009 newFileName
= (char *) xmalloc (MAX_FILENAME_LENGTH
+ 1);
3010 /* Truncate file name */
3011 strncpy (newFileName
,
3012 fileName
+ fileNameLength
- MAX_FILENAME_LENGTH
,
3013 MAX_FILENAME_LENGTH
+ 1);
3017 newFileName
= (char *) xmalloc (fileNameLength
+ 1);
3018 strncpy (newFileName
, fileName
, fileNameLength
+ 1);
3021 if (!do_wide
|| (fileNameLength
<= MAX_FILENAME_LENGTH
))
3023 if (linfo
.li_max_ops_per_insn
== 1)
3024 printf (_("%-35s %11d %#18lx\n"), newFileName
,
3025 state_machine_regs
.line
,
3026 state_machine_regs
.address
);
3028 printf (_("%-35s %11d %#18lx[%d]\n"), newFileName
,
3029 state_machine_regs
.line
,
3030 state_machine_regs
.address
,
3031 state_machine_regs
.op_index
);
3035 if (linfo
.li_max_ops_per_insn
== 1)
3036 printf (_("%s %11d %#18lx\n"), newFileName
,
3037 state_machine_regs
.line
,
3038 state_machine_regs
.address
);
3040 printf (_("%s %11d %#18lx[%d]\n"), newFileName
,
3041 state_machine_regs
.line
,
3042 state_machine_regs
.address
,
3043 state_machine_regs
.op_index
);
3046 if (op_code
== DW_LNE_end_sequence
)
3054 free (directory_table
);
3055 directory_table
= NULL
;
3063 display_debug_lines (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
3065 unsigned char *data
= section
->start
;
3066 unsigned char *end
= data
+ section
->size
;
3068 int retValDecoded
= 1;
3070 if (do_debug_lines
== 0)
3071 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
3073 if (do_debug_lines
& FLAG_DEBUG_LINES_RAW
)
3074 retValRaw
= display_debug_lines_raw (section
, data
, end
);
3076 if (do_debug_lines
& FLAG_DEBUG_LINES_DECODED
)
3077 retValDecoded
= display_debug_lines_decoded (section
, data
, end
);
3079 if (!retValRaw
|| !retValDecoded
)
3086 find_debug_info_for_offset (unsigned long offset
)
3090 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
3093 for (i
= 0; i
< num_debug_info_entries
; i
++)
3094 if (debug_information
[i
].cu_offset
== offset
)
3095 return debug_information
+ i
;
3101 display_debug_pubnames (struct dwarf_section
*section
,
3102 void *file ATTRIBUTE_UNUSED
)
3104 DWARF2_Internal_PubNames names
;
3105 unsigned char *start
= section
->start
;
3106 unsigned char *end
= start
+ section
->size
;
3108 /* It does not matter if this load fails,
3109 we test for that later on. */
3110 load_debug_info (file
);
3112 printf (_("Contents of the %s section:\n\n"), section
->name
);
3116 unsigned char *data
;
3117 unsigned long offset
;
3118 int offset_size
, initial_length_size
;
3122 names
.pn_length
= byte_get (data
, 4);
3124 if (names
.pn_length
== 0xffffffff)
3126 names
.pn_length
= byte_get (data
, 8);
3129 initial_length_size
= 12;
3134 initial_length_size
= 4;
3137 names
.pn_version
= byte_get (data
, 2);
3140 names
.pn_offset
= byte_get (data
, offset_size
);
3141 data
+= offset_size
;
3143 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
3144 && num_debug_info_entries
> 0
3145 && find_debug_info_for_offset (names
.pn_offset
) == NULL
)
3146 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3147 names
.pn_offset
, section
->name
);
3149 names
.pn_size
= byte_get (data
, offset_size
);
3150 data
+= offset_size
;
3152 start
+= names
.pn_length
+ initial_length_size
;
3154 if (names
.pn_version
!= 2 && names
.pn_version
!= 3)
3156 static int warned
= 0;
3160 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
3167 printf (_(" Length: %ld\n"),
3169 printf (_(" Version: %d\n"),
3171 printf (_(" Offset into .debug_info section: 0x%lx\n"),
3173 printf (_(" Size of area in .debug_info section: %ld\n"),
3176 printf (_("\n Offset\tName\n"));
3180 offset
= byte_get (data
, offset_size
);
3184 data
+= offset_size
;
3185 printf (" %-6lx\t%s\n", offset
, data
);
3186 data
+= strlen ((char *) data
) + 1;
3189 while (offset
!= 0);
3197 display_debug_macinfo (struct dwarf_section
*section
,
3198 void *file ATTRIBUTE_UNUSED
)
3200 unsigned char *start
= section
->start
;
3201 unsigned char *end
= start
+ section
->size
;
3202 unsigned char *curr
= start
;
3203 unsigned int bytes_read
;
3204 enum dwarf_macinfo_record_type op
;
3206 printf (_("Contents of the %s section:\n\n"), section
->name
);
3210 unsigned int lineno
;
3213 op
= (enum dwarf_macinfo_record_type
) *curr
;
3218 case DW_MACINFO_start_file
:
3220 unsigned int filenum
;
3222 lineno
= read_leb128 (curr
, & bytes_read
, 0);
3224 filenum
= read_leb128 (curr
, & bytes_read
, 0);
3227 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
3232 case DW_MACINFO_end_file
:
3233 printf (_(" DW_MACINFO_end_file\n"));
3236 case DW_MACINFO_define
:
3237 lineno
= read_leb128 (curr
, & bytes_read
, 0);
3239 string
= (char *) curr
;
3240 curr
+= strlen (string
) + 1;
3241 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
3245 case DW_MACINFO_undef
:
3246 lineno
= read_leb128 (curr
, & bytes_read
, 0);
3248 string
= (char *) curr
;
3249 curr
+= strlen (string
) + 1;
3250 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
3254 case DW_MACINFO_vendor_ext
:
3256 unsigned int constant
;
3258 constant
= read_leb128 (curr
, & bytes_read
, 0);
3260 string
= (char *) curr
;
3261 curr
+= strlen (string
) + 1;
3262 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
3273 display_debug_abbrev (struct dwarf_section
*section
,
3274 void *file ATTRIBUTE_UNUSED
)
3276 abbrev_entry
*entry
;
3277 unsigned char *start
= section
->start
;
3278 unsigned char *end
= start
+ section
->size
;
3280 printf (_("Contents of the %s section:\n\n"), section
->name
);
3286 start
= process_abbrev_section (start
, end
);
3288 if (first_abbrev
== NULL
)
3291 printf (_(" Number TAG\n"));
3293 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
3297 printf (_(" %ld %s [%s]\n"),
3299 get_TAG_name (entry
->tag
),
3300 entry
->children
? _("has children") : _("no children"));
3302 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
3303 printf (_(" %-18s %s\n"),
3304 get_AT_name (attr
->attribute
),
3305 get_FORM_name (attr
->form
));
3316 display_debug_loc (struct dwarf_section
*section
, void *file
)
3318 unsigned char *start
= section
->start
;
3319 unsigned char *section_end
;
3320 unsigned long bytes
;
3321 unsigned char *section_begin
= start
;
3322 unsigned int num_loc_list
= 0;
3323 unsigned long last_offset
= 0;
3324 unsigned int first
= 0;
3327 int seen_first_offset
= 0;
3328 int use_debug_info
= 1;
3329 unsigned char *next
;
3331 bytes
= section
->size
;
3332 section_end
= start
+ bytes
;
3336 printf (_("\nThe %s section is empty.\n"), section
->name
);
3340 if (load_debug_info (file
) == 0)
3342 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
3347 /* Check the order of location list in .debug_info section. If
3348 offsets of location lists are in the ascending order, we can
3349 use `debug_information' directly. */
3350 for (i
= 0; i
< num_debug_info_entries
; i
++)
3354 num
= debug_information
[i
].num_loc_offsets
;
3355 num_loc_list
+= num
;
3357 /* Check if we can use `debug_information' directly. */
3358 if (use_debug_info
&& num
!= 0)
3360 if (!seen_first_offset
)
3362 /* This is the first location list. */
3363 last_offset
= debug_information
[i
].loc_offsets
[0];
3365 seen_first_offset
= 1;
3371 for (; j
< num
; j
++)
3374 debug_information
[i
].loc_offsets
[j
])
3379 last_offset
= debug_information
[i
].loc_offsets
[j
];
3384 if (!use_debug_info
)
3385 /* FIXME: Should we handle this case? */
3386 error (_("Location lists in .debug_info section aren't in ascending order!\n"));
3388 if (!seen_first_offset
)
3389 error (_("No location lists in .debug_info section!\n"));
3391 /* DWARF sections under Mach-O have non-zero addresses. */
3392 if (debug_information
[first
].num_loc_offsets
> 0
3393 && debug_information
[first
].loc_offsets
[0] != section
->address
)
3394 warn (_("Location lists in %s section start at 0x%lx\n"),
3395 section
->name
, debug_information
[first
].loc_offsets
[0]);
3397 printf (_("Contents of the %s section:\n\n"), section
->name
);
3398 printf (_(" Offset Begin End Expression\n"));
3400 seen_first_offset
= 0;
3401 for (i
= first
; i
< num_debug_info_entries
; i
++)
3405 unsigned short length
;
3406 unsigned long offset
;
3407 unsigned int pointer_size
;
3408 unsigned long cu_offset
;
3409 unsigned long base_address
;
3410 int need_frame_base
;
3413 pointer_size
= debug_information
[i
].pointer_size
;
3414 cu_offset
= debug_information
[i
].cu_offset
;
3416 for (j
= 0; j
< debug_information
[i
].num_loc_offsets
; j
++)
3418 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
3419 /* DWARF sections under Mach-O have non-zero addresses. */
3420 offset
= debug_information
[i
].loc_offsets
[j
] - section
->address
;
3421 next
= section_begin
+ offset
;
3422 base_address
= debug_information
[i
].base_address
;
3424 if (!seen_first_offset
)
3425 seen_first_offset
= 1;
3429 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
3430 (unsigned long) (start
- section_begin
),
3431 (unsigned long) (next
- section_begin
));
3432 else if (start
> next
)
3433 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
3434 (unsigned long) (start
- section_begin
),
3435 (unsigned long) (next
- section_begin
));
3439 if (offset
>= bytes
)
3441 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
3448 if (start
+ 2 * pointer_size
> section_end
)
3450 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
3455 /* Note: we use sign extension here in order to be sure that
3456 we can detect the -1 escape value. Sign extension into the
3457 top 32 bits of a 32-bit address will not affect the values
3458 that we display since we always show hex values, and always
3459 the bottom 32-bits. */
3460 begin
= byte_get_signed (start
, pointer_size
);
3461 start
+= pointer_size
;
3462 end
= byte_get_signed (start
, pointer_size
);
3463 start
+= pointer_size
;
3465 printf (" %8.8lx ", offset
);
3467 if (begin
== 0 && end
== 0)
3469 printf (_("<End of list>\n"));
3473 /* Check base address specifiers. */
3474 if (begin
== (dwarf_vma
) -1 && end
!= (dwarf_vma
) -1)
3477 print_dwarf_vma (begin
, pointer_size
);
3478 print_dwarf_vma (end
, pointer_size
);
3479 printf (_("(base address)\n"));
3483 if (start
+ 2 > section_end
)
3485 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
3490 length
= byte_get (start
, 2);
3493 if (start
+ length
> section_end
)
3495 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
3500 print_dwarf_vma (begin
+ base_address
, pointer_size
);
3501 print_dwarf_vma (end
+ base_address
, pointer_size
);
3504 need_frame_base
= decode_location_expression (start
,
3507 cu_offset
, section
);
3510 if (need_frame_base
&& !has_frame_base
)
3511 printf (_(" [without DW_AT_frame_base]"));
3514 fputs (_(" (start == end)"), stdout
);
3515 else if (begin
> end
)
3516 fputs (_(" (start > end)"), stdout
);
3525 if (start
< section_end
)
3526 warn (_("There are %ld unused bytes at the end of section %s\n"),
3527 (long) (section_end
- start
), section
->name
);
3533 display_debug_str (struct dwarf_section
*section
,
3534 void *file ATTRIBUTE_UNUSED
)
3536 unsigned char *start
= section
->start
;
3537 unsigned long bytes
= section
->size
;
3538 dwarf_vma addr
= section
->address
;
3542 printf (_("\nThe %s section is empty.\n"), section
->name
);
3546 printf (_("Contents of the %s section:\n\n"), section
->name
);
3554 lbytes
= (bytes
> 16 ? 16 : bytes
);
3556 printf (" 0x%8.8lx ", (unsigned long) addr
);
3558 for (j
= 0; j
< 16; j
++)
3561 printf ("%2.2x", start
[j
]);
3569 for (j
= 0; j
< lbytes
; j
++)
3572 if (k
>= ' ' && k
< 0x80)
3591 display_debug_info (struct dwarf_section
*section
, void *file
)
3593 return process_debug_info (section
, file
, abbrev
, 0, 0);
3597 display_debug_types (struct dwarf_section
*section
, void *file
)
3599 return process_debug_info (section
, file
, abbrev
, 0, 1);
3603 display_trace_info (struct dwarf_section
*section
, void *file
)
3605 return process_debug_info (section
, file
, trace_abbrev
, 0, 0);
3609 display_debug_aranges (struct dwarf_section
*section
,
3610 void *file ATTRIBUTE_UNUSED
)
3612 unsigned char *start
= section
->start
;
3613 unsigned char *end
= start
+ section
->size
;
3615 printf (_("Contents of the %s section:\n\n"), section
->name
);
3617 /* It does not matter if this load fails,
3618 we test for that later on. */
3619 load_debug_info (file
);
3623 unsigned char *hdrptr
;
3624 DWARF2_Internal_ARange arange
;
3625 unsigned char *addr_ranges
;
3628 unsigned char address_size
;
3631 int initial_length_size
;
3635 arange
.ar_length
= byte_get (hdrptr
, 4);
3638 if (arange
.ar_length
== 0xffffffff)
3640 arange
.ar_length
= byte_get (hdrptr
, 8);
3643 initial_length_size
= 12;
3648 initial_length_size
= 4;
3651 arange
.ar_version
= byte_get (hdrptr
, 2);
3654 arange
.ar_info_offset
= byte_get (hdrptr
, offset_size
);
3655 hdrptr
+= offset_size
;
3657 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
3658 && num_debug_info_entries
> 0
3659 && find_debug_info_for_offset (arange
.ar_info_offset
) == NULL
)
3660 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3661 arange
.ar_info_offset
, section
->name
);
3663 arange
.ar_pointer_size
= byte_get (hdrptr
, 1);
3666 arange
.ar_segment_size
= byte_get (hdrptr
, 1);
3669 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
3671 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
3675 printf (_(" Length: %ld\n"), arange
.ar_length
);
3676 printf (_(" Version: %d\n"), arange
.ar_version
);
3677 printf (_(" Offset into .debug_info: 0x%lx\n"), arange
.ar_info_offset
);
3678 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
3679 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
3681 address_size
= arange
.ar_pointer_size
+ arange
.ar_segment_size
;
3683 /* The DWARF spec does not require that the address size be a power
3684 of two, but we do. This will have to change if we ever encounter
3685 an uneven architecture. */
3686 if ((address_size
& (address_size
- 1)) != 0)
3688 warn (_("Pointer size + Segment size is not a power of two.\n"));
3692 if (address_size
> 4)
3693 printf (_("\n Address Length\n"));
3695 printf (_("\n Address Length\n"));
3697 addr_ranges
= hdrptr
;
3699 /* Must pad to an alignment boundary that is twice the address size. */
3700 excess
= (hdrptr
- start
) % (2 * address_size
);
3702 addr_ranges
+= (2 * address_size
) - excess
;
3704 start
+= arange
.ar_length
+ initial_length_size
;
3706 while (addr_ranges
+ 2 * address_size
<= start
)
3708 address
= byte_get (addr_ranges
, address_size
);
3710 addr_ranges
+= address_size
;
3712 length
= byte_get (addr_ranges
, address_size
);
3714 addr_ranges
+= address_size
;
3717 print_dwarf_vma (address
, address_size
);
3718 print_dwarf_vma (length
, address_size
);
3728 /* Each debug_information[x].range_lists[y] gets this representation for
3729 sorting purposes. */
3733 /* The debug_information[x].range_lists[y] value. */
3734 unsigned long ranges_offset
;
3736 /* Original debug_information to find parameters of the data. */
3737 debug_info
*debug_info_p
;
3740 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
3743 range_entry_compar (const void *ap
, const void *bp
)
3745 const struct range_entry
*a_re
= (const struct range_entry
*) ap
;
3746 const struct range_entry
*b_re
= (const struct range_entry
*) bp
;
3747 const unsigned long a
= a_re
->ranges_offset
;
3748 const unsigned long b
= b_re
->ranges_offset
;
3750 return (a
> b
) - (b
> a
);
3754 display_debug_ranges (struct dwarf_section
*section
,
3755 void *file ATTRIBUTE_UNUSED
)
3757 unsigned char *start
= section
->start
;
3758 unsigned long bytes
;
3759 unsigned char *section_begin
= start
;
3760 unsigned int num_range_list
, i
;
3761 struct range_entry
*range_entries
, *range_entry_fill
;
3763 bytes
= section
->size
;
3767 printf (_("\nThe %s section is empty.\n"), section
->name
);
3771 if (load_debug_info (file
) == 0)
3773 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
3779 for (i
= 0; i
< num_debug_info_entries
; i
++)
3780 num_range_list
+= debug_information
[i
].num_range_lists
;
3782 if (num_range_list
== 0)
3783 error (_("No range lists in .debug_info section!\n"));
3785 range_entries
= (struct range_entry
*)
3786 xmalloc (sizeof (*range_entries
) * num_range_list
);
3787 range_entry_fill
= range_entries
;
3789 for (i
= 0; i
< num_debug_info_entries
; i
++)
3791 debug_info
*debug_info_p
= &debug_information
[i
];
3794 for (j
= 0; j
< debug_info_p
->num_range_lists
; j
++)
3796 range_entry_fill
->ranges_offset
= debug_info_p
->range_lists
[j
];
3797 range_entry_fill
->debug_info_p
= debug_info_p
;
3802 qsort (range_entries
, num_range_list
, sizeof (*range_entries
),
3803 range_entry_compar
);
3805 /* DWARF sections under Mach-O have non-zero addresses. */
3806 if (range_entries
[0].ranges_offset
!= section
->address
)
3807 warn (_("Range lists in %s section start at 0x%lx\n"),
3808 section
->name
, range_entries
[0].ranges_offset
);
3810 printf (_("Contents of the %s section:\n\n"), section
->name
);
3811 printf (_(" Offset Begin End\n"));
3813 for (i
= 0; i
< num_range_list
; i
++)
3815 struct range_entry
*range_entry
= &range_entries
[i
];
3816 debug_info
*debug_info_p
= range_entry
->debug_info_p
;
3817 unsigned int pointer_size
;
3818 unsigned long offset
;
3819 unsigned char *next
;
3820 unsigned long base_address
;
3822 pointer_size
= debug_info_p
->pointer_size
;
3824 /* DWARF sections under Mach-O have non-zero addresses. */
3825 offset
= range_entry
->ranges_offset
- section
->address
;
3826 next
= section_begin
+ offset
;
3827 base_address
= debug_info_p
->base_address
;
3832 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
3833 (unsigned long) (start
- section_begin
),
3834 (unsigned long) (next
- section_begin
), section
->name
);
3835 else if (start
> next
)
3836 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
3837 (unsigned long) (start
- section_begin
),
3838 (unsigned long) (next
- section_begin
), section
->name
);
3847 /* Note: we use sign extension here in order to be sure that
3848 we can detect the -1 escape value. Sign extension into the
3849 top 32 bits of a 32-bit address will not affect the values
3850 that we display since we always show hex values, and always
3851 the bottom 32-bits. */
3852 begin
= byte_get_signed (start
, pointer_size
);
3853 start
+= pointer_size
;
3854 end
= byte_get_signed (start
, pointer_size
);
3855 start
+= pointer_size
;
3857 printf (" %8.8lx ", offset
);
3859 if (begin
== 0 && end
== 0)
3861 printf (_("<End of list>\n"));
3865 /* Check base address specifiers. */
3866 if (begin
== (dwarf_vma
) -1 && end
!= (dwarf_vma
) -1)
3869 print_dwarf_vma (begin
, pointer_size
);
3870 print_dwarf_vma (end
, pointer_size
);
3871 printf ("(base address)\n");
3875 print_dwarf_vma (begin
+ base_address
, pointer_size
);
3876 print_dwarf_vma (end
+ base_address
, pointer_size
);
3879 fputs (_("(start == end)"), stdout
);
3880 else if (begin
> end
)
3881 fputs (_("(start > end)"), stdout
);
3888 free (range_entries
);
3893 typedef struct Frame_Chunk
3895 struct Frame_Chunk
*next
;
3896 unsigned char *chunk_start
;
3898 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
3899 short int *col_type
;
3902 unsigned int code_factor
;
3904 unsigned long pc_begin
;
3905 unsigned long pc_range
;
3909 unsigned char fde_encoding
;
3910 unsigned char cfa_exp
;
3911 unsigned char ptr_size
;
3912 unsigned char segment_size
;
3916 static const char *const *dwarf_regnames
;
3917 static unsigned int dwarf_regnames_count
;
3919 /* A marker for a col_type that means this column was never referenced
3920 in the frame info. */
3921 #define DW_CFA_unreferenced (-1)
3923 /* Return 0 if not more space is needed, 1 if more space is needed,
3924 -1 for invalid reg. */
3927 frame_need_space (Frame_Chunk
*fc
, unsigned int reg
)
3929 int prev
= fc
->ncols
;
3931 if (reg
< (unsigned int) fc
->ncols
)
3934 if (dwarf_regnames_count
3935 && reg
> dwarf_regnames_count
)
3938 fc
->ncols
= reg
+ 1;
3939 fc
->col_type
= (short int *) xcrealloc (fc
->col_type
, fc
->ncols
,
3940 sizeof (short int));
3941 fc
->col_offset
= (int *) xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
3943 while (prev
< fc
->ncols
)
3945 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
3946 fc
->col_offset
[prev
] = 0;
3952 static const char *const dwarf_regnames_i386
[] =
3954 "eax", "ecx", "edx", "ebx",
3955 "esp", "ebp", "esi", "edi",
3956 "eip", "eflags", NULL
,
3957 "st0", "st1", "st2", "st3",
3958 "st4", "st5", "st6", "st7",
3960 "xmm0", "xmm1", "xmm2", "xmm3",
3961 "xmm4", "xmm5", "xmm6", "xmm7",
3962 "mm0", "mm1", "mm2", "mm3",
3963 "mm4", "mm5", "mm6", "mm7",
3964 "fcw", "fsw", "mxcsr",
3965 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
3970 init_dwarf_regnames_i386 (void)
3972 dwarf_regnames
= dwarf_regnames_i386
;
3973 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_i386
);
3976 static const char *const dwarf_regnames_x86_64
[] =
3978 "rax", "rdx", "rcx", "rbx",
3979 "rsi", "rdi", "rbp", "rsp",
3980 "r8", "r9", "r10", "r11",
3981 "r12", "r13", "r14", "r15",
3983 "xmm0", "xmm1", "xmm2", "xmm3",
3984 "xmm4", "xmm5", "xmm6", "xmm7",
3985 "xmm8", "xmm9", "xmm10", "xmm11",
3986 "xmm12", "xmm13", "xmm14", "xmm15",
3987 "st0", "st1", "st2", "st3",
3988 "st4", "st5", "st6", "st7",
3989 "mm0", "mm1", "mm2", "mm3",
3990 "mm4", "mm5", "mm6", "mm7",
3992 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
3993 "fs.base", "gs.base", NULL
, NULL
,
3995 "mxcsr", "fcw", "fsw"
3999 init_dwarf_regnames_x86_64 (void)
4001 dwarf_regnames
= dwarf_regnames_x86_64
;
4002 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_x86_64
);
4006 init_dwarf_regnames (unsigned int e_machine
)
4012 init_dwarf_regnames_i386 ();
4017 init_dwarf_regnames_x86_64 ();
4026 regname (unsigned int regno
, int row
)
4028 static char reg
[64];
4030 && regno
< dwarf_regnames_count
4031 && dwarf_regnames
[regno
] != NULL
)
4034 return dwarf_regnames
[regno
];
4035 snprintf (reg
, sizeof (reg
), "r%d (%s)", regno
,
4036 dwarf_regnames
[regno
]);
4039 snprintf (reg
, sizeof (reg
), "r%d", regno
);
4044 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, int *max_regs
)
4049 if (*max_regs
< fc
->ncols
)
4050 *max_regs
= fc
->ncols
;
4052 if (*need_col_headers
)
4054 static const char *sloc
= " LOC";
4056 *need_col_headers
= 0;
4058 printf ("%-*s CFA ", eh_addr_size
* 2, sloc
);
4060 for (r
= 0; r
< *max_regs
; r
++)
4061 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
4066 printf ("%-5s ", regname (r
, 1));
4072 printf ("%0*lx ", eh_addr_size
* 2, fc
->pc_begin
);
4074 strcpy (tmp
, "exp");
4076 sprintf (tmp
, "%s%+d", regname (fc
->cfa_reg
, 1), fc
->cfa_offset
);
4077 printf ("%-8s ", tmp
);
4079 for (r
= 0; r
< fc
->ncols
; r
++)
4081 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
4083 switch (fc
->col_type
[r
])
4085 case DW_CFA_undefined
:
4088 case DW_CFA_same_value
:
4092 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
4094 case DW_CFA_val_offset
:
4095 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
4097 case DW_CFA_register
:
4098 sprintf (tmp
, "%s", regname (fc
->col_offset
[r
], 0));
4100 case DW_CFA_expression
:
4101 strcpy (tmp
, "exp");
4103 case DW_CFA_val_expression
:
4104 strcpy (tmp
, "vexp");
4107 strcpy (tmp
, "n/a");
4110 printf ("%-5s ", tmp
);
4116 #define GET(N) byte_get (start, N); start += N
4117 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
4118 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
4121 display_debug_frames (struct dwarf_section
*section
,
4122 void *file ATTRIBUTE_UNUSED
)
4124 unsigned char *start
= section
->start
;
4125 unsigned char *end
= start
+ section
->size
;
4126 unsigned char *section_start
= start
;
4127 Frame_Chunk
*chunks
= 0;
4128 Frame_Chunk
*remembered_state
= 0;
4130 int is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
4131 unsigned int length_return
;
4133 const char *bad_reg
= _("bad register: ");
4134 int saved_eh_addr_size
= eh_addr_size
;
4136 printf (_("Contents of the %s section:\n"), section
->name
);
4140 unsigned char *saved_start
;
4141 unsigned char *block_end
;
4142 unsigned long length
;
4143 unsigned long cie_id
;
4146 int need_col_headers
= 1;
4147 unsigned char *augmentation_data
= NULL
;
4148 unsigned long augmentation_data_len
= 0;
4149 int encoded_ptr_size
= saved_eh_addr_size
;
4151 int initial_length_size
;
4153 saved_start
= start
;
4154 length
= byte_get (start
, 4); start
+= 4;
4158 printf ("\n%08lx ZERO terminator\n\n",
4159 (unsigned long)(saved_start
- section_start
));
4163 if (length
== 0xffffffff)
4165 length
= byte_get (start
, 8);
4168 initial_length_size
= 12;
4173 initial_length_size
= 4;
4176 block_end
= saved_start
+ length
+ initial_length_size
;
4177 if (block_end
> end
)
4179 warn ("Invalid length %#08lx in FDE at %#08lx\n",
4180 length
, (unsigned long)(saved_start
- section_start
));
4183 cie_id
= byte_get (start
, offset_size
); start
+= offset_size
;
4185 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
4189 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
4190 memset (fc
, 0, sizeof (Frame_Chunk
));
4194 fc
->chunk_start
= saved_start
;
4196 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
4197 fc
->col_offset
= (int *) xmalloc (sizeof (int));
4198 frame_need_space (fc
, max_regs
- 1);
4202 fc
->augmentation
= (char *) start
;
4203 start
= (unsigned char *) strchr ((char *) start
, '\0') + 1;
4205 if (strcmp (fc
->augmentation
, "eh") == 0)
4206 start
+= eh_addr_size
;
4210 fc
->ptr_size
= GET (1);
4211 fc
->segment_size
= GET (1);
4212 eh_addr_size
= fc
->ptr_size
;
4216 fc
->ptr_size
= eh_addr_size
;
4217 fc
->segment_size
= 0;
4219 fc
->code_factor
= LEB ();
4220 fc
->data_factor
= SLEB ();
4230 if (fc
->augmentation
[0] == 'z')
4232 augmentation_data_len
= LEB ();
4233 augmentation_data
= start
;
4234 start
+= augmentation_data_len
;
4238 if (do_debug_frames_interp
)
4239 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
4240 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
4241 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
4245 printf ("\n%08lx %08lx %08lx CIE\n",
4246 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
4247 printf (" Version: %d\n", version
);
4248 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
4251 printf (" Pointer Size: %u\n", fc
->ptr_size
);
4252 printf (" Segment Size: %u\n", fc
->segment_size
);
4254 printf (" Code alignment factor: %u\n", fc
->code_factor
);
4255 printf (" Data alignment factor: %d\n", fc
->data_factor
);
4256 printf (" Return address column: %d\n", fc
->ra
);
4258 if (augmentation_data_len
)
4261 printf (" Augmentation data: ");
4262 for (i
= 0; i
< augmentation_data_len
; ++i
)
4263 printf (" %02x", augmentation_data
[i
]);
4269 if (augmentation_data_len
)
4271 unsigned char *p
, *q
;
4272 p
= (unsigned char *) fc
->augmentation
+ 1;
4273 q
= augmentation_data
;
4280 q
+= 1 + size_of_encoded_value (*q
);
4282 fc
->fde_encoding
= *q
++;
4290 if (fc
->fde_encoding
)
4291 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
4294 frame_need_space (fc
, fc
->ra
);
4298 unsigned char *look_for
;
4299 static Frame_Chunk fde_fc
;
4300 unsigned long segment_selector
;
4303 memset (fc
, 0, sizeof (Frame_Chunk
));
4305 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
4307 for (cie
= chunks
; cie
; cie
= cie
->next
)
4308 if (cie
->chunk_start
== look_for
)
4313 warn ("Invalid CIE pointer %#08lx in FDE at %#08lx\n",
4314 cie_id
, (unsigned long)(saved_start
- section_start
));
4316 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
4317 fc
->col_offset
= (int *) xmalloc (sizeof (int));
4318 frame_need_space (fc
, max_regs
- 1);
4320 fc
->augmentation
= "";
4321 fc
->fde_encoding
= 0;
4322 fc
->ptr_size
= eh_addr_size
;
4323 fc
->segment_size
= 0;
4327 fc
->ncols
= cie
->ncols
;
4328 fc
->col_type
= (short int *) xcmalloc (fc
->ncols
, sizeof (short int));
4329 fc
->col_offset
= (int *) xcmalloc (fc
->ncols
, sizeof (int));
4330 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
4331 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
4332 fc
->augmentation
= cie
->augmentation
;
4333 fc
->ptr_size
= cie
->ptr_size
;
4334 eh_addr_size
= cie
->ptr_size
;
4335 fc
->segment_size
= cie
->segment_size
;
4336 fc
->code_factor
= cie
->code_factor
;
4337 fc
->data_factor
= cie
->data_factor
;
4338 fc
->cfa_reg
= cie
->cfa_reg
;
4339 fc
->cfa_offset
= cie
->cfa_offset
;
4341 frame_need_space (fc
, max_regs
- 1);
4342 fc
->fde_encoding
= cie
->fde_encoding
;
4345 if (fc
->fde_encoding
)
4346 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
4348 segment_selector
= 0;
4349 if (fc
->segment_size
)
4351 segment_selector
= byte_get (start
, fc
->segment_size
);
4352 start
+= fc
->segment_size
;
4354 fc
->pc_begin
= get_encoded_value (start
, fc
->fde_encoding
);
4355 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
)
4356 fc
->pc_begin
+= section
->address
+ (start
- section_start
);
4357 start
+= encoded_ptr_size
;
4358 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
4359 start
+= encoded_ptr_size
;
4361 if (cie
->augmentation
[0] == 'z')
4363 augmentation_data_len
= LEB ();
4364 augmentation_data
= start
;
4365 start
+= augmentation_data_len
;
4368 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=",
4369 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
4370 (unsigned long)(cie
->chunk_start
- section_start
));
4371 if (fc
->segment_size
)
4372 printf ("%04lx:", segment_selector
);
4373 printf ("%08lx..%08lx\n", fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
4374 if (! do_debug_frames_interp
&& augmentation_data_len
)
4378 printf (" Augmentation data: ");
4379 for (i
= 0; i
< augmentation_data_len
; ++i
)
4380 printf (" %02x", augmentation_data
[i
]);
4386 /* At this point, fc is the current chunk, cie (if any) is set, and
4387 we're about to interpret instructions for the chunk. */
4388 /* ??? At present we need to do this always, since this sizes the
4389 fc->col_type and fc->col_offset arrays, which we write into always.
4390 We should probably split the interpreted and non-interpreted bits
4391 into two different routines, since there's so much that doesn't
4392 really overlap between them. */
4393 if (1 || do_debug_frames_interp
)
4395 /* Start by making a pass over the chunk, allocating storage
4396 and taking note of what registers are used. */
4397 unsigned char *tmp
= start
;
4399 while (start
< block_end
)
4402 unsigned long reg
, temp
;
4409 /* Warning: if you add any more cases to this switch, be
4410 sure to add them to the corresponding switch below. */
4413 case DW_CFA_advance_loc
:
4417 if (frame_need_space (fc
, opa
) >= 0)
4418 fc
->col_type
[opa
] = DW_CFA_undefined
;
4420 case DW_CFA_restore
:
4421 if (frame_need_space (fc
, opa
) >= 0)
4422 fc
->col_type
[opa
] = DW_CFA_undefined
;
4424 case DW_CFA_set_loc
:
4425 start
+= encoded_ptr_size
;
4427 case DW_CFA_advance_loc1
:
4430 case DW_CFA_advance_loc2
:
4433 case DW_CFA_advance_loc4
:
4436 case DW_CFA_offset_extended
:
4437 case DW_CFA_val_offset
:
4438 reg
= LEB (); LEB ();
4439 if (frame_need_space (fc
, reg
) >= 0)
4440 fc
->col_type
[reg
] = DW_CFA_undefined
;
4442 case DW_CFA_restore_extended
:
4444 frame_need_space (fc
, reg
);
4445 if (frame_need_space (fc
, reg
) >= 0)
4446 fc
->col_type
[reg
] = DW_CFA_undefined
;
4448 case DW_CFA_undefined
:
4450 if (frame_need_space (fc
, reg
) >= 0)
4451 fc
->col_type
[reg
] = DW_CFA_undefined
;
4453 case DW_CFA_same_value
:
4455 if (frame_need_space (fc
, reg
) >= 0)
4456 fc
->col_type
[reg
] = DW_CFA_undefined
;
4458 case DW_CFA_register
:
4459 reg
= LEB (); LEB ();
4460 if (frame_need_space (fc
, reg
) >= 0)
4461 fc
->col_type
[reg
] = DW_CFA_undefined
;
4463 case DW_CFA_def_cfa
:
4466 case DW_CFA_def_cfa_register
:
4469 case DW_CFA_def_cfa_offset
:
4472 case DW_CFA_def_cfa_expression
:
4476 case DW_CFA_expression
:
4477 case DW_CFA_val_expression
:
4481 if (frame_need_space (fc
, reg
) >= 0)
4482 fc
->col_type
[reg
] = DW_CFA_undefined
;
4484 case DW_CFA_offset_extended_sf
:
4485 case DW_CFA_val_offset_sf
:
4486 reg
= LEB (); SLEB ();
4487 if (frame_need_space (fc
, reg
) >= 0)
4488 fc
->col_type
[reg
] = DW_CFA_undefined
;
4490 case DW_CFA_def_cfa_sf
:
4493 case DW_CFA_def_cfa_offset_sf
:
4496 case DW_CFA_MIPS_advance_loc8
:
4499 case DW_CFA_GNU_args_size
:
4502 case DW_CFA_GNU_negative_offset_extended
:
4503 reg
= LEB (); LEB ();
4504 if (frame_need_space (fc
, reg
) >= 0)
4505 fc
->col_type
[reg
] = DW_CFA_undefined
;
4514 /* Now we know what registers are used, make a second pass over
4515 the chunk, this time actually printing out the info. */
4517 while (start
< block_end
)
4520 unsigned long ul
, reg
, roffs
;
4523 const char *reg_prefix
= "";
4530 /* Warning: if you add any more cases to this switch, be
4531 sure to add them to the corresponding switch above. */
4534 case DW_CFA_advance_loc
:
4535 if (do_debug_frames_interp
)
4536 frame_display_row (fc
, &need_col_headers
, &max_regs
);
4538 printf (" DW_CFA_advance_loc: %d to %08lx\n",
4539 opa
* fc
->code_factor
,
4540 fc
->pc_begin
+ opa
* fc
->code_factor
);
4541 fc
->pc_begin
+= opa
* fc
->code_factor
;
4546 if (opa
>= (unsigned int) fc
->ncols
)
4547 reg_prefix
= bad_reg
;
4548 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4549 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
4550 reg_prefix
, regname (opa
, 0),
4551 roffs
* fc
->data_factor
);
4552 if (*reg_prefix
== '\0')
4554 fc
->col_type
[opa
] = DW_CFA_offset
;
4555 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
4559 case DW_CFA_restore
:
4560 if (opa
>= (unsigned int) cie
->ncols
4561 || opa
>= (unsigned int) fc
->ncols
)
4562 reg_prefix
= bad_reg
;
4563 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4564 printf (" DW_CFA_restore: %s%s\n",
4565 reg_prefix
, regname (opa
, 0));
4566 if (*reg_prefix
== '\0')
4568 fc
->col_type
[opa
] = cie
->col_type
[opa
];
4569 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
4573 case DW_CFA_set_loc
:
4574 vma
= get_encoded_value (start
, fc
->fde_encoding
);
4575 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
)
4576 vma
+= section
->address
+ (start
- section_start
);
4577 start
+= encoded_ptr_size
;
4578 if (do_debug_frames_interp
)
4579 frame_display_row (fc
, &need_col_headers
, &max_regs
);
4581 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
4585 case DW_CFA_advance_loc1
:
4586 ofs
= byte_get (start
, 1); start
+= 1;
4587 if (do_debug_frames_interp
)
4588 frame_display_row (fc
, &need_col_headers
, &max_regs
);
4590 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
4591 ofs
* fc
->code_factor
,
4592 fc
->pc_begin
+ ofs
* fc
->code_factor
);
4593 fc
->pc_begin
+= ofs
* fc
->code_factor
;
4596 case DW_CFA_advance_loc2
:
4597 ofs
= byte_get (start
, 2); start
+= 2;
4598 if (do_debug_frames_interp
)
4599 frame_display_row (fc
, &need_col_headers
, &max_regs
);
4601 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
4602 ofs
* fc
->code_factor
,
4603 fc
->pc_begin
+ ofs
* fc
->code_factor
);
4604 fc
->pc_begin
+= ofs
* fc
->code_factor
;
4607 case DW_CFA_advance_loc4
:
4608 ofs
= byte_get (start
, 4); start
+= 4;
4609 if (do_debug_frames_interp
)
4610 frame_display_row (fc
, &need_col_headers
, &max_regs
);
4612 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
4613 ofs
* fc
->code_factor
,
4614 fc
->pc_begin
+ ofs
* fc
->code_factor
);
4615 fc
->pc_begin
+= ofs
* fc
->code_factor
;
4618 case DW_CFA_offset_extended
:
4621 if (reg
>= (unsigned int) fc
->ncols
)
4622 reg_prefix
= bad_reg
;
4623 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4624 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
4625 reg_prefix
, regname (reg
, 0),
4626 roffs
* fc
->data_factor
);
4627 if (*reg_prefix
== '\0')
4629 fc
->col_type
[reg
] = DW_CFA_offset
;
4630 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
4634 case DW_CFA_val_offset
:
4637 if (reg
>= (unsigned int) fc
->ncols
)
4638 reg_prefix
= bad_reg
;
4639 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4640 printf (" DW_CFA_val_offset: %s%s at cfa%+ld\n",
4641 reg_prefix
, regname (reg
, 0),
4642 roffs
* fc
->data_factor
);
4643 if (*reg_prefix
== '\0')
4645 fc
->col_type
[reg
] = DW_CFA_val_offset
;
4646 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
4650 case DW_CFA_restore_extended
:
4652 if (reg
>= (unsigned int) cie
->ncols
4653 || reg
>= (unsigned int) fc
->ncols
)
4654 reg_prefix
= bad_reg
;
4655 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4656 printf (" DW_CFA_restore_extended: %s%s\n",
4657 reg_prefix
, regname (reg
, 0));
4658 if (*reg_prefix
== '\0')
4660 fc
->col_type
[reg
] = cie
->col_type
[reg
];
4661 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
4665 case DW_CFA_undefined
:
4667 if (reg
>= (unsigned int) fc
->ncols
)
4668 reg_prefix
= bad_reg
;
4669 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4670 printf (" DW_CFA_undefined: %s%s\n",
4671 reg_prefix
, regname (reg
, 0));
4672 if (*reg_prefix
== '\0')
4674 fc
->col_type
[reg
] = DW_CFA_undefined
;
4675 fc
->col_offset
[reg
] = 0;
4679 case DW_CFA_same_value
:
4681 if (reg
>= (unsigned int) fc
->ncols
)
4682 reg_prefix
= bad_reg
;
4683 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4684 printf (" DW_CFA_same_value: %s%s\n",
4685 reg_prefix
, regname (reg
, 0));
4686 if (*reg_prefix
== '\0')
4688 fc
->col_type
[reg
] = DW_CFA_same_value
;
4689 fc
->col_offset
[reg
] = 0;
4693 case DW_CFA_register
:
4696 if (reg
>= (unsigned int) fc
->ncols
)
4697 reg_prefix
= bad_reg
;
4698 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4700 printf (" DW_CFA_register: %s%s in ",
4701 reg_prefix
, regname (reg
, 0));
4702 puts (regname (roffs
, 0));
4704 if (*reg_prefix
== '\0')
4706 fc
->col_type
[reg
] = DW_CFA_register
;
4707 fc
->col_offset
[reg
] = roffs
;
4711 case DW_CFA_remember_state
:
4712 if (! do_debug_frames_interp
)
4713 printf (" DW_CFA_remember_state\n");
4714 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
4715 rs
->ncols
= fc
->ncols
;
4716 rs
->col_type
= (short int *) xcmalloc (rs
->ncols
,
4717 sizeof (short int));
4718 rs
->col_offset
= (int *) xcmalloc (rs
->ncols
, sizeof (int));
4719 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
4720 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
4721 rs
->next
= remembered_state
;
4722 remembered_state
= rs
;
4725 case DW_CFA_restore_state
:
4726 if (! do_debug_frames_interp
)
4727 printf (" DW_CFA_restore_state\n");
4728 rs
= remembered_state
;
4731 remembered_state
= rs
->next
;
4732 frame_need_space (fc
, rs
->ncols
- 1);
4733 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
4734 memcpy (fc
->col_offset
, rs
->col_offset
,
4735 rs
->ncols
* sizeof (int));
4736 free (rs
->col_type
);
4737 free (rs
->col_offset
);
4740 else if (do_debug_frames_interp
)
4741 printf ("Mismatched DW_CFA_restore_state\n");
4744 case DW_CFA_def_cfa
:
4745 fc
->cfa_reg
= LEB ();
4746 fc
->cfa_offset
= LEB ();
4748 if (! do_debug_frames_interp
)
4749 printf (" DW_CFA_def_cfa: %s ofs %d\n",
4750 regname (fc
->cfa_reg
, 0), fc
->cfa_offset
);
4753 case DW_CFA_def_cfa_register
:
4754 fc
->cfa_reg
= LEB ();
4756 if (! do_debug_frames_interp
)
4757 printf (" DW_CFA_def_cfa_register: %s\n",
4758 regname (fc
->cfa_reg
, 0));
4761 case DW_CFA_def_cfa_offset
:
4762 fc
->cfa_offset
= LEB ();
4763 if (! do_debug_frames_interp
)
4764 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
4768 if (! do_debug_frames_interp
)
4769 printf (" DW_CFA_nop\n");
4772 case DW_CFA_def_cfa_expression
:
4774 if (! do_debug_frames_interp
)
4776 printf (" DW_CFA_def_cfa_expression (");
4777 decode_location_expression (start
, eh_addr_size
, ul
, 0,
4785 case DW_CFA_expression
:
4788 if (reg
>= (unsigned int) fc
->ncols
)
4789 reg_prefix
= bad_reg
;
4790 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4792 printf (" DW_CFA_expression: %s%s (",
4793 reg_prefix
, regname (reg
, 0));
4794 decode_location_expression (start
, eh_addr_size
,
4798 if (*reg_prefix
== '\0')
4799 fc
->col_type
[reg
] = DW_CFA_expression
;
4803 case DW_CFA_val_expression
:
4806 if (reg
>= (unsigned int) fc
->ncols
)
4807 reg_prefix
= bad_reg
;
4808 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4810 printf (" DW_CFA_val_expression: %s%s (",
4811 reg_prefix
, regname (reg
, 0));
4812 decode_location_expression (start
, eh_addr_size
, ul
, 0,
4816 if (*reg_prefix
== '\0')
4817 fc
->col_type
[reg
] = DW_CFA_val_expression
;
4821 case DW_CFA_offset_extended_sf
:
4824 if (frame_need_space (fc
, reg
) < 0)
4825 reg_prefix
= bad_reg
;
4826 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4827 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
4828 reg_prefix
, regname (reg
, 0),
4829 l
* fc
->data_factor
);
4830 if (*reg_prefix
== '\0')
4832 fc
->col_type
[reg
] = DW_CFA_offset
;
4833 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
4837 case DW_CFA_val_offset_sf
:
4840 if (frame_need_space (fc
, reg
) < 0)
4841 reg_prefix
= bad_reg
;
4842 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4843 printf (" DW_CFA_val_offset_sf: %s%s at cfa%+ld\n",
4844 reg_prefix
, regname (reg
, 0),
4845 l
* fc
->data_factor
);
4846 if (*reg_prefix
== '\0')
4848 fc
->col_type
[reg
] = DW_CFA_val_offset
;
4849 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
4853 case DW_CFA_def_cfa_sf
:
4854 fc
->cfa_reg
= LEB ();
4855 fc
->cfa_offset
= SLEB ();
4856 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
4858 if (! do_debug_frames_interp
)
4859 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
4860 regname (fc
->cfa_reg
, 0), fc
->cfa_offset
);
4863 case DW_CFA_def_cfa_offset_sf
:
4864 fc
->cfa_offset
= SLEB ();
4865 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
4866 if (! do_debug_frames_interp
)
4867 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
4870 case DW_CFA_MIPS_advance_loc8
:
4871 ofs
= byte_get (start
, 8); start
+= 8;
4872 if (do_debug_frames_interp
)
4873 frame_display_row (fc
, &need_col_headers
, &max_regs
);
4875 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
4876 ofs
* fc
->code_factor
,
4877 fc
->pc_begin
+ ofs
* fc
->code_factor
);
4878 fc
->pc_begin
+= ofs
* fc
->code_factor
;
4881 case DW_CFA_GNU_window_save
:
4882 if (! do_debug_frames_interp
)
4883 printf (" DW_CFA_GNU_window_save\n");
4886 case DW_CFA_GNU_args_size
:
4888 if (! do_debug_frames_interp
)
4889 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
4892 case DW_CFA_GNU_negative_offset_extended
:
4895 if (frame_need_space (fc
, reg
) < 0)
4896 reg_prefix
= bad_reg
;
4897 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4898 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
4899 reg_prefix
, regname (reg
, 0),
4900 l
* fc
->data_factor
);
4901 if (*reg_prefix
== '\0')
4903 fc
->col_type
[reg
] = DW_CFA_offset
;
4904 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
4909 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
4910 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
4912 warn (_("unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
4917 if (do_debug_frames_interp
)
4918 frame_display_row (fc
, &need_col_headers
, &max_regs
);
4921 eh_addr_size
= saved_eh_addr_size
;
4934 display_debug_not_supported (struct dwarf_section
*section
,
4935 void *file ATTRIBUTE_UNUSED
)
4937 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
4944 cmalloc (size_t nmemb
, size_t size
)
4946 /* Check for overflow. */
4947 if (nmemb
>= ~(size_t) 0 / size
)
4950 return malloc (nmemb
* size
);
4954 xcmalloc (size_t nmemb
, size_t size
)
4956 /* Check for overflow. */
4957 if (nmemb
>= ~(size_t) 0 / size
)
4960 return xmalloc (nmemb
* size
);
4964 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
4966 /* Check for overflow. */
4967 if (nmemb
>= ~(size_t) 0 / size
)
4970 return xrealloc (ptr
, nmemb
* size
);
4974 error (const char *message
, ...)
4978 va_start (args
, message
);
4979 fprintf (stderr
, _("%s: Error: "), program_name
);
4980 vfprintf (stderr
, message
, args
);
4985 warn (const char *message
, ...)
4989 va_start (args
, message
);
4990 fprintf (stderr
, _("%s: Warning: "), program_name
);
4991 vfprintf (stderr
, message
, args
);
4996 free_debug_memory (void)
5002 for (i
= 0; i
< max
; i
++)
5003 free_debug_section ((enum dwarf_section_display_enum
) i
);
5005 if (debug_information
!= NULL
)
5007 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
)
5009 for (i
= 0; i
< num_debug_info_entries
; i
++)
5011 if (!debug_information
[i
].max_loc_offsets
)
5013 free (debug_information
[i
].loc_offsets
);
5014 free (debug_information
[i
].have_frame_base
);
5016 if (!debug_information
[i
].max_range_lists
)
5017 free (debug_information
[i
].range_lists
);
5021 free (debug_information
);
5022 debug_information
= NULL
;
5023 num_debug_info_entries
= 0;
5028 dwarf_select_sections_by_names (const char *names
)
5032 const char * option
;
5036 debug_dump_long_opts
;
5038 static const debug_dump_long_opts opts_table
[] =
5040 /* Please keep this table alpha- sorted. */
5041 { "Ranges", & do_debug_ranges
, 1 },
5042 { "abbrev", & do_debug_abbrevs
, 1 },
5043 { "aranges", & do_debug_aranges
, 1 },
5044 { "frames", & do_debug_frames
, 1 },
5045 { "frames-interp", & do_debug_frames_interp
, 1 },
5046 { "info", & do_debug_info
, 1 },
5047 { "line", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
}, /* For backwards compatibility. */
5048 { "rawline", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
5049 { "decodedline", & do_debug_lines
, FLAG_DEBUG_LINES_DECODED
},
5050 { "loc", & do_debug_loc
, 1 },
5051 { "macro", & do_debug_macinfo
, 1 },
5052 { "pubnames", & do_debug_pubnames
, 1 },
5053 { "pubtypes", & do_debug_pubtypes
, 1 },
5054 /* This entry is for compatability
5055 with earlier versions of readelf. */
5056 { "ranges", & do_debug_aranges
, 1 },
5057 { "str", & do_debug_str
, 1 },
5058 /* These trace_* sections are used by Itanium VMS. */
5059 { "trace_abbrev", & do_trace_abbrevs
, 1 },
5060 { "trace_aranges", & do_trace_aranges
, 1 },
5061 { "trace_info", & do_trace_info
, 1 },
5070 const debug_dump_long_opts
* entry
;
5072 for (entry
= opts_table
; entry
->option
; entry
++)
5074 size_t len
= strlen (entry
->option
);
5076 if (strncmp (p
, entry
->option
, len
) == 0
5077 && (p
[len
] == ',' || p
[len
] == '\0'))
5079 * entry
->variable
|= entry
->val
;
5081 /* The --debug-dump=frames-interp option also
5082 enables the --debug-dump=frames option. */
5083 if (do_debug_frames_interp
)
5084 do_debug_frames
= 1;
5091 if (entry
->option
== NULL
)
5093 warn (_("Unrecognized debug option '%s'\n"), p
);
5094 p
= strchr (p
, ',');
5105 dwarf_select_sections_by_letters (const char *letters
)
5107 unsigned int lindex
= 0;
5109 while (letters
[lindex
])
5110 switch (letters
[lindex
++])
5117 do_debug_abbrevs
= 1;
5121 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
5125 do_debug_lines
|= FLAG_DEBUG_LINES_DECODED
;
5129 do_debug_pubnames
= 1;
5133 do_debug_pubtypes
= 1;
5137 do_debug_aranges
= 1;
5141 do_debug_ranges
= 1;
5145 do_debug_frames_interp
= 1;
5147 do_debug_frames
= 1;
5151 do_debug_macinfo
= 1;
5163 warn (_("Unrecognized debug option '%s'\n"), optarg
);
5169 dwarf_select_sections_all (void)
5172 do_debug_abbrevs
= 1;
5173 do_debug_lines
= FLAG_DEBUG_LINES_RAW
;
5174 do_debug_pubnames
= 1;
5175 do_debug_pubtypes
= 1;
5176 do_debug_aranges
= 1;
5177 do_debug_ranges
= 1;
5178 do_debug_frames
= 1;
5179 do_debug_macinfo
= 1;
5183 do_trace_abbrevs
= 1;
5184 do_trace_aranges
= 1;
5187 struct dwarf_section_display debug_displays
[] =
5189 { { ".debug_abbrev", ".zdebug_abbrev", NULL
, NULL
, 0, 0 },
5190 display_debug_abbrev
, &do_debug_abbrevs
, 0 },
5191 { { ".debug_aranges", ".zdebug_aranges", NULL
, NULL
, 0, 0 },
5192 display_debug_aranges
, &do_debug_aranges
, 1 },
5193 { { ".debug_frame", ".zdebug_frame", NULL
, NULL
, 0, 0 },
5194 display_debug_frames
, &do_debug_frames
, 1 },
5195 { { ".debug_info", ".zdebug_info", NULL
, NULL
, 0, 0 },
5196 display_debug_info
, &do_debug_info
, 1 },
5197 { { ".debug_line", ".zdebug_line", NULL
, NULL
, 0, 0 },
5198 display_debug_lines
, &do_debug_lines
, 1 },
5199 { { ".debug_pubnames", ".zdebug_pubnames", NULL
, NULL
, 0, 0 },
5200 display_debug_pubnames
, &do_debug_pubnames
, 0 },
5201 { { ".eh_frame", "", NULL
, NULL
, 0, 0 },
5202 display_debug_frames
, &do_debug_frames
, 1 },
5203 { { ".debug_macinfo", ".zdebug_macinfo", NULL
, NULL
, 0, 0 },
5204 display_debug_macinfo
, &do_debug_macinfo
, 0 },
5205 { { ".debug_str", ".zdebug_str", NULL
, NULL
, 0, 0 },
5206 display_debug_str
, &do_debug_str
, 0 },
5207 { { ".debug_loc", ".zdebug_loc", NULL
, NULL
, 0, 0 },
5208 display_debug_loc
, &do_debug_loc
, 1 },
5209 { { ".debug_pubtypes", ".zdebug_pubtypes", NULL
, NULL
, 0, 0 },
5210 display_debug_pubnames
, &do_debug_pubtypes
, 0 },
5211 { { ".debug_ranges", ".zdebug_ranges", NULL
, NULL
, 0, 0 },
5212 display_debug_ranges
, &do_debug_ranges
, 1 },
5213 { { ".debug_static_func", ".zdebug_static_func", NULL
, NULL
, 0, 0 },
5214 display_debug_not_supported
, NULL
, 0 },
5215 { { ".debug_static_vars", ".zdebug_static_vars", NULL
, NULL
, 0, 0 },
5216 display_debug_not_supported
, NULL
, 0 },
5217 { { ".debug_types", ".zdebug_types", NULL
, NULL
, 0, 0 },
5218 display_debug_types
, &do_debug_info
, 1 },
5219 { { ".debug_weaknames", ".zdebug_weaknames", NULL
, NULL
, 0, 0 },
5220 display_debug_not_supported
, NULL
, 0 },
5221 { { ".trace_info", "", NULL
, NULL
, 0, 0 },
5222 display_trace_info
, &do_trace_info
, 1 },
5223 { { ".trace_abbrev", "", NULL
, NULL
, 0, 0 },
5224 display_debug_abbrev
, &do_trace_abbrevs
, 0 },
5225 { { ".trace_aranges", "", NULL
, NULL
, 0, 0 },
5226 display_debug_aranges
, &do_trace_aranges
, 0 }