1 /* dwarf.c -- display DWARF contents of a BFD binary file
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 2 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
27 #include "libiberty.h"
29 static int have_frame_base
;
30 static int need_base_address
;
32 static unsigned int last_pointer_size
= 0;
33 static int warned_about_missing_comp_units
= FALSE
;
35 static unsigned int num_debug_info_entries
= 0;
36 static debug_info
*debug_information
= NULL
;
38 dwarf_vma eh_addr_size
;
44 int do_debug_pubnames
;
48 int do_debug_frames_interp
;
53 dwarf_vma (*byte_get
) (unsigned char *, int);
56 byte_get_little_endian (unsigned char *field
, int size
)
64 return ((unsigned int) (field
[0]))
65 | (((unsigned int) (field
[1])) << 8);
68 return ((unsigned long) (field
[0]))
69 | (((unsigned long) (field
[1])) << 8)
70 | (((unsigned long) (field
[2])) << 16)
71 | (((unsigned long) (field
[3])) << 24);
74 if (sizeof (dwarf_vma
) == 8)
75 return ((dwarf_vma
) (field
[0]))
76 | (((dwarf_vma
) (field
[1])) << 8)
77 | (((dwarf_vma
) (field
[2])) << 16)
78 | (((dwarf_vma
) (field
[3])) << 24)
79 | (((dwarf_vma
) (field
[4])) << 32)
80 | (((dwarf_vma
) (field
[5])) << 40)
81 | (((dwarf_vma
) (field
[6])) << 48)
82 | (((dwarf_vma
) (field
[7])) << 56);
83 else if (sizeof (dwarf_vma
) == 4)
84 /* We want to extract data from an 8 byte wide field and
85 place it into a 4 byte wide field. Since this is a little
86 endian source we can just use the 4 byte extraction code. */
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 error (_("Unhandled data length: %d\n"), size
);
99 byte_get_big_endian (unsigned char *field
, int size
)
107 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
110 return ((unsigned long) (field
[3]))
111 | (((unsigned long) (field
[2])) << 8)
112 | (((unsigned long) (field
[1])) << 16)
113 | (((unsigned long) (field
[0])) << 24);
116 if (sizeof (dwarf_vma
) == 8)
117 return ((dwarf_vma
) (field
[7]))
118 | (((dwarf_vma
) (field
[6])) << 8)
119 | (((dwarf_vma
) (field
[5])) << 16)
120 | (((dwarf_vma
) (field
[4])) << 24)
121 | (((dwarf_vma
) (field
[3])) << 32)
122 | (((dwarf_vma
) (field
[2])) << 40)
123 | (((dwarf_vma
) (field
[1])) << 48)
124 | (((dwarf_vma
) (field
[0])) << 56);
125 else if (sizeof (dwarf_vma
) == 4)
127 /* Although we are extracing data from an 8 byte wide field,
128 we are returning only 4 bytes of data. */
130 return ((unsigned long) (field
[3]))
131 | (((unsigned long) (field
[2])) << 8)
132 | (((unsigned long) (field
[1])) << 16)
133 | (((unsigned long) (field
[0])) << 24);
137 error (_("Unhandled data length: %d\n"), size
);
143 byte_get_signed (unsigned char *field
, int size
)
145 dwarf_vma x
= byte_get (field
, size
);
150 return (x
^ 0x80) - 0x80;
152 return (x
^ 0x8000) - 0x8000;
154 return (x
^ 0x80000000) - 0x80000000;
162 static unsigned long int
163 read_leb128 (unsigned char *data
, unsigned int *length_return
, int sign
)
165 unsigned long int result
= 0;
166 unsigned int num_read
= 0;
167 unsigned int shift
= 0;
175 result
|= ((unsigned long int) (byte
& 0x7f)) << shift
;
182 if (length_return
!= NULL
)
183 *length_return
= num_read
;
185 if (sign
&& (shift
< 8 * sizeof (result
)) && (byte
& 0x40))
186 result
|= -1L << shift
;
191 typedef struct State_Machine_Registers
193 unsigned long address
;
200 /* This variable hold the number of the last entry seen
201 in the File Table. */
202 unsigned int last_file_entry
;
205 static SMR state_machine_regs
;
208 reset_state_machine (int is_stmt
)
210 state_machine_regs
.address
= 0;
211 state_machine_regs
.file
= 1;
212 state_machine_regs
.line
= 1;
213 state_machine_regs
.column
= 0;
214 state_machine_regs
.is_stmt
= is_stmt
;
215 state_machine_regs
.basic_block
= 0;
216 state_machine_regs
.end_sequence
= 0;
217 state_machine_regs
.last_file_entry
= 0;
220 /* Handled an extend line op.
221 Returns the number of bytes read. */
224 process_extended_line_op (unsigned char *data
, int is_stmt
)
226 unsigned char op_code
;
227 unsigned int bytes_read
;
232 len
= read_leb128 (data
, & bytes_read
, 0);
237 warn (_("badly formed extended line op encountered!\n"));
244 printf (_(" Extended opcode %d: "), op_code
);
248 case DW_LNE_end_sequence
:
249 printf (_("End of Sequence\n\n"));
250 reset_state_machine (is_stmt
);
253 case DW_LNE_set_address
:
254 adr
= byte_get (data
, len
- bytes_read
- 1);
255 printf (_("set Address to 0x%lx\n"), adr
);
256 state_machine_regs
.address
= adr
;
259 case DW_LNE_define_file
:
260 printf (_(" define new File Table entry\n"));
261 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
263 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
265 data
+= strlen ((char *) data
) + 1;
266 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
268 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
270 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
271 printf (_("%s\n\n"), name
);
275 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
283 fetch_indirect_string (unsigned long offset
)
285 struct dwarf_section
*section
= &debug_displays
[str
].section
;
287 if (section
->start
== NULL
)
288 return _("<no .debug_str section>");
290 /* DWARF sections under Mach-O have non-zero addresses. */
291 offset
-= section
->address
;
292 if (offset
> section
->size
)
294 warn (_("DW_FORM_strp offset too big: %lx\n"), offset
);
295 return _("<offset is too big>");
298 return (const char *) section
->start
+ offset
;
301 /* FIXME: There are better and more efficient ways to handle
302 these structures. For now though, I just want something that
303 is simple to implement. */
304 typedef struct abbrev_attr
306 unsigned long attribute
;
308 struct abbrev_attr
*next
;
312 typedef struct abbrev_entry
317 struct abbrev_attr
*first_attr
;
318 struct abbrev_attr
*last_attr
;
319 struct abbrev_entry
*next
;
323 static abbrev_entry
*first_abbrev
= NULL
;
324 static abbrev_entry
*last_abbrev
= NULL
;
329 abbrev_entry
*abbrev
;
331 for (abbrev
= first_abbrev
; abbrev
;)
333 abbrev_entry
*next
= abbrev
->next
;
336 for (attr
= abbrev
->first_attr
; attr
;)
338 abbrev_attr
*next
= attr
->next
;
348 last_abbrev
= first_abbrev
= NULL
;
352 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
356 entry
= malloc (sizeof (*entry
));
362 entry
->entry
= number
;
364 entry
->children
= children
;
365 entry
->first_attr
= NULL
;
366 entry
->last_attr
= NULL
;
369 if (first_abbrev
== NULL
)
370 first_abbrev
= entry
;
372 last_abbrev
->next
= entry
;
378 add_abbrev_attr (unsigned long attribute
, unsigned long form
)
382 attr
= malloc (sizeof (*attr
));
388 attr
->attribute
= attribute
;
392 if (last_abbrev
->first_attr
== NULL
)
393 last_abbrev
->first_attr
= attr
;
395 last_abbrev
->last_attr
->next
= attr
;
397 last_abbrev
->last_attr
= attr
;
400 /* Processes the (partial) contents of a .debug_abbrev section.
401 Returns NULL if the end of the section was encountered.
402 Returns the address after the last byte read if the end of
403 an abbreviation set was found. */
405 static unsigned char *
406 process_abbrev_section (unsigned char *start
, unsigned char *end
)
408 if (first_abbrev
!= NULL
)
413 unsigned int bytes_read
;
416 unsigned long attribute
;
419 entry
= read_leb128 (start
, & bytes_read
, 0);
422 /* A single zero is supposed to end the section according
423 to the standard. If there's more, then signal that to
426 return start
== end
? NULL
: start
;
428 tag
= read_leb128 (start
, & bytes_read
, 0);
433 add_abbrev (entry
, tag
, children
);
439 attribute
= read_leb128 (start
, & bytes_read
, 0);
442 form
= read_leb128 (start
, & bytes_read
, 0);
446 add_abbrev_attr (attribute
, form
);
448 while (attribute
!= 0);
455 get_TAG_name (unsigned long tag
)
459 case DW_TAG_padding
: return "DW_TAG_padding";
460 case DW_TAG_array_type
: return "DW_TAG_array_type";
461 case DW_TAG_class_type
: return "DW_TAG_class_type";
462 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
463 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
464 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
465 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
466 case DW_TAG_label
: return "DW_TAG_label";
467 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
468 case DW_TAG_member
: return "DW_TAG_member";
469 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
470 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
471 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
472 case DW_TAG_string_type
: return "DW_TAG_string_type";
473 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
474 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
475 case DW_TAG_typedef
: return "DW_TAG_typedef";
476 case DW_TAG_union_type
: return "DW_TAG_union_type";
477 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
478 case DW_TAG_variant
: return "DW_TAG_variant";
479 case DW_TAG_common_block
: return "DW_TAG_common_block";
480 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
481 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
482 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
483 case DW_TAG_module
: return "DW_TAG_module";
484 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
485 case DW_TAG_set_type
: return "DW_TAG_set_type";
486 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
487 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
488 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
489 case DW_TAG_base_type
: return "DW_TAG_base_type";
490 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
491 case DW_TAG_const_type
: return "DW_TAG_const_type";
492 case DW_TAG_constant
: return "DW_TAG_constant";
493 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
494 case DW_TAG_file_type
: return "DW_TAG_file_type";
495 case DW_TAG_friend
: return "DW_TAG_friend";
496 case DW_TAG_namelist
: return "DW_TAG_namelist";
497 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
498 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
499 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
500 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
501 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
502 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
503 case DW_TAG_try_block
: return "DW_TAG_try_block";
504 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
505 case DW_TAG_variable
: return "DW_TAG_variable";
506 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
507 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
508 case DW_TAG_format_label
: return "DW_TAG_format_label";
509 case DW_TAG_function_template
: return "DW_TAG_function_template";
510 case DW_TAG_class_template
: return "DW_TAG_class_template";
511 /* DWARF 2.1 values. */
512 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
513 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
514 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
515 case DW_TAG_namespace
: return "DW_TAG_namespace";
516 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
517 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
518 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
519 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
521 case DW_TAG_upc_shared_type
: return "DW_TAG_upc_shared_type";
522 case DW_TAG_upc_strict_type
: return "DW_TAG_upc_strict_type";
523 case DW_TAG_upc_relaxed_type
: return "DW_TAG_upc_relaxed_type";
526 static char buffer
[100];
528 snprintf (buffer
, sizeof (buffer
), _("Unknown TAG value: %lx"), tag
);
535 get_FORM_name (unsigned long form
)
539 case DW_FORM_addr
: return "DW_FORM_addr";
540 case DW_FORM_block2
: return "DW_FORM_block2";
541 case DW_FORM_block4
: return "DW_FORM_block4";
542 case DW_FORM_data2
: return "DW_FORM_data2";
543 case DW_FORM_data4
: return "DW_FORM_data4";
544 case DW_FORM_data8
: return "DW_FORM_data8";
545 case DW_FORM_string
: return "DW_FORM_string";
546 case DW_FORM_block
: return "DW_FORM_block";
547 case DW_FORM_block1
: return "DW_FORM_block1";
548 case DW_FORM_data1
: return "DW_FORM_data1";
549 case DW_FORM_flag
: return "DW_FORM_flag";
550 case DW_FORM_sdata
: return "DW_FORM_sdata";
551 case DW_FORM_strp
: return "DW_FORM_strp";
552 case DW_FORM_udata
: return "DW_FORM_udata";
553 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
554 case DW_FORM_ref1
: return "DW_FORM_ref1";
555 case DW_FORM_ref2
: return "DW_FORM_ref2";
556 case DW_FORM_ref4
: return "DW_FORM_ref4";
557 case DW_FORM_ref8
: return "DW_FORM_ref8";
558 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
559 case DW_FORM_indirect
: return "DW_FORM_indirect";
562 static char buffer
[100];
564 snprintf (buffer
, sizeof (buffer
), _("Unknown FORM value: %lx"), form
);
570 static unsigned char *
571 display_block (unsigned char *data
, unsigned long length
)
573 printf (_(" %lu byte block: "), length
);
576 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
582 decode_location_expression (unsigned char * data
,
583 unsigned int pointer_size
,
584 unsigned long length
,
585 unsigned long cu_offset
)
588 unsigned int bytes_read
;
589 unsigned long uvalue
;
590 unsigned char *end
= data
+ length
;
591 int need_frame_base
= 0;
600 printf ("DW_OP_addr: %lx",
601 (unsigned long) byte_get (data
, pointer_size
));
602 data
+= pointer_size
;
605 printf ("DW_OP_deref");
608 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
611 printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data
++, 1));
614 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
618 printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data
, 2));
622 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
626 printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data
, 4));
630 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
631 (unsigned long) byte_get (data
+ 4, 4));
635 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
636 (long) byte_get (data
+ 4, 4));
640 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
644 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
648 printf ("DW_OP_dup");
651 printf ("DW_OP_drop");
654 printf ("DW_OP_over");
657 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
660 printf ("DW_OP_swap");
663 printf ("DW_OP_rot");
666 printf ("DW_OP_xderef");
669 printf ("DW_OP_abs");
672 printf ("DW_OP_and");
675 printf ("DW_OP_div");
678 printf ("DW_OP_minus");
681 printf ("DW_OP_mod");
684 printf ("DW_OP_mul");
687 printf ("DW_OP_neg");
690 printf ("DW_OP_not");
696 printf ("DW_OP_plus");
698 case DW_OP_plus_uconst
:
699 printf ("DW_OP_plus_uconst: %lu",
700 read_leb128 (data
, &bytes_read
, 0));
704 printf ("DW_OP_shl");
707 printf ("DW_OP_shr");
710 printf ("DW_OP_shra");
713 printf ("DW_OP_xor");
716 printf ("DW_OP_bra: %ld", (long) byte_get_signed (data
, 2));
738 printf ("DW_OP_skip: %ld", (long) byte_get_signed (data
, 2));
774 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
809 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
844 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
845 read_leb128 (data
, &bytes_read
, 1));
850 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
855 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
859 uvalue
= read_leb128 (data
, &bytes_read
, 0);
861 printf ("DW_OP_bregx: %lu %ld", uvalue
,
862 read_leb128 (data
, &bytes_read
, 1));
866 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
869 case DW_OP_deref_size
:
870 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
872 case DW_OP_xderef_size
:
873 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
876 printf ("DW_OP_nop");
879 /* DWARF 3 extensions. */
880 case DW_OP_push_object_address
:
881 printf ("DW_OP_push_object_address");
884 /* XXX: Strictly speaking for 64-bit DWARF3 files
885 this ought to be an 8-byte wide computation. */
886 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2) + cu_offset
);
890 /* XXX: Strictly speaking for 64-bit DWARF3 files
891 this ought to be an 8-byte wide computation. */
892 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4) + cu_offset
);
896 printf ("DW_OP_call_ref");
899 /* GNU extensions. */
900 case DW_OP_GNU_push_tls_address
:
901 printf ("DW_OP_GNU_push_tls_address");
905 if (op
>= DW_OP_lo_user
906 && op
<= DW_OP_hi_user
)
907 printf (_("(User defined location op)"));
909 printf (_("(Unknown location op)"));
910 /* No way to tell where the next op is, so just bail. */
911 return need_frame_base
;
914 /* Separate the ops. */
919 return need_frame_base
;
922 static unsigned char *
923 read_and_display_attr_value (unsigned long attribute
,
926 unsigned long cu_offset
,
927 unsigned long pointer_size
,
928 unsigned long offset_size
,
930 debug_info
*debug_info_p
,
933 unsigned long uvalue
= 0;
934 unsigned char *block_start
= NULL
;
935 unsigned int bytes_read
;
942 case DW_FORM_ref_addr
:
943 if (dwarf_version
== 2)
945 uvalue
= byte_get (data
, pointer_size
);
946 data
+= pointer_size
;
948 else if (dwarf_version
== 3)
950 uvalue
= byte_get (data
, offset_size
);
955 error (_("Internal error: DWARF version is not 2 or 3.\n"));
960 uvalue
= byte_get (data
, pointer_size
);
961 data
+= pointer_size
;
965 uvalue
= byte_get (data
, offset_size
);
972 uvalue
= byte_get (data
++, 1);
977 uvalue
= byte_get (data
, 2);
983 uvalue
= byte_get (data
, 4);
988 uvalue
= read_leb128 (data
, & bytes_read
, 1);
992 case DW_FORM_ref_udata
:
994 uvalue
= read_leb128 (data
, & bytes_read
, 0);
998 case DW_FORM_indirect
:
999 form
= read_leb128 (data
, & bytes_read
, 0);
1002 printf (" %s", get_FORM_name (form
));
1003 return read_and_display_attr_value (attribute
, form
, data
,
1004 cu_offset
, pointer_size
,
1005 offset_size
, dwarf_version
,
1006 debug_info_p
, do_loc
);
1011 case DW_FORM_ref_addr
:
1013 printf (" <#%lx>", uvalue
);
1019 case DW_FORM_ref_udata
:
1021 printf (" <%lx>", uvalue
+ cu_offset
);
1027 printf (" %#lx", uvalue
);
1036 printf (" %ld", uvalue
);
1043 uvalue
= byte_get (data
, 4);
1044 printf (" %lx", uvalue
);
1045 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
1047 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1048 && num_debug_info_entries
== 0)
1050 if (sizeof (uvalue
) == 8)
1051 uvalue
= byte_get (data
, 8);
1053 error (_("DW_FORM_data8 is unsupported when sizeof (unsigned long) != 8\n"));
1058 case DW_FORM_string
:
1060 printf (" %s", data
);
1061 data
+= strlen ((char *) data
) + 1;
1065 uvalue
= read_leb128 (data
, & bytes_read
, 0);
1066 block_start
= data
+ bytes_read
;
1068 data
= block_start
+ uvalue
;
1070 data
= display_block (block_start
, uvalue
);
1073 case DW_FORM_block1
:
1074 uvalue
= byte_get (data
, 1);
1075 block_start
= data
+ 1;
1077 data
= block_start
+ uvalue
;
1079 data
= display_block (block_start
, uvalue
);
1082 case DW_FORM_block2
:
1083 uvalue
= byte_get (data
, 2);
1084 block_start
= data
+ 2;
1086 data
= block_start
+ uvalue
;
1088 data
= display_block (block_start
, uvalue
);
1091 case DW_FORM_block4
:
1092 uvalue
= byte_get (data
, 4);
1093 block_start
= data
+ 4;
1095 data
= block_start
+ uvalue
;
1097 data
= display_block (block_start
, uvalue
);
1102 printf (_(" (indirect string, offset: 0x%lx): %s"),
1103 uvalue
, fetch_indirect_string (uvalue
));
1106 case DW_FORM_indirect
:
1107 /* Handled above. */
1111 warn (_("Unrecognized form: %lu\n"), form
);
1115 /* For some attributes we can display further information. */
1116 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1117 && num_debug_info_entries
== 0)
1121 case DW_AT_frame_base
:
1122 have_frame_base
= 1;
1123 case DW_AT_location
:
1124 case DW_AT_data_member_location
:
1125 case DW_AT_vtable_elem_location
:
1126 case DW_AT_allocated
:
1127 case DW_AT_associated
:
1128 case DW_AT_data_location
:
1130 case DW_AT_upper_bound
:
1131 case DW_AT_lower_bound
:
1132 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
1134 /* Process location list. */
1135 unsigned int max
= debug_info_p
->max_loc_offsets
;
1136 unsigned int num
= debug_info_p
->num_loc_offsets
;
1138 if (max
== 0 || num
>= max
)
1141 debug_info_p
->loc_offsets
1142 = xcrealloc (debug_info_p
->loc_offsets
,
1143 max
, sizeof (*debug_info_p
->loc_offsets
));
1144 debug_info_p
->have_frame_base
1145 = xcrealloc (debug_info_p
->have_frame_base
,
1146 max
, sizeof (*debug_info_p
->have_frame_base
));
1147 debug_info_p
->max_loc_offsets
= max
;
1149 debug_info_p
->loc_offsets
[num
] = uvalue
;
1150 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
1151 debug_info_p
->num_loc_offsets
++;
1156 if (need_base_address
)
1157 debug_info_p
->base_address
= uvalue
;
1161 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
1163 /* Process range list. */
1164 unsigned int max
= debug_info_p
->max_range_lists
;
1165 unsigned int num
= debug_info_p
->num_range_lists
;
1167 if (max
== 0 || num
>= max
)
1170 debug_info_p
->range_lists
1171 = xcrealloc (debug_info_p
->range_lists
,
1172 max
, sizeof (*debug_info_p
->range_lists
));
1173 debug_info_p
->max_range_lists
= max
;
1175 debug_info_p
->range_lists
[num
] = uvalue
;
1176 debug_info_p
->num_range_lists
++;
1195 case DW_INL_not_inlined
:
1196 printf (_("(not inlined)"));
1198 case DW_INL_inlined
:
1199 printf (_("(inlined)"));
1201 case DW_INL_declared_not_inlined
:
1202 printf (_("(declared as inline but ignored)"));
1204 case DW_INL_declared_inlined
:
1205 printf (_("(declared as inline and inlined)"));
1208 printf (_(" (Unknown inline attribute value: %lx)"), uvalue
);
1213 case DW_AT_language
:
1216 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
1217 case DW_LANG_C89
: printf ("(ANSI C)"); break;
1218 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
1219 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
1220 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
1221 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
1222 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
1223 case DW_LANG_Ada83
: printf ("(Ada)"); break;
1224 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
1225 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
1226 /* DWARF 2.1 values. */
1227 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
1228 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
1229 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
1230 /* MIPS extension. */
1231 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
1232 /* UPC extension. */
1233 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
1235 printf ("(Unknown: %lx)", uvalue
);
1240 case DW_AT_encoding
:
1243 case DW_ATE_void
: printf ("(void)"); break;
1244 case DW_ATE_address
: printf ("(machine address)"); break;
1245 case DW_ATE_boolean
: printf ("(boolean)"); break;
1246 case DW_ATE_complex_float
: printf ("(complex float)"); break;
1247 case DW_ATE_float
: printf ("(float)"); break;
1248 case DW_ATE_signed
: printf ("(signed)"); break;
1249 case DW_ATE_signed_char
: printf ("(signed char)"); break;
1250 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
1251 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
1252 /* DWARF 2.1 value. */
1253 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
1254 case DW_ATE_decimal_float
: printf ("(decimal float)"); break;
1256 if (uvalue
>= DW_ATE_lo_user
1257 && uvalue
<= DW_ATE_hi_user
)
1258 printf ("(user defined type)");
1260 printf ("(unknown type)");
1265 case DW_AT_accessibility
:
1268 case DW_ACCESS_public
: printf ("(public)"); break;
1269 case DW_ACCESS_protected
: printf ("(protected)"); break;
1270 case DW_ACCESS_private
: printf ("(private)"); break;
1272 printf ("(unknown accessibility)");
1277 case DW_AT_visibility
:
1280 case DW_VIS_local
: printf ("(local)"); break;
1281 case DW_VIS_exported
: printf ("(exported)"); break;
1282 case DW_VIS_qualified
: printf ("(qualified)"); break;
1283 default: printf ("(unknown visibility)"); break;
1287 case DW_AT_virtuality
:
1290 case DW_VIRTUALITY_none
: printf ("(none)"); break;
1291 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
1292 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
1293 default: printf ("(unknown virtuality)"); break;
1297 case DW_AT_identifier_case
:
1300 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
1301 case DW_ID_up_case
: printf ("(up_case)"); break;
1302 case DW_ID_down_case
: printf ("(down_case)"); break;
1303 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
1304 default: printf ("(unknown case)"); break;
1308 case DW_AT_calling_convention
:
1311 case DW_CC_normal
: printf ("(normal)"); break;
1312 case DW_CC_program
: printf ("(program)"); break;
1313 case DW_CC_nocall
: printf ("(nocall)"); break;
1315 if (uvalue
>= DW_CC_lo_user
1316 && uvalue
<= DW_CC_hi_user
)
1317 printf ("(user defined)");
1319 printf ("(unknown convention)");
1323 case DW_AT_ordering
:
1326 case -1: printf ("(undefined)"); break;
1327 case 0: printf ("(row major)"); break;
1328 case 1: printf ("(column major)"); break;
1332 case DW_AT_frame_base
:
1333 have_frame_base
= 1;
1334 case DW_AT_location
:
1335 case DW_AT_data_member_location
:
1336 case DW_AT_vtable_elem_location
:
1337 case DW_AT_allocated
:
1338 case DW_AT_associated
:
1339 case DW_AT_data_location
:
1341 case DW_AT_upper_bound
:
1342 case DW_AT_lower_bound
:
1345 int need_frame_base
;
1348 need_frame_base
= decode_location_expression (block_start
,
1353 if (need_frame_base
&& !have_frame_base
)
1354 printf (_(" [without DW_AT_frame_base]"));
1356 else if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
1357 printf (_("(location list)"));
1369 get_AT_name (unsigned long attribute
)
1373 case DW_AT_sibling
: return "DW_AT_sibling";
1374 case DW_AT_location
: return "DW_AT_location";
1375 case DW_AT_name
: return "DW_AT_name";
1376 case DW_AT_ordering
: return "DW_AT_ordering";
1377 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
1378 case DW_AT_byte_size
: return "DW_AT_byte_size";
1379 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
1380 case DW_AT_bit_size
: return "DW_AT_bit_size";
1381 case DW_AT_element_list
: return "DW_AT_element_list";
1382 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
1383 case DW_AT_low_pc
: return "DW_AT_low_pc";
1384 case DW_AT_high_pc
: return "DW_AT_high_pc";
1385 case DW_AT_language
: return "DW_AT_language";
1386 case DW_AT_member
: return "DW_AT_member";
1387 case DW_AT_discr
: return "DW_AT_discr";
1388 case DW_AT_discr_value
: return "DW_AT_discr_value";
1389 case DW_AT_visibility
: return "DW_AT_visibility";
1390 case DW_AT_import
: return "DW_AT_import";
1391 case DW_AT_string_length
: return "DW_AT_string_length";
1392 case DW_AT_common_reference
: return "DW_AT_common_reference";
1393 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
1394 case DW_AT_const_value
: return "DW_AT_const_value";
1395 case DW_AT_containing_type
: return "DW_AT_containing_type";
1396 case DW_AT_default_value
: return "DW_AT_default_value";
1397 case DW_AT_inline
: return "DW_AT_inline";
1398 case DW_AT_is_optional
: return "DW_AT_is_optional";
1399 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
1400 case DW_AT_producer
: return "DW_AT_producer";
1401 case DW_AT_prototyped
: return "DW_AT_prototyped";
1402 case DW_AT_return_addr
: return "DW_AT_return_addr";
1403 case DW_AT_start_scope
: return "DW_AT_start_scope";
1404 case DW_AT_stride_size
: return "DW_AT_stride_size";
1405 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
1406 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
1407 case DW_AT_accessibility
: return "DW_AT_accessibility";
1408 case DW_AT_address_class
: return "DW_AT_address_class";
1409 case DW_AT_artificial
: return "DW_AT_artificial";
1410 case DW_AT_base_types
: return "DW_AT_base_types";
1411 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
1412 case DW_AT_count
: return "DW_AT_count";
1413 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
1414 case DW_AT_decl_column
: return "DW_AT_decl_column";
1415 case DW_AT_decl_file
: return "DW_AT_decl_file";
1416 case DW_AT_decl_line
: return "DW_AT_decl_line";
1417 case DW_AT_declaration
: return "DW_AT_declaration";
1418 case DW_AT_discr_list
: return "DW_AT_discr_list";
1419 case DW_AT_encoding
: return "DW_AT_encoding";
1420 case DW_AT_external
: return "DW_AT_external";
1421 case DW_AT_frame_base
: return "DW_AT_frame_base";
1422 case DW_AT_friend
: return "DW_AT_friend";
1423 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
1424 case DW_AT_macro_info
: return "DW_AT_macro_info";
1425 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
1426 case DW_AT_priority
: return "DW_AT_priority";
1427 case DW_AT_segment
: return "DW_AT_segment";
1428 case DW_AT_specification
: return "DW_AT_specification";
1429 case DW_AT_static_link
: return "DW_AT_static_link";
1430 case DW_AT_type
: return "DW_AT_type";
1431 case DW_AT_use_location
: return "DW_AT_use_location";
1432 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
1433 case DW_AT_virtuality
: return "DW_AT_virtuality";
1434 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
1435 /* DWARF 2.1 values. */
1436 case DW_AT_allocated
: return "DW_AT_allocated";
1437 case DW_AT_associated
: return "DW_AT_associated";
1438 case DW_AT_data_location
: return "DW_AT_data_location";
1439 case DW_AT_stride
: return "DW_AT_stride";
1440 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
1441 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
1442 case DW_AT_extension
: return "DW_AT_extension";
1443 case DW_AT_ranges
: return "DW_AT_ranges";
1444 case DW_AT_trampoline
: return "DW_AT_trampoline";
1445 case DW_AT_call_column
: return "DW_AT_call_column";
1446 case DW_AT_call_file
: return "DW_AT_call_file";
1447 case DW_AT_call_line
: return "DW_AT_call_line";
1448 /* SGI/MIPS extensions. */
1449 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
1450 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
1451 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
1452 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
1453 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
1454 case DW_AT_MIPS_software_pipeline_depth
:
1455 return "DW_AT_MIPS_software_pipeline_depth";
1456 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
1457 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
1458 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
1459 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
1460 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
1461 /* GNU extensions. */
1462 case DW_AT_sf_names
: return "DW_AT_sf_names";
1463 case DW_AT_src_info
: return "DW_AT_src_info";
1464 case DW_AT_mac_info
: return "DW_AT_mac_info";
1465 case DW_AT_src_coords
: return "DW_AT_src_coords";
1466 case DW_AT_body_begin
: return "DW_AT_body_begin";
1467 case DW_AT_body_end
: return "DW_AT_body_end";
1468 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
1469 /* UPC extension. */
1470 case DW_AT_upc_threads_scaled
: return "DW_AT_upc_threads_scaled";
1473 static char buffer
[100];
1475 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
1482 static unsigned char *
1483 read_and_display_attr (unsigned long attribute
,
1485 unsigned char *data
,
1486 unsigned long cu_offset
,
1487 unsigned long pointer_size
,
1488 unsigned long offset_size
,
1490 debug_info
*debug_info_p
,
1494 printf (" %-18s:", get_AT_name (attribute
));
1495 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
1496 pointer_size
, offset_size
,
1497 dwarf_version
, debug_info_p
,
1505 /* Process the contents of a .debug_info section. If do_loc is non-zero
1506 then we are scanning for location lists and we do not want to display
1507 anything to the user. */
1510 process_debug_info (struct dwarf_section
*section
, void *file
,
1513 unsigned char *start
= section
->start
;
1514 unsigned char *end
= start
+ section
->size
;
1515 unsigned char *section_begin
;
1517 unsigned int num_units
= 0;
1519 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1520 && num_debug_info_entries
== 0)
1522 unsigned long length
;
1524 /* First scan the section to get the number of comp units. */
1525 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
1528 /* Read the first 4 bytes. For a 32-bit DWARF section, this
1529 will be the length. For a 64-bit DWARF section, it'll be
1530 the escape code 0xffffffff followed by an 8 byte length. */
1531 length
= byte_get (section_begin
, 4);
1533 if (length
== 0xffffffff)
1535 length
= byte_get (section_begin
+ 4, 8);
1536 section_begin
+= length
+ 12;
1539 section_begin
+= length
+ 4;
1544 error (_("No comp units in %s section ?"), section
->name
);
1548 /* Then allocate an array to hold the information. */
1549 debug_information
= cmalloc (num_units
,
1550 sizeof (* debug_information
));
1551 if (debug_information
== NULL
)
1553 error (_("Not enough memory for a debug info array of %u entries"),
1561 printf (_("The section %s contains:\n\n"), section
->name
);
1563 load_debug_section (str
, file
);
1566 load_debug_section (abbrev
, file
);
1567 if (debug_displays
[abbrev
].section
.start
== NULL
)
1569 warn (_("Unable to locate %s section!\n"),
1570 debug_displays
[abbrev
].section
.name
);
1574 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
1576 DWARF2_Internal_CompUnit compunit
;
1577 unsigned char *hdrptr
;
1578 unsigned char *cu_abbrev_offset_ptr
;
1579 unsigned char *tags
;
1581 unsigned long cu_offset
;
1583 int initial_length_size
;
1587 compunit
.cu_length
= byte_get (hdrptr
, 4);
1590 if (compunit
.cu_length
== 0xffffffff)
1592 compunit
.cu_length
= byte_get (hdrptr
, 8);
1595 initial_length_size
= 12;
1600 initial_length_size
= 4;
1603 compunit
.cu_version
= byte_get (hdrptr
, 2);
1606 cu_offset
= start
- section_begin
;
1607 start
+= compunit
.cu_length
+ initial_length_size
;
1609 cu_abbrev_offset_ptr
= hdrptr
;
1610 compunit
.cu_abbrev_offset
= byte_get (hdrptr
, offset_size
);
1611 hdrptr
+= offset_size
;
1613 compunit
.cu_pointer_size
= byte_get (hdrptr
, 1);
1615 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1616 && num_debug_info_entries
== 0)
1618 debug_information
[unit
].cu_offset
= cu_offset
;
1619 debug_information
[unit
].pointer_size
1620 = compunit
.cu_pointer_size
;
1621 debug_information
[unit
].base_address
= 0;
1622 debug_information
[unit
].loc_offsets
= NULL
;
1623 debug_information
[unit
].have_frame_base
= NULL
;
1624 debug_information
[unit
].max_loc_offsets
= 0;
1625 debug_information
[unit
].num_loc_offsets
= 0;
1626 debug_information
[unit
].range_lists
= NULL
;
1627 debug_information
[unit
].max_range_lists
= 0;
1628 debug_information
[unit
].num_range_lists
= 0;
1635 printf (_(" Compilation Unit @ offset 0x%lx:\n"), cu_offset
);
1636 printf (_(" Length: %ld\n"), compunit
.cu_length
);
1637 printf (_(" Version: %d\n"), compunit
.cu_version
);
1638 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
1639 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
1642 if (compunit
.cu_version
!= 2 && compunit
.cu_version
!= 3)
1644 warn (_("Only version 2 and 3 DWARF debug information is currently supported.\n"));
1650 /* Process the abbrevs used by this compilation unit. DWARF
1651 sections under Mach-O have non-zero addresses. */
1652 process_abbrev_section
1653 ((unsigned char *) debug_displays
[abbrev
].section
.start
1654 + compunit
.cu_abbrev_offset
- debug_displays
[abbrev
].section
.address
,
1655 (unsigned char *) debug_displays
[abbrev
].section
.start
1656 + debug_displays
[abbrev
].section
.size
);
1659 while (tags
< start
)
1661 unsigned int bytes_read
;
1662 unsigned long abbrev_number
;
1663 abbrev_entry
*entry
;
1666 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
1669 /* A null DIE marks the end of a list of children. */
1670 if (abbrev_number
== 0)
1676 /* Scan through the abbreviation list until we reach the
1678 for (entry
= first_abbrev
;
1679 entry
&& entry
->entry
!= abbrev_number
;
1680 entry
= entry
->next
)
1685 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
1691 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
1693 (unsigned long) (tags
- section_begin
1696 get_TAG_name (entry
->tag
));
1701 need_base_address
= 0;
1703 case DW_TAG_compile_unit
:
1704 need_base_address
= 1;
1706 case DW_TAG_entry_point
:
1707 case DW_TAG_inlined_subroutine
:
1708 case DW_TAG_subprogram
:
1709 need_base_address
= 0;
1710 /* Assuming that there is no DW_AT_frame_base. */
1711 have_frame_base
= 0;
1715 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
1716 tags
= read_and_display_attr (attr
->attribute
,
1719 compunit
.cu_pointer_size
,
1721 compunit
.cu_version
,
1722 &debug_information
[unit
],
1725 if (entry
->children
)
1730 /* Set num_debug_info_entries here so that it can be used to check if
1731 we need to process .debug_loc and .debug_ranges sections. */
1732 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1733 && num_debug_info_entries
== 0)
1734 num_debug_info_entries
= num_units
;
1744 /* Locate and scan the .debug_info section in the file and record the pointer
1745 sizes and offsets for the compilation units in it. Usually an executable
1746 will have just one pointer size, but this is not guaranteed, and so we try
1747 not to make any assumptions. Returns zero upon failure, or the number of
1748 compilation units upon success. */
1751 load_debug_info (void * file
)
1753 /* Reset the last pointer size so that we can issue correct error
1754 messages if we are displaying the contents of more than one section. */
1755 last_pointer_size
= 0;
1756 warned_about_missing_comp_units
= FALSE
;
1758 /* If we already have the information there is nothing else to do. */
1759 if (num_debug_info_entries
> 0)
1760 return num_debug_info_entries
;
1762 if (load_debug_section (info
, file
)
1763 && process_debug_info (&debug_displays
[info
].section
, file
, 1))
1764 return num_debug_info_entries
;
1770 display_debug_lines (struct dwarf_section
*section
, void *file
)
1772 unsigned char *start
= section
->start
;
1773 unsigned char *data
= start
;
1774 unsigned char *end
= start
+ section
->size
;
1776 printf (_("\nDump of debug contents of section %s:\n\n"),
1779 load_debug_info (file
);
1783 DWARF2_Internal_LineInfo info
;
1784 unsigned char *standard_opcodes
;
1785 unsigned char *end_of_sequence
;
1786 unsigned char *hdrptr
;
1787 int initial_length_size
;
1793 /* Check the length of the block. */
1794 info
.li_length
= byte_get (hdrptr
, 4);
1797 if (info
.li_length
== 0xffffffff)
1799 /* This section is 64-bit DWARF 3. */
1800 info
.li_length
= byte_get (hdrptr
, 8);
1803 initial_length_size
= 12;
1808 initial_length_size
= 4;
1811 if (info
.li_length
+ initial_length_size
> section
->size
)
1814 (_("The line info appears to be corrupt - the section is too small\n"));
1818 /* Check its version number. */
1819 info
.li_version
= byte_get (hdrptr
, 2);
1821 if (info
.li_version
!= 2 && info
.li_version
!= 3)
1823 warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
1827 info
.li_prologue_length
= byte_get (hdrptr
, offset_size
);
1828 hdrptr
+= offset_size
;
1829 info
.li_min_insn_length
= byte_get (hdrptr
, 1);
1831 info
.li_default_is_stmt
= byte_get (hdrptr
, 1);
1833 info
.li_line_base
= byte_get (hdrptr
, 1);
1835 info
.li_line_range
= byte_get (hdrptr
, 1);
1837 info
.li_opcode_base
= byte_get (hdrptr
, 1);
1840 /* Sign extend the line base field. */
1841 info
.li_line_base
<<= 24;
1842 info
.li_line_base
>>= 24;
1844 printf (_(" Length: %ld\n"), info
.li_length
);
1845 printf (_(" DWARF Version: %d\n"), info
.li_version
);
1846 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
1847 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
1848 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
1849 printf (_(" Line Base: %d\n"), info
.li_line_base
);
1850 printf (_(" Line Range: %d\n"), info
.li_line_range
);
1851 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
1853 end_of_sequence
= data
+ info
.li_length
+ initial_length_size
;
1855 reset_state_machine (info
.li_default_is_stmt
);
1857 /* Display the contents of the Opcodes table. */
1858 standard_opcodes
= hdrptr
;
1860 printf (_("\n Opcodes:\n"));
1862 for (i
= 1; i
< info
.li_opcode_base
; i
++)
1863 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
1865 /* Display the contents of the Directory table. */
1866 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
1869 printf (_("\n The Directory Table is empty.\n"));
1872 printf (_("\n The Directory Table:\n"));
1876 printf (_(" %s\n"), data
);
1878 data
+= strlen ((char *) data
) + 1;
1882 /* Skip the NUL at the end of the table. */
1885 /* Display the contents of the File Name table. */
1887 printf (_("\n The File Name Table is empty.\n"));
1890 printf (_("\n The File Name Table:\n"));
1891 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
1895 unsigned char *name
;
1896 unsigned int bytes_read
;
1898 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
1901 data
+= strlen ((char *) data
) + 1;
1903 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
1905 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
1907 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
1909 printf (_("%s\n"), name
);
1913 /* Skip the NUL at the end of the table. */
1916 /* Now display the statements. */
1917 printf (_("\n Line Number Statements:\n"));
1919 while (data
< end_of_sequence
)
1921 unsigned char op_code
;
1923 unsigned long int uladv
;
1924 unsigned int bytes_read
;
1928 if (op_code
>= info
.li_opcode_base
)
1930 op_code
-= info
.li_opcode_base
;
1931 uladv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
1932 state_machine_regs
.address
+= uladv
;
1933 printf (_(" Special opcode %d: advance Address by %lu to 0x%lx"),
1934 op_code
, uladv
, state_machine_regs
.address
);
1935 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
1936 state_machine_regs
.line
+= adv
;
1937 printf (_(" and Line by %d to %d\n"),
1938 adv
, state_machine_regs
.line
);
1940 else switch (op_code
)
1942 case DW_LNS_extended_op
:
1943 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
);
1947 printf (_(" Copy\n"));
1950 case DW_LNS_advance_pc
:
1951 uladv
= read_leb128 (data
, & bytes_read
, 0);
1952 uladv
*= info
.li_min_insn_length
;
1954 state_machine_regs
.address
+= uladv
;
1955 printf (_(" Advance PC by %lu to 0x%lx\n"), uladv
,
1956 state_machine_regs
.address
);
1959 case DW_LNS_advance_line
:
1960 adv
= read_leb128 (data
, & bytes_read
, 1);
1962 state_machine_regs
.line
+= adv
;
1963 printf (_(" Advance Line by %d to %d\n"), adv
,
1964 state_machine_regs
.line
);
1967 case DW_LNS_set_file
:
1968 adv
= read_leb128 (data
, & bytes_read
, 0);
1970 printf (_(" Set File Name to entry %d in the File Name Table\n"),
1972 state_machine_regs
.file
= adv
;
1975 case DW_LNS_set_column
:
1976 uladv
= read_leb128 (data
, & bytes_read
, 0);
1978 printf (_(" Set column to %lu\n"), uladv
);
1979 state_machine_regs
.column
= uladv
;
1982 case DW_LNS_negate_stmt
:
1983 adv
= state_machine_regs
.is_stmt
;
1985 printf (_(" Set is_stmt to %d\n"), adv
);
1986 state_machine_regs
.is_stmt
= adv
;
1989 case DW_LNS_set_basic_block
:
1990 printf (_(" Set basic block\n"));
1991 state_machine_regs
.basic_block
= 1;
1994 case DW_LNS_const_add_pc
:
1995 uladv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
1996 * info
.li_min_insn_length
);
1997 state_machine_regs
.address
+= uladv
;
1998 printf (_(" Advance PC by constant %lu to 0x%lx\n"), uladv
,
1999 state_machine_regs
.address
);
2002 case DW_LNS_fixed_advance_pc
:
2003 uladv
= byte_get (data
, 2);
2005 state_machine_regs
.address
+= uladv
;
2006 printf (_(" Advance PC by fixed size amount %lu to 0x%lx\n"),
2007 uladv
, state_machine_regs
.address
);
2010 case DW_LNS_set_prologue_end
:
2011 printf (_(" Set prologue_end to true\n"));
2014 case DW_LNS_set_epilogue_begin
:
2015 printf (_(" Set epilogue_begin to true\n"));
2018 case DW_LNS_set_isa
:
2019 uladv
= read_leb128 (data
, & bytes_read
, 0);
2021 printf (_(" Set ISA to %lu\n"), uladv
);
2025 printf (_(" Unknown opcode %d with operands: "), op_code
);
2027 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
2029 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
2030 i
== 1 ? "" : ", ");
2044 display_debug_pubnames (struct dwarf_section
*section
,
2045 void *file ATTRIBUTE_UNUSED
)
2047 DWARF2_Internal_PubNames pubnames
;
2048 unsigned char *start
= section
->start
;
2049 unsigned char *end
= start
+ section
->size
;
2051 printf (_("Contents of the %s section:\n\n"), section
->name
);
2055 unsigned char *data
;
2056 unsigned long offset
;
2057 int offset_size
, initial_length_size
;
2061 pubnames
.pn_length
= byte_get (data
, 4);
2063 if (pubnames
.pn_length
== 0xffffffff)
2065 pubnames
.pn_length
= byte_get (data
, 8);
2068 initial_length_size
= 12;
2073 initial_length_size
= 4;
2076 pubnames
.pn_version
= byte_get (data
, 2);
2078 pubnames
.pn_offset
= byte_get (data
, offset_size
);
2079 data
+= offset_size
;
2080 pubnames
.pn_size
= byte_get (data
, offset_size
);
2081 data
+= offset_size
;
2083 start
+= pubnames
.pn_length
+ initial_length_size
;
2085 if (pubnames
.pn_version
!= 2 && pubnames
.pn_version
!= 3)
2087 static int warned
= 0;
2091 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
2098 printf (_(" Length: %ld\n"),
2099 pubnames
.pn_length
);
2100 printf (_(" Version: %d\n"),
2101 pubnames
.pn_version
);
2102 printf (_(" Offset into .debug_info section: %ld\n"),
2103 pubnames
.pn_offset
);
2104 printf (_(" Size of area in .debug_info section: %ld\n"),
2107 printf (_("\n Offset\tName\n"));
2111 offset
= byte_get (data
, offset_size
);
2115 data
+= offset_size
;
2116 printf (" %-6ld\t\t%s\n", offset
, data
);
2117 data
+= strlen ((char *) data
) + 1;
2120 while (offset
!= 0);
2128 display_debug_macinfo (struct dwarf_section
*section
,
2129 void *file ATTRIBUTE_UNUSED
)
2131 unsigned char *start
= section
->start
;
2132 unsigned char *end
= start
+ section
->size
;
2133 unsigned char *curr
= start
;
2134 unsigned int bytes_read
;
2135 enum dwarf_macinfo_record_type op
;
2137 printf (_("Contents of the %s section:\n\n"), section
->name
);
2141 unsigned int lineno
;
2149 case DW_MACINFO_start_file
:
2151 unsigned int filenum
;
2153 lineno
= read_leb128 (curr
, & bytes_read
, 0);
2155 filenum
= read_leb128 (curr
, & bytes_read
, 0);
2158 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
2163 case DW_MACINFO_end_file
:
2164 printf (_(" DW_MACINFO_end_file\n"));
2167 case DW_MACINFO_define
:
2168 lineno
= read_leb128 (curr
, & bytes_read
, 0);
2170 string
= (char *) curr
;
2171 curr
+= strlen (string
) + 1;
2172 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
2176 case DW_MACINFO_undef
:
2177 lineno
= read_leb128 (curr
, & bytes_read
, 0);
2179 string
= (char *) curr
;
2180 curr
+= strlen (string
) + 1;
2181 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
2185 case DW_MACINFO_vendor_ext
:
2187 unsigned int constant
;
2189 constant
= read_leb128 (curr
, & bytes_read
, 0);
2191 string
= (char *) curr
;
2192 curr
+= strlen (string
) + 1;
2193 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
2204 display_debug_abbrev (struct dwarf_section
*section
,
2205 void *file ATTRIBUTE_UNUSED
)
2207 abbrev_entry
*entry
;
2208 unsigned char *start
= section
->start
;
2209 unsigned char *end
= start
+ section
->size
;
2211 printf (_("Contents of the %s section:\n\n"), section
->name
);
2217 start
= process_abbrev_section (start
, end
);
2219 if (first_abbrev
== NULL
)
2222 printf (_(" Number TAG\n"));
2224 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
2228 printf (_(" %ld %s [%s]\n"),
2230 get_TAG_name (entry
->tag
),
2231 entry
->children
? _("has children") : _("no children"));
2233 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
2234 printf (_(" %-18s %s\n"),
2235 get_AT_name (attr
->attribute
),
2236 get_FORM_name (attr
->form
));
2247 display_debug_loc (struct dwarf_section
*section
, void *file
)
2249 unsigned char *start
= section
->start
;
2250 unsigned char *section_end
;
2251 unsigned long bytes
;
2252 unsigned char *section_begin
= start
;
2253 unsigned int num_loc_list
= 0;
2254 unsigned long last_offset
= 0;
2255 unsigned int first
= 0;
2258 int seen_first_offset
= 0;
2259 int use_debug_info
= 1;
2260 unsigned char *next
;
2262 bytes
= section
->size
;
2263 section_end
= start
+ bytes
;
2267 printf (_("\nThe %s section is empty.\n"), section
->name
);
2271 load_debug_info (file
);
2273 /* Check the order of location list in .debug_info section. If
2274 offsets of location lists are in the ascending order, we can
2275 use `debug_information' directly. */
2276 for (i
= 0; i
< num_debug_info_entries
; i
++)
2280 num
= debug_information
[i
].num_loc_offsets
;
2281 num_loc_list
+= num
;
2283 /* Check if we can use `debug_information' directly. */
2284 if (use_debug_info
&& num
!= 0)
2286 if (!seen_first_offset
)
2288 /* This is the first location list. */
2289 last_offset
= debug_information
[i
].loc_offsets
[0];
2291 seen_first_offset
= 1;
2297 for (; j
< num
; j
++)
2300 debug_information
[i
].loc_offsets
[j
])
2305 last_offset
= debug_information
[i
].loc_offsets
[j
];
2310 if (!use_debug_info
)
2311 /* FIXME: Should we handle this case? */
2312 error (_("Location lists in .debug_info section aren't in ascending order!\n"));
2314 if (!seen_first_offset
)
2315 error (_("No location lists in .debug_info section!\n"));
2317 /* DWARF sections under Mach-O have non-zero addresses. */
2318 if (debug_information
[first
].loc_offsets
[0] != section
->address
)
2319 warn (_("Location lists in %s section start at 0x%lx\n"),
2320 section
->name
, debug_information
[first
].loc_offsets
[0]);
2322 printf (_("Contents of the %s section:\n\n"), section
->name
);
2323 printf (_(" Offset Begin End Expression\n"));
2325 seen_first_offset
= 0;
2326 for (i
= first
; i
< num_debug_info_entries
; i
++)
2328 unsigned long begin
;
2330 unsigned short length
;
2331 unsigned long offset
;
2332 unsigned int pointer_size
;
2333 unsigned long cu_offset
;
2334 unsigned long base_address
;
2335 int need_frame_base
;
2338 pointer_size
= debug_information
[i
].pointer_size
;
2339 cu_offset
= debug_information
[i
].cu_offset
;
2341 for (j
= 0; j
< debug_information
[i
].num_loc_offsets
; j
++)
2343 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
2344 /* DWARF sections under Mach-O have non-zero addresses. */
2345 offset
= debug_information
[i
].loc_offsets
[j
] - section
->address
;
2346 next
= section_begin
+ offset
;
2347 base_address
= debug_information
[i
].base_address
;
2349 if (!seen_first_offset
)
2350 seen_first_offset
= 1;
2354 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
2355 (long)(start
- section_begin
), (long)(next
- section_begin
));
2356 else if (start
> next
)
2357 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
2358 (long)(start
- section_begin
), (long)(next
- section_begin
));
2362 if (offset
>= bytes
)
2364 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
2371 if (start
+ 2 * pointer_size
> section_end
)
2373 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
2378 begin
= byte_get (start
, pointer_size
);
2379 start
+= pointer_size
;
2380 end
= byte_get (start
, pointer_size
);
2381 start
+= pointer_size
;
2383 if (begin
== 0 && end
== 0)
2385 printf (_(" %8.8lx <End of list>\n"), offset
);
2389 /* Check base address specifiers. */
2390 if (begin
== -1UL && end
!= -1UL)
2393 printf (_(" %8.8lx %8.8lx %8.8lx (base address)\n"),
2394 offset
, begin
, end
);
2398 if (start
+ 2 > section_end
)
2400 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
2405 length
= byte_get (start
, 2);
2408 if (start
+ length
> section_end
)
2410 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
2415 printf (" %8.8lx %8.8lx %8.8lx (",
2416 offset
, begin
+ base_address
, end
+ base_address
);
2417 need_frame_base
= decode_location_expression (start
,
2423 if (need_frame_base
&& !has_frame_base
)
2424 printf (_(" [without DW_AT_frame_base]"));
2427 fputs (_(" (start == end)"), stdout
);
2428 else if (begin
> end
)
2429 fputs (_(" (start > end)"), stdout
);
2441 display_debug_str (struct dwarf_section
*section
,
2442 void *file ATTRIBUTE_UNUSED
)
2444 unsigned char *start
= section
->start
;
2445 unsigned long bytes
= section
->size
;
2446 dwarf_vma addr
= section
->address
;
2450 printf (_("\nThe %s section is empty.\n"), section
->name
);
2454 printf (_("Contents of the %s section:\n\n"), section
->name
);
2462 lbytes
= (bytes
> 16 ? 16 : bytes
);
2464 printf (" 0x%8.8lx ", (unsigned long) addr
);
2466 for (j
= 0; j
< 16; j
++)
2469 printf ("%2.2x", start
[j
]);
2477 for (j
= 0; j
< lbytes
; j
++)
2480 if (k
>= ' ' && k
< 0x80)
2500 display_debug_info (struct dwarf_section
*section
, void *file
)
2502 return process_debug_info (section
, file
, 0);
2507 display_debug_aranges (struct dwarf_section
*section
,
2508 void *file ATTRIBUTE_UNUSED
)
2510 unsigned char *start
= section
->start
;
2511 unsigned char *end
= start
+ section
->size
;
2513 printf (_("The section %s contains:\n\n"), section
->name
);
2517 unsigned char *hdrptr
;
2518 DWARF2_Internal_ARange arange
;
2519 unsigned char *ranges
;
2520 unsigned long length
;
2521 unsigned long address
;
2522 unsigned char address_size
;
2525 int initial_length_size
;
2529 arange
.ar_length
= byte_get (hdrptr
, 4);
2532 if (arange
.ar_length
== 0xffffffff)
2534 arange
.ar_length
= byte_get (hdrptr
, 8);
2537 initial_length_size
= 12;
2542 initial_length_size
= 4;
2545 arange
.ar_version
= byte_get (hdrptr
, 2);
2548 arange
.ar_info_offset
= byte_get (hdrptr
, offset_size
);
2549 hdrptr
+= offset_size
;
2551 arange
.ar_pointer_size
= byte_get (hdrptr
, 1);
2554 arange
.ar_segment_size
= byte_get (hdrptr
, 1);
2557 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
2559 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
2563 printf (_(" Length: %ld\n"), arange
.ar_length
);
2564 printf (_(" Version: %d\n"), arange
.ar_version
);
2565 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
2566 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
2567 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
2569 address_size
= arange
.ar_pointer_size
+ arange
.ar_segment_size
;
2571 /* The DWARF spec does not require that the address size be a power
2572 of two, but we do. This will have to change if we ever encounter
2573 an uneven architecture. */
2574 if ((address_size
& (address_size
- 1)) != 0)
2576 warn (_("Pointer size + Segment size is not a power of two.\n"));
2580 printf (_("\n Address Length\n"));
2584 /* Must pad to an alignment boundary that is twice the address size. */
2585 excess
= (hdrptr
- start
) % (2 * address_size
);
2587 ranges
+= (2 * address_size
) - excess
;
2589 start
+= arange
.ar_length
+ initial_length_size
;
2591 while (ranges
+ 2 * address_size
<= start
)
2593 address
= byte_get (ranges
, address_size
);
2595 ranges
+= address_size
;
2597 length
= byte_get (ranges
, address_size
);
2599 ranges
+= address_size
;
2601 printf (" %8.8lx %lu\n", address
, length
);
2611 display_debug_ranges (struct dwarf_section
*section
,
2612 void *file ATTRIBUTE_UNUSED
)
2614 unsigned char *start
= section
->start
;
2615 unsigned char *section_end
;
2616 unsigned long bytes
;
2617 unsigned char *section_begin
= start
;
2618 unsigned int num_range_list
= 0;
2619 unsigned long last_offset
= 0;
2620 unsigned int first
= 0;
2623 int seen_first_offset
= 0;
2624 int use_debug_info
= 1;
2625 unsigned char *next
;
2627 bytes
= section
->size
;
2628 section_end
= start
+ bytes
;
2632 printf (_("\nThe %s section is empty.\n"), section
->name
);
2636 load_debug_info (file
);
2638 /* Check the order of range list in .debug_info section. If
2639 offsets of range lists are in the ascending order, we can
2640 use `debug_information' directly. */
2641 for (i
= 0; i
< num_debug_info_entries
; i
++)
2645 num
= debug_information
[i
].num_range_lists
;
2646 num_range_list
+= num
;
2648 /* Check if we can use `debug_information' directly. */
2649 if (use_debug_info
&& num
!= 0)
2651 if (!seen_first_offset
)
2653 /* This is the first range list. */
2654 last_offset
= debug_information
[i
].range_lists
[0];
2656 seen_first_offset
= 1;
2662 for (; j
< num
; j
++)
2665 debug_information
[i
].range_lists
[j
])
2670 last_offset
= debug_information
[i
].range_lists
[j
];
2675 if (!use_debug_info
)
2676 /* FIXME: Should we handle this case? */
2677 error (_("Range lists in .debug_info section aren't in ascending order!\n"));
2679 if (!seen_first_offset
)
2680 error (_("No range lists in .debug_info section!\n"));
2682 /* DWARF sections under Mach-O have non-zero addresses. */
2683 if (debug_information
[first
].range_lists
[0] != section
->address
)
2684 warn (_("Range lists in %s section start at 0x%lx\n"),
2685 section
->name
, debug_information
[first
].range_lists
[0]);
2687 printf (_("Contents of the %s section:\n\n"), section
->name
);
2688 printf (_(" Offset Begin End\n"));
2690 seen_first_offset
= 0;
2691 for (i
= first
; i
< num_debug_info_entries
; i
++)
2693 unsigned long begin
;
2695 unsigned long offset
;
2696 unsigned int pointer_size
;
2697 unsigned long base_address
;
2699 pointer_size
= debug_information
[i
].pointer_size
;
2701 for (j
= 0; j
< debug_information
[i
].num_range_lists
; j
++)
2703 /* DWARF sections under Mach-O have non-zero addresses. */
2704 offset
= debug_information
[i
].range_lists
[j
] - section
->address
;
2705 next
= section_begin
+ offset
;
2706 base_address
= debug_information
[i
].base_address
;
2708 if (!seen_first_offset
)
2709 seen_first_offset
= 1;
2713 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
2714 (long)(start
- section_begin
),
2715 (long)(next
- section_begin
), section
->name
);
2716 else if (start
> next
)
2717 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
2718 (long)(start
- section_begin
),
2719 (long)(next
- section_begin
), section
->name
);
2725 begin
= byte_get (start
, pointer_size
);
2726 start
+= pointer_size
;
2727 end
= byte_get (start
, pointer_size
);
2728 start
+= pointer_size
;
2730 if (begin
== 0 && end
== 0)
2732 printf (_(" %8.8lx <End of list>\n"), offset
);
2736 /* Check base address specifiers. */
2737 if (begin
== -1UL && end
!= -1UL)
2740 printf (" %8.8lx %8.8lx %8.8lx (base address)\n",
2741 offset
, begin
, end
);
2745 printf (" %8.8lx %8.8lx %8.8lx",
2746 offset
, begin
+ base_address
, end
+ base_address
);
2749 fputs (_(" (start == end)"), stdout
);
2750 else if (begin
> end
)
2751 fputs (_(" (start > end)"), stdout
);
2761 typedef struct Frame_Chunk
2763 struct Frame_Chunk
*next
;
2764 unsigned char *chunk_start
;
2766 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
2767 short int *col_type
;
2770 unsigned int code_factor
;
2772 unsigned long pc_begin
;
2773 unsigned long pc_range
;
2777 unsigned char fde_encoding
;
2778 unsigned char cfa_exp
;
2782 /* A marker for a col_type that means this column was never referenced
2783 in the frame info. */
2784 #define DW_CFA_unreferenced (-1)
2787 frame_need_space (Frame_Chunk
*fc
, int reg
)
2789 int prev
= fc
->ncols
;
2791 if (reg
< fc
->ncols
)
2794 fc
->ncols
= reg
+ 1;
2795 fc
->col_type
= xcrealloc (fc
->col_type
, fc
->ncols
, sizeof (short int));
2796 fc
->col_offset
= xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
2798 while (prev
< fc
->ncols
)
2800 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
2801 fc
->col_offset
[prev
] = 0;
2807 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, int *max_regs
)
2812 if (*max_regs
< fc
->ncols
)
2813 *max_regs
= fc
->ncols
;
2815 if (*need_col_headers
)
2817 *need_col_headers
= 0;
2819 printf (" LOC CFA ");
2821 for (r
= 0; r
< *max_regs
; r
++)
2822 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
2827 printf ("r%-4d", r
);
2833 printf ("%08lx ", fc
->pc_begin
);
2835 strcpy (tmp
, "exp");
2837 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
2838 printf ("%-8s ", tmp
);
2840 for (r
= 0; r
< fc
->ncols
; r
++)
2842 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
2844 switch (fc
->col_type
[r
])
2846 case DW_CFA_undefined
:
2849 case DW_CFA_same_value
:
2853 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
2855 case DW_CFA_val_offset
:
2856 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
2858 case DW_CFA_register
:
2859 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
2861 case DW_CFA_expression
:
2862 strcpy (tmp
, "exp");
2864 case DW_CFA_val_expression
:
2865 strcpy (tmp
, "vexp");
2868 strcpy (tmp
, "n/a");
2871 printf ("%-5s", tmp
);
2878 size_of_encoded_value (int encoding
)
2880 switch (encoding
& 0x7)
2883 case 0: return eh_addr_size
;
2891 get_encoded_value (unsigned char *data
, int encoding
)
2893 int size
= size_of_encoded_value (encoding
);
2895 if (encoding
& DW_EH_PE_signed
)
2896 return byte_get_signed (data
, size
);
2898 return byte_get (data
, size
);
2901 #define GET(N) byte_get (start, N); start += N
2902 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
2903 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
2906 display_debug_frames (struct dwarf_section
*section
,
2907 void *file ATTRIBUTE_UNUSED
)
2909 unsigned char *start
= section
->start
;
2910 unsigned char *end
= start
+ section
->size
;
2911 unsigned char *section_start
= start
;
2912 Frame_Chunk
*chunks
= 0;
2913 Frame_Chunk
*remembered_state
= 0;
2915 int is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
2916 unsigned int length_return
;
2919 printf (_("The section %s contains:\n"), section
->name
);
2923 unsigned char *saved_start
;
2924 unsigned char *block_end
;
2925 unsigned long length
;
2926 unsigned long cie_id
;
2929 int need_col_headers
= 1;
2930 unsigned char *augmentation_data
= NULL
;
2931 unsigned long augmentation_data_len
= 0;
2932 int encoded_ptr_size
= eh_addr_size
;
2934 int initial_length_size
;
2936 saved_start
= start
;
2937 length
= byte_get (start
, 4); start
+= 4;
2941 printf ("\n%08lx ZERO terminator\n\n",
2942 (unsigned long)(saved_start
- section_start
));
2946 if (length
== 0xffffffff)
2948 length
= byte_get (start
, 8);
2951 initial_length_size
= 12;
2956 initial_length_size
= 4;
2959 block_end
= saved_start
+ length
+ initial_length_size
;
2960 if (block_end
> end
)
2962 warn ("Invalid length %#08lx in FDE at %#08lx\n",
2963 length
, (unsigned long)(saved_start
- section_start
));
2966 cie_id
= byte_get (start
, offset_size
); start
+= offset_size
;
2968 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
2972 fc
= xmalloc (sizeof (Frame_Chunk
));
2973 memset (fc
, 0, sizeof (Frame_Chunk
));
2977 fc
->chunk_start
= saved_start
;
2979 fc
->col_type
= xmalloc (sizeof (short int));
2980 fc
->col_offset
= xmalloc (sizeof (int));
2981 frame_need_space (fc
, max_regs
-1);
2985 fc
->augmentation
= (char *) start
;
2986 start
= (unsigned char *) strchr ((char *) start
, '\0') + 1;
2988 if (fc
->augmentation
[0] == 'z')
2990 fc
->code_factor
= LEB ();
2991 fc
->data_factor
= SLEB ();
3000 augmentation_data_len
= LEB ();
3001 augmentation_data
= start
;
3002 start
+= augmentation_data_len
;
3004 else if (strcmp (fc
->augmentation
, "eh") == 0)
3006 start
+= eh_addr_size
;
3007 fc
->code_factor
= LEB ();
3008 fc
->data_factor
= SLEB ();
3020 fc
->code_factor
= LEB ();
3021 fc
->data_factor
= SLEB ();
3033 if (do_debug_frames_interp
)
3034 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
3035 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
3036 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
3040 printf ("\n%08lx %08lx %08lx CIE\n",
3041 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
3042 printf (" Version: %d\n", version
);
3043 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
3044 printf (" Code alignment factor: %u\n", fc
->code_factor
);
3045 printf (" Data alignment factor: %d\n", fc
->data_factor
);
3046 printf (" Return address column: %d\n", fc
->ra
);
3048 if (augmentation_data_len
)
3051 printf (" Augmentation data: ");
3052 for (i
= 0; i
< augmentation_data_len
; ++i
)
3053 printf (" %02x", augmentation_data
[i
]);
3059 if (augmentation_data_len
)
3061 unsigned char *p
, *q
;
3062 p
= (unsigned char *) fc
->augmentation
+ 1;
3063 q
= augmentation_data
;
3070 q
+= 1 + size_of_encoded_value (*q
);
3072 fc
->fde_encoding
= *q
++;
3078 if (fc
->fde_encoding
)
3079 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
3082 frame_need_space (fc
, fc
->ra
);
3086 unsigned char *look_for
;
3087 static Frame_Chunk fde_fc
;
3090 memset (fc
, 0, sizeof (Frame_Chunk
));
3092 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
3094 for (cie
= chunks
; cie
; cie
= cie
->next
)
3095 if (cie
->chunk_start
== look_for
)
3100 warn ("Invalid CIE pointer %#08lx in FDE at %#08lx\n",
3101 cie_id
, (unsigned long)(saved_start
- section_start
));
3103 fc
->col_type
= xmalloc (sizeof (short int));
3104 fc
->col_offset
= xmalloc (sizeof (int));
3105 frame_need_space (fc
, max_regs
- 1);
3107 fc
->augmentation
= "";
3108 fc
->fde_encoding
= 0;
3112 fc
->ncols
= cie
->ncols
;
3113 fc
->col_type
= xcmalloc (fc
->ncols
, sizeof (short int));
3114 fc
->col_offset
= xcmalloc (fc
->ncols
, sizeof (int));
3115 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
3116 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
3117 fc
->augmentation
= cie
->augmentation
;
3118 fc
->code_factor
= cie
->code_factor
;
3119 fc
->data_factor
= cie
->data_factor
;
3120 fc
->cfa_reg
= cie
->cfa_reg
;
3121 fc
->cfa_offset
= cie
->cfa_offset
;
3123 frame_need_space (fc
, max_regs
-1);
3124 fc
->fde_encoding
= cie
->fde_encoding
;
3127 if (fc
->fde_encoding
)
3128 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
3130 fc
->pc_begin
= get_encoded_value (start
, fc
->fde_encoding
);
3131 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
3132 /* Don't adjust for relocatable file since there's
3133 invariably a pcrel reloc here, which we haven't
3136 fc
->pc_begin
+= section
->address
+ (start
- section_start
);
3137 start
+= encoded_ptr_size
;
3138 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
3139 start
+= encoded_ptr_size
;
3141 if (cie
->augmentation
[0] == 'z')
3143 augmentation_data_len
= LEB ();
3144 augmentation_data
= start
;
3145 start
+= augmentation_data_len
;
3148 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
3149 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
3150 (unsigned long)(cie
->chunk_start
- section_start
),
3151 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
3152 if (! do_debug_frames_interp
&& augmentation_data_len
)
3156 printf (" Augmentation data: ");
3157 for (i
= 0; i
< augmentation_data_len
; ++i
)
3158 printf (" %02x", augmentation_data
[i
]);
3164 /* At this point, fc is the current chunk, cie (if any) is set, and
3165 we're about to interpret instructions for the chunk. */
3166 /* ??? At present we need to do this always, since this sizes the
3167 fc->col_type and fc->col_offset arrays, which we write into always.
3168 We should probably split the interpreted and non-interpreted bits
3169 into two different routines, since there's so much that doesn't
3170 really overlap between them. */
3171 if (1 || do_debug_frames_interp
)
3173 /* Start by making a pass over the chunk, allocating storage
3174 and taking note of what registers are used. */
3175 unsigned char *tmp
= start
;
3177 while (start
< block_end
)
3180 unsigned long reg
, tmp
;
3187 /* Warning: if you add any more cases to this switch, be
3188 sure to add them to the corresponding switch below. */
3191 case DW_CFA_advance_loc
:
3195 frame_need_space (fc
, opa
);
3196 fc
->col_type
[opa
] = DW_CFA_undefined
;
3198 case DW_CFA_restore
:
3199 frame_need_space (fc
, opa
);
3200 fc
->col_type
[opa
] = DW_CFA_undefined
;
3202 case DW_CFA_set_loc
:
3203 start
+= encoded_ptr_size
;
3205 case DW_CFA_advance_loc1
:
3208 case DW_CFA_advance_loc2
:
3211 case DW_CFA_advance_loc4
:
3214 case DW_CFA_offset_extended
:
3215 case DW_CFA_val_offset
:
3216 reg
= LEB (); LEB ();
3217 frame_need_space (fc
, reg
);
3218 fc
->col_type
[reg
] = DW_CFA_undefined
;
3220 case DW_CFA_restore_extended
:
3222 frame_need_space (fc
, reg
);
3223 fc
->col_type
[reg
] = DW_CFA_undefined
;
3225 case DW_CFA_undefined
:
3227 frame_need_space (fc
, reg
);
3228 fc
->col_type
[reg
] = DW_CFA_undefined
;
3230 case DW_CFA_same_value
:
3232 frame_need_space (fc
, reg
);
3233 fc
->col_type
[reg
] = DW_CFA_undefined
;
3235 case DW_CFA_register
:
3236 reg
= LEB (); LEB ();
3237 frame_need_space (fc
, reg
);
3238 fc
->col_type
[reg
] = DW_CFA_undefined
;
3240 case DW_CFA_def_cfa
:
3243 case DW_CFA_def_cfa_register
:
3246 case DW_CFA_def_cfa_offset
:
3249 case DW_CFA_def_cfa_expression
:
3253 case DW_CFA_expression
:
3254 case DW_CFA_val_expression
:
3258 frame_need_space (fc
, reg
);
3259 fc
->col_type
[reg
] = DW_CFA_undefined
;
3261 case DW_CFA_offset_extended_sf
:
3262 case DW_CFA_val_offset_sf
:
3263 reg
= LEB (); SLEB ();
3264 frame_need_space (fc
, reg
);
3265 fc
->col_type
[reg
] = DW_CFA_undefined
;
3267 case DW_CFA_def_cfa_sf
:
3270 case DW_CFA_def_cfa_offset_sf
:
3273 case DW_CFA_MIPS_advance_loc8
:
3276 case DW_CFA_GNU_args_size
:
3279 case DW_CFA_GNU_negative_offset_extended
:
3280 reg
= LEB (); LEB ();
3281 frame_need_space (fc
, reg
);
3282 fc
->col_type
[reg
] = DW_CFA_undefined
;
3291 /* Now we know what registers are used, make a second pass over
3292 the chunk, this time actually printing out the info. */
3294 while (start
< block_end
)
3297 unsigned long ul
, reg
, roffs
;
3306 /* Warning: if you add any more cases to this switch, be
3307 sure to add them to the corresponding switch above. */
3310 case DW_CFA_advance_loc
:
3311 if (do_debug_frames_interp
)
3312 frame_display_row (fc
, &need_col_headers
, &max_regs
);
3314 printf (" DW_CFA_advance_loc: %d to %08lx\n",
3315 opa
* fc
->code_factor
,
3316 fc
->pc_begin
+ opa
* fc
->code_factor
);
3317 fc
->pc_begin
+= opa
* fc
->code_factor
;
3322 if (! do_debug_frames_interp
)
3323 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
3324 opa
, roffs
* fc
->data_factor
);
3325 fc
->col_type
[opa
] = DW_CFA_offset
;
3326 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
3329 case DW_CFA_restore
:
3330 if (! do_debug_frames_interp
)
3331 printf (" DW_CFA_restore: r%d\n", opa
);
3332 fc
->col_type
[opa
] = cie
->col_type
[opa
];
3333 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
3336 case DW_CFA_set_loc
:
3337 vma
= get_encoded_value (start
, fc
->fde_encoding
);
3338 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
3340 vma
+= section
->address
+ (start
- section_start
);
3341 start
+= encoded_ptr_size
;
3342 if (do_debug_frames_interp
)
3343 frame_display_row (fc
, &need_col_headers
, &max_regs
);
3345 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
3349 case DW_CFA_advance_loc1
:
3350 ofs
= byte_get (start
, 1); start
+= 1;
3351 if (do_debug_frames_interp
)
3352 frame_display_row (fc
, &need_col_headers
, &max_regs
);
3354 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
3355 ofs
* fc
->code_factor
,
3356 fc
->pc_begin
+ ofs
* fc
->code_factor
);
3357 fc
->pc_begin
+= ofs
* fc
->code_factor
;
3360 case DW_CFA_advance_loc2
:
3361 ofs
= byte_get (start
, 2); start
+= 2;
3362 if (do_debug_frames_interp
)
3363 frame_display_row (fc
, &need_col_headers
, &max_regs
);
3365 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
3366 ofs
* fc
->code_factor
,
3367 fc
->pc_begin
+ ofs
* fc
->code_factor
);
3368 fc
->pc_begin
+= ofs
* fc
->code_factor
;
3371 case DW_CFA_advance_loc4
:
3372 ofs
= byte_get (start
, 4); start
+= 4;
3373 if (do_debug_frames_interp
)
3374 frame_display_row (fc
, &need_col_headers
, &max_regs
);
3376 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
3377 ofs
* fc
->code_factor
,
3378 fc
->pc_begin
+ ofs
* fc
->code_factor
);
3379 fc
->pc_begin
+= ofs
* fc
->code_factor
;
3382 case DW_CFA_offset_extended
:
3385 if (! do_debug_frames_interp
)
3386 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
3387 reg
, roffs
* fc
->data_factor
);
3388 fc
->col_type
[reg
] = DW_CFA_offset
;
3389 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
3392 case DW_CFA_val_offset
:
3395 if (! do_debug_frames_interp
)
3396 printf (" DW_CFA_val_offset: r%ld at cfa%+ld\n",
3397 reg
, roffs
* fc
->data_factor
);
3398 fc
->col_type
[reg
] = DW_CFA_val_offset
;
3399 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
3402 case DW_CFA_restore_extended
:
3404 if (! do_debug_frames_interp
)
3405 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
3406 fc
->col_type
[reg
] = cie
->col_type
[reg
];
3407 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
3410 case DW_CFA_undefined
:
3412 if (! do_debug_frames_interp
)
3413 printf (" DW_CFA_undefined: r%ld\n", reg
);
3414 fc
->col_type
[reg
] = DW_CFA_undefined
;
3415 fc
->col_offset
[reg
] = 0;
3418 case DW_CFA_same_value
:
3420 if (! do_debug_frames_interp
)
3421 printf (" DW_CFA_same_value: r%ld\n", reg
);
3422 fc
->col_type
[reg
] = DW_CFA_same_value
;
3423 fc
->col_offset
[reg
] = 0;
3426 case DW_CFA_register
:
3429 if (! do_debug_frames_interp
)
3430 printf (" DW_CFA_register: r%ld in r%ld\n", reg
, roffs
);
3431 fc
->col_type
[reg
] = DW_CFA_register
;
3432 fc
->col_offset
[reg
] = roffs
;
3435 case DW_CFA_remember_state
:
3436 if (! do_debug_frames_interp
)
3437 printf (" DW_CFA_remember_state\n");
3438 rs
= xmalloc (sizeof (Frame_Chunk
));
3439 rs
->ncols
= fc
->ncols
;
3440 rs
->col_type
= xcmalloc (rs
->ncols
, sizeof (short int));
3441 rs
->col_offset
= xcmalloc (rs
->ncols
, sizeof (int));
3442 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
3443 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
3444 rs
->next
= remembered_state
;
3445 remembered_state
= rs
;
3448 case DW_CFA_restore_state
:
3449 if (! do_debug_frames_interp
)
3450 printf (" DW_CFA_restore_state\n");
3451 rs
= remembered_state
;
3454 remembered_state
= rs
->next
;
3455 frame_need_space (fc
, rs
->ncols
-1);
3456 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
3457 memcpy (fc
->col_offset
, rs
->col_offset
,
3458 rs
->ncols
* sizeof (int));
3459 free (rs
->col_type
);
3460 free (rs
->col_offset
);
3463 else if (do_debug_frames_interp
)
3464 printf ("Mismatched DW_CFA_restore_state\n");
3467 case DW_CFA_def_cfa
:
3468 fc
->cfa_reg
= LEB ();
3469 fc
->cfa_offset
= LEB ();
3471 if (! do_debug_frames_interp
)
3472 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
3473 fc
->cfa_reg
, fc
->cfa_offset
);
3476 case DW_CFA_def_cfa_register
:
3477 fc
->cfa_reg
= LEB ();
3479 if (! do_debug_frames_interp
)
3480 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
3483 case DW_CFA_def_cfa_offset
:
3484 fc
->cfa_offset
= LEB ();
3485 if (! do_debug_frames_interp
)
3486 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
3490 if (! do_debug_frames_interp
)
3491 printf (" DW_CFA_nop\n");
3494 case DW_CFA_def_cfa_expression
:
3496 if (! do_debug_frames_interp
)
3498 printf (" DW_CFA_def_cfa_expression (");
3499 decode_location_expression (start
, eh_addr_size
, ul
, 0);
3506 case DW_CFA_expression
:
3509 if (! do_debug_frames_interp
)
3511 printf (" DW_CFA_expression: r%ld (", reg
);
3512 decode_location_expression (start
, eh_addr_size
, ul
, 0);
3515 fc
->col_type
[reg
] = DW_CFA_expression
;
3519 case DW_CFA_val_expression
:
3522 if (! do_debug_frames_interp
)
3524 printf (" DW_CFA_val_expression: r%ld (", reg
);
3525 decode_location_expression (start
, eh_addr_size
, ul
, 0);
3528 fc
->col_type
[reg
] = DW_CFA_val_expression
;
3532 case DW_CFA_offset_extended_sf
:
3535 frame_need_space (fc
, reg
);
3536 if (! do_debug_frames_interp
)
3537 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
3538 reg
, l
* fc
->data_factor
);
3539 fc
->col_type
[reg
] = DW_CFA_offset
;
3540 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
3543 case DW_CFA_val_offset_sf
:
3546 frame_need_space (fc
, reg
);
3547 if (! do_debug_frames_interp
)
3548 printf (" DW_CFA_val_offset_sf: r%ld at cfa%+ld\n",
3549 reg
, l
* fc
->data_factor
);
3550 fc
->col_type
[reg
] = DW_CFA_val_offset
;
3551 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
3554 case DW_CFA_def_cfa_sf
:
3555 fc
->cfa_reg
= LEB ();
3556 fc
->cfa_offset
= SLEB ();
3557 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
3559 if (! do_debug_frames_interp
)
3560 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
3561 fc
->cfa_reg
, fc
->cfa_offset
);
3564 case DW_CFA_def_cfa_offset_sf
:
3565 fc
->cfa_offset
= SLEB ();
3566 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
3567 if (! do_debug_frames_interp
)
3568 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
3571 case DW_CFA_MIPS_advance_loc8
:
3572 ofs
= byte_get (start
, 8); start
+= 8;
3573 if (do_debug_frames_interp
)
3574 frame_display_row (fc
, &need_col_headers
, &max_regs
);
3576 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
3577 ofs
* fc
->code_factor
,
3578 fc
->pc_begin
+ ofs
* fc
->code_factor
);
3579 fc
->pc_begin
+= ofs
* fc
->code_factor
;
3582 case DW_CFA_GNU_window_save
:
3583 if (! do_debug_frames_interp
)
3584 printf (" DW_CFA_GNU_window_save\n");
3587 case DW_CFA_GNU_args_size
:
3589 if (! do_debug_frames_interp
)
3590 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
3593 case DW_CFA_GNU_negative_offset_extended
:
3596 frame_need_space (fc
, reg
);
3597 if (! do_debug_frames_interp
)
3598 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
3599 reg
, l
* fc
->data_factor
);
3600 fc
->col_type
[reg
] = DW_CFA_offset
;
3601 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
3605 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
3606 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
3608 warn (_("unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
3613 if (do_debug_frames_interp
)
3614 frame_display_row (fc
, &need_col_headers
, &max_regs
);
3629 display_debug_not_supported (struct dwarf_section
*section
,
3630 void *file ATTRIBUTE_UNUSED
)
3632 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
3639 cmalloc (size_t nmemb
, size_t size
)
3641 /* Check for overflow. */
3642 if (nmemb
>= ~(size_t) 0 / size
)
3645 return malloc (nmemb
* size
);
3649 xcmalloc (size_t nmemb
, size_t size
)
3651 /* Check for overflow. */
3652 if (nmemb
>= ~(size_t) 0 / size
)
3655 return xmalloc (nmemb
* size
);
3659 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
3661 /* Check for overflow. */
3662 if (nmemb
>= ~(size_t) 0 / size
)
3665 return xrealloc (ptr
, nmemb
* size
);
3669 error (const char *message
, ...)
3673 va_start (args
, message
);
3674 fprintf (stderr
, _("%s: Error: "), program_name
);
3675 vfprintf (stderr
, message
, args
);
3680 warn (const char *message
, ...)
3684 va_start (args
, message
);
3685 fprintf (stderr
, _("%s: Warning: "), program_name
);
3686 vfprintf (stderr
, message
, args
);
3691 free_debug_memory (void)
3693 enum dwarf_section_display_enum i
;
3697 for (i
= 0; i
< max
; i
++)
3698 free_debug_section (i
);
3700 if (debug_information
)
3702 for (i
= 0; i
< num_debug_info_entries
; i
++)
3704 if (!debug_information
[i
].max_loc_offsets
)
3706 free (debug_information
[i
].loc_offsets
);
3707 free (debug_information
[i
].have_frame_base
);
3709 if (!debug_information
[i
].max_range_lists
)
3710 free (debug_information
[i
].range_lists
);
3712 free (debug_information
);
3713 debug_information
= NULL
;
3714 num_debug_info_entries
= 0;
3719 struct dwarf_section_display debug_displays
[] =
3721 { { ".debug_abbrev", NULL
, 0, 0 },
3722 display_debug_abbrev
, 0, 0 },
3723 { { ".debug_aranges", NULL
, 0, 0 },
3724 display_debug_aranges
, 0, 0 },
3725 { { ".debug_frame", NULL
, 0, 0 },
3726 display_debug_frames
, 1, 0 },
3727 { { ".debug_info", NULL
, 0, 0 },
3728 display_debug_info
, 1, 0 },
3729 { { ".debug_line", NULL
, 0, 0 },
3730 display_debug_lines
, 0, 0 },
3731 { { ".debug_pubnames", NULL
, 0, 0 },
3732 display_debug_pubnames
, 0, 0 },
3733 { { ".eh_frame", NULL
, 0, 0 },
3734 display_debug_frames
, 1, 1 },
3735 { { ".debug_macinfo", NULL
, 0, 0 },
3736 display_debug_macinfo
, 0, 0 },
3737 { { ".debug_str", NULL
, 0, 0 },
3738 display_debug_str
, 0, 0 },
3739 { { ".debug_loc", NULL
, 0, 0 },
3740 display_debug_loc
, 0, 0 },
3741 { { ".debug_pubtypes", NULL
, 0, 0 },
3742 display_debug_pubnames
, 0, 0 },
3743 { { ".debug_ranges", NULL
, 0, 0 },
3744 display_debug_ranges
, 0, 0 },
3745 { { ".debug_static_func", NULL
, 0, 0 },
3746 display_debug_not_supported
, 0, 0 },
3747 { { ".debug_static_vars", NULL
, 0, 0 },
3748 display_debug_not_supported
, 0, 0 },
3749 { { ".debug_types", NULL
, 0, 0 },
3750 display_debug_not_supported
, 0, 0 },
3751 { { ".debug_weaknames", NULL
, 0, 0 },
3752 display_debug_not_supported
, 0, 0 }