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 int offset_size
,
717 unsigned long length
,
718 unsigned long cu_offset
,
719 struct dwarf_section
* section
)
722 unsigned int bytes_read
;
723 unsigned long uvalue
;
724 unsigned char *end
= data
+ length
;
725 int need_frame_base
= 0;
734 printf ("DW_OP_addr: %lx",
735 (unsigned long) byte_get (data
, pointer_size
));
736 data
+= pointer_size
;
739 printf ("DW_OP_deref");
742 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
745 printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data
++, 1));
748 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
752 printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data
, 2));
756 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
760 printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data
, 4));
764 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
765 (unsigned long) byte_get (data
+ 4, 4));
769 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
770 (long) byte_get (data
+ 4, 4));
774 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
778 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
782 printf ("DW_OP_dup");
785 printf ("DW_OP_drop");
788 printf ("DW_OP_over");
791 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
794 printf ("DW_OP_swap");
797 printf ("DW_OP_rot");
800 printf ("DW_OP_xderef");
803 printf ("DW_OP_abs");
806 printf ("DW_OP_and");
809 printf ("DW_OP_div");
812 printf ("DW_OP_minus");
815 printf ("DW_OP_mod");
818 printf ("DW_OP_mul");
821 printf ("DW_OP_neg");
824 printf ("DW_OP_not");
830 printf ("DW_OP_plus");
832 case DW_OP_plus_uconst
:
833 printf ("DW_OP_plus_uconst: %lu",
834 read_leb128 (data
, &bytes_read
, 0));
838 printf ("DW_OP_shl");
841 printf ("DW_OP_shr");
844 printf ("DW_OP_shra");
847 printf ("DW_OP_xor");
850 printf ("DW_OP_bra: %ld", (long) byte_get_signed (data
, 2));
872 printf ("DW_OP_skip: %ld", (long) byte_get_signed (data
, 2));
908 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
943 printf ("DW_OP_reg%d (%s)", op
- DW_OP_reg0
,
944 regname (op
- DW_OP_reg0
, 1));
979 printf ("DW_OP_breg%d (%s): %ld", op
- DW_OP_breg0
,
980 regname (op
- DW_OP_breg0
, 1),
981 read_leb128 (data
, &bytes_read
, 1));
986 uvalue
= read_leb128 (data
, &bytes_read
, 0);
988 printf ("DW_OP_regx: %lu (%s)", uvalue
, regname (uvalue
, 1));
992 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
996 uvalue
= read_leb128 (data
, &bytes_read
, 0);
998 printf ("DW_OP_bregx: %lu (%s) %ld", uvalue
, regname (uvalue
, 1),
999 read_leb128 (data
, &bytes_read
, 1));
1003 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
1006 case DW_OP_deref_size
:
1007 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
1009 case DW_OP_xderef_size
:
1010 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
1013 printf ("DW_OP_nop");
1016 /* DWARF 3 extensions. */
1017 case DW_OP_push_object_address
:
1018 printf ("DW_OP_push_object_address");
1021 /* XXX: Strictly speaking for 64-bit DWARF3 files
1022 this ought to be an 8-byte wide computation. */
1023 printf ("DW_OP_call2: <0x%lx>", (long) byte_get (data
, 2) + cu_offset
);
1027 /* XXX: Strictly speaking for 64-bit DWARF3 files
1028 this ought to be an 8-byte wide computation. */
1029 printf ("DW_OP_call4: <0x%lx>", (long) byte_get (data
, 4) + cu_offset
);
1032 case DW_OP_call_ref
:
1033 /* XXX: Strictly speaking for 64-bit DWARF3 files
1034 this ought to be an 8-byte wide computation. */
1035 if (dwarf_version
== -1)
1037 printf (_("(DW_OP_call_ref in frame info)"));
1038 /* No way to tell where the next op is, so just bail. */
1039 return need_frame_base
;
1041 if (dwarf_version
== 2)
1043 printf ("DW_OP_call_ref: <0x%lx>",
1044 (long) byte_get (data
, pointer_size
));
1045 data
+= pointer_size
;
1049 printf ("DW_OP_call_ref: <0x%lx>",
1050 (long) byte_get (data
, offset_size
));
1051 data
+= offset_size
;
1054 case DW_OP_form_tls_address
:
1055 printf ("DW_OP_form_tls_address");
1057 case DW_OP_call_frame_cfa
:
1058 printf ("DW_OP_call_frame_cfa");
1060 case DW_OP_bit_piece
:
1061 printf ("DW_OP_bit_piece: ");
1062 printf ("size: %lu ", read_leb128 (data
, &bytes_read
, 0));
1064 printf ("offset: %lu ", read_leb128 (data
, &bytes_read
, 0));
1068 /* DWARF 4 extensions. */
1069 case DW_OP_stack_value
:
1070 printf ("DW_OP_stack_value");
1073 case DW_OP_implicit_value
:
1074 printf ("DW_OP_implicit_value");
1075 uvalue
= read_leb128 (data
, &bytes_read
, 0);
1077 display_block (data
, uvalue
);
1081 /* GNU extensions. */
1082 case DW_OP_GNU_push_tls_address
:
1083 printf ("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown");
1085 case DW_OP_GNU_uninit
:
1086 printf ("DW_OP_GNU_uninit");
1087 /* FIXME: Is there data associated with this OP ? */
1089 case DW_OP_GNU_encoded_addr
:
1095 addr
= get_encoded_value (data
, encoding
);
1096 if ((encoding
& 0x70) == DW_EH_PE_pcrel
)
1097 addr
+= section
->address
+ (data
- section
->start
);
1098 data
+= size_of_encoded_value (encoding
);
1100 printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding
);
1101 print_dwarf_vma (addr
, pointer_size
);
1104 case DW_OP_GNU_implicit_pointer
:
1105 /* XXX: Strictly speaking for 64-bit DWARF3 files
1106 this ought to be an 8-byte wide computation. */
1107 if (dwarf_version
== -1)
1109 printf (_("(DW_OP_GNU_implicit_pointer in frame info)"));
1110 /* No way to tell where the next op is, so just bail. */
1111 return need_frame_base
;
1113 if (dwarf_version
== 2)
1115 printf ("DW_OP_GNU_implicit_pointer: <0x%lx> %ld",
1116 (long) byte_get (data
, pointer_size
),
1117 read_leb128 (data
+ pointer_size
, &bytes_read
, 1));
1118 data
+= pointer_size
+ bytes_read
;
1122 printf ("DW_OP_GNU_implicit_pointer: <0x%lx> %ld",
1123 (long) byte_get (data
, offset_size
),
1124 read_leb128 (data
+ offset_size
, &bytes_read
, 1));
1125 data
+= offset_size
+ bytes_read
;
1129 /* HP extensions. */
1130 case DW_OP_HP_is_value
:
1131 printf ("DW_OP_HP_is_value");
1132 /* FIXME: Is there data associated with this OP ? */
1134 case DW_OP_HP_fltconst4
:
1135 printf ("DW_OP_HP_fltconst4");
1136 /* FIXME: Is there data associated with this OP ? */
1138 case DW_OP_HP_fltconst8
:
1139 printf ("DW_OP_HP_fltconst8");
1140 /* FIXME: Is there data associated with this OP ? */
1142 case DW_OP_HP_mod_range
:
1143 printf ("DW_OP_HP_mod_range");
1144 /* FIXME: Is there data associated with this OP ? */
1146 case DW_OP_HP_unmod_range
:
1147 printf ("DW_OP_HP_unmod_range");
1148 /* FIXME: Is there data associated with this OP ? */
1151 printf ("DW_OP_HP_tls");
1152 /* FIXME: Is there data associated with this OP ? */
1155 /* PGI (STMicroelectronics) extensions. */
1156 case DW_OP_PGI_omp_thread_num
:
1157 /* Pushes the thread number for the current thread as it would be
1158 returned by the standard OpenMP library function:
1159 omp_get_thread_num(). The "current thread" is the thread for
1160 which the expression is being evaluated. */
1161 printf ("DW_OP_PGI_omp_thread_num");
1165 if (op
>= DW_OP_lo_user
1166 && op
<= DW_OP_hi_user
)
1167 printf (_("(User defined location op)"));
1169 printf (_("(Unknown location op)"));
1170 /* No way to tell where the next op is, so just bail. */
1171 return need_frame_base
;
1174 /* Separate the ops. */
1179 return need_frame_base
;
1182 static unsigned char *
1183 read_and_display_attr_value (unsigned long attribute
,
1185 unsigned char * data
,
1186 unsigned long cu_offset
,
1187 unsigned long pointer_size
,
1188 unsigned long offset_size
,
1190 debug_info
* debug_info_p
,
1192 struct dwarf_section
* section
)
1194 unsigned long uvalue
= 0;
1195 unsigned char *block_start
= NULL
;
1196 unsigned char * orig_data
= data
;
1197 unsigned int bytes_read
;
1204 case DW_FORM_ref_addr
:
1205 if (dwarf_version
== 2)
1207 uvalue
= byte_get (data
, pointer_size
);
1208 data
+= pointer_size
;
1210 else if (dwarf_version
== 3 || dwarf_version
== 4)
1212 uvalue
= byte_get (data
, offset_size
);
1213 data
+= offset_size
;
1217 error (_("Internal error: DWARF version is not 2, 3 or 4.\n"));
1222 uvalue
= byte_get (data
, pointer_size
);
1223 data
+= pointer_size
;
1227 case DW_FORM_sec_offset
:
1228 uvalue
= byte_get (data
, offset_size
);
1229 data
+= offset_size
;
1232 case DW_FORM_flag_present
:
1239 uvalue
= byte_get (data
++, 1);
1244 uvalue
= byte_get (data
, 2);
1250 uvalue
= byte_get (data
, 4);
1255 uvalue
= read_leb128 (data
, & bytes_read
, 1);
1259 case DW_FORM_ref_udata
:
1261 uvalue
= read_leb128 (data
, & bytes_read
, 0);
1265 case DW_FORM_indirect
:
1266 form
= read_leb128 (data
, & bytes_read
, 0);
1269 printf (" %s", get_FORM_name (form
));
1270 return read_and_display_attr_value (attribute
, form
, data
,
1271 cu_offset
, pointer_size
,
1272 offset_size
, dwarf_version
,
1273 debug_info_p
, do_loc
,
1279 case DW_FORM_ref_addr
:
1281 printf (" <0x%lx>", uvalue
);
1287 case DW_FORM_ref_udata
:
1289 printf (" <0x%lx>", uvalue
+ cu_offset
);
1294 case DW_FORM_sec_offset
:
1296 printf (" 0x%lx", uvalue
);
1299 case DW_FORM_flag_present
:
1306 printf (" %ld", uvalue
);
1313 uvalue
= byte_get (data
, 4);
1314 printf (" 0x%lx", uvalue
);
1315 printf (" 0x%lx", (unsigned long) byte_get (data
+ 4, 4));
1317 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1318 && num_debug_info_entries
== 0)
1320 if (sizeof (uvalue
) == 8)
1321 uvalue
= byte_get (data
, 8);
1323 error (_("DW_FORM_data8 is unsupported when sizeof (unsigned long) != 8\n"));
1328 case DW_FORM_string
:
1330 printf (" %s", data
);
1331 data
+= strlen ((char *) data
) + 1;
1335 case DW_FORM_exprloc
:
1336 uvalue
= read_leb128 (data
, & bytes_read
, 0);
1337 block_start
= data
+ bytes_read
;
1339 data
= block_start
+ uvalue
;
1341 data
= display_block (block_start
, uvalue
);
1344 case DW_FORM_block1
:
1345 uvalue
= byte_get (data
, 1);
1346 block_start
= data
+ 1;
1348 data
= block_start
+ uvalue
;
1350 data
= display_block (block_start
, uvalue
);
1353 case DW_FORM_block2
:
1354 uvalue
= byte_get (data
, 2);
1355 block_start
= data
+ 2;
1357 data
= block_start
+ uvalue
;
1359 data
= display_block (block_start
, uvalue
);
1362 case DW_FORM_block4
:
1363 uvalue
= byte_get (data
, 4);
1364 block_start
= data
+ 4;
1366 data
= block_start
+ uvalue
;
1368 data
= display_block (block_start
, uvalue
);
1373 printf (_(" (indirect string, offset: 0x%lx): %s"),
1374 uvalue
, fetch_indirect_string (uvalue
));
1377 case DW_FORM_indirect
:
1378 /* Handled above. */
1381 case DW_FORM_ref_sig8
:
1385 printf (" signature: ");
1386 for (i
= 0; i
< 8; i
++)
1388 printf ("%02x", (unsigned) byte_get (data
, 1));
1397 warn (_("Unrecognized form: %lu\n"), form
);
1401 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1402 && num_debug_info_entries
== 0)
1406 case DW_AT_frame_base
:
1407 have_frame_base
= 1;
1408 case DW_AT_location
:
1409 case DW_AT_string_length
:
1410 case DW_AT_return_addr
:
1411 case DW_AT_data_member_location
:
1412 case DW_AT_vtable_elem_location
:
1414 case DW_AT_static_link
:
1415 case DW_AT_use_location
:
1416 if (form
== DW_FORM_data4
1417 || form
== DW_FORM_data8
1418 || form
== DW_FORM_sec_offset
)
1420 /* Process location list. */
1421 unsigned int lmax
= debug_info_p
->max_loc_offsets
;
1422 unsigned int num
= debug_info_p
->num_loc_offsets
;
1424 if (lmax
== 0 || num
>= lmax
)
1427 debug_info_p
->loc_offsets
= (long unsigned int *)
1428 xcrealloc (debug_info_p
->loc_offsets
,
1429 lmax
, sizeof (*debug_info_p
->loc_offsets
));
1430 debug_info_p
->have_frame_base
= (int *)
1431 xcrealloc (debug_info_p
->have_frame_base
,
1432 lmax
, sizeof (*debug_info_p
->have_frame_base
));
1433 debug_info_p
->max_loc_offsets
= lmax
;
1435 debug_info_p
->loc_offsets
[num
] = uvalue
;
1436 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
1437 debug_info_p
->num_loc_offsets
++;
1442 if (need_base_address
)
1443 debug_info_p
->base_address
= uvalue
;
1447 if (form
== DW_FORM_data4
1448 || form
== DW_FORM_data8
1449 || form
== DW_FORM_sec_offset
)
1451 /* Process range list. */
1452 unsigned int lmax
= debug_info_p
->max_range_lists
;
1453 unsigned int num
= debug_info_p
->num_range_lists
;
1455 if (lmax
== 0 || num
>= lmax
)
1458 debug_info_p
->range_lists
= (long unsigned int *)
1459 xcrealloc (debug_info_p
->range_lists
,
1460 lmax
, sizeof (*debug_info_p
->range_lists
));
1461 debug_info_p
->max_range_lists
= lmax
;
1463 debug_info_p
->range_lists
[num
] = uvalue
;
1464 debug_info_p
->num_range_lists
++;
1476 /* For some attributes we can display further information. */
1484 case DW_INL_not_inlined
:
1485 printf (_("(not inlined)"));
1487 case DW_INL_inlined
:
1488 printf (_("(inlined)"));
1490 case DW_INL_declared_not_inlined
:
1491 printf (_("(declared as inline but ignored)"));
1493 case DW_INL_declared_inlined
:
1494 printf (_("(declared as inline and inlined)"));
1497 printf (_(" (Unknown inline attribute value: %lx)"), uvalue
);
1502 case DW_AT_language
:
1505 /* Ordered by the numeric value of these constants. */
1506 case DW_LANG_C89
: printf ("(ANSI C)"); break;
1507 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
1508 case DW_LANG_Ada83
: printf ("(Ada)"); break;
1509 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
1510 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
1511 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
1512 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
1513 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
1514 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
1515 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
1516 /* DWARF 2.1 values. */
1517 case DW_LANG_Java
: printf ("(Java)"); break;
1518 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
1519 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
1520 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
1521 /* DWARF 3 values. */
1522 case DW_LANG_PLI
: printf ("(PLI)"); break;
1523 case DW_LANG_ObjC
: printf ("(Objective C)"); break;
1524 case DW_LANG_ObjC_plus_plus
: printf ("(Objective C++)"); break;
1525 case DW_LANG_UPC
: printf ("(Unified Parallel C)"); break;
1526 case DW_LANG_D
: printf ("(D)"); break;
1527 /* DWARF 4 values. */
1528 case DW_LANG_Python
: printf ("(Python)"); break;
1529 /* MIPS extension. */
1530 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
1531 /* UPC extension. */
1532 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
1534 if (uvalue
>= DW_LANG_lo_user
&& uvalue
<= DW_LANG_hi_user
)
1535 printf ("(implementation defined: %lx)", uvalue
);
1537 printf ("(Unknown: %lx)", uvalue
);
1542 case DW_AT_encoding
:
1545 case DW_ATE_void
: printf ("(void)"); break;
1546 case DW_ATE_address
: printf ("(machine address)"); break;
1547 case DW_ATE_boolean
: printf ("(boolean)"); break;
1548 case DW_ATE_complex_float
: printf ("(complex float)"); break;
1549 case DW_ATE_float
: printf ("(float)"); break;
1550 case DW_ATE_signed
: printf ("(signed)"); break;
1551 case DW_ATE_signed_char
: printf ("(signed char)"); break;
1552 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
1553 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
1554 /* DWARF 2.1 values: */
1555 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
1556 case DW_ATE_decimal_float
: printf ("(decimal float)"); break;
1557 /* DWARF 3 values: */
1558 case DW_ATE_packed_decimal
: printf ("(packed_decimal)"); break;
1559 case DW_ATE_numeric_string
: printf ("(numeric_string)"); break;
1560 case DW_ATE_edited
: printf ("(edited)"); break;
1561 case DW_ATE_signed_fixed
: printf ("(signed_fixed)"); break;
1562 case DW_ATE_unsigned_fixed
: printf ("(unsigned_fixed)"); break;
1563 /* HP extensions: */
1564 case DW_ATE_HP_float80
: printf ("(HP_float80)"); break;
1565 case DW_ATE_HP_complex_float80
: printf ("(HP_complex_float80)"); break;
1566 case DW_ATE_HP_float128
: printf ("(HP_float128)"); break;
1567 case DW_ATE_HP_complex_float128
:printf ("(HP_complex_float128)"); break;
1568 case DW_ATE_HP_floathpintel
: printf ("(HP_floathpintel)"); break;
1569 case DW_ATE_HP_imaginary_float80
: printf ("(HP_imaginary_float80)"); break;
1570 case DW_ATE_HP_imaginary_float128
: printf ("(HP_imaginary_float128)"); break;
1573 if (uvalue
>= DW_ATE_lo_user
1574 && uvalue
<= DW_ATE_hi_user
)
1575 printf ("(user defined type)");
1577 printf ("(unknown type)");
1582 case DW_AT_accessibility
:
1585 case DW_ACCESS_public
: printf ("(public)"); break;
1586 case DW_ACCESS_protected
: printf ("(protected)"); break;
1587 case DW_ACCESS_private
: printf ("(private)"); break;
1589 printf ("(unknown accessibility)");
1594 case DW_AT_visibility
:
1597 case DW_VIS_local
: printf ("(local)"); break;
1598 case DW_VIS_exported
: printf ("(exported)"); break;
1599 case DW_VIS_qualified
: printf ("(qualified)"); break;
1600 default: printf ("(unknown visibility)"); break;
1604 case DW_AT_virtuality
:
1607 case DW_VIRTUALITY_none
: printf ("(none)"); break;
1608 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
1609 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
1610 default: printf ("(unknown virtuality)"); break;
1614 case DW_AT_identifier_case
:
1617 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
1618 case DW_ID_up_case
: printf ("(up_case)"); break;
1619 case DW_ID_down_case
: printf ("(down_case)"); break;
1620 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
1621 default: printf ("(unknown case)"); break;
1625 case DW_AT_calling_convention
:
1628 case DW_CC_normal
: printf ("(normal)"); break;
1629 case DW_CC_program
: printf ("(program)"); break;
1630 case DW_CC_nocall
: printf ("(nocall)"); break;
1632 if (uvalue
>= DW_CC_lo_user
1633 && uvalue
<= DW_CC_hi_user
)
1634 printf ("(user defined)");
1636 printf ("(unknown convention)");
1640 case DW_AT_ordering
:
1643 case -1: printf ("(undefined)"); break;
1644 case 0: printf ("(row major)"); break;
1645 case 1: printf ("(column major)"); break;
1649 case DW_AT_frame_base
:
1650 have_frame_base
= 1;
1651 case DW_AT_location
:
1652 case DW_AT_string_length
:
1653 case DW_AT_return_addr
:
1654 case DW_AT_data_member_location
:
1655 case DW_AT_vtable_elem_location
:
1657 case DW_AT_static_link
:
1658 case DW_AT_use_location
:
1659 if (form
== DW_FORM_data4
1660 || form
== DW_FORM_data8
1661 || form
== DW_FORM_sec_offset
)
1662 printf (_("(location list)"));
1664 case DW_AT_allocated
:
1665 case DW_AT_associated
:
1666 case DW_AT_data_location
:
1668 case DW_AT_upper_bound
:
1669 case DW_AT_lower_bound
:
1672 int need_frame_base
;
1675 need_frame_base
= decode_location_expression (block_start
,
1680 cu_offset
, section
);
1682 if (need_frame_base
&& !have_frame_base
)
1683 printf (_(" [without DW_AT_frame_base]"));
1689 if (form
== DW_FORM_ref_sig8
)
1692 if (form
== DW_FORM_ref1
1693 || form
== DW_FORM_ref2
1694 || form
== DW_FORM_ref4
)
1695 uvalue
+= cu_offset
;
1697 if (uvalue
>= section
->size
)
1698 warn (_("Offset %lx used as value for DW_AT_import attribute of DIE at offset %lx is too big.\n"),
1699 uvalue
, (unsigned long) (orig_data
- section
->start
));
1702 unsigned long abbrev_number
;
1703 abbrev_entry
* entry
;
1705 abbrev_number
= read_leb128 (section
->start
+ uvalue
, NULL
, 0);
1707 printf ("[Abbrev Number: %ld", abbrev_number
);
1708 for (entry
= first_abbrev
; entry
!= NULL
; entry
= entry
->next
)
1709 if (entry
->entry
== abbrev_number
)
1712 printf (" (%s)", get_TAG_name (entry
->tag
));
1726 get_AT_name (unsigned long attribute
)
1730 case DW_AT_sibling
: return "DW_AT_sibling";
1731 case DW_AT_location
: return "DW_AT_location";
1732 case DW_AT_name
: return "DW_AT_name";
1733 case DW_AT_ordering
: return "DW_AT_ordering";
1734 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
1735 case DW_AT_byte_size
: return "DW_AT_byte_size";
1736 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
1737 case DW_AT_bit_size
: return "DW_AT_bit_size";
1738 case DW_AT_element_list
: return "DW_AT_element_list";
1739 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
1740 case DW_AT_low_pc
: return "DW_AT_low_pc";
1741 case DW_AT_high_pc
: return "DW_AT_high_pc";
1742 case DW_AT_language
: return "DW_AT_language";
1743 case DW_AT_member
: return "DW_AT_member";
1744 case DW_AT_discr
: return "DW_AT_discr";
1745 case DW_AT_discr_value
: return "DW_AT_discr_value";
1746 case DW_AT_visibility
: return "DW_AT_visibility";
1747 case DW_AT_import
: return "DW_AT_import";
1748 case DW_AT_string_length
: return "DW_AT_string_length";
1749 case DW_AT_common_reference
: return "DW_AT_common_reference";
1750 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
1751 case DW_AT_const_value
: return "DW_AT_const_value";
1752 case DW_AT_containing_type
: return "DW_AT_containing_type";
1753 case DW_AT_default_value
: return "DW_AT_default_value";
1754 case DW_AT_inline
: return "DW_AT_inline";
1755 case DW_AT_is_optional
: return "DW_AT_is_optional";
1756 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
1757 case DW_AT_producer
: return "DW_AT_producer";
1758 case DW_AT_prototyped
: return "DW_AT_prototyped";
1759 case DW_AT_return_addr
: return "DW_AT_return_addr";
1760 case DW_AT_start_scope
: return "DW_AT_start_scope";
1761 case DW_AT_stride_size
: return "DW_AT_stride_size";
1762 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
1763 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
1764 case DW_AT_accessibility
: return "DW_AT_accessibility";
1765 case DW_AT_address_class
: return "DW_AT_address_class";
1766 case DW_AT_artificial
: return "DW_AT_artificial";
1767 case DW_AT_base_types
: return "DW_AT_base_types";
1768 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
1769 case DW_AT_count
: return "DW_AT_count";
1770 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
1771 case DW_AT_decl_column
: return "DW_AT_decl_column";
1772 case DW_AT_decl_file
: return "DW_AT_decl_file";
1773 case DW_AT_decl_line
: return "DW_AT_decl_line";
1774 case DW_AT_declaration
: return "DW_AT_declaration";
1775 case DW_AT_discr_list
: return "DW_AT_discr_list";
1776 case DW_AT_encoding
: return "DW_AT_encoding";
1777 case DW_AT_external
: return "DW_AT_external";
1778 case DW_AT_frame_base
: return "DW_AT_frame_base";
1779 case DW_AT_friend
: return "DW_AT_friend";
1780 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
1781 case DW_AT_macro_info
: return "DW_AT_macro_info";
1782 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
1783 case DW_AT_priority
: return "DW_AT_priority";
1784 case DW_AT_segment
: return "DW_AT_segment";
1785 case DW_AT_specification
: return "DW_AT_specification";
1786 case DW_AT_static_link
: return "DW_AT_static_link";
1787 case DW_AT_type
: return "DW_AT_type";
1788 case DW_AT_use_location
: return "DW_AT_use_location";
1789 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
1790 case DW_AT_virtuality
: return "DW_AT_virtuality";
1791 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
1792 /* DWARF 2.1 values. */
1793 case DW_AT_allocated
: return "DW_AT_allocated";
1794 case DW_AT_associated
: return "DW_AT_associated";
1795 case DW_AT_data_location
: return "DW_AT_data_location";
1796 case DW_AT_stride
: return "DW_AT_stride";
1797 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
1798 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
1799 case DW_AT_extension
: return "DW_AT_extension";
1800 case DW_AT_ranges
: return "DW_AT_ranges";
1801 case DW_AT_trampoline
: return "DW_AT_trampoline";
1802 case DW_AT_call_column
: return "DW_AT_call_column";
1803 case DW_AT_call_file
: return "DW_AT_call_file";
1804 case DW_AT_call_line
: return "DW_AT_call_line";
1805 case DW_AT_description
: return "DW_AT_description";
1806 case DW_AT_binary_scale
: return "DW_AT_binary_scale";
1807 case DW_AT_decimal_scale
: return "DW_AT_decimal_scale";
1808 case DW_AT_small
: return "DW_AT_small";
1809 case DW_AT_decimal_sign
: return "DW_AT_decimal_sign";
1810 case DW_AT_digit_count
: return "DW_AT_digit_count";
1811 case DW_AT_picture_string
: return "DW_AT_picture_string";
1812 case DW_AT_mutable
: return "DW_AT_mutable";
1813 case DW_AT_threads_scaled
: return "DW_AT_threads_scaled";
1814 case DW_AT_explicit
: return "DW_AT_explicit";
1815 case DW_AT_object_pointer
: return "DW_AT_object_pointer";
1816 case DW_AT_endianity
: return "DW_AT_endianity";
1817 case DW_AT_elemental
: return "DW_AT_elemental";
1818 case DW_AT_pure
: return "DW_AT_pure";
1819 case DW_AT_recursive
: return "DW_AT_recursive";
1820 /* DWARF 4 values. */
1821 case DW_AT_signature
: return "DW_AT_signature";
1822 case DW_AT_main_subprogram
: return "DW_AT_main_subprogram";
1823 case DW_AT_data_bit_offset
: return "DW_AT_data_bit_offset";
1824 case DW_AT_const_expr
: return "DW_AT_const_expr";
1825 case DW_AT_enum_class
: return "DW_AT_enum_class";
1826 case DW_AT_linkage_name
: return "DW_AT_linkage_name";
1828 /* HP and SGI/MIPS extensions. */
1829 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
1830 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
1831 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
1832 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
1833 case DW_AT_MIPS_software_pipeline_depth
: return "DW_AT_MIPS_software_pipeline_depth";
1834 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
1835 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
1836 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
1837 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
1838 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
1840 /* HP Extensions. */
1841 case DW_AT_HP_block_index
: return "DW_AT_HP_block_index";
1842 case DW_AT_HP_actuals_stmt_list
: return "DW_AT_HP_actuals_stmt_list";
1843 case DW_AT_HP_proc_per_section
: return "DW_AT_HP_proc_per_section";
1844 case DW_AT_HP_raw_data_ptr
: return "DW_AT_HP_raw_data_ptr";
1845 case DW_AT_HP_pass_by_reference
: return "DW_AT_HP_pass_by_reference";
1846 case DW_AT_HP_opt_level
: return "DW_AT_HP_opt_level";
1847 case DW_AT_HP_prof_version_id
: return "DW_AT_HP_prof_version_id";
1848 case DW_AT_HP_opt_flags
: return "DW_AT_HP_opt_flags";
1849 case DW_AT_HP_cold_region_low_pc
: return "DW_AT_HP_cold_region_low_pc";
1850 case DW_AT_HP_cold_region_high_pc
: return "DW_AT_HP_cold_region_high_pc";
1851 case DW_AT_HP_all_variables_modifiable
: return "DW_AT_HP_all_variables_modifiable";
1852 case DW_AT_HP_linkage_name
: return "DW_AT_HP_linkage_name";
1853 case DW_AT_HP_prof_flags
: return "DW_AT_HP_prof_flags";
1855 /* One value is shared by the MIPS and HP extensions: */
1856 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
1858 /* GNU extensions. */
1859 case DW_AT_sf_names
: return "DW_AT_sf_names";
1860 case DW_AT_src_info
: return "DW_AT_src_info";
1861 case DW_AT_mac_info
: return "DW_AT_mac_info";
1862 case DW_AT_src_coords
: return "DW_AT_src_coords";
1863 case DW_AT_body_begin
: return "DW_AT_body_begin";
1864 case DW_AT_body_end
: return "DW_AT_body_end";
1865 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
1866 case DW_AT_GNU_guarded_by
: return "DW_AT_GNU_guarded_by";
1867 case DW_AT_GNU_pt_guarded_by
: return "DW_AT_GNU_pt_guarded_by";
1868 case DW_AT_GNU_guarded
: return "DW_AT_GNU_guarded";
1869 case DW_AT_GNU_pt_guarded
: return "DW_AT_GNU_pt_guarded";
1870 case DW_AT_GNU_locks_excluded
: return "DW_AT_GNU_locks_excluded";
1871 case DW_AT_GNU_exclusive_locks_required
: return "DW_AT_GNU_exclusive_locks_required";
1872 case DW_AT_GNU_shared_locks_required
: return "DW_AT_GNU_shared_locks_required";
1873 case DW_AT_GNU_odr_signature
: return "DW_AT_GNU_odr_signature";
1874 case DW_AT_use_GNAT_descriptive_type
: return "DW_AT_use_GNAT_descriptive_type";
1875 case DW_AT_GNAT_descriptive_type
: return "DW_AT_GNAT_descriptive_type";
1877 /* UPC extension. */
1878 case DW_AT_upc_threads_scaled
: return "DW_AT_upc_threads_scaled";
1880 /* PGI (STMicroelectronics) extensions. */
1881 case DW_AT_PGI_lbase
: return "DW_AT_PGI_lbase";
1882 case DW_AT_PGI_soffset
: return "DW_AT_PGI_soffset";
1883 case DW_AT_PGI_lstride
: return "DW_AT_PGI_lstride";
1887 static char buffer
[100];
1889 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
1896 static unsigned char *
1897 read_and_display_attr (unsigned long attribute
,
1899 unsigned char * data
,
1900 unsigned long cu_offset
,
1901 unsigned long pointer_size
,
1902 unsigned long offset_size
,
1904 debug_info
* debug_info_p
,
1906 struct dwarf_section
* section
)
1909 printf (" %-18s:", get_AT_name (attribute
));
1910 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
1911 pointer_size
, offset_size
,
1912 dwarf_version
, debug_info_p
,
1920 /* Process the contents of a .debug_info section. If do_loc is non-zero
1921 then we are scanning for location lists and we do not want to display
1922 anything to the user. If do_types is non-zero, we are processing
1923 a .debug_types section instead of a .debug_info section. */
1926 process_debug_info (struct dwarf_section
*section
,
1928 enum dwarf_section_display_enum abbrev_sec
,
1932 unsigned char *start
= section
->start
;
1933 unsigned char *end
= start
+ section
->size
;
1934 unsigned char *section_begin
;
1936 unsigned int num_units
= 0;
1938 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1939 && num_debug_info_entries
== 0
1942 unsigned long length
;
1944 /* First scan the section to get the number of comp units. */
1945 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
1948 /* Read the first 4 bytes. For a 32-bit DWARF section, this
1949 will be the length. For a 64-bit DWARF section, it'll be
1950 the escape code 0xffffffff followed by an 8 byte length. */
1951 length
= byte_get (section_begin
, 4);
1953 if (length
== 0xffffffff)
1955 length
= byte_get (section_begin
+ 4, 8);
1956 section_begin
+= length
+ 12;
1958 else if (length
>= 0xfffffff0 && length
< 0xffffffff)
1960 warn (_("Reserved length value (%lx) found in section %s\n"), length
, section
->name
);
1964 section_begin
+= length
+ 4;
1966 /* Negative values are illegal, they may even cause infinite
1967 looping. This can happen if we can't accurately apply
1968 relocations to an object file. */
1969 if ((signed long) length
<= 0)
1971 warn (_("Corrupt unit length (%lx) found in section %s\n"), length
, section
->name
);
1978 error (_("No comp units in %s section ?"), section
->name
);
1982 /* Then allocate an array to hold the information. */
1983 debug_information
= (debug_info
*) cmalloc (num_units
,
1984 sizeof (* debug_information
));
1985 if (debug_information
== NULL
)
1987 error (_("Not enough memory for a debug info array of %u entries"),
1995 printf (_("Contents of the %s section:\n\n"), section
->name
);
1997 load_debug_section (str
, file
);
2000 load_debug_section (abbrev_sec
, file
);
2001 if (debug_displays
[abbrev_sec
].section
.start
== NULL
)
2003 warn (_("Unable to locate %s section!\n"),
2004 debug_displays
[abbrev_sec
].section
.name
);
2008 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
2010 DWARF2_Internal_CompUnit compunit
;
2011 unsigned char *hdrptr
;
2012 unsigned char *tags
;
2014 unsigned long cu_offset
;
2016 int initial_length_size
;
2017 unsigned char signature
[8] = { 0 };
2018 unsigned long type_offset
= 0;
2022 compunit
.cu_length
= byte_get (hdrptr
, 4);
2025 if (compunit
.cu_length
== 0xffffffff)
2027 compunit
.cu_length
= byte_get (hdrptr
, 8);
2030 initial_length_size
= 12;
2035 initial_length_size
= 4;
2038 compunit
.cu_version
= byte_get (hdrptr
, 2);
2041 cu_offset
= start
- section_begin
;
2043 compunit
.cu_abbrev_offset
= byte_get (hdrptr
, offset_size
);
2044 hdrptr
+= offset_size
;
2046 compunit
.cu_pointer_size
= byte_get (hdrptr
, 1);
2053 for (i
= 0; i
< 8; i
++)
2055 signature
[i
] = byte_get (hdrptr
, 1);
2059 type_offset
= byte_get (hdrptr
, offset_size
);
2060 hdrptr
+= offset_size
;
2063 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2064 && num_debug_info_entries
== 0
2067 debug_information
[unit
].cu_offset
= cu_offset
;
2068 debug_information
[unit
].pointer_size
2069 = compunit
.cu_pointer_size
;
2070 debug_information
[unit
].offset_size
= offset_size
;
2071 debug_information
[unit
].dwarf_version
= compunit
.cu_version
;
2072 debug_information
[unit
].base_address
= 0;
2073 debug_information
[unit
].loc_offsets
= NULL
;
2074 debug_information
[unit
].have_frame_base
= NULL
;
2075 debug_information
[unit
].max_loc_offsets
= 0;
2076 debug_information
[unit
].num_loc_offsets
= 0;
2077 debug_information
[unit
].range_lists
= NULL
;
2078 debug_information
[unit
].max_range_lists
= 0;
2079 debug_information
[unit
].num_range_lists
= 0;
2084 printf (_(" Compilation Unit @ offset 0x%lx:\n"), cu_offset
);
2085 printf (_(" Length: 0x%lx (%s)\n"), compunit
.cu_length
,
2086 initial_length_size
== 8 ? "64-bit" : "32-bit");
2087 printf (_(" Version: %d\n"), compunit
.cu_version
);
2088 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
2089 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
2093 printf (_(" Signature: "));
2094 for (i
= 0; i
< 8; i
++)
2095 printf ("%02x", signature
[i
]);
2097 printf (_(" Type Offset: 0x%lx\n"), type_offset
);
2101 if (cu_offset
+ compunit
.cu_length
+ initial_length_size
2104 warn (_("Debug info is corrupted, length of CU at %lx extends beyond end of section (length = %lx)\n"),
2105 cu_offset
, compunit
.cu_length
);
2109 start
+= compunit
.cu_length
+ initial_length_size
;
2111 if (compunit
.cu_version
!= 2
2112 && compunit
.cu_version
!= 3
2113 && compunit
.cu_version
!= 4)
2115 warn (_("CU at offset %lx contains corrupt or unsupported version number: %d.\n"),
2116 cu_offset
, compunit
.cu_version
);
2122 /* Process the abbrevs used by this compilation unit. DWARF
2123 sections under Mach-O have non-zero addresses. */
2124 if (compunit
.cu_abbrev_offset
>= debug_displays
[abbrev_sec
].section
.size
)
2125 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
2126 (unsigned long) compunit
.cu_abbrev_offset
,
2127 (unsigned long) debug_displays
[abbrev_sec
].section
.size
);
2129 process_abbrev_section
2130 ((unsigned char *) debug_displays
[abbrev_sec
].section
.start
2131 + compunit
.cu_abbrev_offset
,
2132 (unsigned char *) debug_displays
[abbrev_sec
].section
.start
2133 + debug_displays
[abbrev_sec
].section
.size
);
2136 while (tags
< start
)
2138 unsigned int bytes_read
;
2139 unsigned long abbrev_number
;
2140 unsigned long die_offset
;
2141 abbrev_entry
*entry
;
2144 die_offset
= tags
- section_begin
;
2146 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
2149 /* A null DIE marks the end of a list of siblings or it may also be
2150 a section padding. */
2151 if (abbrev_number
== 0)
2153 /* Check if it can be a section padding for the last CU. */
2154 if (level
== 0 && start
== end
)
2158 for (chk
= tags
; chk
< start
; chk
++)
2168 static unsigned num_bogus_warns
= 0;
2170 if (num_bogus_warns
< 3)
2172 warn (_("Bogus end-of-siblings marker detected at offset %lx in .debug_info section\n"),
2175 if (num_bogus_warns
== 3)
2176 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
2183 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
2184 level
, die_offset
, abbrev_number
);
2186 /* Scan through the abbreviation list until we reach the
2188 for (entry
= first_abbrev
;
2189 entry
&& entry
->entry
!= abbrev_number
;
2190 entry
= entry
->next
)
2200 warn (_("DIE at offset %lx refers to abbreviation number %lu which does not exist\n"),
2201 die_offset
, abbrev_number
);
2206 printf (" (%s)\n", get_TAG_name (entry
->tag
));
2211 need_base_address
= 0;
2213 case DW_TAG_compile_unit
:
2214 need_base_address
= 1;
2216 case DW_TAG_entry_point
:
2217 case DW_TAG_subprogram
:
2218 need_base_address
= 0;
2219 /* Assuming that there is no DW_AT_frame_base. */
2220 have_frame_base
= 0;
2224 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
2227 /* Show the offset from where the tag was extracted. */
2228 printf (" <%2lx>", (unsigned long)(tags
- section_begin
));
2230 tags
= read_and_display_attr (attr
->attribute
,
2233 compunit
.cu_pointer_size
,
2235 compunit
.cu_version
,
2236 debug_information
+ unit
,
2240 if (entry
->children
)
2245 /* Set num_debug_info_entries here so that it can be used to check if
2246 we need to process .debug_loc and .debug_ranges sections. */
2247 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2248 && num_debug_info_entries
== 0
2250 num_debug_info_entries
= num_units
;
2260 /* Locate and scan the .debug_info section in the file and record the pointer
2261 sizes and offsets for the compilation units in it. Usually an executable
2262 will have just one pointer size, but this is not guaranteed, and so we try
2263 not to make any assumptions. Returns zero upon failure, or the number of
2264 compilation units upon success. */
2267 load_debug_info (void * file
)
2269 /* Reset the last pointer size so that we can issue correct error
2270 messages if we are displaying the contents of more than one section. */
2271 last_pointer_size
= 0;
2272 warned_about_missing_comp_units
= FALSE
;
2274 /* If we have already tried and failed to load the .debug_info
2275 section then do not bother to repear the task. */
2276 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
2279 /* If we already have the information there is nothing else to do. */
2280 if (num_debug_info_entries
> 0)
2281 return num_debug_info_entries
;
2283 if (load_debug_section (info
, file
)
2284 && process_debug_info (&debug_displays
[info
].section
, file
, abbrev
, 1, 0))
2285 return num_debug_info_entries
;
2287 num_debug_info_entries
= DEBUG_INFO_UNAVAILABLE
;
2292 display_debug_lines_raw (struct dwarf_section
*section
,
2293 unsigned char *data
,
2296 unsigned char *start
= section
->start
;
2298 printf (_("Raw dump of debug contents of section %s:\n\n"),
2303 DWARF2_Internal_LineInfo linfo
;
2304 unsigned char *standard_opcodes
;
2305 unsigned char *end_of_sequence
;
2306 unsigned char *hdrptr
;
2307 unsigned long hdroff
;
2308 int initial_length_size
;
2313 hdroff
= hdrptr
- start
;
2315 /* Check the length of the block. */
2316 linfo
.li_length
= byte_get (hdrptr
, 4);
2319 if (linfo
.li_length
== 0xffffffff)
2321 /* This section is 64-bit DWARF 3. */
2322 linfo
.li_length
= byte_get (hdrptr
, 8);
2325 initial_length_size
= 12;
2330 initial_length_size
= 4;
2333 if (linfo
.li_length
+ initial_length_size
> section
->size
)
2336 (_("The information in section %s appears to be corrupt - the section is too small\n"),
2341 /* Check its version number. */
2342 linfo
.li_version
= byte_get (hdrptr
, 2);
2344 if (linfo
.li_version
!= 2
2345 && linfo
.li_version
!= 3
2346 && linfo
.li_version
!= 4)
2348 warn (_("Only DWARF version 2, 3 and 4 line info is currently supported.\n"));
2352 linfo
.li_prologue_length
= byte_get (hdrptr
, offset_size
);
2353 hdrptr
+= offset_size
;
2354 linfo
.li_min_insn_length
= byte_get (hdrptr
, 1);
2356 if (linfo
.li_version
>= 4)
2358 linfo
.li_max_ops_per_insn
= byte_get (hdrptr
, 1);
2360 if (linfo
.li_max_ops_per_insn
== 0)
2362 warn (_("Invalid maximum operations per insn.\n"));
2367 linfo
.li_max_ops_per_insn
= 1;
2368 linfo
.li_default_is_stmt
= byte_get (hdrptr
, 1);
2370 linfo
.li_line_base
= byte_get (hdrptr
, 1);
2372 linfo
.li_line_range
= byte_get (hdrptr
, 1);
2374 linfo
.li_opcode_base
= byte_get (hdrptr
, 1);
2377 /* Sign extend the line base field. */
2378 linfo
.li_line_base
<<= 24;
2379 linfo
.li_line_base
>>= 24;
2381 printf (_(" Offset: 0x%lx\n"), hdroff
);
2382 printf (_(" Length: %ld\n"), linfo
.li_length
);
2383 printf (_(" DWARF Version: %d\n"), linfo
.li_version
);
2384 printf (_(" Prologue Length: %d\n"), linfo
.li_prologue_length
);
2385 printf (_(" Minimum Instruction Length: %d\n"), linfo
.li_min_insn_length
);
2386 if (linfo
.li_version
>= 4)
2387 printf (_(" Maximum Ops per Instruction: %d\n"), linfo
.li_max_ops_per_insn
);
2388 printf (_(" Initial value of 'is_stmt': %d\n"), linfo
.li_default_is_stmt
);
2389 printf (_(" Line Base: %d\n"), linfo
.li_line_base
);
2390 printf (_(" Line Range: %d\n"), linfo
.li_line_range
);
2391 printf (_(" Opcode Base: %d\n"), linfo
.li_opcode_base
);
2393 end_of_sequence
= data
+ linfo
.li_length
+ initial_length_size
;
2395 reset_state_machine (linfo
.li_default_is_stmt
);
2397 /* Display the contents of the Opcodes table. */
2398 standard_opcodes
= hdrptr
;
2400 printf (_("\n Opcodes:\n"));
2402 for (i
= 1; i
< linfo
.li_opcode_base
; i
++)
2403 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
2405 /* Display the contents of the Directory table. */
2406 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
2409 printf (_("\n The Directory Table is empty.\n"));
2412 printf (_("\n The Directory Table:\n"));
2416 printf (" %s\n", data
);
2418 data
+= strlen ((char *) data
) + 1;
2422 /* Skip the NUL at the end of the table. */
2425 /* Display the contents of the File Name table. */
2427 printf (_("\n The File Name Table is empty.\n"));
2430 printf (_("\n The File Name Table:\n"));
2431 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
2435 unsigned char *name
;
2436 unsigned int bytes_read
;
2438 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
2441 data
+= strlen ((char *) data
) + 1;
2443 printf ("%lu\t", read_leb128 (data
, & bytes_read
, 0));
2445 printf ("%lu\t", read_leb128 (data
, & bytes_read
, 0));
2447 printf ("%lu\t", read_leb128 (data
, & bytes_read
, 0));
2449 printf ("%s\n", name
);
2453 /* Skip the NUL at the end of the table. */
2456 /* Now display the statements. */
2457 printf (_("\n Line Number Statements:\n"));
2459 while (data
< end_of_sequence
)
2461 unsigned char op_code
;
2463 unsigned long int uladv
;
2464 unsigned int bytes_read
;
2468 if (op_code
>= linfo
.li_opcode_base
)
2470 op_code
-= linfo
.li_opcode_base
;
2471 uladv
= (op_code
/ linfo
.li_line_range
);
2472 if (linfo
.li_max_ops_per_insn
== 1)
2474 uladv
*= linfo
.li_min_insn_length
;
2475 state_machine_regs
.address
+= uladv
;
2476 printf (_(" Special opcode %d: advance Address by %lu to 0x%lx"),
2477 op_code
, uladv
, state_machine_regs
.address
);
2481 state_machine_regs
.address
2482 += ((state_machine_regs
.op_index
+ uladv
)
2483 / linfo
.li_max_ops_per_insn
)
2484 * linfo
.li_min_insn_length
;
2485 state_machine_regs
.op_index
2486 = (state_machine_regs
.op_index
+ uladv
)
2487 % linfo
.li_max_ops_per_insn
;
2488 printf (_(" Special opcode %d: advance Address by %lu to 0x%lx[%d]"),
2489 op_code
, uladv
, state_machine_regs
.address
,
2490 state_machine_regs
.op_index
);
2492 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
2493 state_machine_regs
.line
+= adv
;
2494 printf (_(" and Line by %d to %d\n"),
2495 adv
, state_machine_regs
.line
);
2497 else switch (op_code
)
2499 case DW_LNS_extended_op
:
2500 data
+= process_extended_line_op (data
, linfo
.li_default_is_stmt
);
2504 printf (_(" Copy\n"));
2507 case DW_LNS_advance_pc
:
2508 uladv
= read_leb128 (data
, & bytes_read
, 0);
2510 if (linfo
.li_max_ops_per_insn
== 1)
2512 uladv
*= linfo
.li_min_insn_length
;
2513 state_machine_regs
.address
+= uladv
;
2514 printf (_(" Advance PC by %lu to 0x%lx\n"), uladv
,
2515 state_machine_regs
.address
);
2519 state_machine_regs
.address
2520 += ((state_machine_regs
.op_index
+ uladv
)
2521 / linfo
.li_max_ops_per_insn
)
2522 * linfo
.li_min_insn_length
;
2523 state_machine_regs
.op_index
2524 = (state_machine_regs
.op_index
+ uladv
)
2525 % linfo
.li_max_ops_per_insn
;
2526 printf (_(" Advance PC by %lu to 0x%lx[%d]\n"), uladv
,
2527 state_machine_regs
.address
,
2528 state_machine_regs
.op_index
);
2532 case DW_LNS_advance_line
:
2533 adv
= read_leb128 (data
, & bytes_read
, 1);
2535 state_machine_regs
.line
+= adv
;
2536 printf (_(" Advance Line by %d to %d\n"), adv
,
2537 state_machine_regs
.line
);
2540 case DW_LNS_set_file
:
2541 adv
= read_leb128 (data
, & bytes_read
, 0);
2543 printf (_(" Set File Name to entry %d in the File Name Table\n"),
2545 state_machine_regs
.file
= adv
;
2548 case DW_LNS_set_column
:
2549 uladv
= read_leb128 (data
, & bytes_read
, 0);
2551 printf (_(" Set column to %lu\n"), uladv
);
2552 state_machine_regs
.column
= uladv
;
2555 case DW_LNS_negate_stmt
:
2556 adv
= state_machine_regs
.is_stmt
;
2558 printf (_(" Set is_stmt to %d\n"), adv
);
2559 state_machine_regs
.is_stmt
= adv
;
2562 case DW_LNS_set_basic_block
:
2563 printf (_(" Set basic block\n"));
2564 state_machine_regs
.basic_block
= 1;
2567 case DW_LNS_const_add_pc
:
2568 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
2569 if (linfo
.li_max_ops_per_insn
)
2571 uladv
*= linfo
.li_min_insn_length
;
2572 state_machine_regs
.address
+= uladv
;
2573 printf (_(" Advance PC by constant %lu to 0x%lx\n"), uladv
,
2574 state_machine_regs
.address
);
2578 state_machine_regs
.address
2579 += ((state_machine_regs
.op_index
+ uladv
)
2580 / linfo
.li_max_ops_per_insn
)
2581 * linfo
.li_min_insn_length
;
2582 state_machine_regs
.op_index
2583 = (state_machine_regs
.op_index
+ uladv
)
2584 % linfo
.li_max_ops_per_insn
;
2585 printf (_(" Advance PC by constant %lu to 0x%lx[%d]\n"),
2586 uladv
, state_machine_regs
.address
,
2587 state_machine_regs
.op_index
);
2591 case DW_LNS_fixed_advance_pc
:
2592 uladv
= byte_get (data
, 2);
2594 state_machine_regs
.address
+= uladv
;
2595 state_machine_regs
.op_index
= 0;
2596 printf (_(" Advance PC by fixed size amount %lu to 0x%lx\n"),
2597 uladv
, state_machine_regs
.address
);
2600 case DW_LNS_set_prologue_end
:
2601 printf (_(" Set prologue_end to true\n"));
2604 case DW_LNS_set_epilogue_begin
:
2605 printf (_(" Set epilogue_begin to true\n"));
2608 case DW_LNS_set_isa
:
2609 uladv
= read_leb128 (data
, & bytes_read
, 0);
2611 printf (_(" Set ISA to %lu\n"), uladv
);
2615 printf (_(" Unknown opcode %d with operands: "), op_code
);
2617 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
2619 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
2620 i
== 1 ? "" : ", ");
2635 unsigned char *name
;
2636 unsigned int directory_index
;
2637 unsigned int modification_date
;
2638 unsigned int length
;
2641 /* Output a decoded representation of the .debug_line section. */
2644 display_debug_lines_decoded (struct dwarf_section
*section
,
2645 unsigned char *data
,
2648 printf (_("Decoded dump of debug contents of section %s:\n\n"),
2653 /* This loop amounts to one iteration per compilation unit. */
2654 DWARF2_Internal_LineInfo linfo
;
2655 unsigned char *standard_opcodes
;
2656 unsigned char *end_of_sequence
;
2657 unsigned char *hdrptr
;
2658 int initial_length_size
;
2661 File_Entry
*file_table
= NULL
;
2662 unsigned char **directory_table
= NULL
;
2666 /* Extract information from the Line Number Program Header.
2667 (section 6.2.4 in the Dwarf3 doc). */
2669 /* Get the length of this CU's line number information block. */
2670 linfo
.li_length
= byte_get (hdrptr
, 4);
2673 if (linfo
.li_length
== 0xffffffff)
2675 /* This section is 64-bit DWARF 3. */
2676 linfo
.li_length
= byte_get (hdrptr
, 8);
2679 initial_length_size
= 12;
2684 initial_length_size
= 4;
2687 if (linfo
.li_length
+ initial_length_size
> section
->size
)
2689 warn (_("The line info appears to be corrupt - "
2690 "the section is too small\n"));
2694 /* Get this CU's Line Number Block version number. */
2695 linfo
.li_version
= byte_get (hdrptr
, 2);
2697 if (linfo
.li_version
!= 2
2698 && linfo
.li_version
!= 3
2699 && linfo
.li_version
!= 4)
2701 warn (_("Only DWARF version 2, 3 and 4 line info is currently "
2706 linfo
.li_prologue_length
= byte_get (hdrptr
, offset_size
);
2707 hdrptr
+= offset_size
;
2708 linfo
.li_min_insn_length
= byte_get (hdrptr
, 1);
2710 if (linfo
.li_version
>= 4)
2712 linfo
.li_max_ops_per_insn
= byte_get (hdrptr
, 1);
2714 if (linfo
.li_max_ops_per_insn
== 0)
2716 warn (_("Invalid maximum operations per insn.\n"));
2721 linfo
.li_max_ops_per_insn
= 1;
2722 linfo
.li_default_is_stmt
= byte_get (hdrptr
, 1);
2724 linfo
.li_line_base
= byte_get (hdrptr
, 1);
2726 linfo
.li_line_range
= byte_get (hdrptr
, 1);
2728 linfo
.li_opcode_base
= byte_get (hdrptr
, 1);
2731 /* Sign extend the line base field. */
2732 linfo
.li_line_base
<<= 24;
2733 linfo
.li_line_base
>>= 24;
2735 /* Find the end of this CU's Line Number Information Block. */
2736 end_of_sequence
= data
+ linfo
.li_length
+ initial_length_size
;
2738 reset_state_machine (linfo
.li_default_is_stmt
);
2740 /* Save a pointer to the contents of the Opcodes table. */
2741 standard_opcodes
= hdrptr
;
2743 /* Traverse the Directory table just to count entries. */
2744 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
2747 unsigned int n_directories
= 0;
2748 unsigned char *ptr_directory_table
= data
;
2752 data
+= strlen ((char *) data
) + 1;
2756 /* Go through the directory table again to save the directories. */
2757 directory_table
= (unsigned char **)
2758 xmalloc (n_directories
* sizeof (unsigned char *));
2761 while (*ptr_directory_table
!= 0)
2763 directory_table
[i
] = ptr_directory_table
;
2764 ptr_directory_table
+= strlen ((char *) ptr_directory_table
) + 1;
2768 /* Skip the NUL at the end of the table. */
2771 /* Traverse the File Name table just to count the entries. */
2774 unsigned int n_files
= 0;
2775 unsigned char *ptr_file_name_table
= data
;
2779 unsigned int bytes_read
;
2781 /* Skip Name, directory index, last modification time and length
2783 data
+= strlen ((char *) data
) + 1;
2784 read_leb128 (data
, & bytes_read
, 0);
2786 read_leb128 (data
, & bytes_read
, 0);
2788 read_leb128 (data
, & bytes_read
, 0);
2794 /* Go through the file table again to save the strings. */
2795 file_table
= (File_Entry
*) xmalloc (n_files
* sizeof (File_Entry
));
2798 while (*ptr_file_name_table
!= 0)
2800 unsigned int bytes_read
;
2802 file_table
[i
].name
= ptr_file_name_table
;
2803 ptr_file_name_table
+= strlen ((char *) ptr_file_name_table
) + 1;
2805 /* We are not interested in directory, time or size. */
2806 file_table
[i
].directory_index
= read_leb128 (ptr_file_name_table
,
2808 ptr_file_name_table
+= bytes_read
;
2809 file_table
[i
].modification_date
= read_leb128 (ptr_file_name_table
,
2811 ptr_file_name_table
+= bytes_read
;
2812 file_table
[i
].length
= read_leb128 (ptr_file_name_table
, & bytes_read
, 0);
2813 ptr_file_name_table
+= bytes_read
;
2818 /* Print the Compilation Unit's name and a header. */
2819 if (directory_table
== NULL
)
2821 printf (_("CU: %s:\n"), file_table
[0].name
);
2822 printf (_("File name Line number Starting address\n"));
2826 if (do_wide
|| strlen ((char *) directory_table
[0]) < 76)
2827 printf (_("CU: %s/%s:\n"), directory_table
[0],
2828 file_table
[0].name
);
2830 printf ("%s:\n", file_table
[0].name
);
2832 printf (_("File name Line number Starting address\n"));
2836 /* Skip the NUL at the end of the table. */
2839 /* This loop iterates through the Dwarf Line Number Program. */
2840 while (data
< end_of_sequence
)
2842 unsigned char op_code
;
2844 unsigned long int uladv
;
2845 unsigned int bytes_read
;
2846 int is_special_opcode
= 0;
2850 if (op_code
>= linfo
.li_opcode_base
)
2852 op_code
-= linfo
.li_opcode_base
;
2853 uladv
= (op_code
/ linfo
.li_line_range
);
2854 if (linfo
.li_max_ops_per_insn
== 1)
2856 uladv
*= linfo
.li_min_insn_length
;
2857 state_machine_regs
.address
+= uladv
;
2861 state_machine_regs
.address
2862 += ((state_machine_regs
.op_index
+ uladv
)
2863 / linfo
.li_max_ops_per_insn
)
2864 * linfo
.li_min_insn_length
;
2865 state_machine_regs
.op_index
2866 = (state_machine_regs
.op_index
+ uladv
)
2867 % linfo
.li_max_ops_per_insn
;
2870 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
2871 state_machine_regs
.line
+= adv
;
2872 is_special_opcode
= 1;
2874 else switch (op_code
)
2876 case DW_LNS_extended_op
:
2878 unsigned int ext_op_code_len
;
2879 unsigned char ext_op_code
;
2880 unsigned char *op_code_data
= data
;
2882 ext_op_code_len
= read_leb128 (op_code_data
, &bytes_read
, 0);
2883 op_code_data
+= bytes_read
;
2885 if (ext_op_code_len
== 0)
2887 warn (_("badly formed extended line op encountered!\n"));
2890 ext_op_code_len
+= bytes_read
;
2891 ext_op_code
= *op_code_data
++;
2893 switch (ext_op_code
)
2895 case DW_LNE_end_sequence
:
2896 reset_state_machine (linfo
.li_default_is_stmt
);
2898 case DW_LNE_set_address
:
2899 state_machine_regs
.address
=
2900 byte_get (op_code_data
, ext_op_code_len
- bytes_read
- 1);
2901 state_machine_regs
.op_index
= 0;
2903 case DW_LNE_define_file
:
2905 unsigned int dir_index
= 0;
2907 ++state_machine_regs
.last_file_entry
;
2908 op_code_data
+= strlen ((char *) op_code_data
) + 1;
2909 dir_index
= read_leb128 (op_code_data
, & bytes_read
, 0);
2910 op_code_data
+= bytes_read
;
2911 read_leb128 (op_code_data
, & bytes_read
, 0);
2912 op_code_data
+= bytes_read
;
2913 read_leb128 (op_code_data
, & bytes_read
, 0);
2915 printf ("%s:\n", directory_table
[dir_index
]);
2919 printf (_("UNKNOWN: length %d\n"), ext_op_code_len
- bytes_read
);
2922 data
+= ext_op_code_len
;
2928 case DW_LNS_advance_pc
:
2929 uladv
= read_leb128 (data
, & bytes_read
, 0);
2931 if (linfo
.li_max_ops_per_insn
== 1)
2933 uladv
*= linfo
.li_min_insn_length
;
2934 state_machine_regs
.address
+= uladv
;
2938 state_machine_regs
.address
2939 += ((state_machine_regs
.op_index
+ uladv
)
2940 / linfo
.li_max_ops_per_insn
)
2941 * linfo
.li_min_insn_length
;
2942 state_machine_regs
.op_index
2943 = (state_machine_regs
.op_index
+ uladv
)
2944 % linfo
.li_max_ops_per_insn
;
2948 case DW_LNS_advance_line
:
2949 adv
= read_leb128 (data
, & bytes_read
, 1);
2951 state_machine_regs
.line
+= adv
;
2954 case DW_LNS_set_file
:
2955 adv
= read_leb128 (data
, & bytes_read
, 0);
2957 state_machine_regs
.file
= adv
;
2958 if (file_table
[state_machine_regs
.file
- 1].directory_index
== 0)
2960 /* If directory index is 0, that means current directory. */
2961 printf ("\n./%s:[++]\n",
2962 file_table
[state_machine_regs
.file
- 1].name
);
2966 /* The directory index starts counting at 1. */
2967 printf ("\n%s/%s:\n",
2968 directory_table
[file_table
[state_machine_regs
.file
- 1].directory_index
- 1],
2969 file_table
[state_machine_regs
.file
- 1].name
);
2973 case DW_LNS_set_column
:
2974 uladv
= read_leb128 (data
, & bytes_read
, 0);
2976 state_machine_regs
.column
= uladv
;
2979 case DW_LNS_negate_stmt
:
2980 adv
= state_machine_regs
.is_stmt
;
2982 state_machine_regs
.is_stmt
= adv
;
2985 case DW_LNS_set_basic_block
:
2986 state_machine_regs
.basic_block
= 1;
2989 case DW_LNS_const_add_pc
:
2990 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
2991 if (linfo
.li_max_ops_per_insn
== 1)
2993 uladv
*= linfo
.li_min_insn_length
;
2994 state_machine_regs
.address
+= uladv
;
2998 state_machine_regs
.address
2999 += ((state_machine_regs
.op_index
+ uladv
)
3000 / linfo
.li_max_ops_per_insn
)
3001 * linfo
.li_min_insn_length
;
3002 state_machine_regs
.op_index
3003 = (state_machine_regs
.op_index
+ uladv
)
3004 % linfo
.li_max_ops_per_insn
;
3008 case DW_LNS_fixed_advance_pc
:
3009 uladv
= byte_get (data
, 2);
3011 state_machine_regs
.address
+= uladv
;
3012 state_machine_regs
.op_index
= 0;
3015 case DW_LNS_set_prologue_end
:
3018 case DW_LNS_set_epilogue_begin
:
3021 case DW_LNS_set_isa
:
3022 uladv
= read_leb128 (data
, & bytes_read
, 0);
3024 printf (_(" Set ISA to %lu\n"), uladv
);
3028 printf (_(" Unknown opcode %d with operands: "), op_code
);
3030 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
3032 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
3033 i
== 1 ? "" : ", ");
3040 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
3041 to the DWARF address/line matrix. */
3042 if ((is_special_opcode
) || (op_code
== DW_LNE_end_sequence
)
3043 || (op_code
== DW_LNS_copy
))
3045 const unsigned int MAX_FILENAME_LENGTH
= 35;
3046 char *fileName
= (char *)file_table
[state_machine_regs
.file
- 1].name
;
3047 char *newFileName
= NULL
;
3048 size_t fileNameLength
= strlen (fileName
);
3050 if ((fileNameLength
> MAX_FILENAME_LENGTH
) && (!do_wide
))
3052 newFileName
= (char *) xmalloc (MAX_FILENAME_LENGTH
+ 1);
3053 /* Truncate file name */
3054 strncpy (newFileName
,
3055 fileName
+ fileNameLength
- MAX_FILENAME_LENGTH
,
3056 MAX_FILENAME_LENGTH
+ 1);
3060 newFileName
= (char *) xmalloc (fileNameLength
+ 1);
3061 strncpy (newFileName
, fileName
, fileNameLength
+ 1);
3064 if (!do_wide
|| (fileNameLength
<= MAX_FILENAME_LENGTH
))
3066 if (linfo
.li_max_ops_per_insn
== 1)
3067 printf ("%-35s %11d %#18lx\n", newFileName
,
3068 state_machine_regs
.line
,
3069 state_machine_regs
.address
);
3071 printf ("%-35s %11d %#18lx[%d]\n", newFileName
,
3072 state_machine_regs
.line
,
3073 state_machine_regs
.address
,
3074 state_machine_regs
.op_index
);
3078 if (linfo
.li_max_ops_per_insn
== 1)
3079 printf ("%s %11d %#18lx\n", newFileName
,
3080 state_machine_regs
.line
,
3081 state_machine_regs
.address
);
3083 printf ("%s %11d %#18lx[%d]\n", newFileName
,
3084 state_machine_regs
.line
,
3085 state_machine_regs
.address
,
3086 state_machine_regs
.op_index
);
3089 if (op_code
== DW_LNE_end_sequence
)
3097 free (directory_table
);
3098 directory_table
= NULL
;
3106 display_debug_lines (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
3108 unsigned char *data
= section
->start
;
3109 unsigned char *end
= data
+ section
->size
;
3111 int retValDecoded
= 1;
3113 if (do_debug_lines
== 0)
3114 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
3116 if (do_debug_lines
& FLAG_DEBUG_LINES_RAW
)
3117 retValRaw
= display_debug_lines_raw (section
, data
, end
);
3119 if (do_debug_lines
& FLAG_DEBUG_LINES_DECODED
)
3120 retValDecoded
= display_debug_lines_decoded (section
, data
, end
);
3122 if (!retValRaw
|| !retValDecoded
)
3129 find_debug_info_for_offset (unsigned long offset
)
3133 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
3136 for (i
= 0; i
< num_debug_info_entries
; i
++)
3137 if (debug_information
[i
].cu_offset
== offset
)
3138 return debug_information
+ i
;
3144 display_debug_pubnames (struct dwarf_section
*section
,
3145 void *file ATTRIBUTE_UNUSED
)
3147 DWARF2_Internal_PubNames names
;
3148 unsigned char *start
= section
->start
;
3149 unsigned char *end
= start
+ section
->size
;
3151 /* It does not matter if this load fails,
3152 we test for that later on. */
3153 load_debug_info (file
);
3155 printf (_("Contents of the %s section:\n\n"), section
->name
);
3159 unsigned char *data
;
3160 unsigned long offset
;
3161 int offset_size
, initial_length_size
;
3165 names
.pn_length
= byte_get (data
, 4);
3167 if (names
.pn_length
== 0xffffffff)
3169 names
.pn_length
= byte_get (data
, 8);
3172 initial_length_size
= 12;
3177 initial_length_size
= 4;
3180 names
.pn_version
= byte_get (data
, 2);
3183 names
.pn_offset
= byte_get (data
, offset_size
);
3184 data
+= offset_size
;
3186 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
3187 && num_debug_info_entries
> 0
3188 && find_debug_info_for_offset (names
.pn_offset
) == NULL
)
3189 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3190 names
.pn_offset
, section
->name
);
3192 names
.pn_size
= byte_get (data
, offset_size
);
3193 data
+= offset_size
;
3195 start
+= names
.pn_length
+ initial_length_size
;
3197 if (names
.pn_version
!= 2 && names
.pn_version
!= 3)
3199 static int warned
= 0;
3203 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
3210 printf (_(" Length: %ld\n"),
3212 printf (_(" Version: %d\n"),
3214 printf (_(" Offset into .debug_info section: 0x%lx\n"),
3216 printf (_(" Size of area in .debug_info section: %ld\n"),
3219 printf (_("\n Offset\tName\n"));
3223 offset
= byte_get (data
, offset_size
);
3227 data
+= offset_size
;
3228 printf (" %-6lx\t%s\n", offset
, data
);
3229 data
+= strlen ((char *) data
) + 1;
3232 while (offset
!= 0);
3240 display_debug_macinfo (struct dwarf_section
*section
,
3241 void *file ATTRIBUTE_UNUSED
)
3243 unsigned char *start
= section
->start
;
3244 unsigned char *end
= start
+ section
->size
;
3245 unsigned char *curr
= start
;
3246 unsigned int bytes_read
;
3247 enum dwarf_macinfo_record_type op
;
3249 printf (_("Contents of the %s section:\n\n"), section
->name
);
3253 unsigned int lineno
;
3256 op
= (enum dwarf_macinfo_record_type
) *curr
;
3261 case DW_MACINFO_start_file
:
3263 unsigned int filenum
;
3265 lineno
= read_leb128 (curr
, & bytes_read
, 0);
3267 filenum
= read_leb128 (curr
, & bytes_read
, 0);
3270 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
3275 case DW_MACINFO_end_file
:
3276 printf (_(" DW_MACINFO_end_file\n"));
3279 case DW_MACINFO_define
:
3280 lineno
= read_leb128 (curr
, & bytes_read
, 0);
3282 string
= (char *) curr
;
3283 curr
+= strlen (string
) + 1;
3284 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
3288 case DW_MACINFO_undef
:
3289 lineno
= read_leb128 (curr
, & bytes_read
, 0);
3291 string
= (char *) curr
;
3292 curr
+= strlen (string
) + 1;
3293 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
3297 case DW_MACINFO_vendor_ext
:
3299 unsigned int constant
;
3301 constant
= read_leb128 (curr
, & bytes_read
, 0);
3303 string
= (char *) curr
;
3304 curr
+= strlen (string
) + 1;
3305 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
3316 display_debug_abbrev (struct dwarf_section
*section
,
3317 void *file ATTRIBUTE_UNUSED
)
3319 abbrev_entry
*entry
;
3320 unsigned char *start
= section
->start
;
3321 unsigned char *end
= start
+ section
->size
;
3323 printf (_("Contents of the %s section:\n\n"), section
->name
);
3329 start
= process_abbrev_section (start
, end
);
3331 if (first_abbrev
== NULL
)
3334 printf (_(" Number TAG\n"));
3336 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
3340 printf (" %ld %s [%s]\n",
3342 get_TAG_name (entry
->tag
),
3343 entry
->children
? _("has children") : _("no children"));
3345 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
3346 printf (" %-18s %s\n",
3347 get_AT_name (attr
->attribute
),
3348 get_FORM_name (attr
->form
));
3359 display_debug_loc (struct dwarf_section
*section
, void *file
)
3361 unsigned char *start
= section
->start
;
3362 unsigned char *section_end
;
3363 unsigned long bytes
;
3364 unsigned char *section_begin
= start
;
3365 unsigned int num_loc_list
= 0;
3366 unsigned long last_offset
= 0;
3367 unsigned int first
= 0;
3370 int seen_first_offset
= 0;
3371 int use_debug_info
= 1;
3372 unsigned char *next
;
3374 bytes
= section
->size
;
3375 section_end
= start
+ bytes
;
3379 printf (_("\nThe %s section is empty.\n"), section
->name
);
3383 if (load_debug_info (file
) == 0)
3385 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
3390 /* Check the order of location list in .debug_info section. If
3391 offsets of location lists are in the ascending order, we can
3392 use `debug_information' directly. */
3393 for (i
= 0; i
< num_debug_info_entries
; i
++)
3397 num
= debug_information
[i
].num_loc_offsets
;
3398 num_loc_list
+= num
;
3400 /* Check if we can use `debug_information' directly. */
3401 if (use_debug_info
&& num
!= 0)
3403 if (!seen_first_offset
)
3405 /* This is the first location list. */
3406 last_offset
= debug_information
[i
].loc_offsets
[0];
3408 seen_first_offset
= 1;
3414 for (; j
< num
; j
++)
3417 debug_information
[i
].loc_offsets
[j
])
3422 last_offset
= debug_information
[i
].loc_offsets
[j
];
3427 if (!use_debug_info
)
3428 /* FIXME: Should we handle this case? */
3429 error (_("Location lists in .debug_info section aren't in ascending order!\n"));
3431 if (!seen_first_offset
)
3432 error (_("No location lists in .debug_info section!\n"));
3434 /* DWARF sections under Mach-O have non-zero addresses. */
3435 if (debug_information
[first
].num_loc_offsets
> 0
3436 && debug_information
[first
].loc_offsets
[0] != section
->address
)
3437 warn (_("Location lists in %s section start at 0x%lx\n"),
3438 section
->name
, debug_information
[first
].loc_offsets
[0]);
3440 printf (_("Contents of the %s section:\n\n"), section
->name
);
3441 printf (_(" Offset Begin End Expression\n"));
3443 seen_first_offset
= 0;
3444 for (i
= first
; i
< num_debug_info_entries
; i
++)
3448 unsigned short length
;
3449 unsigned long offset
;
3450 unsigned int pointer_size
;
3451 unsigned int offset_size
;
3453 unsigned long cu_offset
;
3454 unsigned long base_address
;
3455 int need_frame_base
;
3458 pointer_size
= debug_information
[i
].pointer_size
;
3459 cu_offset
= debug_information
[i
].cu_offset
;
3460 offset_size
= debug_information
[i
].offset_size
;
3461 dwarf_version
= debug_information
[i
].dwarf_version
;
3463 for (j
= 0; j
< debug_information
[i
].num_loc_offsets
; j
++)
3465 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
3466 /* DWARF sections under Mach-O have non-zero addresses. */
3467 offset
= debug_information
[i
].loc_offsets
[j
] - section
->address
;
3468 next
= section_begin
+ offset
;
3469 base_address
= debug_information
[i
].base_address
;
3471 if (!seen_first_offset
)
3472 seen_first_offset
= 1;
3476 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
3477 (unsigned long) (start
- section_begin
),
3478 (unsigned long) (next
- section_begin
));
3479 else if (start
> next
)
3480 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
3481 (unsigned long) (start
- section_begin
),
3482 (unsigned long) (next
- section_begin
));
3486 if (offset
>= bytes
)
3488 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
3495 if (start
+ 2 * pointer_size
> section_end
)
3497 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
3502 /* Note: we use sign extension here in order to be sure that
3503 we can detect the -1 escape value. Sign extension into the
3504 top 32 bits of a 32-bit address will not affect the values
3505 that we display since we always show hex values, and always
3506 the bottom 32-bits. */
3507 begin
= byte_get_signed (start
, pointer_size
);
3508 start
+= pointer_size
;
3509 end
= byte_get_signed (start
, pointer_size
);
3510 start
+= pointer_size
;
3512 printf (" %8.8lx ", offset
);
3514 if (begin
== 0 && end
== 0)
3516 printf (_("<End of list>\n"));
3520 /* Check base address specifiers. */
3521 if (begin
== (dwarf_vma
) -1 && end
!= (dwarf_vma
) -1)
3524 print_dwarf_vma (begin
, pointer_size
);
3525 print_dwarf_vma (end
, pointer_size
);
3526 printf (_("(base address)\n"));
3530 if (start
+ 2 > section_end
)
3532 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
3537 length
= byte_get (start
, 2);
3540 if (start
+ length
> section_end
)
3542 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
3547 print_dwarf_vma (begin
+ base_address
, pointer_size
);
3548 print_dwarf_vma (end
+ base_address
, pointer_size
);
3551 need_frame_base
= decode_location_expression (start
,
3556 cu_offset
, section
);
3559 if (need_frame_base
&& !has_frame_base
)
3560 printf (_(" [without DW_AT_frame_base]"));
3563 fputs (_(" (start == end)"), stdout
);
3564 else if (begin
> end
)
3565 fputs (_(" (start > end)"), stdout
);
3574 if (start
< section_end
)
3575 warn (_("There are %ld unused bytes at the end of section %s\n"),
3576 (long) (section_end
- start
), section
->name
);
3582 display_debug_str (struct dwarf_section
*section
,
3583 void *file ATTRIBUTE_UNUSED
)
3585 unsigned char *start
= section
->start
;
3586 unsigned long bytes
= section
->size
;
3587 dwarf_vma addr
= section
->address
;
3591 printf (_("\nThe %s section is empty.\n"), section
->name
);
3595 printf (_("Contents of the %s section:\n\n"), section
->name
);
3603 lbytes
= (bytes
> 16 ? 16 : bytes
);
3605 printf (" 0x%8.8lx ", (unsigned long) addr
);
3607 for (j
= 0; j
< 16; j
++)
3610 printf ("%2.2x", start
[j
]);
3618 for (j
= 0; j
< lbytes
; j
++)
3621 if (k
>= ' ' && k
< 0x80)
3640 display_debug_info (struct dwarf_section
*section
, void *file
)
3642 return process_debug_info (section
, file
, abbrev
, 0, 0);
3646 display_debug_types (struct dwarf_section
*section
, void *file
)
3648 return process_debug_info (section
, file
, abbrev
, 0, 1);
3652 display_trace_info (struct dwarf_section
*section
, void *file
)
3654 return process_debug_info (section
, file
, trace_abbrev
, 0, 0);
3658 display_debug_aranges (struct dwarf_section
*section
,
3659 void *file ATTRIBUTE_UNUSED
)
3661 unsigned char *start
= section
->start
;
3662 unsigned char *end
= start
+ section
->size
;
3664 printf (_("Contents of the %s section:\n\n"), section
->name
);
3666 /* It does not matter if this load fails,
3667 we test for that later on. */
3668 load_debug_info (file
);
3672 unsigned char *hdrptr
;
3673 DWARF2_Internal_ARange arange
;
3674 unsigned char *addr_ranges
;
3677 unsigned char address_size
;
3680 int initial_length_size
;
3684 arange
.ar_length
= byte_get (hdrptr
, 4);
3687 if (arange
.ar_length
== 0xffffffff)
3689 arange
.ar_length
= byte_get (hdrptr
, 8);
3692 initial_length_size
= 12;
3697 initial_length_size
= 4;
3700 arange
.ar_version
= byte_get (hdrptr
, 2);
3703 arange
.ar_info_offset
= byte_get (hdrptr
, offset_size
);
3704 hdrptr
+= offset_size
;
3706 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
3707 && num_debug_info_entries
> 0
3708 && find_debug_info_for_offset (arange
.ar_info_offset
) == NULL
)
3709 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3710 arange
.ar_info_offset
, section
->name
);
3712 arange
.ar_pointer_size
= byte_get (hdrptr
, 1);
3715 arange
.ar_segment_size
= byte_get (hdrptr
, 1);
3718 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
3720 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
3724 printf (_(" Length: %ld\n"), arange
.ar_length
);
3725 printf (_(" Version: %d\n"), arange
.ar_version
);
3726 printf (_(" Offset into .debug_info: 0x%lx\n"), arange
.ar_info_offset
);
3727 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
3728 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
3730 address_size
= arange
.ar_pointer_size
+ arange
.ar_segment_size
;
3732 /* The DWARF spec does not require that the address size be a power
3733 of two, but we do. This will have to change if we ever encounter
3734 an uneven architecture. */
3735 if ((address_size
& (address_size
- 1)) != 0)
3737 warn (_("Pointer size + Segment size is not a power of two.\n"));
3741 if (address_size
> 4)
3742 printf (_("\n Address Length\n"));
3744 printf (_("\n Address Length\n"));
3746 addr_ranges
= hdrptr
;
3748 /* Must pad to an alignment boundary that is twice the address size. */
3749 excess
= (hdrptr
- start
) % (2 * address_size
);
3751 addr_ranges
+= (2 * address_size
) - excess
;
3753 start
+= arange
.ar_length
+ initial_length_size
;
3755 while (addr_ranges
+ 2 * address_size
<= start
)
3757 address
= byte_get (addr_ranges
, address_size
);
3759 addr_ranges
+= address_size
;
3761 length
= byte_get (addr_ranges
, address_size
);
3763 addr_ranges
+= address_size
;
3766 print_dwarf_vma (address
, address_size
);
3767 print_dwarf_vma (length
, address_size
);
3777 /* Each debug_information[x].range_lists[y] gets this representation for
3778 sorting purposes. */
3782 /* The debug_information[x].range_lists[y] value. */
3783 unsigned long ranges_offset
;
3785 /* Original debug_information to find parameters of the data. */
3786 debug_info
*debug_info_p
;
3789 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
3792 range_entry_compar (const void *ap
, const void *bp
)
3794 const struct range_entry
*a_re
= (const struct range_entry
*) ap
;
3795 const struct range_entry
*b_re
= (const struct range_entry
*) bp
;
3796 const unsigned long a
= a_re
->ranges_offset
;
3797 const unsigned long b
= b_re
->ranges_offset
;
3799 return (a
> b
) - (b
> a
);
3803 display_debug_ranges (struct dwarf_section
*section
,
3804 void *file ATTRIBUTE_UNUSED
)
3806 unsigned char *start
= section
->start
;
3807 unsigned long bytes
;
3808 unsigned char *section_begin
= start
;
3809 unsigned int num_range_list
, i
;
3810 struct range_entry
*range_entries
, *range_entry_fill
;
3812 bytes
= section
->size
;
3816 printf (_("\nThe %s section is empty.\n"), section
->name
);
3820 if (load_debug_info (file
) == 0)
3822 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
3828 for (i
= 0; i
< num_debug_info_entries
; i
++)
3829 num_range_list
+= debug_information
[i
].num_range_lists
;
3831 if (num_range_list
== 0)
3832 error (_("No range lists in .debug_info section!\n"));
3834 range_entries
= (struct range_entry
*)
3835 xmalloc (sizeof (*range_entries
) * num_range_list
);
3836 range_entry_fill
= range_entries
;
3838 for (i
= 0; i
< num_debug_info_entries
; i
++)
3840 debug_info
*debug_info_p
= &debug_information
[i
];
3843 for (j
= 0; j
< debug_info_p
->num_range_lists
; j
++)
3845 range_entry_fill
->ranges_offset
= debug_info_p
->range_lists
[j
];
3846 range_entry_fill
->debug_info_p
= debug_info_p
;
3851 qsort (range_entries
, num_range_list
, sizeof (*range_entries
),
3852 range_entry_compar
);
3854 /* DWARF sections under Mach-O have non-zero addresses. */
3855 if (range_entries
[0].ranges_offset
!= section
->address
)
3856 warn (_("Range lists in %s section start at 0x%lx\n"),
3857 section
->name
, range_entries
[0].ranges_offset
);
3859 printf (_("Contents of the %s section:\n\n"), section
->name
);
3860 printf (_(" Offset Begin End\n"));
3862 for (i
= 0; i
< num_range_list
; i
++)
3864 struct range_entry
*range_entry
= &range_entries
[i
];
3865 debug_info
*debug_info_p
= range_entry
->debug_info_p
;
3866 unsigned int pointer_size
;
3867 unsigned long offset
;
3868 unsigned char *next
;
3869 unsigned long base_address
;
3871 pointer_size
= debug_info_p
->pointer_size
;
3873 /* DWARF sections under Mach-O have non-zero addresses. */
3874 offset
= range_entry
->ranges_offset
- section
->address
;
3875 next
= section_begin
+ offset
;
3876 base_address
= debug_info_p
->base_address
;
3881 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
3882 (unsigned long) (start
- section_begin
),
3883 (unsigned long) (next
- section_begin
), section
->name
);
3884 else if (start
> next
)
3885 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
3886 (unsigned long) (start
- section_begin
),
3887 (unsigned long) (next
- section_begin
), section
->name
);
3896 /* Note: we use sign extension here in order to be sure that
3897 we can detect the -1 escape value. Sign extension into the
3898 top 32 bits of a 32-bit address will not affect the values
3899 that we display since we always show hex values, and always
3900 the bottom 32-bits. */
3901 begin
= byte_get_signed (start
, pointer_size
);
3902 start
+= pointer_size
;
3903 end
= byte_get_signed (start
, pointer_size
);
3904 start
+= pointer_size
;
3906 printf (" %8.8lx ", offset
);
3908 if (begin
== 0 && end
== 0)
3910 printf (_("<End of list>\n"));
3914 /* Check base address specifiers. */
3915 if (begin
== (dwarf_vma
) -1 && end
!= (dwarf_vma
) -1)
3918 print_dwarf_vma (begin
, pointer_size
);
3919 print_dwarf_vma (end
, pointer_size
);
3920 printf ("(base address)\n");
3924 print_dwarf_vma (begin
+ base_address
, pointer_size
);
3925 print_dwarf_vma (end
+ base_address
, pointer_size
);
3928 fputs (_("(start == end)"), stdout
);
3929 else if (begin
> end
)
3930 fputs (_("(start > end)"), stdout
);
3937 free (range_entries
);
3942 typedef struct Frame_Chunk
3944 struct Frame_Chunk
*next
;
3945 unsigned char *chunk_start
;
3947 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
3948 short int *col_type
;
3951 unsigned int code_factor
;
3953 unsigned long pc_begin
;
3954 unsigned long pc_range
;
3958 unsigned char fde_encoding
;
3959 unsigned char cfa_exp
;
3960 unsigned char ptr_size
;
3961 unsigned char segment_size
;
3965 static const char *const *dwarf_regnames
;
3966 static unsigned int dwarf_regnames_count
;
3968 /* A marker for a col_type that means this column was never referenced
3969 in the frame info. */
3970 #define DW_CFA_unreferenced (-1)
3972 /* Return 0 if not more space is needed, 1 if more space is needed,
3973 -1 for invalid reg. */
3976 frame_need_space (Frame_Chunk
*fc
, unsigned int reg
)
3978 int prev
= fc
->ncols
;
3980 if (reg
< (unsigned int) fc
->ncols
)
3983 if (dwarf_regnames_count
3984 && reg
> dwarf_regnames_count
)
3987 fc
->ncols
= reg
+ 1;
3988 fc
->col_type
= (short int *) xcrealloc (fc
->col_type
, fc
->ncols
,
3989 sizeof (short int));
3990 fc
->col_offset
= (int *) xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
3992 while (prev
< fc
->ncols
)
3994 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
3995 fc
->col_offset
[prev
] = 0;
4001 static const char *const dwarf_regnames_i386
[] =
4003 "eax", "ecx", "edx", "ebx",
4004 "esp", "ebp", "esi", "edi",
4005 "eip", "eflags", NULL
,
4006 "st0", "st1", "st2", "st3",
4007 "st4", "st5", "st6", "st7",
4009 "xmm0", "xmm1", "xmm2", "xmm3",
4010 "xmm4", "xmm5", "xmm6", "xmm7",
4011 "mm0", "mm1", "mm2", "mm3",
4012 "mm4", "mm5", "mm6", "mm7",
4013 "fcw", "fsw", "mxcsr",
4014 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
4019 init_dwarf_regnames_i386 (void)
4021 dwarf_regnames
= dwarf_regnames_i386
;
4022 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_i386
);
4025 static const char *const dwarf_regnames_x86_64
[] =
4027 "rax", "rdx", "rcx", "rbx",
4028 "rsi", "rdi", "rbp", "rsp",
4029 "r8", "r9", "r10", "r11",
4030 "r12", "r13", "r14", "r15",
4032 "xmm0", "xmm1", "xmm2", "xmm3",
4033 "xmm4", "xmm5", "xmm6", "xmm7",
4034 "xmm8", "xmm9", "xmm10", "xmm11",
4035 "xmm12", "xmm13", "xmm14", "xmm15",
4036 "st0", "st1", "st2", "st3",
4037 "st4", "st5", "st6", "st7",
4038 "mm0", "mm1", "mm2", "mm3",
4039 "mm4", "mm5", "mm6", "mm7",
4041 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
4042 "fs.base", "gs.base", NULL
, NULL
,
4044 "mxcsr", "fcw", "fsw"
4048 init_dwarf_regnames_x86_64 (void)
4050 dwarf_regnames
= dwarf_regnames_x86_64
;
4051 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_x86_64
);
4055 init_dwarf_regnames (unsigned int e_machine
)
4061 init_dwarf_regnames_i386 ();
4066 init_dwarf_regnames_x86_64 ();
4075 regname (unsigned int regno
, int row
)
4077 static char reg
[64];
4079 && regno
< dwarf_regnames_count
4080 && dwarf_regnames
[regno
] != NULL
)
4083 return dwarf_regnames
[regno
];
4084 snprintf (reg
, sizeof (reg
), "r%d (%s)", regno
,
4085 dwarf_regnames
[regno
]);
4088 snprintf (reg
, sizeof (reg
), "r%d", regno
);
4093 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, int *max_regs
)
4098 if (*max_regs
< fc
->ncols
)
4099 *max_regs
= fc
->ncols
;
4101 if (*need_col_headers
)
4103 static const char *sloc
= " LOC";
4105 *need_col_headers
= 0;
4107 printf ("%-*s CFA ", eh_addr_size
* 2, sloc
);
4109 for (r
= 0; r
< *max_regs
; r
++)
4110 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
4115 printf ("%-5s ", regname (r
, 1));
4121 printf ("%0*lx ", eh_addr_size
* 2, fc
->pc_begin
);
4123 strcpy (tmp
, "exp");
4125 sprintf (tmp
, "%s%+d", regname (fc
->cfa_reg
, 1), fc
->cfa_offset
);
4126 printf ("%-8s ", tmp
);
4128 for (r
= 0; r
< fc
->ncols
; r
++)
4130 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
4132 switch (fc
->col_type
[r
])
4134 case DW_CFA_undefined
:
4137 case DW_CFA_same_value
:
4141 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
4143 case DW_CFA_val_offset
:
4144 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
4146 case DW_CFA_register
:
4147 sprintf (tmp
, "%s", regname (fc
->col_offset
[r
], 0));
4149 case DW_CFA_expression
:
4150 strcpy (tmp
, "exp");
4152 case DW_CFA_val_expression
:
4153 strcpy (tmp
, "vexp");
4156 strcpy (tmp
, "n/a");
4159 printf ("%-5s ", tmp
);
4165 #define GET(N) byte_get (start, N); start += N
4166 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
4167 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
4170 display_debug_frames (struct dwarf_section
*section
,
4171 void *file ATTRIBUTE_UNUSED
)
4173 unsigned char *start
= section
->start
;
4174 unsigned char *end
= start
+ section
->size
;
4175 unsigned char *section_start
= start
;
4176 Frame_Chunk
*chunks
= 0;
4177 Frame_Chunk
*remembered_state
= 0;
4179 int is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
4180 unsigned int length_return
;
4182 const char *bad_reg
= _("bad register: ");
4183 int saved_eh_addr_size
= eh_addr_size
;
4185 printf (_("Contents of the %s section:\n"), section
->name
);
4189 unsigned char *saved_start
;
4190 unsigned char *block_end
;
4191 unsigned long length
;
4192 unsigned long cie_id
;
4195 int need_col_headers
= 1;
4196 unsigned char *augmentation_data
= NULL
;
4197 unsigned long augmentation_data_len
= 0;
4198 int encoded_ptr_size
= saved_eh_addr_size
;
4200 int initial_length_size
;
4202 saved_start
= start
;
4203 length
= byte_get (start
, 4); start
+= 4;
4207 printf ("\n%08lx ZERO terminator\n\n",
4208 (unsigned long)(saved_start
- section_start
));
4212 if (length
== 0xffffffff)
4214 length
= byte_get (start
, 8);
4217 initial_length_size
= 12;
4222 initial_length_size
= 4;
4225 block_end
= saved_start
+ length
+ initial_length_size
;
4226 if (block_end
> end
)
4228 warn ("Invalid length %#08lx in FDE at %#08lx\n",
4229 length
, (unsigned long)(saved_start
- section_start
));
4232 cie_id
= byte_get (start
, offset_size
); start
+= offset_size
;
4234 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
4238 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
4239 memset (fc
, 0, sizeof (Frame_Chunk
));
4243 fc
->chunk_start
= saved_start
;
4245 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
4246 fc
->col_offset
= (int *) xmalloc (sizeof (int));
4247 frame_need_space (fc
, max_regs
- 1);
4251 fc
->augmentation
= (char *) start
;
4252 start
= (unsigned char *) strchr ((char *) start
, '\0') + 1;
4254 if (strcmp (fc
->augmentation
, "eh") == 0)
4255 start
+= eh_addr_size
;
4259 fc
->ptr_size
= GET (1);
4260 fc
->segment_size
= GET (1);
4261 eh_addr_size
= fc
->ptr_size
;
4265 fc
->ptr_size
= eh_addr_size
;
4266 fc
->segment_size
= 0;
4268 fc
->code_factor
= LEB ();
4269 fc
->data_factor
= SLEB ();
4279 if (fc
->augmentation
[0] == 'z')
4281 augmentation_data_len
= LEB ();
4282 augmentation_data
= start
;
4283 start
+= augmentation_data_len
;
4287 if (do_debug_frames_interp
)
4288 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
4289 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
4290 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
4294 printf ("\n%08lx %08lx %08lx CIE\n",
4295 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
4296 printf (" Version: %d\n", version
);
4297 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
4300 printf (" Pointer Size: %u\n", fc
->ptr_size
);
4301 printf (" Segment Size: %u\n", fc
->segment_size
);
4303 printf (" Code alignment factor: %u\n", fc
->code_factor
);
4304 printf (" Data alignment factor: %d\n", fc
->data_factor
);
4305 printf (" Return address column: %d\n", fc
->ra
);
4307 if (augmentation_data_len
)
4310 printf (" Augmentation data: ");
4311 for (i
= 0; i
< augmentation_data_len
; ++i
)
4312 printf (" %02x", augmentation_data
[i
]);
4318 if (augmentation_data_len
)
4320 unsigned char *p
, *q
;
4321 p
= (unsigned char *) fc
->augmentation
+ 1;
4322 q
= augmentation_data
;
4329 q
+= 1 + size_of_encoded_value (*q
);
4331 fc
->fde_encoding
= *q
++;
4339 if (fc
->fde_encoding
)
4340 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
4343 frame_need_space (fc
, fc
->ra
);
4347 unsigned char *look_for
;
4348 static Frame_Chunk fde_fc
;
4349 unsigned long segment_selector
;
4352 memset (fc
, 0, sizeof (Frame_Chunk
));
4354 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
4356 for (cie
= chunks
; cie
; cie
= cie
->next
)
4357 if (cie
->chunk_start
== look_for
)
4362 warn ("Invalid CIE pointer %#08lx in FDE at %#08lx\n",
4363 cie_id
, (unsigned long)(saved_start
- section_start
));
4365 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
4366 fc
->col_offset
= (int *) xmalloc (sizeof (int));
4367 frame_need_space (fc
, max_regs
- 1);
4369 fc
->augmentation
= "";
4370 fc
->fde_encoding
= 0;
4371 fc
->ptr_size
= eh_addr_size
;
4372 fc
->segment_size
= 0;
4376 fc
->ncols
= cie
->ncols
;
4377 fc
->col_type
= (short int *) xcmalloc (fc
->ncols
, sizeof (short int));
4378 fc
->col_offset
= (int *) xcmalloc (fc
->ncols
, sizeof (int));
4379 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
4380 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
4381 fc
->augmentation
= cie
->augmentation
;
4382 fc
->ptr_size
= cie
->ptr_size
;
4383 eh_addr_size
= cie
->ptr_size
;
4384 fc
->segment_size
= cie
->segment_size
;
4385 fc
->code_factor
= cie
->code_factor
;
4386 fc
->data_factor
= cie
->data_factor
;
4387 fc
->cfa_reg
= cie
->cfa_reg
;
4388 fc
->cfa_offset
= cie
->cfa_offset
;
4390 frame_need_space (fc
, max_regs
- 1);
4391 fc
->fde_encoding
= cie
->fde_encoding
;
4394 if (fc
->fde_encoding
)
4395 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
4397 segment_selector
= 0;
4398 if (fc
->segment_size
)
4400 segment_selector
= byte_get (start
, fc
->segment_size
);
4401 start
+= fc
->segment_size
;
4403 fc
->pc_begin
= get_encoded_value (start
, fc
->fde_encoding
);
4404 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
)
4405 fc
->pc_begin
+= section
->address
+ (start
- section_start
);
4406 start
+= encoded_ptr_size
;
4407 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
4408 start
+= encoded_ptr_size
;
4410 if (cie
->augmentation
[0] == 'z')
4412 augmentation_data_len
= LEB ();
4413 augmentation_data
= start
;
4414 start
+= augmentation_data_len
;
4417 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=",
4418 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
4419 (unsigned long)(cie
->chunk_start
- section_start
));
4420 if (fc
->segment_size
)
4421 printf ("%04lx:", segment_selector
);
4422 printf ("%08lx..%08lx\n", fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
4423 if (! do_debug_frames_interp
&& augmentation_data_len
)
4427 printf (" Augmentation data: ");
4428 for (i
= 0; i
< augmentation_data_len
; ++i
)
4429 printf (" %02x", augmentation_data
[i
]);
4435 /* At this point, fc is the current chunk, cie (if any) is set, and
4436 we're about to interpret instructions for the chunk. */
4437 /* ??? At present we need to do this always, since this sizes the
4438 fc->col_type and fc->col_offset arrays, which we write into always.
4439 We should probably split the interpreted and non-interpreted bits
4440 into two different routines, since there's so much that doesn't
4441 really overlap between them. */
4442 if (1 || do_debug_frames_interp
)
4444 /* Start by making a pass over the chunk, allocating storage
4445 and taking note of what registers are used. */
4446 unsigned char *tmp
= start
;
4448 while (start
< block_end
)
4451 unsigned long reg
, temp
;
4458 /* Warning: if you add any more cases to this switch, be
4459 sure to add them to the corresponding switch below. */
4462 case DW_CFA_advance_loc
:
4466 if (frame_need_space (fc
, opa
) >= 0)
4467 fc
->col_type
[opa
] = DW_CFA_undefined
;
4469 case DW_CFA_restore
:
4470 if (frame_need_space (fc
, opa
) >= 0)
4471 fc
->col_type
[opa
] = DW_CFA_undefined
;
4473 case DW_CFA_set_loc
:
4474 start
+= encoded_ptr_size
;
4476 case DW_CFA_advance_loc1
:
4479 case DW_CFA_advance_loc2
:
4482 case DW_CFA_advance_loc4
:
4485 case DW_CFA_offset_extended
:
4486 case DW_CFA_val_offset
:
4487 reg
= LEB (); LEB ();
4488 if (frame_need_space (fc
, reg
) >= 0)
4489 fc
->col_type
[reg
] = DW_CFA_undefined
;
4491 case DW_CFA_restore_extended
:
4493 frame_need_space (fc
, reg
);
4494 if (frame_need_space (fc
, reg
) >= 0)
4495 fc
->col_type
[reg
] = DW_CFA_undefined
;
4497 case DW_CFA_undefined
:
4499 if (frame_need_space (fc
, reg
) >= 0)
4500 fc
->col_type
[reg
] = DW_CFA_undefined
;
4502 case DW_CFA_same_value
:
4504 if (frame_need_space (fc
, reg
) >= 0)
4505 fc
->col_type
[reg
] = DW_CFA_undefined
;
4507 case DW_CFA_register
:
4508 reg
= LEB (); LEB ();
4509 if (frame_need_space (fc
, reg
) >= 0)
4510 fc
->col_type
[reg
] = DW_CFA_undefined
;
4512 case DW_CFA_def_cfa
:
4515 case DW_CFA_def_cfa_register
:
4518 case DW_CFA_def_cfa_offset
:
4521 case DW_CFA_def_cfa_expression
:
4525 case DW_CFA_expression
:
4526 case DW_CFA_val_expression
:
4530 if (frame_need_space (fc
, reg
) >= 0)
4531 fc
->col_type
[reg
] = DW_CFA_undefined
;
4533 case DW_CFA_offset_extended_sf
:
4534 case DW_CFA_val_offset_sf
:
4535 reg
= LEB (); SLEB ();
4536 if (frame_need_space (fc
, reg
) >= 0)
4537 fc
->col_type
[reg
] = DW_CFA_undefined
;
4539 case DW_CFA_def_cfa_sf
:
4542 case DW_CFA_def_cfa_offset_sf
:
4545 case DW_CFA_MIPS_advance_loc8
:
4548 case DW_CFA_GNU_args_size
:
4551 case DW_CFA_GNU_negative_offset_extended
:
4552 reg
= LEB (); LEB ();
4553 if (frame_need_space (fc
, reg
) >= 0)
4554 fc
->col_type
[reg
] = DW_CFA_undefined
;
4563 /* Now we know what registers are used, make a second pass over
4564 the chunk, this time actually printing out the info. */
4566 while (start
< block_end
)
4569 unsigned long ul
, reg
, roffs
;
4572 const char *reg_prefix
= "";
4579 /* Warning: if you add any more cases to this switch, be
4580 sure to add them to the corresponding switch above. */
4583 case DW_CFA_advance_loc
:
4584 if (do_debug_frames_interp
)
4585 frame_display_row (fc
, &need_col_headers
, &max_regs
);
4587 printf (" DW_CFA_advance_loc: %d to %08lx\n",
4588 opa
* fc
->code_factor
,
4589 fc
->pc_begin
+ opa
* fc
->code_factor
);
4590 fc
->pc_begin
+= opa
* fc
->code_factor
;
4595 if (opa
>= (unsigned int) fc
->ncols
)
4596 reg_prefix
= bad_reg
;
4597 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4598 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
4599 reg_prefix
, regname (opa
, 0),
4600 roffs
* fc
->data_factor
);
4601 if (*reg_prefix
== '\0')
4603 fc
->col_type
[opa
] = DW_CFA_offset
;
4604 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
4608 case DW_CFA_restore
:
4609 if (opa
>= (unsigned int) cie
->ncols
4610 || opa
>= (unsigned int) fc
->ncols
)
4611 reg_prefix
= bad_reg
;
4612 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4613 printf (" DW_CFA_restore: %s%s\n",
4614 reg_prefix
, regname (opa
, 0));
4615 if (*reg_prefix
== '\0')
4617 fc
->col_type
[opa
] = cie
->col_type
[opa
];
4618 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
4622 case DW_CFA_set_loc
:
4623 vma
= get_encoded_value (start
, fc
->fde_encoding
);
4624 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
)
4625 vma
+= section
->address
+ (start
- section_start
);
4626 start
+= encoded_ptr_size
;
4627 if (do_debug_frames_interp
)
4628 frame_display_row (fc
, &need_col_headers
, &max_regs
);
4630 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
4634 case DW_CFA_advance_loc1
:
4635 ofs
= byte_get (start
, 1); start
+= 1;
4636 if (do_debug_frames_interp
)
4637 frame_display_row (fc
, &need_col_headers
, &max_regs
);
4639 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
4640 ofs
* fc
->code_factor
,
4641 fc
->pc_begin
+ ofs
* fc
->code_factor
);
4642 fc
->pc_begin
+= ofs
* fc
->code_factor
;
4645 case DW_CFA_advance_loc2
:
4646 ofs
= byte_get (start
, 2); start
+= 2;
4647 if (do_debug_frames_interp
)
4648 frame_display_row (fc
, &need_col_headers
, &max_regs
);
4650 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
4651 ofs
* fc
->code_factor
,
4652 fc
->pc_begin
+ ofs
* fc
->code_factor
);
4653 fc
->pc_begin
+= ofs
* fc
->code_factor
;
4656 case DW_CFA_advance_loc4
:
4657 ofs
= byte_get (start
, 4); start
+= 4;
4658 if (do_debug_frames_interp
)
4659 frame_display_row (fc
, &need_col_headers
, &max_regs
);
4661 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
4662 ofs
* fc
->code_factor
,
4663 fc
->pc_begin
+ ofs
* fc
->code_factor
);
4664 fc
->pc_begin
+= ofs
* fc
->code_factor
;
4667 case DW_CFA_offset_extended
:
4670 if (reg
>= (unsigned int) fc
->ncols
)
4671 reg_prefix
= bad_reg
;
4672 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4673 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
4674 reg_prefix
, regname (reg
, 0),
4675 roffs
* fc
->data_factor
);
4676 if (*reg_prefix
== '\0')
4678 fc
->col_type
[reg
] = DW_CFA_offset
;
4679 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
4683 case DW_CFA_val_offset
:
4686 if (reg
>= (unsigned int) fc
->ncols
)
4687 reg_prefix
= bad_reg
;
4688 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4689 printf (" DW_CFA_val_offset: %s%s at cfa%+ld\n",
4690 reg_prefix
, regname (reg
, 0),
4691 roffs
* fc
->data_factor
);
4692 if (*reg_prefix
== '\0')
4694 fc
->col_type
[reg
] = DW_CFA_val_offset
;
4695 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
4699 case DW_CFA_restore_extended
:
4701 if (reg
>= (unsigned int) cie
->ncols
4702 || reg
>= (unsigned int) fc
->ncols
)
4703 reg_prefix
= bad_reg
;
4704 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4705 printf (" DW_CFA_restore_extended: %s%s\n",
4706 reg_prefix
, regname (reg
, 0));
4707 if (*reg_prefix
== '\0')
4709 fc
->col_type
[reg
] = cie
->col_type
[reg
];
4710 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
4714 case DW_CFA_undefined
:
4716 if (reg
>= (unsigned int) fc
->ncols
)
4717 reg_prefix
= bad_reg
;
4718 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4719 printf (" DW_CFA_undefined: %s%s\n",
4720 reg_prefix
, regname (reg
, 0));
4721 if (*reg_prefix
== '\0')
4723 fc
->col_type
[reg
] = DW_CFA_undefined
;
4724 fc
->col_offset
[reg
] = 0;
4728 case DW_CFA_same_value
:
4730 if (reg
>= (unsigned int) fc
->ncols
)
4731 reg_prefix
= bad_reg
;
4732 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4733 printf (" DW_CFA_same_value: %s%s\n",
4734 reg_prefix
, regname (reg
, 0));
4735 if (*reg_prefix
== '\0')
4737 fc
->col_type
[reg
] = DW_CFA_same_value
;
4738 fc
->col_offset
[reg
] = 0;
4742 case DW_CFA_register
:
4745 if (reg
>= (unsigned int) fc
->ncols
)
4746 reg_prefix
= bad_reg
;
4747 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4749 printf (" DW_CFA_register: %s%s in ",
4750 reg_prefix
, regname (reg
, 0));
4751 puts (regname (roffs
, 0));
4753 if (*reg_prefix
== '\0')
4755 fc
->col_type
[reg
] = DW_CFA_register
;
4756 fc
->col_offset
[reg
] = roffs
;
4760 case DW_CFA_remember_state
:
4761 if (! do_debug_frames_interp
)
4762 printf (" DW_CFA_remember_state\n");
4763 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
4764 rs
->ncols
= fc
->ncols
;
4765 rs
->col_type
= (short int *) xcmalloc (rs
->ncols
,
4766 sizeof (short int));
4767 rs
->col_offset
= (int *) xcmalloc (rs
->ncols
, sizeof (int));
4768 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
4769 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
4770 rs
->next
= remembered_state
;
4771 remembered_state
= rs
;
4774 case DW_CFA_restore_state
:
4775 if (! do_debug_frames_interp
)
4776 printf (" DW_CFA_restore_state\n");
4777 rs
= remembered_state
;
4780 remembered_state
= rs
->next
;
4781 frame_need_space (fc
, rs
->ncols
- 1);
4782 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
4783 memcpy (fc
->col_offset
, rs
->col_offset
,
4784 rs
->ncols
* sizeof (int));
4785 free (rs
->col_type
);
4786 free (rs
->col_offset
);
4789 else if (do_debug_frames_interp
)
4790 printf ("Mismatched DW_CFA_restore_state\n");
4793 case DW_CFA_def_cfa
:
4794 fc
->cfa_reg
= LEB ();
4795 fc
->cfa_offset
= LEB ();
4797 if (! do_debug_frames_interp
)
4798 printf (" DW_CFA_def_cfa: %s ofs %d\n",
4799 regname (fc
->cfa_reg
, 0), fc
->cfa_offset
);
4802 case DW_CFA_def_cfa_register
:
4803 fc
->cfa_reg
= LEB ();
4805 if (! do_debug_frames_interp
)
4806 printf (" DW_CFA_def_cfa_register: %s\n",
4807 regname (fc
->cfa_reg
, 0));
4810 case DW_CFA_def_cfa_offset
:
4811 fc
->cfa_offset
= LEB ();
4812 if (! do_debug_frames_interp
)
4813 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
4817 if (! do_debug_frames_interp
)
4818 printf (" DW_CFA_nop\n");
4821 case DW_CFA_def_cfa_expression
:
4823 if (! do_debug_frames_interp
)
4825 printf (" DW_CFA_def_cfa_expression (");
4826 decode_location_expression (start
, eh_addr_size
, 0, -1,
4834 case DW_CFA_expression
:
4837 if (reg
>= (unsigned int) fc
->ncols
)
4838 reg_prefix
= bad_reg
;
4839 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4841 printf (" DW_CFA_expression: %s%s (",
4842 reg_prefix
, regname (reg
, 0));
4843 decode_location_expression (start
, eh_addr_size
, 0, -1,
4847 if (*reg_prefix
== '\0')
4848 fc
->col_type
[reg
] = DW_CFA_expression
;
4852 case DW_CFA_val_expression
:
4855 if (reg
>= (unsigned int) fc
->ncols
)
4856 reg_prefix
= bad_reg
;
4857 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4859 printf (" DW_CFA_val_expression: %s%s (",
4860 reg_prefix
, regname (reg
, 0));
4861 decode_location_expression (start
, eh_addr_size
, 0, -1,
4865 if (*reg_prefix
== '\0')
4866 fc
->col_type
[reg
] = DW_CFA_val_expression
;
4870 case DW_CFA_offset_extended_sf
:
4873 if (frame_need_space (fc
, reg
) < 0)
4874 reg_prefix
= bad_reg
;
4875 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4876 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
4877 reg_prefix
, regname (reg
, 0),
4878 l
* fc
->data_factor
);
4879 if (*reg_prefix
== '\0')
4881 fc
->col_type
[reg
] = DW_CFA_offset
;
4882 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
4886 case DW_CFA_val_offset_sf
:
4889 if (frame_need_space (fc
, reg
) < 0)
4890 reg_prefix
= bad_reg
;
4891 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4892 printf (" DW_CFA_val_offset_sf: %s%s at cfa%+ld\n",
4893 reg_prefix
, regname (reg
, 0),
4894 l
* fc
->data_factor
);
4895 if (*reg_prefix
== '\0')
4897 fc
->col_type
[reg
] = DW_CFA_val_offset
;
4898 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
4902 case DW_CFA_def_cfa_sf
:
4903 fc
->cfa_reg
= LEB ();
4904 fc
->cfa_offset
= SLEB ();
4905 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
4907 if (! do_debug_frames_interp
)
4908 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
4909 regname (fc
->cfa_reg
, 0), fc
->cfa_offset
);
4912 case DW_CFA_def_cfa_offset_sf
:
4913 fc
->cfa_offset
= SLEB ();
4914 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
4915 if (! do_debug_frames_interp
)
4916 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
4919 case DW_CFA_MIPS_advance_loc8
:
4920 ofs
= byte_get (start
, 8); start
+= 8;
4921 if (do_debug_frames_interp
)
4922 frame_display_row (fc
, &need_col_headers
, &max_regs
);
4924 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
4925 ofs
* fc
->code_factor
,
4926 fc
->pc_begin
+ ofs
* fc
->code_factor
);
4927 fc
->pc_begin
+= ofs
* fc
->code_factor
;
4930 case DW_CFA_GNU_window_save
:
4931 if (! do_debug_frames_interp
)
4932 printf (" DW_CFA_GNU_window_save\n");
4935 case DW_CFA_GNU_args_size
:
4937 if (! do_debug_frames_interp
)
4938 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
4941 case DW_CFA_GNU_negative_offset_extended
:
4944 if (frame_need_space (fc
, reg
) < 0)
4945 reg_prefix
= bad_reg
;
4946 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
4947 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
4948 reg_prefix
, regname (reg
, 0),
4949 l
* fc
->data_factor
);
4950 if (*reg_prefix
== '\0')
4952 fc
->col_type
[reg
] = DW_CFA_offset
;
4953 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
4958 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
4959 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
4961 warn (_("unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
4966 if (do_debug_frames_interp
)
4967 frame_display_row (fc
, &need_col_headers
, &max_regs
);
4970 eh_addr_size
= saved_eh_addr_size
;
4983 display_debug_not_supported (struct dwarf_section
*section
,
4984 void *file ATTRIBUTE_UNUSED
)
4986 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
4993 cmalloc (size_t nmemb
, size_t size
)
4995 /* Check for overflow. */
4996 if (nmemb
>= ~(size_t) 0 / size
)
4999 return malloc (nmemb
* size
);
5003 xcmalloc (size_t nmemb
, size_t size
)
5005 /* Check for overflow. */
5006 if (nmemb
>= ~(size_t) 0 / size
)
5009 return xmalloc (nmemb
* size
);
5013 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
5015 /* Check for overflow. */
5016 if (nmemb
>= ~(size_t) 0 / size
)
5019 return xrealloc (ptr
, nmemb
* size
);
5023 error (const char *message
, ...)
5027 va_start (args
, message
);
5028 fprintf (stderr
, _("%s: Error: "), program_name
);
5029 vfprintf (stderr
, message
, args
);
5034 warn (const char *message
, ...)
5038 va_start (args
, message
);
5039 fprintf (stderr
, _("%s: Warning: "), program_name
);
5040 vfprintf (stderr
, message
, args
);
5045 free_debug_memory (void)
5051 for (i
= 0; i
< max
; i
++)
5052 free_debug_section ((enum dwarf_section_display_enum
) i
);
5054 if (debug_information
!= NULL
)
5056 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
)
5058 for (i
= 0; i
< num_debug_info_entries
; i
++)
5060 if (!debug_information
[i
].max_loc_offsets
)
5062 free (debug_information
[i
].loc_offsets
);
5063 free (debug_information
[i
].have_frame_base
);
5065 if (!debug_information
[i
].max_range_lists
)
5066 free (debug_information
[i
].range_lists
);
5070 free (debug_information
);
5071 debug_information
= NULL
;
5072 num_debug_info_entries
= 0;
5077 dwarf_select_sections_by_names (const char *names
)
5081 const char * option
;
5085 debug_dump_long_opts
;
5087 static const debug_dump_long_opts opts_table
[] =
5089 /* Please keep this table alpha- sorted. */
5090 { "Ranges", & do_debug_ranges
, 1 },
5091 { "abbrev", & do_debug_abbrevs
, 1 },
5092 { "aranges", & do_debug_aranges
, 1 },
5093 { "frames", & do_debug_frames
, 1 },
5094 { "frames-interp", & do_debug_frames_interp
, 1 },
5095 { "info", & do_debug_info
, 1 },
5096 { "line", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
}, /* For backwards compatibility. */
5097 { "rawline", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
5098 { "decodedline", & do_debug_lines
, FLAG_DEBUG_LINES_DECODED
},
5099 { "loc", & do_debug_loc
, 1 },
5100 { "macro", & do_debug_macinfo
, 1 },
5101 { "pubnames", & do_debug_pubnames
, 1 },
5102 { "pubtypes", & do_debug_pubtypes
, 1 },
5103 /* This entry is for compatability
5104 with earlier versions of readelf. */
5105 { "ranges", & do_debug_aranges
, 1 },
5106 { "str", & do_debug_str
, 1 },
5107 /* These trace_* sections are used by Itanium VMS. */
5108 { "trace_abbrev", & do_trace_abbrevs
, 1 },
5109 { "trace_aranges", & do_trace_aranges
, 1 },
5110 { "trace_info", & do_trace_info
, 1 },
5119 const debug_dump_long_opts
* entry
;
5121 for (entry
= opts_table
; entry
->option
; entry
++)
5123 size_t len
= strlen (entry
->option
);
5125 if (strncmp (p
, entry
->option
, len
) == 0
5126 && (p
[len
] == ',' || p
[len
] == '\0'))
5128 * entry
->variable
|= entry
->val
;
5130 /* The --debug-dump=frames-interp option also
5131 enables the --debug-dump=frames option. */
5132 if (do_debug_frames_interp
)
5133 do_debug_frames
= 1;
5140 if (entry
->option
== NULL
)
5142 warn (_("Unrecognized debug option '%s'\n"), p
);
5143 p
= strchr (p
, ',');
5154 dwarf_select_sections_by_letters (const char *letters
)
5156 unsigned int lindex
= 0;
5158 while (letters
[lindex
])
5159 switch (letters
[lindex
++])
5166 do_debug_abbrevs
= 1;
5170 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
5174 do_debug_lines
|= FLAG_DEBUG_LINES_DECODED
;
5178 do_debug_pubnames
= 1;
5182 do_debug_pubtypes
= 1;
5186 do_debug_aranges
= 1;
5190 do_debug_ranges
= 1;
5194 do_debug_frames_interp
= 1;
5196 do_debug_frames
= 1;
5200 do_debug_macinfo
= 1;
5212 warn (_("Unrecognized debug option '%s'\n"), optarg
);
5218 dwarf_select_sections_all (void)
5221 do_debug_abbrevs
= 1;
5222 do_debug_lines
= FLAG_DEBUG_LINES_RAW
;
5223 do_debug_pubnames
= 1;
5224 do_debug_pubtypes
= 1;
5225 do_debug_aranges
= 1;
5226 do_debug_ranges
= 1;
5227 do_debug_frames
= 1;
5228 do_debug_macinfo
= 1;
5232 do_trace_abbrevs
= 1;
5233 do_trace_aranges
= 1;
5236 struct dwarf_section_display debug_displays
[] =
5238 { { ".debug_abbrev", ".zdebug_abbrev", NULL
, NULL
, 0, 0 },
5239 display_debug_abbrev
, &do_debug_abbrevs
, 0 },
5240 { { ".debug_aranges", ".zdebug_aranges", NULL
, NULL
, 0, 0 },
5241 display_debug_aranges
, &do_debug_aranges
, 1 },
5242 { { ".debug_frame", ".zdebug_frame", NULL
, NULL
, 0, 0 },
5243 display_debug_frames
, &do_debug_frames
, 1 },
5244 { { ".debug_info", ".zdebug_info", NULL
, NULL
, 0, 0 },
5245 display_debug_info
, &do_debug_info
, 1 },
5246 { { ".debug_line", ".zdebug_line", NULL
, NULL
, 0, 0 },
5247 display_debug_lines
, &do_debug_lines
, 1 },
5248 { { ".debug_pubnames", ".zdebug_pubnames", NULL
, NULL
, 0, 0 },
5249 display_debug_pubnames
, &do_debug_pubnames
, 0 },
5250 { { ".eh_frame", "", NULL
, NULL
, 0, 0 },
5251 display_debug_frames
, &do_debug_frames
, 1 },
5252 { { ".debug_macinfo", ".zdebug_macinfo", NULL
, NULL
, 0, 0 },
5253 display_debug_macinfo
, &do_debug_macinfo
, 0 },
5254 { { ".debug_str", ".zdebug_str", NULL
, NULL
, 0, 0 },
5255 display_debug_str
, &do_debug_str
, 0 },
5256 { { ".debug_loc", ".zdebug_loc", NULL
, NULL
, 0, 0 },
5257 display_debug_loc
, &do_debug_loc
, 1 },
5258 { { ".debug_pubtypes", ".zdebug_pubtypes", NULL
, NULL
, 0, 0 },
5259 display_debug_pubnames
, &do_debug_pubtypes
, 0 },
5260 { { ".debug_ranges", ".zdebug_ranges", NULL
, NULL
, 0, 0 },
5261 display_debug_ranges
, &do_debug_ranges
, 1 },
5262 { { ".debug_static_func", ".zdebug_static_func", NULL
, NULL
, 0, 0 },
5263 display_debug_not_supported
, NULL
, 0 },
5264 { { ".debug_static_vars", ".zdebug_static_vars", NULL
, NULL
, 0, 0 },
5265 display_debug_not_supported
, NULL
, 0 },
5266 { { ".debug_types", ".zdebug_types", NULL
, NULL
, 0, 0 },
5267 display_debug_types
, &do_debug_info
, 1 },
5268 { { ".debug_weaknames", ".zdebug_weaknames", NULL
, NULL
, 0, 0 },
5269 display_debug_not_supported
, NULL
, 0 },
5270 { { ".trace_info", "", NULL
, NULL
, 0, 0 },
5271 display_trace_info
, &do_trace_info
, 1 },
5272 { { ".trace_abbrev", "", NULL
, NULL
, 0, 0 },
5273 display_debug_abbrev
, &do_trace_abbrevs
, 0 },
5274 { { ".trace_aranges", "", NULL
, NULL
, 0, 0 },
5275 display_debug_aranges
, &do_trace_aranges
, 0 }