1 /* dwarf.c -- display DWARF contents of a BFD binary file
2 Copyright 2005, 2006, 2007
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 /* Ordered by the numeric value of these constants. */
1217 case DW_LANG_C89
: printf ("(ANSI C)"); break;
1218 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
1219 case DW_LANG_Ada83
: printf ("(Ada)"); break;
1220 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
1221 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
1222 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
1223 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
1224 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
1225 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
1226 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
1227 /* DWARF 2.1 values. */
1228 case DW_LANG_Java
: printf ("(Java)"); break;
1229 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
1230 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
1231 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
1232 /* DWARF 3 values. */
1233 case DW_LANG_PLI
: printf ("(PLI)"); break;
1234 case DW_LANG_ObjC
: printf ("(Objective C)"); break;
1235 case DW_LANG_ObjC_plus_plus
: printf ("(Objective C++)"); break;
1236 case DW_LANG_UPC
: printf ("(Unified Parallel C)"); break;
1237 case DW_LANG_D
: printf ("(D)"); break;
1238 /* MIPS extension. */
1239 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
1240 /* UPC extension. */
1241 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
1243 if (uvalue
>= DW_LANG_lo_user
&& uvalue
<= DW_LANG_hi_user
)
1244 printf ("(implementation defined: %lx)", uvalue
);
1246 printf ("(Unknown: %lx)", uvalue
);
1251 case DW_AT_encoding
:
1254 case DW_ATE_void
: printf ("(void)"); break;
1255 case DW_ATE_address
: printf ("(machine address)"); break;
1256 case DW_ATE_boolean
: printf ("(boolean)"); break;
1257 case DW_ATE_complex_float
: printf ("(complex float)"); break;
1258 case DW_ATE_float
: printf ("(float)"); break;
1259 case DW_ATE_signed
: printf ("(signed)"); break;
1260 case DW_ATE_signed_char
: printf ("(signed char)"); break;
1261 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
1262 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
1263 /* DWARF 2.1 value. */
1264 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
1265 case DW_ATE_decimal_float
: printf ("(decimal float)"); break;
1267 if (uvalue
>= DW_ATE_lo_user
1268 && uvalue
<= DW_ATE_hi_user
)
1269 printf ("(user defined type)");
1271 printf ("(unknown type)");
1276 case DW_AT_accessibility
:
1279 case DW_ACCESS_public
: printf ("(public)"); break;
1280 case DW_ACCESS_protected
: printf ("(protected)"); break;
1281 case DW_ACCESS_private
: printf ("(private)"); break;
1283 printf ("(unknown accessibility)");
1288 case DW_AT_visibility
:
1291 case DW_VIS_local
: printf ("(local)"); break;
1292 case DW_VIS_exported
: printf ("(exported)"); break;
1293 case DW_VIS_qualified
: printf ("(qualified)"); break;
1294 default: printf ("(unknown visibility)"); break;
1298 case DW_AT_virtuality
:
1301 case DW_VIRTUALITY_none
: printf ("(none)"); break;
1302 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
1303 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
1304 default: printf ("(unknown virtuality)"); break;
1308 case DW_AT_identifier_case
:
1311 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
1312 case DW_ID_up_case
: printf ("(up_case)"); break;
1313 case DW_ID_down_case
: printf ("(down_case)"); break;
1314 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
1315 default: printf ("(unknown case)"); break;
1319 case DW_AT_calling_convention
:
1322 case DW_CC_normal
: printf ("(normal)"); break;
1323 case DW_CC_program
: printf ("(program)"); break;
1324 case DW_CC_nocall
: printf ("(nocall)"); break;
1326 if (uvalue
>= DW_CC_lo_user
1327 && uvalue
<= DW_CC_hi_user
)
1328 printf ("(user defined)");
1330 printf ("(unknown convention)");
1334 case DW_AT_ordering
:
1337 case -1: printf ("(undefined)"); break;
1338 case 0: printf ("(row major)"); break;
1339 case 1: printf ("(column major)"); break;
1343 case DW_AT_frame_base
:
1344 have_frame_base
= 1;
1345 case DW_AT_location
:
1346 case DW_AT_data_member_location
:
1347 case DW_AT_vtable_elem_location
:
1348 case DW_AT_allocated
:
1349 case DW_AT_associated
:
1350 case DW_AT_data_location
:
1352 case DW_AT_upper_bound
:
1353 case DW_AT_lower_bound
:
1356 int need_frame_base
;
1359 need_frame_base
= decode_location_expression (block_start
,
1364 if (need_frame_base
&& !have_frame_base
)
1365 printf (_(" [without DW_AT_frame_base]"));
1367 else if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
1368 printf (_("(location list)"));
1380 get_AT_name (unsigned long attribute
)
1384 case DW_AT_sibling
: return "DW_AT_sibling";
1385 case DW_AT_location
: return "DW_AT_location";
1386 case DW_AT_name
: return "DW_AT_name";
1387 case DW_AT_ordering
: return "DW_AT_ordering";
1388 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
1389 case DW_AT_byte_size
: return "DW_AT_byte_size";
1390 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
1391 case DW_AT_bit_size
: return "DW_AT_bit_size";
1392 case DW_AT_element_list
: return "DW_AT_element_list";
1393 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
1394 case DW_AT_low_pc
: return "DW_AT_low_pc";
1395 case DW_AT_high_pc
: return "DW_AT_high_pc";
1396 case DW_AT_language
: return "DW_AT_language";
1397 case DW_AT_member
: return "DW_AT_member";
1398 case DW_AT_discr
: return "DW_AT_discr";
1399 case DW_AT_discr_value
: return "DW_AT_discr_value";
1400 case DW_AT_visibility
: return "DW_AT_visibility";
1401 case DW_AT_import
: return "DW_AT_import";
1402 case DW_AT_string_length
: return "DW_AT_string_length";
1403 case DW_AT_common_reference
: return "DW_AT_common_reference";
1404 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
1405 case DW_AT_const_value
: return "DW_AT_const_value";
1406 case DW_AT_containing_type
: return "DW_AT_containing_type";
1407 case DW_AT_default_value
: return "DW_AT_default_value";
1408 case DW_AT_inline
: return "DW_AT_inline";
1409 case DW_AT_is_optional
: return "DW_AT_is_optional";
1410 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
1411 case DW_AT_producer
: return "DW_AT_producer";
1412 case DW_AT_prototyped
: return "DW_AT_prototyped";
1413 case DW_AT_return_addr
: return "DW_AT_return_addr";
1414 case DW_AT_start_scope
: return "DW_AT_start_scope";
1415 case DW_AT_stride_size
: return "DW_AT_stride_size";
1416 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
1417 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
1418 case DW_AT_accessibility
: return "DW_AT_accessibility";
1419 case DW_AT_address_class
: return "DW_AT_address_class";
1420 case DW_AT_artificial
: return "DW_AT_artificial";
1421 case DW_AT_base_types
: return "DW_AT_base_types";
1422 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
1423 case DW_AT_count
: return "DW_AT_count";
1424 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
1425 case DW_AT_decl_column
: return "DW_AT_decl_column";
1426 case DW_AT_decl_file
: return "DW_AT_decl_file";
1427 case DW_AT_decl_line
: return "DW_AT_decl_line";
1428 case DW_AT_declaration
: return "DW_AT_declaration";
1429 case DW_AT_discr_list
: return "DW_AT_discr_list";
1430 case DW_AT_encoding
: return "DW_AT_encoding";
1431 case DW_AT_external
: return "DW_AT_external";
1432 case DW_AT_frame_base
: return "DW_AT_frame_base";
1433 case DW_AT_friend
: return "DW_AT_friend";
1434 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
1435 case DW_AT_macro_info
: return "DW_AT_macro_info";
1436 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
1437 case DW_AT_priority
: return "DW_AT_priority";
1438 case DW_AT_segment
: return "DW_AT_segment";
1439 case DW_AT_specification
: return "DW_AT_specification";
1440 case DW_AT_static_link
: return "DW_AT_static_link";
1441 case DW_AT_type
: return "DW_AT_type";
1442 case DW_AT_use_location
: return "DW_AT_use_location";
1443 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
1444 case DW_AT_virtuality
: return "DW_AT_virtuality";
1445 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
1446 /* DWARF 2.1 values. */
1447 case DW_AT_allocated
: return "DW_AT_allocated";
1448 case DW_AT_associated
: return "DW_AT_associated";
1449 case DW_AT_data_location
: return "DW_AT_data_location";
1450 case DW_AT_stride
: return "DW_AT_stride";
1451 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
1452 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
1453 case DW_AT_extension
: return "DW_AT_extension";
1454 case DW_AT_ranges
: return "DW_AT_ranges";
1455 case DW_AT_trampoline
: return "DW_AT_trampoline";
1456 case DW_AT_call_column
: return "DW_AT_call_column";
1457 case DW_AT_call_file
: return "DW_AT_call_file";
1458 case DW_AT_call_line
: return "DW_AT_call_line";
1459 /* SGI/MIPS extensions. */
1460 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
1461 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
1462 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
1463 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
1464 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
1465 case DW_AT_MIPS_software_pipeline_depth
:
1466 return "DW_AT_MIPS_software_pipeline_depth";
1467 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
1468 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
1469 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
1470 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
1471 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
1472 /* GNU extensions. */
1473 case DW_AT_sf_names
: return "DW_AT_sf_names";
1474 case DW_AT_src_info
: return "DW_AT_src_info";
1475 case DW_AT_mac_info
: return "DW_AT_mac_info";
1476 case DW_AT_src_coords
: return "DW_AT_src_coords";
1477 case DW_AT_body_begin
: return "DW_AT_body_begin";
1478 case DW_AT_body_end
: return "DW_AT_body_end";
1479 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
1480 /* UPC extension. */
1481 case DW_AT_upc_threads_scaled
: return "DW_AT_upc_threads_scaled";
1484 static char buffer
[100];
1486 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
1493 static unsigned char *
1494 read_and_display_attr (unsigned long attribute
,
1496 unsigned char *data
,
1497 unsigned long cu_offset
,
1498 unsigned long pointer_size
,
1499 unsigned long offset_size
,
1501 debug_info
*debug_info_p
,
1505 printf (" %-18s:", get_AT_name (attribute
));
1506 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
1507 pointer_size
, offset_size
,
1508 dwarf_version
, debug_info_p
,
1516 /* Process the contents of a .debug_info section. If do_loc is non-zero
1517 then we are scanning for location lists and we do not want to display
1518 anything to the user. */
1521 process_debug_info (struct dwarf_section
*section
, void *file
,
1524 unsigned char *start
= section
->start
;
1525 unsigned char *end
= start
+ section
->size
;
1526 unsigned char *section_begin
;
1528 unsigned int num_units
= 0;
1530 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1531 && num_debug_info_entries
== 0)
1533 unsigned long length
;
1535 /* First scan the section to get the number of comp units. */
1536 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
1539 /* Read the first 4 bytes. For a 32-bit DWARF section, this
1540 will be the length. For a 64-bit DWARF section, it'll be
1541 the escape code 0xffffffff followed by an 8 byte length. */
1542 length
= byte_get (section_begin
, 4);
1544 if (length
== 0xffffffff)
1546 length
= byte_get (section_begin
+ 4, 8);
1547 section_begin
+= length
+ 12;
1550 section_begin
+= length
+ 4;
1555 error (_("No comp units in %s section ?"), section
->name
);
1559 /* Then allocate an array to hold the information. */
1560 debug_information
= cmalloc (num_units
,
1561 sizeof (* debug_information
));
1562 if (debug_information
== NULL
)
1564 error (_("Not enough memory for a debug info array of %u entries"),
1572 printf (_("The section %s contains:\n\n"), section
->name
);
1574 load_debug_section (str
, file
);
1577 load_debug_section (abbrev
, file
);
1578 if (debug_displays
[abbrev
].section
.start
== NULL
)
1580 warn (_("Unable to locate %s section!\n"),
1581 debug_displays
[abbrev
].section
.name
);
1585 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
1587 DWARF2_Internal_CompUnit compunit
;
1588 unsigned char *hdrptr
;
1589 unsigned char *cu_abbrev_offset_ptr
;
1590 unsigned char *tags
;
1592 unsigned long cu_offset
;
1594 int initial_length_size
;
1598 compunit
.cu_length
= byte_get (hdrptr
, 4);
1601 if (compunit
.cu_length
== 0xffffffff)
1603 compunit
.cu_length
= byte_get (hdrptr
, 8);
1606 initial_length_size
= 12;
1611 initial_length_size
= 4;
1614 compunit
.cu_version
= byte_get (hdrptr
, 2);
1617 cu_offset
= start
- section_begin
;
1619 cu_abbrev_offset_ptr
= hdrptr
;
1620 compunit
.cu_abbrev_offset
= byte_get (hdrptr
, offset_size
);
1621 hdrptr
+= offset_size
;
1623 compunit
.cu_pointer_size
= byte_get (hdrptr
, 1);
1625 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1626 && num_debug_info_entries
== 0)
1628 debug_information
[unit
].cu_offset
= cu_offset
;
1629 debug_information
[unit
].pointer_size
1630 = compunit
.cu_pointer_size
;
1631 debug_information
[unit
].base_address
= 0;
1632 debug_information
[unit
].loc_offsets
= NULL
;
1633 debug_information
[unit
].have_frame_base
= NULL
;
1634 debug_information
[unit
].max_loc_offsets
= 0;
1635 debug_information
[unit
].num_loc_offsets
= 0;
1636 debug_information
[unit
].range_lists
= NULL
;
1637 debug_information
[unit
].max_range_lists
= 0;
1638 debug_information
[unit
].num_range_lists
= 0;
1643 printf (_(" Compilation Unit @ offset 0x%lx:\n"), cu_offset
);
1644 printf (_(" Length: %ld\n"), compunit
.cu_length
);
1645 printf (_(" Version: %d\n"), compunit
.cu_version
);
1646 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
1647 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
1650 if (cu_offset
+ compunit
.cu_length
+ initial_length_size
1653 warn (_("Debug info is corrupted, length is invalid (section is %lu bytes)\n"),
1654 (unsigned long)section
->size
);
1658 start
+= compunit
.cu_length
+ initial_length_size
;
1660 if (compunit
.cu_version
!= 2 && compunit
.cu_version
!= 3)
1662 warn (_("Only version 2 and 3 DWARF debug information is currently supported.\n"));
1668 /* Process the abbrevs used by this compilation unit. DWARF
1669 sections under Mach-O have non-zero addresses. */
1670 if (compunit
.cu_abbrev_offset
>= debug_displays
[abbrev
].section
.size
)
1671 warn (_("Debug info is corrupted, abbrev offset is invalid (section is %lu bytes)\n"),
1672 (unsigned long)debug_displays
[abbrev
].section
.size
);
1674 process_abbrev_section
1675 ((unsigned char *) debug_displays
[abbrev
].section
.start
1676 + compunit
.cu_abbrev_offset
- debug_displays
[abbrev
].section
.address
,
1677 (unsigned char *) debug_displays
[abbrev
].section
.start
1678 + debug_displays
[abbrev
].section
.size
);
1681 while (tags
< start
)
1683 unsigned int bytes_read
;
1684 unsigned long abbrev_number
;
1685 abbrev_entry
*entry
;
1688 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
1691 /* A null DIE marks the end of a list of children. */
1692 if (abbrev_number
== 0)
1699 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
1701 (unsigned long) (tags
- section_begin
1705 /* Scan through the abbreviation list until we reach the
1707 for (entry
= first_abbrev
;
1708 entry
&& entry
->entry
!= abbrev_number
;
1709 entry
= entry
->next
)
1719 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
1725 printf (_(" (%s)\n"), get_TAG_name (entry
->tag
));
1730 need_base_address
= 0;
1732 case DW_TAG_compile_unit
:
1733 need_base_address
= 1;
1735 case DW_TAG_entry_point
:
1736 case DW_TAG_inlined_subroutine
:
1737 case DW_TAG_subprogram
:
1738 need_base_address
= 0;
1739 /* Assuming that there is no DW_AT_frame_base. */
1740 have_frame_base
= 0;
1744 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
1747 /* Show the offset from where the tag was extracted. */
1748 printf (" <%2lx>", (unsigned long)(tags
- section_begin
));
1750 tags
= read_and_display_attr (attr
->attribute
,
1753 compunit
.cu_pointer_size
,
1755 compunit
.cu_version
,
1756 &debug_information
[unit
],
1760 if (entry
->children
)
1765 /* Set num_debug_info_entries here so that it can be used to check if
1766 we need to process .debug_loc and .debug_ranges sections. */
1767 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1768 && num_debug_info_entries
== 0)
1769 num_debug_info_entries
= num_units
;
1779 /* Locate and scan the .debug_info section in the file and record the pointer
1780 sizes and offsets for the compilation units in it. Usually an executable
1781 will have just one pointer size, but this is not guaranteed, and so we try
1782 not to make any assumptions. Returns zero upon failure, or the number of
1783 compilation units upon success. */
1786 load_debug_info (void * file
)
1788 /* Reset the last pointer size so that we can issue correct error
1789 messages if we are displaying the contents of more than one section. */
1790 last_pointer_size
= 0;
1791 warned_about_missing_comp_units
= FALSE
;
1793 /* If we already have the information there is nothing else to do. */
1794 if (num_debug_info_entries
> 0)
1795 return num_debug_info_entries
;
1797 if (load_debug_section (info
, file
)
1798 && process_debug_info (&debug_displays
[info
].section
, file
, 1))
1799 return num_debug_info_entries
;
1805 display_debug_lines (struct dwarf_section
*section
, void *file
)
1807 unsigned char *start
= section
->start
;
1808 unsigned char *data
= start
;
1809 unsigned char *end
= start
+ section
->size
;
1811 printf (_("\nDump of debug contents of section %s:\n\n"),
1814 load_debug_info (file
);
1818 DWARF2_Internal_LineInfo info
;
1819 unsigned char *standard_opcodes
;
1820 unsigned char *end_of_sequence
;
1821 unsigned char *hdrptr
;
1822 int initial_length_size
;
1828 /* Check the length of the block. */
1829 info
.li_length
= byte_get (hdrptr
, 4);
1832 if (info
.li_length
== 0xffffffff)
1834 /* This section is 64-bit DWARF 3. */
1835 info
.li_length
= byte_get (hdrptr
, 8);
1838 initial_length_size
= 12;
1843 initial_length_size
= 4;
1846 if (info
.li_length
+ initial_length_size
> section
->size
)
1849 (_("The line info appears to be corrupt - the section is too small\n"));
1853 /* Check its version number. */
1854 info
.li_version
= byte_get (hdrptr
, 2);
1856 if (info
.li_version
!= 2 && info
.li_version
!= 3)
1858 warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
1862 info
.li_prologue_length
= byte_get (hdrptr
, offset_size
);
1863 hdrptr
+= offset_size
;
1864 info
.li_min_insn_length
= byte_get (hdrptr
, 1);
1866 info
.li_default_is_stmt
= byte_get (hdrptr
, 1);
1868 info
.li_line_base
= byte_get (hdrptr
, 1);
1870 info
.li_line_range
= byte_get (hdrptr
, 1);
1872 info
.li_opcode_base
= byte_get (hdrptr
, 1);
1875 /* Sign extend the line base field. */
1876 info
.li_line_base
<<= 24;
1877 info
.li_line_base
>>= 24;
1879 printf (_(" Length: %ld\n"), info
.li_length
);
1880 printf (_(" DWARF Version: %d\n"), info
.li_version
);
1881 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
1882 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
1883 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
1884 printf (_(" Line Base: %d\n"), info
.li_line_base
);
1885 printf (_(" Line Range: %d\n"), info
.li_line_range
);
1886 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
1888 end_of_sequence
= data
+ info
.li_length
+ initial_length_size
;
1890 reset_state_machine (info
.li_default_is_stmt
);
1892 /* Display the contents of the Opcodes table. */
1893 standard_opcodes
= hdrptr
;
1895 printf (_("\n Opcodes:\n"));
1897 for (i
= 1; i
< info
.li_opcode_base
; i
++)
1898 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
1900 /* Display the contents of the Directory table. */
1901 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
1904 printf (_("\n The Directory Table is empty.\n"));
1907 printf (_("\n The Directory Table:\n"));
1911 printf (_(" %s\n"), data
);
1913 data
+= strlen ((char *) data
) + 1;
1917 /* Skip the NUL at the end of the table. */
1920 /* Display the contents of the File Name table. */
1922 printf (_("\n The File Name Table is empty.\n"));
1925 printf (_("\n The File Name Table:\n"));
1926 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
1930 unsigned char *name
;
1931 unsigned int bytes_read
;
1933 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
1936 data
+= strlen ((char *) data
) + 1;
1938 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
1940 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
1942 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
1944 printf (_("%s\n"), name
);
1948 /* Skip the NUL at the end of the table. */
1951 /* Now display the statements. */
1952 printf (_("\n Line Number Statements:\n"));
1954 while (data
< end_of_sequence
)
1956 unsigned char op_code
;
1958 unsigned long int uladv
;
1959 unsigned int bytes_read
;
1963 if (op_code
>= info
.li_opcode_base
)
1965 op_code
-= info
.li_opcode_base
;
1966 uladv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
1967 state_machine_regs
.address
+= uladv
;
1968 printf (_(" Special opcode %d: advance Address by %lu to 0x%lx"),
1969 op_code
, uladv
, state_machine_regs
.address
);
1970 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
1971 state_machine_regs
.line
+= adv
;
1972 printf (_(" and Line by %d to %d\n"),
1973 adv
, state_machine_regs
.line
);
1975 else switch (op_code
)
1977 case DW_LNS_extended_op
:
1978 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
);
1982 printf (_(" Copy\n"));
1985 case DW_LNS_advance_pc
:
1986 uladv
= read_leb128 (data
, & bytes_read
, 0);
1987 uladv
*= info
.li_min_insn_length
;
1989 state_machine_regs
.address
+= uladv
;
1990 printf (_(" Advance PC by %lu to 0x%lx\n"), uladv
,
1991 state_machine_regs
.address
);
1994 case DW_LNS_advance_line
:
1995 adv
= read_leb128 (data
, & bytes_read
, 1);
1997 state_machine_regs
.line
+= adv
;
1998 printf (_(" Advance Line by %d to %d\n"), adv
,
1999 state_machine_regs
.line
);
2002 case DW_LNS_set_file
:
2003 adv
= read_leb128 (data
, & bytes_read
, 0);
2005 printf (_(" Set File Name to entry %d in the File Name Table\n"),
2007 state_machine_regs
.file
= adv
;
2010 case DW_LNS_set_column
:
2011 uladv
= read_leb128 (data
, & bytes_read
, 0);
2013 printf (_(" Set column to %lu\n"), uladv
);
2014 state_machine_regs
.column
= uladv
;
2017 case DW_LNS_negate_stmt
:
2018 adv
= state_machine_regs
.is_stmt
;
2020 printf (_(" Set is_stmt to %d\n"), adv
);
2021 state_machine_regs
.is_stmt
= adv
;
2024 case DW_LNS_set_basic_block
:
2025 printf (_(" Set basic block\n"));
2026 state_machine_regs
.basic_block
= 1;
2029 case DW_LNS_const_add_pc
:
2030 uladv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
2031 * info
.li_min_insn_length
);
2032 state_machine_regs
.address
+= uladv
;
2033 printf (_(" Advance PC by constant %lu to 0x%lx\n"), uladv
,
2034 state_machine_regs
.address
);
2037 case DW_LNS_fixed_advance_pc
:
2038 uladv
= byte_get (data
, 2);
2040 state_machine_regs
.address
+= uladv
;
2041 printf (_(" Advance PC by fixed size amount %lu to 0x%lx\n"),
2042 uladv
, state_machine_regs
.address
);
2045 case DW_LNS_set_prologue_end
:
2046 printf (_(" Set prologue_end to true\n"));
2049 case DW_LNS_set_epilogue_begin
:
2050 printf (_(" Set epilogue_begin to true\n"));
2053 case DW_LNS_set_isa
:
2054 uladv
= read_leb128 (data
, & bytes_read
, 0);
2056 printf (_(" Set ISA to %lu\n"), uladv
);
2060 printf (_(" Unknown opcode %d with operands: "), op_code
);
2062 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
2064 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
2065 i
== 1 ? "" : ", ");
2079 display_debug_pubnames (struct dwarf_section
*section
,
2080 void *file ATTRIBUTE_UNUSED
)
2082 DWARF2_Internal_PubNames pubnames
;
2083 unsigned char *start
= section
->start
;
2084 unsigned char *end
= start
+ section
->size
;
2086 printf (_("Contents of the %s section:\n\n"), section
->name
);
2090 unsigned char *data
;
2091 unsigned long offset
;
2092 int offset_size
, initial_length_size
;
2096 pubnames
.pn_length
= byte_get (data
, 4);
2098 if (pubnames
.pn_length
== 0xffffffff)
2100 pubnames
.pn_length
= byte_get (data
, 8);
2103 initial_length_size
= 12;
2108 initial_length_size
= 4;
2111 pubnames
.pn_version
= byte_get (data
, 2);
2113 pubnames
.pn_offset
= byte_get (data
, offset_size
);
2114 data
+= offset_size
;
2115 pubnames
.pn_size
= byte_get (data
, offset_size
);
2116 data
+= offset_size
;
2118 start
+= pubnames
.pn_length
+ initial_length_size
;
2120 if (pubnames
.pn_version
!= 2 && pubnames
.pn_version
!= 3)
2122 static int warned
= 0;
2126 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
2133 printf (_(" Length: %ld\n"),
2134 pubnames
.pn_length
);
2135 printf (_(" Version: %d\n"),
2136 pubnames
.pn_version
);
2137 printf (_(" Offset into .debug_info section: %ld\n"),
2138 pubnames
.pn_offset
);
2139 printf (_(" Size of area in .debug_info section: %ld\n"),
2142 printf (_("\n Offset\tName\n"));
2146 offset
= byte_get (data
, offset_size
);
2150 data
+= offset_size
;
2151 printf (" %-6ld\t\t%s\n", offset
, data
);
2152 data
+= strlen ((char *) data
) + 1;
2155 while (offset
!= 0);
2163 display_debug_macinfo (struct dwarf_section
*section
,
2164 void *file ATTRIBUTE_UNUSED
)
2166 unsigned char *start
= section
->start
;
2167 unsigned char *end
= start
+ section
->size
;
2168 unsigned char *curr
= start
;
2169 unsigned int bytes_read
;
2170 enum dwarf_macinfo_record_type op
;
2172 printf (_("Contents of the %s section:\n\n"), section
->name
);
2176 unsigned int lineno
;
2184 case DW_MACINFO_start_file
:
2186 unsigned int filenum
;
2188 lineno
= read_leb128 (curr
, & bytes_read
, 0);
2190 filenum
= read_leb128 (curr
, & bytes_read
, 0);
2193 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
2198 case DW_MACINFO_end_file
:
2199 printf (_(" DW_MACINFO_end_file\n"));
2202 case DW_MACINFO_define
:
2203 lineno
= read_leb128 (curr
, & bytes_read
, 0);
2205 string
= (char *) curr
;
2206 curr
+= strlen (string
) + 1;
2207 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
2211 case DW_MACINFO_undef
:
2212 lineno
= read_leb128 (curr
, & bytes_read
, 0);
2214 string
= (char *) curr
;
2215 curr
+= strlen (string
) + 1;
2216 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
2220 case DW_MACINFO_vendor_ext
:
2222 unsigned int constant
;
2224 constant
= read_leb128 (curr
, & bytes_read
, 0);
2226 string
= (char *) curr
;
2227 curr
+= strlen (string
) + 1;
2228 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
2239 display_debug_abbrev (struct dwarf_section
*section
,
2240 void *file ATTRIBUTE_UNUSED
)
2242 abbrev_entry
*entry
;
2243 unsigned char *start
= section
->start
;
2244 unsigned char *end
= start
+ section
->size
;
2246 printf (_("Contents of the %s section:\n\n"), section
->name
);
2252 start
= process_abbrev_section (start
, end
);
2254 if (first_abbrev
== NULL
)
2257 printf (_(" Number TAG\n"));
2259 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
2263 printf (_(" %ld %s [%s]\n"),
2265 get_TAG_name (entry
->tag
),
2266 entry
->children
? _("has children") : _("no children"));
2268 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
2269 printf (_(" %-18s %s\n"),
2270 get_AT_name (attr
->attribute
),
2271 get_FORM_name (attr
->form
));
2282 display_debug_loc (struct dwarf_section
*section
, void *file
)
2284 unsigned char *start
= section
->start
;
2285 unsigned char *section_end
;
2286 unsigned long bytes
;
2287 unsigned char *section_begin
= start
;
2288 unsigned int num_loc_list
= 0;
2289 unsigned long last_offset
= 0;
2290 unsigned int first
= 0;
2293 int seen_first_offset
= 0;
2294 int use_debug_info
= 1;
2295 unsigned char *next
;
2297 bytes
= section
->size
;
2298 section_end
= start
+ bytes
;
2302 printf (_("\nThe %s section is empty.\n"), section
->name
);
2306 load_debug_info (file
);
2308 /* Check the order of location list in .debug_info section. If
2309 offsets of location lists are in the ascending order, we can
2310 use `debug_information' directly. */
2311 for (i
= 0; i
< num_debug_info_entries
; i
++)
2315 num
= debug_information
[i
].num_loc_offsets
;
2316 num_loc_list
+= num
;
2318 /* Check if we can use `debug_information' directly. */
2319 if (use_debug_info
&& num
!= 0)
2321 if (!seen_first_offset
)
2323 /* This is the first location list. */
2324 last_offset
= debug_information
[i
].loc_offsets
[0];
2326 seen_first_offset
= 1;
2332 for (; j
< num
; j
++)
2335 debug_information
[i
].loc_offsets
[j
])
2340 last_offset
= debug_information
[i
].loc_offsets
[j
];
2345 if (!use_debug_info
)
2346 /* FIXME: Should we handle this case? */
2347 error (_("Location lists in .debug_info section aren't in ascending order!\n"));
2349 if (!seen_first_offset
)
2350 error (_("No location lists in .debug_info section!\n"));
2352 /* DWARF sections under Mach-O have non-zero addresses. */
2353 if (debug_information
[first
].num_loc_offsets
> 0
2354 && debug_information
[first
].loc_offsets
[0] != section
->address
)
2355 warn (_("Location lists in %s section start at 0x%lx\n"),
2356 section
->name
, debug_information
[first
].loc_offsets
[0]);
2358 printf (_("Contents of the %s section:\n\n"), section
->name
);
2359 printf (_(" Offset Begin End Expression\n"));
2361 seen_first_offset
= 0;
2362 for (i
= first
; i
< num_debug_info_entries
; i
++)
2364 unsigned long begin
;
2366 unsigned short length
;
2367 unsigned long offset
;
2368 unsigned int pointer_size
;
2369 unsigned long cu_offset
;
2370 unsigned long base_address
;
2371 int need_frame_base
;
2374 pointer_size
= debug_information
[i
].pointer_size
;
2375 cu_offset
= debug_information
[i
].cu_offset
;
2377 for (j
= 0; j
< debug_information
[i
].num_loc_offsets
; j
++)
2379 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
2380 /* DWARF sections under Mach-O have non-zero addresses. */
2381 offset
= debug_information
[i
].loc_offsets
[j
] - section
->address
;
2382 next
= section_begin
+ offset
;
2383 base_address
= debug_information
[i
].base_address
;
2385 if (!seen_first_offset
)
2386 seen_first_offset
= 1;
2390 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
2391 (long)(start
- section_begin
), (long)(next
- section_begin
));
2392 else if (start
> next
)
2393 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
2394 (long)(start
- section_begin
), (long)(next
- section_begin
));
2398 if (offset
>= bytes
)
2400 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
2407 if (start
+ 2 * pointer_size
> section_end
)
2409 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
2414 begin
= byte_get (start
, pointer_size
);
2415 start
+= pointer_size
;
2416 end
= byte_get (start
, pointer_size
);
2417 start
+= pointer_size
;
2419 if (begin
== 0 && end
== 0)
2421 printf (_(" %8.8lx <End of list>\n"), offset
);
2425 /* Check base address specifiers. */
2426 if (begin
== -1UL && end
!= -1UL)
2429 printf (_(" %8.8lx %8.8lx %8.8lx (base address)\n"),
2430 offset
, begin
, end
);
2434 if (start
+ 2 > section_end
)
2436 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
2441 length
= byte_get (start
, 2);
2444 if (start
+ length
> section_end
)
2446 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
2451 printf (" %8.8lx %8.8lx %8.8lx (",
2452 offset
, begin
+ base_address
, end
+ base_address
);
2453 need_frame_base
= decode_location_expression (start
,
2459 if (need_frame_base
&& !has_frame_base
)
2460 printf (_(" [without DW_AT_frame_base]"));
2463 fputs (_(" (start == end)"), stdout
);
2464 else if (begin
> end
)
2465 fputs (_(" (start > end)"), stdout
);
2477 display_debug_str (struct dwarf_section
*section
,
2478 void *file ATTRIBUTE_UNUSED
)
2480 unsigned char *start
= section
->start
;
2481 unsigned long bytes
= section
->size
;
2482 dwarf_vma addr
= section
->address
;
2486 printf (_("\nThe %s section is empty.\n"), section
->name
);
2490 printf (_("Contents of the %s section:\n\n"), section
->name
);
2498 lbytes
= (bytes
> 16 ? 16 : bytes
);
2500 printf (" 0x%8.8lx ", (unsigned long) addr
);
2502 for (j
= 0; j
< 16; j
++)
2505 printf ("%2.2x", start
[j
]);
2513 for (j
= 0; j
< lbytes
; j
++)
2516 if (k
>= ' ' && k
< 0x80)
2535 display_debug_info (struct dwarf_section
*section
, void *file
)
2537 return process_debug_info (section
, file
, 0);
2542 display_debug_aranges (struct dwarf_section
*section
,
2543 void *file ATTRIBUTE_UNUSED
)
2545 unsigned char *start
= section
->start
;
2546 unsigned char *end
= start
+ section
->size
;
2548 printf (_("The section %s contains:\n\n"), section
->name
);
2552 unsigned char *hdrptr
;
2553 DWARF2_Internal_ARange arange
;
2554 unsigned char *ranges
;
2555 unsigned long length
;
2556 unsigned long address
;
2557 unsigned char address_size
;
2560 int initial_length_size
;
2564 arange
.ar_length
= byte_get (hdrptr
, 4);
2567 if (arange
.ar_length
== 0xffffffff)
2569 arange
.ar_length
= byte_get (hdrptr
, 8);
2572 initial_length_size
= 12;
2577 initial_length_size
= 4;
2580 arange
.ar_version
= byte_get (hdrptr
, 2);
2583 arange
.ar_info_offset
= byte_get (hdrptr
, offset_size
);
2584 hdrptr
+= offset_size
;
2586 arange
.ar_pointer_size
= byte_get (hdrptr
, 1);
2589 arange
.ar_segment_size
= byte_get (hdrptr
, 1);
2592 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
2594 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
2598 printf (_(" Length: %ld\n"), arange
.ar_length
);
2599 printf (_(" Version: %d\n"), arange
.ar_version
);
2600 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
2601 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
2602 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
2604 address_size
= arange
.ar_pointer_size
+ arange
.ar_segment_size
;
2606 /* The DWARF spec does not require that the address size be a power
2607 of two, but we do. This will have to change if we ever encounter
2608 an uneven architecture. */
2609 if ((address_size
& (address_size
- 1)) != 0)
2611 warn (_("Pointer size + Segment size is not a power of two.\n"));
2615 if (address_size
> 4)
2616 printf (_("\n Address Length\n"));
2618 printf (_("\n Address Length\n"));
2622 /* Must pad to an alignment boundary that is twice the address size. */
2623 excess
= (hdrptr
- start
) % (2 * address_size
);
2625 ranges
+= (2 * address_size
) - excess
;
2627 start
+= arange
.ar_length
+ initial_length_size
;
2629 while (ranges
+ 2 * address_size
<= start
)
2631 address
= byte_get (ranges
, address_size
);
2633 ranges
+= address_size
;
2635 length
= byte_get (ranges
, address_size
);
2637 ranges
+= address_size
;
2639 if (address_size
> 4)
2640 printf (" 0x%16.16lx 0x%lx\n", address
, length
);
2642 printf (" 0x%8.8lx 0x%lx\n", address
, length
);
2652 display_debug_ranges (struct dwarf_section
*section
,
2653 void *file ATTRIBUTE_UNUSED
)
2655 unsigned char *start
= section
->start
;
2656 unsigned char *section_end
;
2657 unsigned long bytes
;
2658 unsigned char *section_begin
= start
;
2659 unsigned int num_range_list
= 0;
2660 unsigned long last_offset
= 0;
2661 unsigned int first
= 0;
2664 int seen_first_offset
= 0;
2665 int use_debug_info
= 1;
2666 unsigned char *next
;
2668 bytes
= section
->size
;
2669 section_end
= start
+ bytes
;
2673 printf (_("\nThe %s section is empty.\n"), section
->name
);
2677 load_debug_info (file
);
2679 /* Check the order of range list in .debug_info section. If
2680 offsets of range lists are in the ascending order, we can
2681 use `debug_information' directly. */
2682 for (i
= 0; i
< num_debug_info_entries
; i
++)
2686 num
= debug_information
[i
].num_range_lists
;
2687 num_range_list
+= num
;
2689 /* Check if we can use `debug_information' directly. */
2690 if (use_debug_info
&& num
!= 0)
2692 if (!seen_first_offset
)
2694 /* This is the first range list. */
2695 last_offset
= debug_information
[i
].range_lists
[0];
2697 seen_first_offset
= 1;
2703 for (; j
< num
; j
++)
2706 debug_information
[i
].range_lists
[j
])
2711 last_offset
= debug_information
[i
].range_lists
[j
];
2716 if (!use_debug_info
)
2717 /* FIXME: Should we handle this case? */
2718 error (_("Range lists in .debug_info section aren't in ascending order!\n"));
2720 if (!seen_first_offset
)
2721 error (_("No range lists in .debug_info section!\n"));
2723 /* DWARF sections under Mach-O have non-zero addresses. */
2724 if (debug_information
[first
].num_range_lists
> 0
2725 && debug_information
[first
].range_lists
[0] != section
->address
)
2726 warn (_("Range lists in %s section start at 0x%lx\n"),
2727 section
->name
, debug_information
[first
].range_lists
[0]);
2729 printf (_("Contents of the %s section:\n\n"), section
->name
);
2730 printf (_(" Offset Begin End\n"));
2732 seen_first_offset
= 0;
2733 for (i
= first
; i
< num_debug_info_entries
; i
++)
2735 unsigned long begin
;
2737 unsigned long offset
;
2738 unsigned int pointer_size
;
2739 unsigned long base_address
;
2741 pointer_size
= debug_information
[i
].pointer_size
;
2743 for (j
= 0; j
< debug_information
[i
].num_range_lists
; j
++)
2745 /* DWARF sections under Mach-O have non-zero addresses. */
2746 offset
= debug_information
[i
].range_lists
[j
] - section
->address
;
2747 next
= section_begin
+ offset
;
2748 base_address
= debug_information
[i
].base_address
;
2750 if (!seen_first_offset
)
2751 seen_first_offset
= 1;
2755 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
2756 (long)(start
- section_begin
),
2757 (long)(next
- section_begin
), section
->name
);
2758 else if (start
> next
)
2759 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
2760 (long)(start
- section_begin
),
2761 (long)(next
- section_begin
), section
->name
);
2767 begin
= byte_get (start
, pointer_size
);
2768 start
+= pointer_size
;
2769 end
= byte_get (start
, pointer_size
);
2770 start
+= pointer_size
;
2772 if (begin
== 0 && end
== 0)
2774 printf (_(" %8.8lx <End of list>\n"), offset
);
2778 /* Check base address specifiers. */
2779 if (begin
== -1UL && end
!= -1UL)
2782 printf (" %8.8lx %8.8lx %8.8lx (base address)\n",
2783 offset
, begin
, end
);
2787 printf (" %8.8lx %8.8lx %8.8lx",
2788 offset
, begin
+ base_address
, end
+ base_address
);
2791 fputs (_(" (start == end)"), stdout
);
2792 else if (begin
> end
)
2793 fputs (_(" (start > end)"), stdout
);
2803 typedef struct Frame_Chunk
2805 struct Frame_Chunk
*next
;
2806 unsigned char *chunk_start
;
2808 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
2809 short int *col_type
;
2812 unsigned int code_factor
;
2814 unsigned long pc_begin
;
2815 unsigned long pc_range
;
2819 unsigned char fde_encoding
;
2820 unsigned char cfa_exp
;
2824 /* A marker for a col_type that means this column was never referenced
2825 in the frame info. */
2826 #define DW_CFA_unreferenced (-1)
2829 frame_need_space (Frame_Chunk
*fc
, int reg
)
2831 int prev
= fc
->ncols
;
2833 if (reg
< fc
->ncols
)
2836 fc
->ncols
= reg
+ 1;
2837 fc
->col_type
= xcrealloc (fc
->col_type
, fc
->ncols
, sizeof (short int));
2838 fc
->col_offset
= xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
2840 while (prev
< fc
->ncols
)
2842 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
2843 fc
->col_offset
[prev
] = 0;
2849 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, int *max_regs
)
2854 if (*max_regs
< fc
->ncols
)
2855 *max_regs
= fc
->ncols
;
2857 if (*need_col_headers
)
2859 *need_col_headers
= 0;
2861 printf (" LOC CFA ");
2863 for (r
= 0; r
< *max_regs
; r
++)
2864 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
2869 printf ("r%-4d", r
);
2875 printf ("%08lx ", fc
->pc_begin
);
2877 strcpy (tmp
, "exp");
2879 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
2880 printf ("%-8s ", tmp
);
2882 for (r
= 0; r
< fc
->ncols
; r
++)
2884 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
2886 switch (fc
->col_type
[r
])
2888 case DW_CFA_undefined
:
2891 case DW_CFA_same_value
:
2895 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
2897 case DW_CFA_val_offset
:
2898 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
2900 case DW_CFA_register
:
2901 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
2903 case DW_CFA_expression
:
2904 strcpy (tmp
, "exp");
2906 case DW_CFA_val_expression
:
2907 strcpy (tmp
, "vexp");
2910 strcpy (tmp
, "n/a");
2913 printf ("%-5s", tmp
);
2920 size_of_encoded_value (int encoding
)
2922 switch (encoding
& 0x7)
2925 case 0: return eh_addr_size
;
2933 get_encoded_value (unsigned char *data
, int encoding
)
2935 int size
= size_of_encoded_value (encoding
);
2937 if (encoding
& DW_EH_PE_signed
)
2938 return byte_get_signed (data
, size
);
2940 return byte_get (data
, size
);
2943 #define GET(N) byte_get (start, N); start += N
2944 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
2945 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
2948 display_debug_frames (struct dwarf_section
*section
,
2949 void *file ATTRIBUTE_UNUSED
)
2951 unsigned char *start
= section
->start
;
2952 unsigned char *end
= start
+ section
->size
;
2953 unsigned char *section_start
= start
;
2954 Frame_Chunk
*chunks
= 0;
2955 Frame_Chunk
*remembered_state
= 0;
2957 int is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
2958 unsigned int length_return
;
2961 printf (_("The section %s contains:\n"), section
->name
);
2965 unsigned char *saved_start
;
2966 unsigned char *block_end
;
2967 unsigned long length
;
2968 unsigned long cie_id
;
2971 int need_col_headers
= 1;
2972 unsigned char *augmentation_data
= NULL
;
2973 unsigned long augmentation_data_len
= 0;
2974 int encoded_ptr_size
= eh_addr_size
;
2976 int initial_length_size
;
2978 saved_start
= start
;
2979 length
= byte_get (start
, 4); start
+= 4;
2983 printf ("\n%08lx ZERO terminator\n\n",
2984 (unsigned long)(saved_start
- section_start
));
2988 if (length
== 0xffffffff)
2990 length
= byte_get (start
, 8);
2993 initial_length_size
= 12;
2998 initial_length_size
= 4;
3001 block_end
= saved_start
+ length
+ initial_length_size
;
3002 if (block_end
> end
)
3004 warn ("Invalid length %#08lx in FDE at %#08lx\n",
3005 length
, (unsigned long)(saved_start
- section_start
));
3008 cie_id
= byte_get (start
, offset_size
); start
+= offset_size
;
3010 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
3014 fc
= xmalloc (sizeof (Frame_Chunk
));
3015 memset (fc
, 0, sizeof (Frame_Chunk
));
3019 fc
->chunk_start
= saved_start
;
3021 fc
->col_type
= xmalloc (sizeof (short int));
3022 fc
->col_offset
= xmalloc (sizeof (int));
3023 frame_need_space (fc
, max_regs
-1);
3027 fc
->augmentation
= (char *) start
;
3028 start
= (unsigned char *) strchr ((char *) start
, '\0') + 1;
3030 if (fc
->augmentation
[0] == 'z')
3032 fc
->code_factor
= LEB ();
3033 fc
->data_factor
= SLEB ();
3042 augmentation_data_len
= LEB ();
3043 augmentation_data
= start
;
3044 start
+= augmentation_data_len
;
3046 else if (strcmp (fc
->augmentation
, "eh") == 0)
3048 start
+= eh_addr_size
;
3049 fc
->code_factor
= LEB ();
3050 fc
->data_factor
= SLEB ();
3062 fc
->code_factor
= LEB ();
3063 fc
->data_factor
= SLEB ();
3075 if (do_debug_frames_interp
)
3076 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
3077 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
3078 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
3082 printf ("\n%08lx %08lx %08lx CIE\n",
3083 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
3084 printf (" Version: %d\n", version
);
3085 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
3086 printf (" Code alignment factor: %u\n", fc
->code_factor
);
3087 printf (" Data alignment factor: %d\n", fc
->data_factor
);
3088 printf (" Return address column: %d\n", fc
->ra
);
3090 if (augmentation_data_len
)
3093 printf (" Augmentation data: ");
3094 for (i
= 0; i
< augmentation_data_len
; ++i
)
3095 printf (" %02x", augmentation_data
[i
]);
3101 if (augmentation_data_len
)
3103 unsigned char *p
, *q
;
3104 p
= (unsigned char *) fc
->augmentation
+ 1;
3105 q
= augmentation_data
;
3112 q
+= 1 + size_of_encoded_value (*q
);
3114 fc
->fde_encoding
= *q
++;
3120 if (fc
->fde_encoding
)
3121 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
3124 frame_need_space (fc
, fc
->ra
);
3128 unsigned char *look_for
;
3129 static Frame_Chunk fde_fc
;
3132 memset (fc
, 0, sizeof (Frame_Chunk
));
3134 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
3136 for (cie
= chunks
; cie
; cie
= cie
->next
)
3137 if (cie
->chunk_start
== look_for
)
3142 warn ("Invalid CIE pointer %#08lx in FDE at %#08lx\n",
3143 cie_id
, (unsigned long)(saved_start
- section_start
));
3145 fc
->col_type
= xmalloc (sizeof (short int));
3146 fc
->col_offset
= xmalloc (sizeof (int));
3147 frame_need_space (fc
, max_regs
- 1);
3149 fc
->augmentation
= "";
3150 fc
->fde_encoding
= 0;
3154 fc
->ncols
= cie
->ncols
;
3155 fc
->col_type
= xcmalloc (fc
->ncols
, sizeof (short int));
3156 fc
->col_offset
= xcmalloc (fc
->ncols
, sizeof (int));
3157 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
3158 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
3159 fc
->augmentation
= cie
->augmentation
;
3160 fc
->code_factor
= cie
->code_factor
;
3161 fc
->data_factor
= cie
->data_factor
;
3162 fc
->cfa_reg
= cie
->cfa_reg
;
3163 fc
->cfa_offset
= cie
->cfa_offset
;
3165 frame_need_space (fc
, max_regs
-1);
3166 fc
->fde_encoding
= cie
->fde_encoding
;
3169 if (fc
->fde_encoding
)
3170 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
3172 fc
->pc_begin
= get_encoded_value (start
, fc
->fde_encoding
);
3173 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
3174 /* Don't adjust for relocatable file since there's
3175 invariably a pcrel reloc here, which we haven't
3178 fc
->pc_begin
+= section
->address
+ (start
- section_start
);
3179 start
+= encoded_ptr_size
;
3180 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
3181 start
+= encoded_ptr_size
;
3183 if (cie
->augmentation
[0] == 'z')
3185 augmentation_data_len
= LEB ();
3186 augmentation_data
= start
;
3187 start
+= augmentation_data_len
;
3190 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
3191 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
3192 (unsigned long)(cie
->chunk_start
- section_start
),
3193 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
3194 if (! do_debug_frames_interp
&& augmentation_data_len
)
3198 printf (" Augmentation data: ");
3199 for (i
= 0; i
< augmentation_data_len
; ++i
)
3200 printf (" %02x", augmentation_data
[i
]);
3206 /* At this point, fc is the current chunk, cie (if any) is set, and
3207 we're about to interpret instructions for the chunk. */
3208 /* ??? At present we need to do this always, since this sizes the
3209 fc->col_type and fc->col_offset arrays, which we write into always.
3210 We should probably split the interpreted and non-interpreted bits
3211 into two different routines, since there's so much that doesn't
3212 really overlap between them. */
3213 if (1 || do_debug_frames_interp
)
3215 /* Start by making a pass over the chunk, allocating storage
3216 and taking note of what registers are used. */
3217 unsigned char *tmp
= start
;
3219 while (start
< block_end
)
3222 unsigned long reg
, tmp
;
3229 /* Warning: if you add any more cases to this switch, be
3230 sure to add them to the corresponding switch below. */
3233 case DW_CFA_advance_loc
:
3237 frame_need_space (fc
, opa
);
3238 fc
->col_type
[opa
] = DW_CFA_undefined
;
3240 case DW_CFA_restore
:
3241 frame_need_space (fc
, opa
);
3242 fc
->col_type
[opa
] = DW_CFA_undefined
;
3244 case DW_CFA_set_loc
:
3245 start
+= encoded_ptr_size
;
3247 case DW_CFA_advance_loc1
:
3250 case DW_CFA_advance_loc2
:
3253 case DW_CFA_advance_loc4
:
3256 case DW_CFA_offset_extended
:
3257 case DW_CFA_val_offset
:
3258 reg
= LEB (); LEB ();
3259 frame_need_space (fc
, reg
);
3260 fc
->col_type
[reg
] = DW_CFA_undefined
;
3262 case DW_CFA_restore_extended
:
3264 frame_need_space (fc
, reg
);
3265 fc
->col_type
[reg
] = DW_CFA_undefined
;
3267 case DW_CFA_undefined
:
3269 frame_need_space (fc
, reg
);
3270 fc
->col_type
[reg
] = DW_CFA_undefined
;
3272 case DW_CFA_same_value
:
3274 frame_need_space (fc
, reg
);
3275 fc
->col_type
[reg
] = DW_CFA_undefined
;
3277 case DW_CFA_register
:
3278 reg
= LEB (); LEB ();
3279 frame_need_space (fc
, reg
);
3280 fc
->col_type
[reg
] = DW_CFA_undefined
;
3282 case DW_CFA_def_cfa
:
3285 case DW_CFA_def_cfa_register
:
3288 case DW_CFA_def_cfa_offset
:
3291 case DW_CFA_def_cfa_expression
:
3295 case DW_CFA_expression
:
3296 case DW_CFA_val_expression
:
3300 frame_need_space (fc
, reg
);
3301 fc
->col_type
[reg
] = DW_CFA_undefined
;
3303 case DW_CFA_offset_extended_sf
:
3304 case DW_CFA_val_offset_sf
:
3305 reg
= LEB (); SLEB ();
3306 frame_need_space (fc
, reg
);
3307 fc
->col_type
[reg
] = DW_CFA_undefined
;
3309 case DW_CFA_def_cfa_sf
:
3312 case DW_CFA_def_cfa_offset_sf
:
3315 case DW_CFA_MIPS_advance_loc8
:
3318 case DW_CFA_GNU_args_size
:
3321 case DW_CFA_GNU_negative_offset_extended
:
3322 reg
= LEB (); LEB ();
3323 frame_need_space (fc
, reg
);
3324 fc
->col_type
[reg
] = DW_CFA_undefined
;
3333 /* Now we know what registers are used, make a second pass over
3334 the chunk, this time actually printing out the info. */
3336 while (start
< block_end
)
3339 unsigned long ul
, reg
, roffs
;
3348 /* Warning: if you add any more cases to this switch, be
3349 sure to add them to the corresponding switch above. */
3352 case DW_CFA_advance_loc
:
3353 if (do_debug_frames_interp
)
3354 frame_display_row (fc
, &need_col_headers
, &max_regs
);
3356 printf (" DW_CFA_advance_loc: %d to %08lx\n",
3357 opa
* fc
->code_factor
,
3358 fc
->pc_begin
+ opa
* fc
->code_factor
);
3359 fc
->pc_begin
+= opa
* fc
->code_factor
;
3364 if (! do_debug_frames_interp
)
3365 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
3366 opa
, roffs
* fc
->data_factor
);
3367 fc
->col_type
[opa
] = DW_CFA_offset
;
3368 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
3371 case DW_CFA_restore
:
3372 if (! do_debug_frames_interp
)
3373 printf (" DW_CFA_restore: r%d\n", opa
);
3374 fc
->col_type
[opa
] = cie
->col_type
[opa
];
3375 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
3378 case DW_CFA_set_loc
:
3379 vma
= get_encoded_value (start
, fc
->fde_encoding
);
3380 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
3382 vma
+= section
->address
+ (start
- section_start
);
3383 start
+= encoded_ptr_size
;
3384 if (do_debug_frames_interp
)
3385 frame_display_row (fc
, &need_col_headers
, &max_regs
);
3387 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
3391 case DW_CFA_advance_loc1
:
3392 ofs
= byte_get (start
, 1); start
+= 1;
3393 if (do_debug_frames_interp
)
3394 frame_display_row (fc
, &need_col_headers
, &max_regs
);
3396 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
3397 ofs
* fc
->code_factor
,
3398 fc
->pc_begin
+ ofs
* fc
->code_factor
);
3399 fc
->pc_begin
+= ofs
* fc
->code_factor
;
3402 case DW_CFA_advance_loc2
:
3403 ofs
= byte_get (start
, 2); start
+= 2;
3404 if (do_debug_frames_interp
)
3405 frame_display_row (fc
, &need_col_headers
, &max_regs
);
3407 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
3408 ofs
* fc
->code_factor
,
3409 fc
->pc_begin
+ ofs
* fc
->code_factor
);
3410 fc
->pc_begin
+= ofs
* fc
->code_factor
;
3413 case DW_CFA_advance_loc4
:
3414 ofs
= byte_get (start
, 4); start
+= 4;
3415 if (do_debug_frames_interp
)
3416 frame_display_row (fc
, &need_col_headers
, &max_regs
);
3418 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
3419 ofs
* fc
->code_factor
,
3420 fc
->pc_begin
+ ofs
* fc
->code_factor
);
3421 fc
->pc_begin
+= ofs
* fc
->code_factor
;
3424 case DW_CFA_offset_extended
:
3427 if (! do_debug_frames_interp
)
3428 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
3429 reg
, roffs
* fc
->data_factor
);
3430 fc
->col_type
[reg
] = DW_CFA_offset
;
3431 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
3434 case DW_CFA_val_offset
:
3437 if (! do_debug_frames_interp
)
3438 printf (" DW_CFA_val_offset: r%ld at cfa%+ld\n",
3439 reg
, roffs
* fc
->data_factor
);
3440 fc
->col_type
[reg
] = DW_CFA_val_offset
;
3441 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
3444 case DW_CFA_restore_extended
:
3446 if (! do_debug_frames_interp
)
3447 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
3448 fc
->col_type
[reg
] = cie
->col_type
[reg
];
3449 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
3452 case DW_CFA_undefined
:
3454 if (! do_debug_frames_interp
)
3455 printf (" DW_CFA_undefined: r%ld\n", reg
);
3456 fc
->col_type
[reg
] = DW_CFA_undefined
;
3457 fc
->col_offset
[reg
] = 0;
3460 case DW_CFA_same_value
:
3462 if (! do_debug_frames_interp
)
3463 printf (" DW_CFA_same_value: r%ld\n", reg
);
3464 fc
->col_type
[reg
] = DW_CFA_same_value
;
3465 fc
->col_offset
[reg
] = 0;
3468 case DW_CFA_register
:
3471 if (! do_debug_frames_interp
)
3472 printf (" DW_CFA_register: r%ld in r%ld\n", reg
, roffs
);
3473 fc
->col_type
[reg
] = DW_CFA_register
;
3474 fc
->col_offset
[reg
] = roffs
;
3477 case DW_CFA_remember_state
:
3478 if (! do_debug_frames_interp
)
3479 printf (" DW_CFA_remember_state\n");
3480 rs
= xmalloc (sizeof (Frame_Chunk
));
3481 rs
->ncols
= fc
->ncols
;
3482 rs
->col_type
= xcmalloc (rs
->ncols
, sizeof (short int));
3483 rs
->col_offset
= xcmalloc (rs
->ncols
, sizeof (int));
3484 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
3485 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
3486 rs
->next
= remembered_state
;
3487 remembered_state
= rs
;
3490 case DW_CFA_restore_state
:
3491 if (! do_debug_frames_interp
)
3492 printf (" DW_CFA_restore_state\n");
3493 rs
= remembered_state
;
3496 remembered_state
= rs
->next
;
3497 frame_need_space (fc
, rs
->ncols
-1);
3498 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
3499 memcpy (fc
->col_offset
, rs
->col_offset
,
3500 rs
->ncols
* sizeof (int));
3501 free (rs
->col_type
);
3502 free (rs
->col_offset
);
3505 else if (do_debug_frames_interp
)
3506 printf ("Mismatched DW_CFA_restore_state\n");
3509 case DW_CFA_def_cfa
:
3510 fc
->cfa_reg
= LEB ();
3511 fc
->cfa_offset
= LEB ();
3513 if (! do_debug_frames_interp
)
3514 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
3515 fc
->cfa_reg
, fc
->cfa_offset
);
3518 case DW_CFA_def_cfa_register
:
3519 fc
->cfa_reg
= LEB ();
3521 if (! do_debug_frames_interp
)
3522 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
3525 case DW_CFA_def_cfa_offset
:
3526 fc
->cfa_offset
= LEB ();
3527 if (! do_debug_frames_interp
)
3528 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
3532 if (! do_debug_frames_interp
)
3533 printf (" DW_CFA_nop\n");
3536 case DW_CFA_def_cfa_expression
:
3538 if (! do_debug_frames_interp
)
3540 printf (" DW_CFA_def_cfa_expression (");
3541 decode_location_expression (start
, eh_addr_size
, ul
, 0);
3548 case DW_CFA_expression
:
3551 if (! do_debug_frames_interp
)
3553 printf (" DW_CFA_expression: r%ld (", reg
);
3554 decode_location_expression (start
, eh_addr_size
, ul
, 0);
3557 fc
->col_type
[reg
] = DW_CFA_expression
;
3561 case DW_CFA_val_expression
:
3564 if (! do_debug_frames_interp
)
3566 printf (" DW_CFA_val_expression: r%ld (", reg
);
3567 decode_location_expression (start
, eh_addr_size
, ul
, 0);
3570 fc
->col_type
[reg
] = DW_CFA_val_expression
;
3574 case DW_CFA_offset_extended_sf
:
3577 frame_need_space (fc
, reg
);
3578 if (! do_debug_frames_interp
)
3579 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
3580 reg
, l
* fc
->data_factor
);
3581 fc
->col_type
[reg
] = DW_CFA_offset
;
3582 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
3585 case DW_CFA_val_offset_sf
:
3588 frame_need_space (fc
, reg
);
3589 if (! do_debug_frames_interp
)
3590 printf (" DW_CFA_val_offset_sf: r%ld at cfa%+ld\n",
3591 reg
, l
* fc
->data_factor
);
3592 fc
->col_type
[reg
] = DW_CFA_val_offset
;
3593 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
3596 case DW_CFA_def_cfa_sf
:
3597 fc
->cfa_reg
= LEB ();
3598 fc
->cfa_offset
= SLEB ();
3599 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
3601 if (! do_debug_frames_interp
)
3602 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
3603 fc
->cfa_reg
, fc
->cfa_offset
);
3606 case DW_CFA_def_cfa_offset_sf
:
3607 fc
->cfa_offset
= SLEB ();
3608 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
3609 if (! do_debug_frames_interp
)
3610 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
3613 case DW_CFA_MIPS_advance_loc8
:
3614 ofs
= byte_get (start
, 8); start
+= 8;
3615 if (do_debug_frames_interp
)
3616 frame_display_row (fc
, &need_col_headers
, &max_regs
);
3618 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
3619 ofs
* fc
->code_factor
,
3620 fc
->pc_begin
+ ofs
* fc
->code_factor
);
3621 fc
->pc_begin
+= ofs
* fc
->code_factor
;
3624 case DW_CFA_GNU_window_save
:
3625 if (! do_debug_frames_interp
)
3626 printf (" DW_CFA_GNU_window_save\n");
3629 case DW_CFA_GNU_args_size
:
3631 if (! do_debug_frames_interp
)
3632 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
3635 case DW_CFA_GNU_negative_offset_extended
:
3638 frame_need_space (fc
, reg
);
3639 if (! do_debug_frames_interp
)
3640 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
3641 reg
, l
* fc
->data_factor
);
3642 fc
->col_type
[reg
] = DW_CFA_offset
;
3643 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
3647 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
3648 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
3650 warn (_("unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
3655 if (do_debug_frames_interp
)
3656 frame_display_row (fc
, &need_col_headers
, &max_regs
);
3671 display_debug_not_supported (struct dwarf_section
*section
,
3672 void *file ATTRIBUTE_UNUSED
)
3674 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
3681 cmalloc (size_t nmemb
, size_t size
)
3683 /* Check for overflow. */
3684 if (nmemb
>= ~(size_t) 0 / size
)
3687 return malloc (nmemb
* size
);
3691 xcmalloc (size_t nmemb
, size_t size
)
3693 /* Check for overflow. */
3694 if (nmemb
>= ~(size_t) 0 / size
)
3697 return xmalloc (nmemb
* size
);
3701 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
3703 /* Check for overflow. */
3704 if (nmemb
>= ~(size_t) 0 / size
)
3707 return xrealloc (ptr
, nmemb
* size
);
3711 error (const char *message
, ...)
3715 va_start (args
, message
);
3716 fprintf (stderr
, _("%s: Error: "), program_name
);
3717 vfprintf (stderr
, message
, args
);
3722 warn (const char *message
, ...)
3726 va_start (args
, message
);
3727 fprintf (stderr
, _("%s: Warning: "), program_name
);
3728 vfprintf (stderr
, message
, args
);
3733 free_debug_memory (void)
3735 enum dwarf_section_display_enum i
;
3739 for (i
= 0; i
< max
; i
++)
3740 free_debug_section (i
);
3742 if (debug_information
)
3744 for (i
= 0; i
< num_debug_info_entries
; i
++)
3746 if (!debug_information
[i
].max_loc_offsets
)
3748 free (debug_information
[i
].loc_offsets
);
3749 free (debug_information
[i
].have_frame_base
);
3751 if (!debug_information
[i
].max_range_lists
)
3752 free (debug_information
[i
].range_lists
);
3754 free (debug_information
);
3755 debug_information
= NULL
;
3756 num_debug_info_entries
= 0;
3761 struct dwarf_section_display debug_displays
[] =
3763 { { ".debug_abbrev", NULL
, 0, 0 },
3764 display_debug_abbrev
, 0, 0 },
3765 { { ".debug_aranges", NULL
, 0, 0 },
3766 display_debug_aranges
, 0, 0 },
3767 { { ".debug_frame", NULL
, 0, 0 },
3768 display_debug_frames
, 1, 0 },
3769 { { ".debug_info", NULL
, 0, 0 },
3770 display_debug_info
, 1, 0 },
3771 { { ".debug_line", NULL
, 0, 0 },
3772 display_debug_lines
, 0, 0 },
3773 { { ".debug_pubnames", NULL
, 0, 0 },
3774 display_debug_pubnames
, 0, 0 },
3775 { { ".eh_frame", NULL
, 0, 0 },
3776 display_debug_frames
, 1, 1 },
3777 { { ".debug_macinfo", NULL
, 0, 0 },
3778 display_debug_macinfo
, 0, 0 },
3779 { { ".debug_str", NULL
, 0, 0 },
3780 display_debug_str
, 0, 0 },
3781 { { ".debug_loc", NULL
, 0, 0 },
3782 display_debug_loc
, 0, 0 },
3783 { { ".debug_pubtypes", NULL
, 0, 0 },
3784 display_debug_pubnames
, 0, 0 },
3785 { { ".debug_ranges", NULL
, 0, 0 },
3786 display_debug_ranges
, 0, 0 },
3787 { { ".debug_static_func", NULL
, 0, 0 },
3788 display_debug_not_supported
, 0, 0 },
3789 { { ".debug_static_vars", NULL
, 0, 0 },
3790 display_debug_not_supported
, 0, 0 },
3791 { { ".debug_types", NULL
, 0, 0 },
3792 display_debug_not_supported
, 0, 0 },
3793 { { ".debug_weaknames", NULL
, 0, 0 },
3794 display_debug_not_supported
, 0, 0 }