2 * dwarfwriter.c: Creation of DWARF debug information
5 * Zoltan Varga (vargaz@gmail.com)
7 * (C) 2008-2009 Novell, Inc.
12 #if !defined(DISABLE_AOT) && !defined(DISABLE_JIT)
13 #include "dwarfwriter.h"
15 #include <sys/types.h>
22 #include <mono/metadata/mono-endian.h>
23 #include <mono/metadata/debug-mono-symfile.h>
24 #include <mono/utils/mono-compiler.h>
27 #include <mono/utils/freebsd-elf32.h>
28 #include <mono/utils/freebsd-elf64.h>
31 #include <mono/utils/freebsd-dwarf.h>
33 struct _MonoDwarfWriter
36 GHashTable
*class_to_die
, *class_to_vtype_die
, *class_to_pointer_die
;
37 GHashTable
*class_to_reference_die
;
38 int fde_index
, tdie_index
, line_number_file_index
, line_number_dir_index
;
39 GHashTable
*file_to_index
, *dir_to_index
;
41 int il_file_line_index
, loclist_index
;
44 const char *temp_prefix
;
45 gboolean emit_line
, appending
;
49 * mono_dwarf_writer_create:
51 * Create a DWARF writer object. WRITER is the underlying image writer this
52 * writer will emit to. IL_FILE is the file where IL code will be dumped to for
53 * methods which have no line number info. It can be NULL.
54 * If APPENDING is TRUE, the output file will be in assembleable state after each
55 * call to the _emit_ functions. This is used for XDEBUG. If APPENDING is FALSE,
56 * a separate mono_dwarf_writer_close () call is needed to finish the emission of
60 mono_dwarf_writer_create (MonoImageWriter
*writer
, FILE *il_file
, int il_file_start_line
, gboolean appending
)
62 MonoDwarfWriter
*w
= g_new0 (MonoDwarfWriter
, 1);
65 * The appending flag is needed because we use subsections to order things in
66 * the debug info, and:
67 * - apple's assembler doesn't support them
68 * - the binary writer has problems with subsections+alignment
69 * So instead of subsections, we use the _close () function in AOT mode,
70 * which writes out things in order.
75 w
->il_file_line_index
= il_file_start_line
;
76 w
->appending
= appending
;
79 g_assert (img_writer_subsections_supported (w
->w
));
81 w
->fp
= img_writer_get_fp (w
->w
);
82 w
->temp_prefix
= img_writer_get_temp_label_prefix (w
->w
);
84 w
->class_to_die
= g_hash_table_new (NULL
, NULL
);
85 w
->class_to_vtype_die
= g_hash_table_new (NULL
, NULL
);
86 w
->class_to_pointer_die
= g_hash_table_new (NULL
, NULL
);
87 w
->class_to_reference_die
= g_hash_table_new (NULL
, NULL
);
93 mono_dwarf_writer_destroy (MonoDwarfWriter
*w
)
99 mono_dwarf_writer_get_il_file_line_index (MonoDwarfWriter
*w
)
101 return w
->il_file_line_index
;
104 /* Wrappers around the image writer functions */
107 emit_section_change (MonoDwarfWriter
*w
, const char *section_name
, int subsection_index
)
109 img_writer_emit_section_change (w
->w
, section_name
, subsection_index
);
113 emit_push_section (MonoDwarfWriter
*w
, const char *section_name
, int subsection
)
115 img_writer_emit_push_section (w
->w
, section_name
, subsection
);
119 emit_pop_section (MonoDwarfWriter
*w
)
121 img_writer_emit_pop_section (w
->w
);
125 emit_local_symbol (MonoDwarfWriter
*w
, const char *name
, const char *end_label
, gboolean func
)
127 img_writer_emit_local_symbol (w
->w
, name
, end_label
, func
);
131 emit_label (MonoDwarfWriter
*w
, const char *name
)
133 img_writer_emit_label (w
->w
, name
);
137 emit_bytes (MonoDwarfWriter
*w
, const guint8
* buf
, int size
)
139 img_writer_emit_bytes (w
->w
, buf
, size
);
143 emit_string (MonoDwarfWriter
*w
, const char *value
)
145 img_writer_emit_string (w
->w
, value
);
149 emit_line (MonoDwarfWriter
*w
)
151 img_writer_emit_line (w
->w
);
155 emit_alignment (MonoDwarfWriter
*w
, int size
)
157 img_writer_emit_alignment (w
->w
, size
);
161 emit_pointer_unaligned (MonoDwarfWriter
*w
, const char *target
)
163 img_writer_emit_pointer_unaligned (w
->w
, target
);
167 emit_pointer (MonoDwarfWriter
*w
, const char *target
)
169 img_writer_emit_pointer (w
->w
, target
);
173 emit_int16 (MonoDwarfWriter
*w
, int value
)
175 img_writer_emit_int16 (w
->w
, value
);
179 emit_int32 (MonoDwarfWriter
*w
, int value
)
181 img_writer_emit_int32 (w
->w
, value
);
185 emit_symbol_diff (MonoDwarfWriter
*w
, const char *end
, const char* start
, int offset
)
187 img_writer_emit_symbol_diff (w
->w
, end
, start
, offset
);
191 emit_zero_bytes (MonoDwarfWriter
*w
, int num
)
193 img_writer_emit_zero_bytes (w
->w
, num
);
197 emit_byte (MonoDwarfWriter
*w
, guint8 val
)
199 img_writer_emit_byte (w
->w
, val
);
202 static G_GNUC_UNUSED
void
203 emit_uleb128 (MonoDwarfWriter
*w
, guint32 value
)
206 guint8 b
= value
& 0x7f;
208 if (value
!= 0) /* more bytes to come */
214 static G_GNUC_UNUSED
void
215 emit_sleb128 (MonoDwarfWriter
*w
, gint64 value
)
218 gboolean negative
= (value
< 0);
225 /* the following is unnecessary if the
226 * implementation of >>= uses an arithmetic rather
227 * than logical shift for a signed left operand
231 value
|= - ((gint64
)1 <<(size
- 7));
232 /* sign bit of byte is second high order bit (0x40) */
233 if ((value
== 0 && !(byte
& 0x40)) ||
234 (value
== -1 && (byte
& 0x40)))
242 static G_GNUC_UNUSED
void
243 encode_uleb128 (guint32 value
, guint8
*buf
, guint8
**endbuf
)
248 guint8 b
= value
& 0x7f;
250 if (value
!= 0) /* more bytes to come */
258 static G_GNUC_UNUSED
void
259 encode_sleb128 (gint32 value
, guint8
*buf
, guint8
**endbuf
)
262 gboolean negative
= (value
< 0);
270 /* the following is unnecessary if the
271 * implementation of >>= uses an arithmetic rather
272 * than logical shift for a signed left operand
276 value
|= - (1 <<(size
- 7));
277 /* sign bit of byte is second high order bit (0x40) */
278 if ((value
== 0 && !(byte
& 0x40)) ||
279 (value
== -1 && (byte
& 0x40)))
290 emit_dwarf_abbrev (MonoDwarfWriter
*w
, int code
, int tag
, gboolean has_child
,
291 int *attrs
, int attrs_len
)
295 emit_uleb128 (w
, code
);
296 emit_uleb128 (w
, tag
);
297 emit_byte (w
, has_child
);
299 for (i
= 0; i
< attrs_len
; i
++)
300 emit_uleb128 (w
, attrs
[i
]);
306 emit_cie (MonoDwarfWriter
*w
)
308 emit_section_change (w
, ".debug_frame", 0);
310 emit_alignment (w
, 8);
313 emit_symbol_diff (w
, ".Lcie0_end", ".Lcie0_start", 0); /* length */
314 emit_label (w
, ".Lcie0_start");
315 emit_int32 (w
, 0xffffffff); /* CIE id */
316 emit_byte (w
, 3); /* version */
317 emit_string (w
, ""); /* augmention */
318 emit_sleb128 (w
, 1); /* code alignment factor */
319 emit_sleb128 (w
, mono_unwind_get_dwarf_data_align ()); /* data alignment factor */
320 emit_uleb128 (w
, mono_unwind_get_dwarf_pc_reg ());
322 w
->cie_program
= w
->cie_program
;
323 if (w
->cie_program
) {
325 guint8
*uw_info
= mono_unwind_ops_encode (w
->cie_program
, &uw_info_len
);
326 emit_bytes (w
, uw_info
, uw_info_len
);
330 emit_alignment (w
, sizeof (gpointer
));
331 emit_label (w
, ".Lcie0_end");
335 emit_pointer_value (MonoDwarfWriter
*w
, gpointer ptr
)
337 gssize val
= (gssize
)ptr
;
338 emit_bytes (w
, (guint8
*)&val
, sizeof (gpointer
));
342 emit_fde (MonoDwarfWriter
*w
, int fde_index
, char *start_symbol
, char *end_symbol
,
343 guint8
*code
, guint32 code_size
, GSList
*unwind_ops
, gboolean use_cie
)
351 emit_section_change (w
, ".debug_frame", 0);
353 sprintf (symbol1
, ".Lfde%d_start", fde_index
);
354 sprintf (symbol2
, ".Lfde%d_end", fde_index
);
355 emit_symbol_diff (w
, symbol2
, symbol1
, 0); /* length */
356 emit_label (w
, symbol1
);
357 emit_int32 (w
, 0); /* CIE_pointer */
359 emit_pointer (w
, start_symbol
); /* initial_location */
361 emit_symbol_diff (w
, end_symbol
, start_symbol
, 0); /* address_range */
363 g_assert (code_size
);
364 emit_int32 (w
, code_size
);
367 emit_pointer_value (w
, code
);
368 emit_int32 (w
, code_size
);
370 #if SIZEOF_VOID_P == 8
371 /* Upper 32 bits of code size */
376 if (w
->cie_program
) {
377 // FIXME: Check that the ops really begin with the CIE program */
380 for (i
= 0; i
< g_slist_length (w
->cie_program
); ++i
)
385 /* Convert the list of MonoUnwindOps to the format used by DWARF */
386 uw_info
= mono_unwind_ops_encode (l
, &uw_info_len
);
387 emit_bytes (w
, uw_info
, uw_info_len
);
390 emit_alignment (w
, sizeof (mgreg_t
));
391 emit_label (w
, symbol2
);
395 #define ABBREV_COMPILE_UNIT 1
396 #define ABBREV_SUBPROGRAM 2
397 #define ABBREV_PARAM 3
398 #define ABBREV_BASE_TYPE 4
399 #define ABBREV_STRUCT_TYPE 5
400 #define ABBREV_DATA_MEMBER 6
401 #define ABBREV_TYPEDEF 7
402 #define ABBREV_ENUM_TYPE 8
403 #define ABBREV_ENUMERATOR 9
404 #define ABBREV_NAMESPACE 10
405 #define ABBREV_VARIABLE 11
406 #define ABBREV_VARIABLE_LOCLIST 12
407 #define ABBREV_POINTER_TYPE 13
408 #define ABBREV_REFERENCE_TYPE 14
409 #define ABBREV_PARAM_LOCLIST 15
410 #define ABBREV_INHERITANCE 16
411 #define ABBREV_STRUCT_TYPE_NOCHILDREN 17
413 static int compile_unit_attr
[] = {
414 DW_AT_producer
,DW_FORM_string
,
415 DW_AT_name
,DW_FORM_string
,
416 DW_AT_comp_dir
,DW_FORM_string
,
417 DW_AT_language
,DW_FORM_data1
,
418 DW_AT_low_pc
,DW_FORM_addr
,
419 DW_AT_high_pc
,DW_FORM_addr
,
420 DW_AT_stmt_list
,DW_FORM_data4
423 static int subprogram_attr
[] = {
424 DW_AT_name
, DW_FORM_string
,
425 DW_AT_low_pc
, DW_FORM_addr
,
426 DW_AT_high_pc
, DW_FORM_addr
,
427 DW_AT_frame_base
, DW_FORM_block1
430 static int param_attr
[] = {
431 DW_AT_name
, DW_FORM_string
,
432 DW_AT_type
, DW_FORM_ref4
,
433 DW_AT_location
, DW_FORM_block1
436 static int param_loclist_attr
[] = {
437 DW_AT_name
, DW_FORM_string
,
438 DW_AT_type
, DW_FORM_ref4
,
439 DW_AT_location
, DW_FORM_data4
442 static int base_type_attr
[] = {
443 DW_AT_byte_size
, DW_FORM_data1
,
444 DW_AT_encoding
, DW_FORM_data1
,
445 DW_AT_name
, DW_FORM_string
448 static int struct_type_attr
[] = {
449 DW_AT_name
, DW_FORM_string
,
450 DW_AT_byte_size
, DW_FORM_udata
,
453 static int data_member_attr
[] = {
454 DW_AT_name
, DW_FORM_string
,
455 DW_AT_type
, DW_FORM_ref4
,
456 DW_AT_data_member_location
, DW_FORM_block1
459 static int typedef_attr
[] = {
460 DW_AT_name
, DW_FORM_string
,
461 DW_AT_type
, DW_FORM_ref4
464 static int pointer_type_attr
[] = {
465 DW_AT_type
, DW_FORM_ref4
,
468 static int reference_type_attr
[] = {
469 DW_AT_type
, DW_FORM_ref4
,
472 static int enum_type_attr
[] = {
473 DW_AT_name
, DW_FORM_string
,
474 DW_AT_byte_size
, DW_FORM_udata
,
475 DW_AT_type
, DW_FORM_ref4
,
478 static int enumerator_attr
[] = {
479 DW_AT_name
, DW_FORM_string
,
480 DW_AT_const_value
, DW_FORM_sdata
,
483 static int namespace_attr
[] = {
484 DW_AT_name
, DW_FORM_string
,
487 static int variable_attr
[] = {
488 DW_AT_name
, DW_FORM_string
,
489 DW_AT_type
, DW_FORM_ref4
,
490 DW_AT_location
, DW_FORM_block1
493 static int variable_loclist_attr
[] = {
494 DW_AT_name
, DW_FORM_string
,
495 DW_AT_type
, DW_FORM_ref4
,
496 DW_AT_location
, DW_FORM_data4
499 static int inheritance_attr
[] = {
500 DW_AT_type
, DW_FORM_ref4
,
501 DW_AT_data_member_location
, DW_FORM_block1
504 typedef struct DwarfBasicType
{
505 const char *die_name
, *name
;
511 static DwarfBasicType basic_types
[] = {
512 { ".LDIE_I1", "sbyte", MONO_TYPE_I1
, 1, DW_ATE_signed
},
513 { ".LDIE_U1", "byte", MONO_TYPE_U1
, 1, DW_ATE_unsigned
},
514 { ".LDIE_I2", "short", MONO_TYPE_I2
, 2, DW_ATE_signed
},
515 { ".LDIE_U2", "ushort", MONO_TYPE_U2
, 2, DW_ATE_unsigned
},
516 { ".LDIE_I4", "int", MONO_TYPE_I4
, 4, DW_ATE_signed
},
517 { ".LDIE_U4", "uint", MONO_TYPE_U4
, 4, DW_ATE_unsigned
},
518 { ".LDIE_I8", "long", MONO_TYPE_I8
, 8, DW_ATE_signed
},
519 { ".LDIE_U8", "ulong", MONO_TYPE_U8
, 8, DW_ATE_unsigned
},
520 { ".LDIE_I", "intptr", MONO_TYPE_I
, SIZEOF_VOID_P
, DW_ATE_signed
},
521 { ".LDIE_U", "uintptr", MONO_TYPE_U
, SIZEOF_VOID_P
, DW_ATE_unsigned
},
522 { ".LDIE_R4", "float", MONO_TYPE_R4
, 4, DW_ATE_float
},
523 { ".LDIE_R8", "double", MONO_TYPE_R8
, 8, DW_ATE_float
},
524 { ".LDIE_BOOLEAN", "boolean", MONO_TYPE_BOOLEAN
, 1, DW_ATE_boolean
},
525 { ".LDIE_CHAR", "char", MONO_TYPE_CHAR
, 2, DW_ATE_unsigned_char
},
526 { ".LDIE_STRING", "string", MONO_TYPE_STRING
, sizeof (gpointer
), DW_ATE_address
},
527 { ".LDIE_OBJECT", "object", MONO_TYPE_OBJECT
, sizeof (gpointer
), DW_ATE_address
},
528 { ".LDIE_SZARRAY", "object", MONO_TYPE_SZARRAY
, sizeof (gpointer
), DW_ATE_address
},
531 /* Constants for encoding line number special opcodes */
532 #define OPCODE_BASE 13
534 #define LINE_RANGE 14
536 /* Subsections of the .debug_line section */
537 #define LINE_SUBSECTION_HEADER 1
538 #define LINE_SUBSECTION_INCLUDES 2
539 #define LINE_SUBSECTION_FILES 3
540 #define LINE_SUBSECTION_DATA 4
541 #define LINE_SUBSECTION_END 5
544 emit_line_number_file_name (MonoDwarfWriter
*w
, const char *name
,
545 gint64 last_mod_time
, gint64 file_size
)
549 char *basename
= NULL
;
551 if (!w
->file_to_index
)
552 w
->file_to_index
= g_hash_table_new (g_str_hash
, g_str_equal
);
554 index
= GPOINTER_TO_UINT (g_hash_table_lookup (w
->file_to_index
, name
));
558 if (g_path_is_absolute (name
)) {
559 char *dir
= g_path_get_dirname (name
);
561 if (!w
->dir_to_index
)
562 w
->dir_to_index
= g_hash_table_new (g_str_hash
, g_str_equal
);
564 dir_index
= GPOINTER_TO_UINT (g_hash_table_lookup (w
->dir_to_index
, dir
));
565 if (dir_index
== 0) {
566 emit_section_change (w
, ".debug_line", LINE_SUBSECTION_INCLUDES
);
567 emit_string (w
, dir
);
569 dir_index
= ++ w
->line_number_dir_index
;
570 g_hash_table_insert (w
->dir_to_index
, g_strdup (dir
), GUINT_TO_POINTER (dir_index
));
575 basename
= g_path_get_basename (name
);
580 emit_section_change (w
, ".debug_line", LINE_SUBSECTION_FILES
);
583 emit_string (w
, basename
);
585 emit_string (w
, name
);
586 emit_uleb128 (w
, dir_index
);
590 emit_section_change (w
, ".debug_line", LINE_SUBSECTION_DATA
);
595 index
= ++ w
->line_number_file_index
;
596 g_hash_table_insert (w
->file_to_index
, g_strdup (name
), GUINT_TO_POINTER (index
));
602 emit_line_number_info_begin (MonoDwarfWriter
*w
)
604 /* Line number info header */
606 * GAS seems to emit its own data to the end of the first subsection, so we use
607 * subsections 1, 2 etc:
608 * 1 - contains the header
609 * 2 - contains the file names
610 * 3 - contains the end of the header + the data
613 emit_section_change (w
, ".debug_line", 0);
614 emit_label (w
, ".Ldebug_line_section_start");
615 emit_section_change (w
, ".debug_line", LINE_SUBSECTION_HEADER
);
616 emit_label (w
, ".Ldebug_line_start");
617 emit_symbol_diff (w
, ".Ldebug_line_end", ".", -4); /* length */
618 emit_int16 (w
, 0x2); /* version */
619 emit_symbol_diff (w
, ".Ldebug_line_header_end", ".", -4); /* header_length */
620 emit_byte (w
, 1); /* minimum_instruction_length */
621 emit_byte (w
, 1); /* default_is_stmt */
622 emit_byte (w
, LINE_BASE
); /* line_base */
623 emit_byte (w
, LINE_RANGE
); /* line_range */
624 emit_byte (w
, OPCODE_BASE
); /* opcode_base */
625 emit_byte (w
, 0); /* standard_opcode_lengths */
639 emit_section_change (w
, ".debug_line", LINE_SUBSECTION_INCLUDES
);
641 /* End of Includes */
642 emit_section_change (w
, ".debug_line", LINE_SUBSECTION_FILES
);
646 emit_line_number_file_name (w
, "xdb.il", 0, 0);
649 emit_section_change (w
, ".debug_line", LINE_SUBSECTION_DATA
);
652 emit_label (w
, ".Ldebug_line_header_end");
654 /* Emit this into a separate subsection so it gets placed at the end */
655 emit_section_change (w
, ".debug_line", LINE_SUBSECTION_END
);
659 emit_byte (w
, DW_LNE_end_sequence
);
661 emit_label (w
, ".Ldebug_line_end");
665 * Some assemblers like apple's do not support subsections, so we can't place
666 * .Ldebug_info_end at the end of the section using subsections. Instead, we
667 * define it every time something gets added to the .debug_info section.
668 * The apple assember seems to use the last definition.
671 emit_debug_info_end (MonoDwarfWriter
*w
)
673 /* This doesn't seem to work/required with recent iphone sdk versions */
675 if (!img_writer_subsections_supported (w
->w
))
676 fprintf (w
->fp
, "\n.set %sdebug_info_end,.\n", w
->temp_prefix
);
681 mono_dwarf_writer_emit_base_info (MonoDwarfWriter
*w
, GSList
*base_unwind_program
)
683 char *s
, *build_info
;
686 if (!img_writer_subsections_supported (w
->w
))
687 /* Can't emit line number info without subsections */
688 w
->emit_line
= FALSE
;
692 w
->cie_program
= base_unwind_program
;
694 emit_section_change (w
, ".debug_abbrev", 0);
695 emit_dwarf_abbrev (w
, ABBREV_COMPILE_UNIT
, DW_TAG_compile_unit
, TRUE
,
696 compile_unit_attr
, G_N_ELEMENTS (compile_unit_attr
));
697 emit_dwarf_abbrev (w
, ABBREV_SUBPROGRAM
, DW_TAG_subprogram
, TRUE
,
698 subprogram_attr
, G_N_ELEMENTS (subprogram_attr
));
699 emit_dwarf_abbrev (w
, ABBREV_PARAM
, DW_TAG_formal_parameter
, FALSE
,
700 param_attr
, G_N_ELEMENTS (param_attr
));
701 emit_dwarf_abbrev (w
, ABBREV_PARAM_LOCLIST
, DW_TAG_formal_parameter
, FALSE
,
702 param_loclist_attr
, G_N_ELEMENTS (param_loclist_attr
));
703 emit_dwarf_abbrev (w
, ABBREV_BASE_TYPE
, DW_TAG_base_type
, FALSE
,
704 base_type_attr
, G_N_ELEMENTS (base_type_attr
));
705 emit_dwarf_abbrev (w
, ABBREV_STRUCT_TYPE
, DW_TAG_class_type
, TRUE
,
706 struct_type_attr
, G_N_ELEMENTS (struct_type_attr
));
707 emit_dwarf_abbrev (w
, ABBREV_STRUCT_TYPE_NOCHILDREN
, DW_TAG_class_type
, FALSE
,
708 struct_type_attr
, G_N_ELEMENTS (struct_type_attr
));
709 emit_dwarf_abbrev (w
, ABBREV_DATA_MEMBER
, DW_TAG_member
, FALSE
,
710 data_member_attr
, G_N_ELEMENTS (data_member_attr
));
711 emit_dwarf_abbrev (w
, ABBREV_TYPEDEF
, DW_TAG_typedef
, FALSE
,
712 typedef_attr
, G_N_ELEMENTS (typedef_attr
));
713 emit_dwarf_abbrev (w
, ABBREV_ENUM_TYPE
, DW_TAG_enumeration_type
, TRUE
,
714 enum_type_attr
, G_N_ELEMENTS (enum_type_attr
));
715 emit_dwarf_abbrev (w
, ABBREV_ENUMERATOR
, DW_TAG_enumerator
, FALSE
,
716 enumerator_attr
, G_N_ELEMENTS (enumerator_attr
));
717 emit_dwarf_abbrev (w
, ABBREV_NAMESPACE
, DW_TAG_namespace
, TRUE
,
718 namespace_attr
, G_N_ELEMENTS (namespace_attr
));
719 emit_dwarf_abbrev (w
, ABBREV_VARIABLE
, DW_TAG_variable
, FALSE
,
720 variable_attr
, G_N_ELEMENTS (variable_attr
));
721 emit_dwarf_abbrev (w
, ABBREV_VARIABLE_LOCLIST
, DW_TAG_variable
, FALSE
,
722 variable_loclist_attr
, G_N_ELEMENTS (variable_loclist_attr
));
723 emit_dwarf_abbrev (w
, ABBREV_POINTER_TYPE
, DW_TAG_pointer_type
, FALSE
,
724 pointer_type_attr
, G_N_ELEMENTS (pointer_type_attr
));
725 emit_dwarf_abbrev (w
, ABBREV_REFERENCE_TYPE
, DW_TAG_reference_type
, FALSE
,
726 reference_type_attr
, G_N_ELEMENTS (reference_type_attr
));
727 emit_dwarf_abbrev (w
, ABBREV_INHERITANCE
, DW_TAG_inheritance
, FALSE
,
728 inheritance_attr
, G_N_ELEMENTS (inheritance_attr
));
731 emit_section_change (w
, ".debug_info", 0);
732 emit_label (w
, ".Ldebug_info_start");
733 emit_symbol_diff (w
, ".Ldebug_info_end", ".Ldebug_info_begin", 0); /* length */
734 emit_label (w
, ".Ldebug_info_begin");
735 emit_int16 (w
, 0x2); /* DWARF version 2 */
736 emit_int32 (w
, 0); /* .debug_abbrev offset */
737 emit_byte (w
, sizeof (gpointer
)); /* address size */
739 if (img_writer_subsections_supported (w
->w
) && w
->appending
) {
740 /* Emit this into a separate section so it gets placed at the end */
741 emit_section_change (w
, ".debug_info", 1);
742 emit_byte (w
, 0); /* close COMPILE_UNIT */
743 emit_label (w
, ".Ldebug_info_end");
744 emit_section_change (w
, ".debug_info", 0);
747 /* Compilation unit */
748 emit_uleb128 (w
, ABBREV_COMPILE_UNIT
);
749 build_info
= mono_get_runtime_build_info ();
750 s
= g_strdup_printf ("Mono AOT Compiler %s", build_info
);
754 emit_string (w
, "JITted code");
756 emit_byte (w
, DW_LANG_C
);
757 emit_pointer_value (w
, 0);
758 emit_pointer_value (w
, 0);
759 /* offset into .debug_line section */
760 emit_symbol_diff (w
, ".Ldebug_line_start", ".Ldebug_line_section_start", 0);
763 for (i
= 0; i
< G_N_ELEMENTS (basic_types
); ++i
) {
764 emit_label (w
, basic_types
[i
].die_name
);
765 emit_uleb128 (w
, ABBREV_BASE_TYPE
);
766 emit_byte (w
, basic_types
[i
].size
);
767 emit_byte (w
, basic_types
[i
].encoding
);
768 emit_string (w
, basic_types
[i
].name
);
771 emit_debug_info_end (w
);
773 /* debug_loc section */
774 emit_section_change (w
, ".debug_loc", 0);
775 emit_label (w
, ".Ldebug_loc_start");
777 /* debug_line section */
779 * We emit some info even if emit_line is FALSE, as the
780 * apple linker seems to require a .debug_line section.
782 emit_line_number_info_begin (w
);
788 * mono_dwarf_writer_close:
790 * Finalize the emitted debugging info.
793 mono_dwarf_writer_close (MonoDwarfWriter
*w
)
796 emit_section_change (w
, ".debug_info", 0);
797 emit_byte (w
, 0); /* close COMPILE_UNIT */
798 emit_label (w
, ".Ldebug_info_end");
802 static void emit_type (MonoDwarfWriter
*w
, MonoType
*t
);
803 static const char* get_type_die (MonoDwarfWriter
*w
, MonoType
*t
);
806 get_class_die (MonoDwarfWriter
*w
, MonoClass
*klass
, gboolean vtype
)
811 cache
= w
->class_to_vtype_die
;
813 cache
= w
->class_to_die
;
815 return g_hash_table_lookup (cache
, klass
);
818 /* Returns the local symbol pointing to the emitted debug info */
820 emit_class_dwarf_info (MonoDwarfWriter
*w
, MonoClass
*klass
, gboolean vtype
)
822 char *die
, *pointer_die
, *reference_die
;
825 MonoClassField
*field
;
828 gboolean emit_namespace
= FALSE
, has_children
;
832 cache
= w
->class_to_vtype_die
;
834 cache
= w
->class_to_die
;
836 die
= g_hash_table_lookup (cache
, klass
);
840 if (!((klass
->byval_arg
.type
== MONO_TYPE_CLASS
) || (klass
->byval_arg
.type
== MONO_TYPE_OBJECT
) || klass
->byval_arg
.type
== MONO_TYPE_GENERICINST
|| klass
->enumtype
|| (klass
->byval_arg
.type
== MONO_TYPE_VALUETYPE
&& vtype
) ||
841 (klass
->byval_arg
.type
>= MONO_TYPE_BOOLEAN
&& klass
->byval_arg
.type
<= MONO_TYPE_R8
&& !vtype
)))
845 * FIXME: gdb can't handle namespaces in languages it doesn't know about.
848 if (klass->name_space && klass->name_space [0] != '\0')
849 emit_namespace = TRUE;
851 if (emit_namespace
) {
852 emit_uleb128 (w
, ABBREV_NAMESPACE
);
853 emit_string (w
, klass
->name_space
);
856 full_name
= g_strdup_printf ("%s%s%s", klass
->name_space
, klass
->name_space
? "." : "", klass
->name
);
858 * gdb doesn't support namespaces for non-C++ dwarf objects, so use _
859 * to separate components.
861 for (p
= full_name
; *p
; p
++)
865 die
= g_strdup_printf (".LTDIE_%d", w
->tdie_index
);
866 pointer_die
= g_strdup_printf (".LTDIE_%d_POINTER", w
->tdie_index
);
867 reference_die
= g_strdup_printf (".LTDIE_%d_REFERENCE", w
->tdie_index
);
870 g_hash_table_insert (w
->class_to_pointer_die
, klass
, pointer_die
);
871 g_hash_table_insert (w
->class_to_reference_die
, klass
, reference_die
);
872 g_hash_table_insert (cache
, klass
, die
);
874 if (klass
->enumtype
) {
875 int size
= mono_class_value_size (mono_class_from_mono_type (mono_class_enum_basetype (klass
)), NULL
);
879 emit_uleb128 (w
, ABBREV_ENUM_TYPE
);
880 emit_string (w
, full_name
);
881 emit_uleb128 (w
, size
);
882 for (k
= 0; k
< G_N_ELEMENTS (basic_types
); ++k
)
883 if (basic_types
[k
].type
== mono_class_enum_basetype (klass
)->type
)
885 g_assert (k
< G_N_ELEMENTS (basic_types
));
886 emit_symbol_diff (w
, basic_types
[k
].die_name
, ".Ldebug_info_start", 0);
888 /* Emit enum values */
890 while ((field
= mono_class_get_fields (klass
, &iter
))) {
893 MonoTypeEnum def_type
;
895 if (strcmp ("value__", mono_field_get_name (field
)) == 0)
897 if (mono_field_is_deleted (field
))
900 emit_uleb128 (w
, ABBREV_ENUMERATOR
);
901 emit_string (w
, mono_field_get_name (field
));
903 p
= mono_class_get_field_default_value (field
, &def_type
);
904 len
= mono_metadata_decode_blob_size (p
, &p
);
905 switch (mono_class_enum_basetype (klass
)->type
) {
908 case MONO_TYPE_BOOLEAN
:
909 emit_sleb128 (w
, *p
);
914 emit_sleb128 (w
, read16 (p
));
918 emit_sleb128 (w
, read32 (p
));
922 emit_sleb128 (w
, read64 (p
));
926 #if SIZEOF_VOID_P == 8
927 emit_sleb128 (w
, read64 (p
));
929 emit_sleb128 (w
, read32 (p
));
933 g_assert_not_reached ();
944 parent_die
= emit_class_dwarf_info (w
, klass
->parent
, FALSE
);
948 /* Emit field types */
950 while ((field
= mono_class_get_fields (klass
, &iter
))) {
951 if (field
->type
->attrs
& FIELD_ATTRIBUTE_STATIC
)
954 emit_type (w
, field
->type
);
958 has_children
= parent_die
|| mono_class_get_fields (klass
, &iter
);
962 emit_uleb128 (w
, has_children
? ABBREV_STRUCT_TYPE
: ABBREV_STRUCT_TYPE_NOCHILDREN
);
963 emit_string (w
, full_name
);
964 emit_uleb128 (w
, klass
->instance_size
);
967 emit_uleb128 (w
, ABBREV_INHERITANCE
);
968 emit_symbol_diff (w
, parent_die
, ".Ldebug_info_start", 0);
971 *p
++= DW_OP_plus_uconst
;
972 encode_uleb128 (0, p
, &p
);
973 emit_byte (w
, p
- buf
);
974 emit_bytes (w
, buf
, p
- buf
);
979 while ((field
= mono_class_get_fields (klass
, &iter
))) {
980 if (field
->type
->attrs
& FIELD_ATTRIBUTE_STATIC
)
983 fdie
= get_type_die (w
, field
->type
);
985 emit_uleb128 (w
, ABBREV_DATA_MEMBER
);
986 emit_string (w
, field
->name
);
987 emit_symbol_diff (w
, fdie
, ".Ldebug_info_start", 0);
990 *p
++= DW_OP_plus_uconst
;
991 if (klass
->valuetype
&& vtype
)
992 encode_uleb128 (field
->offset
- sizeof (MonoObject
), p
, &p
);
994 encode_uleb128 (field
->offset
, p
, &p
);
996 emit_byte (w
, p
- buf
);
997 emit_bytes (w
, buf
, p
- buf
);
1004 emit_uleb128 (w
, 0x0);
1006 /* Add a typedef, so we can reference the type without a 'struct' in gdb */
1007 emit_uleb128 (w
, ABBREV_TYPEDEF
);
1008 emit_string (w
, full_name
);
1009 emit_symbol_diff (w
, die
, ".Ldebug_info_start", 0);
1011 /* Add a pointer type */
1012 emit_label (w
, pointer_die
);
1014 emit_uleb128 (w
, ABBREV_POINTER_TYPE
);
1015 emit_symbol_diff (w
, die
, ".Ldebug_info_start", 0);
1017 /* Add a reference type */
1018 emit_label (w
, reference_die
);
1020 emit_uleb128 (w
, ABBREV_REFERENCE_TYPE
);
1021 emit_symbol_diff (w
, die
, ".Ldebug_info_start", 0);
1025 if (emit_namespace
) {
1027 emit_uleb128 (w
, 0x0);
1033 static gboolean base_types_emitted
[64];
1036 get_type_die (MonoDwarfWriter
*w
, MonoType
*t
)
1038 MonoClass
*klass
= mono_class_from_mono_type (t
);
1043 if (t
->type
== MONO_TYPE_VALUETYPE
) {
1044 tdie
= g_hash_table_lookup (w
->class_to_pointer_die
, klass
);
1047 tdie
= get_class_die (w
, klass
, FALSE
);
1048 /* Should return a pointer type to a reference */
1051 t
= &mono_defaults
.int_class
->byval_arg
;
1053 for (j
= 0; j
< G_N_ELEMENTS (basic_types
); ++j
)
1054 if (basic_types
[j
].type
== t
->type
)
1056 if (j
< G_N_ELEMENTS (basic_types
)) {
1057 tdie
= basic_types
[j
].die_name
;
1060 case MONO_TYPE_CLASS
:
1061 tdie
= g_hash_table_lookup (w
->class_to_reference_die
, klass
);
1062 //tdie = ".LDIE_OBJECT";
1064 case MONO_TYPE_ARRAY
:
1065 tdie
= ".LDIE_OBJECT";
1067 case MONO_TYPE_VALUETYPE
:
1068 if (klass
->enumtype
)
1069 tdie
= get_class_die (w
, klass
, FALSE
);
1073 case MONO_TYPE_GENERICINST
:
1074 if (!MONO_TYPE_ISSTRUCT (t
)) {
1075 tdie
= g_hash_table_lookup (w
->class_to_reference_die
, klass
);
1095 emit_type (MonoDwarfWriter
*w
, MonoType
*t
)
1097 MonoClass
*klass
= mono_class_from_mono_type (t
);
1102 if (t
->type
== MONO_TYPE_VALUETYPE
) {
1103 tdie
= emit_class_dwarf_info (w
, klass
, TRUE
);
1108 emit_class_dwarf_info (w
, klass
, FALSE
);
1111 t
= &mono_defaults
.int_class
->byval_arg
;
1113 for (j
= 0; j
< G_N_ELEMENTS (basic_types
); ++j
)
1114 if (basic_types
[j
].type
== t
->type
)
1116 if (j
< G_N_ELEMENTS (basic_types
)) {
1117 /* Emit a boxed version of base types */
1118 if (j
< 64 && !base_types_emitted
[j
]) {
1119 emit_class_dwarf_info (w
, klass
, FALSE
);
1120 base_types_emitted
[j
] = TRUE
;
1124 case MONO_TYPE_CLASS
:
1125 emit_class_dwarf_info (w
, klass
, FALSE
);
1127 case MONO_TYPE_ARRAY
:
1129 case MONO_TYPE_VALUETYPE
:
1130 if (klass
->enumtype
)
1131 emit_class_dwarf_info (w
, klass
, FALSE
);
1133 case MONO_TYPE_GENERICINST
:
1134 if (!MONO_TYPE_ISSTRUCT (t
))
1135 emit_class_dwarf_info (w
, klass
, FALSE
);
1146 emit_var_type (MonoDwarfWriter
*w
, MonoType
*t
)
1150 tdie
= get_type_die (w
, t
);
1152 emit_symbol_diff (w
, tdie
, ".Ldebug_info_start", 0);
1156 encode_var_location (MonoDwarfWriter
*w
, MonoInst
*ins
, guint8
*p
, guint8
**endp
)
1159 /* FIXME: This needs a location list, since the args can go from reg->stack */
1160 if (!ins
|| ins
->flags
& MONO_INST_IS_DEAD
) {
1161 /* gdb treats this as optimized out */
1162 } else if (ins
->opcode
== OP_REGVAR
) {
1163 *p
= DW_OP_reg0
+ mono_hw_reg_to_dwarf_reg (ins
->dreg
);
1165 } else if (ins
->opcode
== OP_REGOFFSET
) {
1166 *p
++= DW_OP_breg0
+ mono_hw_reg_to_dwarf_reg (ins
->inst_basereg
);
1167 encode_sleb128 (ins
->inst_offset
, p
, &p
);
1177 emit_loclist (MonoDwarfWriter
*w
, MonoInst
*ins
,
1178 guint8
*loclist_begin_addr
, guint8
*loclist_end_addr
,
1179 guint8
*expr
, guint32 expr_len
)
1183 emit_push_section (w
, ".debug_loc", 0);
1184 sprintf (label
, ".Lloclist_%d", w
->loclist_index
++ );
1185 emit_label (w
, label
);
1187 emit_pointer_value (w
, loclist_begin_addr
);
1188 emit_pointer_value (w
, loclist_end_addr
);
1189 emit_byte (w
, expr_len
% 256);
1190 emit_byte (w
, expr_len
/ 256);
1191 emit_bytes (w
, expr
, expr_len
);
1193 emit_pointer_value (w
, NULL
);
1194 emit_pointer_value (w
, NULL
);
1196 emit_pop_section (w
);
1197 emit_symbol_diff (w
, label
, ".Ldebug_loc_start", 0);
1201 * MonoDisHelper->tokener doesn't take an IP argument, and we can't add one since
1202 * it is a public header.
1204 static const guint8
*token_handler_ip
;
1207 token_handler (MonoDisHelper
*dh
, MonoMethod
*method
, guint32 token
)
1210 MonoMethod
*cmethod
;
1212 MonoClassField
*field
;
1213 gpointer data
= NULL
;
1215 if (method
->wrapper_type
)
1216 data
= mono_method_get_wrapper_data (method
, token
);
1218 switch (*token_handler_ip
) {
1222 if (method
->wrapper_type
)
1225 klass
= mono_class_get_full (method
->klass
->image
, token
, NULL
);
1226 res
= g_strdup_printf ("<%s>", klass
->name
);
1231 if (method
->wrapper_type
)
1234 cmethod
= mono_get_method_full (method
->klass
->image
, token
, NULL
, NULL
);
1235 desc
= mono_method_full_name (cmethod
, TRUE
);
1236 res
= g_strdup_printf ("<%s>", desc
);
1240 if (method
->wrapper_type
) {
1241 desc
= mono_signature_get_desc (data
, FALSE
);
1242 res
= g_strdup_printf ("<%s>", desc
);
1245 res
= g_strdup_printf ("<0x%08x>", token
);
1252 if (method
->wrapper_type
)
1255 field
= mono_field_from_token (method
->klass
->image
, token
, &klass
, NULL
);
1256 desc
= mono_field_full_name (field
);
1257 res
= g_strdup_printf ("<%s>", desc
);
1261 res
= g_strdup_printf ("<0x%08x>", token
);
1271 * Produce a disassembled form of the IL instruction at IP. This is an extension
1272 * of mono_disasm_code_one () which can disasm tokens, handle wrapper methods, and
1273 * CEE_MONO_ opcodes.
1276 disasm_ins (MonoMethod
*method
, const guchar
*ip
, const guint8
**endip
)
1280 MonoMethodHeader
*header
= mono_method_get_header (method
);
1282 memset (&dh
, 0, sizeof (dh
));
1284 dh
.label_format
= "IL_%04x: ";
1285 dh
.label_target
= "IL_%04x";
1286 dh
.tokener
= token_handler
;
1288 token_handler_ip
= ip
;
1289 if (*ip
== MONO_CUSTOM_PREFIX
) {
1294 case CEE_MONO_ICALL
: {
1295 MonoJitICallInfo
*info
;
1297 token
= read32 (ip
+ 2);
1298 data
= mono_method_get_wrapper_data (method
, token
);
1299 info
= mono_find_jit_icall_by_addr (data
);
1302 dis
= g_strdup_printf ("IL_%04x: mono_icall <%s>", (int)(ip
- header
->code
), info
->name
);
1306 case CEE_MONO_CLASSCONST
: {
1307 token
= read32 (ip
+ 2);
1308 data
= mono_method_get_wrapper_data (method
, token
);
1310 dis
= g_strdup_printf ("IL_%04x: mono_classconst <%s>", (int)(ip
- header
->code
), ((MonoClass
*)data
)->name
);
1315 dis
= mono_disasm_code_one (&dh
, method
, ip
, &ip
);
1318 dis
= mono_disasm_code_one (&dh
, method
, ip
, &ip
);
1320 token_handler_ip
= NULL
;
1323 mono_metadata_free_mh (header
);
1328 il_offset_from_address (MonoMethod
*method
, MonoDebugMethodJitInfo
*jit
,
1329 guint32 native_offset
)
1333 if (!jit
->line_numbers
)
1336 for (i
= jit
->num_line_numbers
- 1; i
>= 0; i
--) {
1337 MonoDebugLineNumberEntry lne
= jit
->line_numbers
[i
];
1339 if (lne
.native_offset
<= native_offset
)
1340 return lne
.il_offset
;
1346 static int max_special_addr_diff
= 0;
1349 emit_advance_op (MonoDwarfWriter
*w
, int line_diff
, int addr_diff
)
1353 /* Use a special opcode if possible */
1354 if (line_diff
- LINE_BASE
>= 0 && line_diff
- LINE_BASE
< LINE_RANGE
) {
1355 if (max_special_addr_diff
== 0)
1356 max_special_addr_diff
= (255 - OPCODE_BASE
) / LINE_RANGE
;
1358 if (addr_diff
> max_special_addr_diff
&& (addr_diff
< 2 * max_special_addr_diff
)) {
1359 emit_byte (w
, DW_LNS_const_add_pc
);
1360 addr_diff
-= max_special_addr_diff
;
1363 opcode
= (line_diff
- LINE_BASE
) + (LINE_RANGE
* addr_diff
) + OPCODE_BASE
;
1369 emit_byte (w
, opcode
);
1371 emit_byte (w
, DW_LNS_advance_line
);
1372 emit_sleb128 (w
, line_diff
);
1373 emit_byte (w
, DW_LNS_advance_pc
);
1374 emit_sleb128 (w
, addr_diff
);
1375 emit_byte (w
, DW_LNS_copy
);
1380 compare_lne (MonoDebugLineNumberEntry
*a
, MonoDebugLineNumberEntry
*b
)
1382 if (a
->native_offset
== b
->native_offset
)
1383 return a
->il_offset
- b
->il_offset
;
1385 return a
->native_offset
- b
->native_offset
;
1389 emit_line_number_info (MonoDwarfWriter
*w
, MonoMethod
*method
,
1390 char *start_symbol
, char *end_symbol
,
1391 guint8
*code
, guint32 code_size
,
1392 MonoDebugMethodJitInfo
*debug_info
)
1394 guint32 prev_line
= 0;
1395 guint32 prev_native_offset
= 0;
1396 int i
, file_index
, il_offset
, prev_il_offset
;
1397 gboolean first
= TRUE
;
1398 MonoDebugSourceLocation
*loc
;
1399 char *prev_file_name
= NULL
;
1400 MonoMethodHeader
*header
= mono_method_get_header (method
);
1401 MonoDebugMethodInfo
*minfo
;
1402 MonoDebugLineNumberEntry
*ln_array
;
1403 int *native_to_il_offset
= NULL
;
1405 if (!w
->emit_line
) {
1406 mono_metadata_free_mh (header
);
1410 minfo
= mono_debug_lookup_method (method
);
1412 /* Compute the native->IL offset mapping */
1414 g_assert (code_size
);
1416 ln_array
= g_new0 (MonoDebugLineNumberEntry
, debug_info
->num_line_numbers
);
1417 memcpy (ln_array
, debug_info
->line_numbers
, debug_info
->num_line_numbers
* sizeof (MonoDebugLineNumberEntry
));
1419 qsort (ln_array
, debug_info
->num_line_numbers
, sizeof (MonoDebugLineNumberEntry
), (gpointer
)compare_lne
);
1421 native_to_il_offset
= g_new0 (int, code_size
+ 1);
1423 for (i
= 0; i
< debug_info
->num_line_numbers
; ++i
) {
1425 MonoDebugLineNumberEntry
*lne
= &ln_array
[i
];
1428 for (j
= 0; j
< lne
->native_offset
; ++j
)
1429 native_to_il_offset
[j
] = -1;
1432 if (i
< debug_info
->num_line_numbers
- 1) {
1433 MonoDebugLineNumberEntry
*lne_next
= &ln_array
[i
+ 1];
1435 for (j
= lne
->native_offset
; j
< lne_next
->native_offset
; ++j
)
1436 native_to_il_offset
[j
] = lne
->il_offset
;
1438 for (j
= lne
->native_offset
; j
< code_size
; ++j
)
1439 native_to_il_offset
[j
] = lne
->il_offset
;
1445 prev_il_offset
= -1;
1447 for (i
= 0; i
< code_size
; ++i
) {
1451 if (!debug_info
->line_numbers
)
1454 if (native_to_il_offset
)
1455 il_offset
= native_to_il_offset
[i
];
1457 il_offset
= il_offset_from_address (method
, debug_info
, i
);
1459 il_offset = il_offset_from_address (method, debug_info, i);
1461 g_assert (il_offset == native_to_il_offset [i]);
1464 il_offset
= native_to_il_offset
[i
];
1468 if (il_offset
== prev_il_offset
)
1471 prev_il_offset
= il_offset
;
1473 loc
= mono_debug_symfile_lookup_location (minfo
, il_offset
);
1475 // Added the loc->source_file check as otherwise we can
1476 // crash, see the sample in bug 553191 that makes this code
1477 // crash when we call strcmp on loc->source_file below
1478 if (loc
&& loc
->source_file
) {
1479 int line_diff
= (gint32
)loc
->row
- (gint32
)prev_line
;
1480 int addr_diff
= i
- prev_native_offset
;
1483 emit_section_change (w
, ".debug_line", LINE_SUBSECTION_DATA
);
1486 emit_byte (w
, sizeof (gpointer
) + 1);
1487 emit_byte (w
, DW_LNE_set_address
);
1489 emit_pointer_unaligned (w
, start_symbol
);
1491 emit_pointer_value (w
, code
);
1494 * The prolog+initlocals region does not have a line number, this
1495 * makes them belong to the first line of the method.
1497 emit_byte (w
, DW_LNS_advance_line
);
1498 emit_sleb128 (w
, (gint32
)loc
->row
- (gint32
)prev_line
);
1499 prev_line
= loc
->row
;
1502 if (loc
->row
!= prev_line
) {
1503 if (!prev_file_name
|| strcmp (loc
->source_file
, prev_file_name
) != 0) {
1504 /* Add an entry to the file table */
1505 /* FIXME: Avoid duplicates */
1506 file_index
= emit_line_number_file_name (w
, loc
->source_file
, 0, 0);
1507 g_free (prev_file_name
);
1508 prev_file_name
= g_strdup (loc
->source_file
);
1510 emit_byte (w
, DW_LNS_set_file
);
1511 emit_uleb128 (w
, file_index
);
1512 emit_byte (w
, DW_LNS_copy
);
1515 //printf ("X: %p(+0x%x) %d %s:%d(+%d)\n", code + i, addr_diff, loc->il_offset, loc->source_file, loc->row, line_diff);
1517 emit_advance_op (w
, line_diff
, addr_diff
);
1519 prev_line
= loc
->row
;
1520 prev_native_offset
= i
;
1525 mono_debug_symfile_free_location (loc
);
1529 g_free (native_to_il_offset
);
1530 g_free (prev_file_name
);
1533 emit_byte (w
, DW_LNS_advance_pc
);
1534 emit_sleb128 (w
, code_size
- prev_native_offset
);
1535 emit_byte (w
, DW_LNS_copy
);
1539 emit_byte (w
, DW_LNE_end_sequence
);
1540 } else if (!start_symbol
) {
1541 /* No debug info, XDEBUG mode */
1543 const guint8
*ip
= header
->code
;
1544 int prev_line
, prev_native_offset
;
1548 * Emit the IL code into a temporary file and emit line number info
1549 * referencing that file.
1552 name
= mono_method_full_name (method
, TRUE
);
1553 fprintf (w
->il_file
, "// %s\n", name
);
1554 w
->il_file_line_index
++;
1557 il_to_line
= g_new0 (int, header
->code_size
);
1559 emit_section_change (w
, ".debug_line", LINE_SUBSECTION_DATA
);
1561 emit_byte (w
, sizeof (gpointer
) + 1);
1562 emit_byte (w
, DW_LNE_set_address
);
1563 emit_pointer_value (w
, code
);
1565 // FIXME: Optimize this
1566 while (ip
< header
->code
+ header
->code_size
) {
1567 int il_offset
= ip
- header
->code
;
1570 w
->il_file_line_index
++;
1572 dis
= disasm_ins (method
, ip
, &ip
);
1573 fprintf (w
->il_file
, "%s\n", dis
);
1576 il_to_line
[il_offset
] = w
->il_file_line_index
;
1579 /* Emit line number info */
1581 prev_native_offset
= 0;
1582 for (i
= 0; i
< debug_info
->num_line_numbers
; ++i
) {
1583 MonoDebugLineNumberEntry
*lne
= &debug_info
->line_numbers
[i
];
1586 if (lne
->il_offset
>= header
->code_size
)
1588 line
= il_to_line
[lne
->il_offset
];
1591 * This seems to happen randomly, it looks like il_offset points
1592 * into the middle of an instruction.
1596 printf ("%s\n", mono_method_full_name (method, TRUE));
1597 printf ("%d %d\n", lne->il_offset, header->code_size);
1602 if (line
- prev_line
!= 0) {
1603 emit_advance_op (w
, line
- prev_line
, (gint32
)lne
->native_offset
- prev_native_offset
);
1606 prev_native_offset
= lne
->native_offset
;
1610 emit_byte (w
, DW_LNS_advance_pc
);
1611 emit_sleb128 (w
, code_size
- prev_native_offset
);
1612 emit_byte (w
, DW_LNS_copy
);
1616 emit_byte (w
, DW_LNE_end_sequence
);
1618 fflush (w
->il_file
);
1619 g_free (il_to_line
);
1621 mono_metadata_free_mh (header
);
1624 static MonoMethodVar
*
1625 find_vmv (MonoCompile
*cfg
, MonoInst
*ins
)
1630 for (j
= 0; j
< cfg
->num_varinfo
; ++j
) {
1631 if (cfg
->varinfo
[j
] == ins
)
1635 if (j
< cfg
->num_varinfo
) {
1636 return MONO_VARINFO (cfg
, j
);
1644 mono_dwarf_writer_emit_method (MonoDwarfWriter
*w
, MonoCompile
*cfg
, MonoMethod
*method
, char *start_symbol
, char *end_symbol
, guint8
*code
, guint32 code_size
, MonoInst
**args
, MonoInst
**locals
, GSList
*unwind_info
, MonoDebugMethodJitInfo
*debug_info
)
1647 MonoMethodSignature
*sig
;
1648 MonoMethodHeader
*header
;
1650 MonoDebugLocalsInfo
*locals_info
;
1655 emit_section_change (w
, ".debug_info", 0);
1657 sig
= mono_method_signature (method
);
1658 header
= mono_method_get_header (method
);
1660 /* Parameter types */
1661 for (i
= 0; i
< sig
->param_count
+ sig
->hasthis
; ++i
) {
1664 if (i
== 0 && sig
->hasthis
) {
1665 if (method
->klass
->valuetype
)
1666 t
= &method
->klass
->this_arg
;
1668 t
= &method
->klass
->byval_arg
;
1670 t
= sig
->params
[i
- sig
->hasthis
];
1675 //emit_type (w, &mono_defaults.int32_class->byval_arg);
1678 for (i
= 0; i
< header
->num_locals
; ++i
) {
1679 emit_type (w
, header
->locals
[i
]);
1683 names
= g_new0 (char *, sig
->param_count
);
1684 mono_method_get_param_names (method
, (const char **) names
);
1686 emit_uleb128 (w
, ABBREV_SUBPROGRAM
);
1687 name
= mono_method_full_name (method
, FALSE
);
1688 emit_string (w
, name
);
1691 emit_pointer_unaligned (w
, start_symbol
);
1692 emit_pointer_unaligned (w
, end_symbol
);
1694 emit_pointer_value (w
, code
);
1695 emit_pointer_value (w
, code
+ code_size
);
1699 emit_byte (w
, DW_OP_breg6
);
1703 for (i
= 0; i
< sig
->param_count
+ sig
->hasthis
; ++i
) {
1704 MonoInst
*arg
= args
? args
[i
] : NULL
;
1707 char pname_buf
[128];
1708 MonoMethodVar
*vmv
= NULL
;
1709 gboolean need_loclist
= FALSE
;
1711 vmv
= find_vmv (cfg
, arg
);
1712 if (code
&& vmv
&& (vmv
->live_range_start
|| vmv
->live_range_end
))
1713 need_loclist
= TRUE
;
1715 if (i
== 0 && sig
->hasthis
) {
1716 if (method
->klass
->valuetype
)
1717 t
= &method
->klass
->this_arg
;
1719 t
= &method
->klass
->byval_arg
;
1722 t
= sig
->params
[i
- sig
->hasthis
];
1723 pname
= names
[i
- sig
->hasthis
];
1726 emit_uleb128 (w
, need_loclist
? ABBREV_PARAM_LOCLIST
: ABBREV_PARAM
);
1728 if (pname
[0] == '\0') {
1729 sprintf (pname_buf
, "param%d", i
- sig
->hasthis
);
1732 emit_string (w
, pname
);
1734 if (!arg
|| arg
->flags
& MONO_INST_IS_DEAD
)
1735 emit_var_type (w
, &mono_defaults
.int32_class
->byval_arg
);
1737 emit_var_type (w
, t
);
1740 encode_var_location (w
, arg
, p
, &p
);
1742 vmv
->live_range_start
= 0;
1743 if (vmv
->live_range_end
== 0)
1744 /* FIXME: Uses made in calls are not recorded */
1745 vmv
->live_range_end
= code_size
;
1746 emit_loclist (w
, arg
, code
+ vmv
->live_range_start
, code
+ vmv
->live_range_end
, buf
, p
- buf
);
1748 emit_byte (w
, p
- buf
);
1749 emit_bytes (w
, buf
, p
- buf
);
1755 locals_info
= mono_debug_lookup_locals (method
);
1757 for (i
= 0; i
< header
->num_locals
; ++i
) {
1758 MonoInst
*ins
= locals
[i
];
1759 char name_buf
[128];
1761 MonoMethodVar
*vmv
= NULL
;
1762 gboolean need_loclist
= FALSE
;
1765 /* ins->dreg no longer contains the original vreg */
1766 vmv
= find_vmv (cfg
, ins
);
1768 if (vmv
->live_range_start
) {
1769 /* This variable has a precise live range */
1770 need_loclist
= TRUE
;
1774 emit_uleb128 (w
, need_loclist
? ABBREV_VARIABLE_LOCLIST
: ABBREV_VARIABLE
);
1778 for (j
= 0; j
< locals_info
->num_locals
; ++j
)
1779 if (locals_info
->locals
[j
].index
== i
)
1781 if (j
< locals_info
->num_locals
)
1782 lname
= locals_info
->locals
[j
].name
;
1785 emit_string (w
, lname
);
1787 sprintf (name_buf
, "V_%d", i
);
1788 emit_string (w
, name_buf
);
1791 if (!ins
|| ins
->flags
& MONO_INST_IS_DEAD
)
1792 emit_var_type (w
, &mono_defaults
.int32_class
->byval_arg
);
1794 emit_var_type (w
, header
->locals
[i
]);
1797 encode_var_location (w
, ins
, p
, &p
);
1800 if (vmv
->live_range_end
== 0)
1801 /* FIXME: Uses made in calls are not recorded */
1802 vmv
->live_range_end
= code_size
;
1803 emit_loclist (w
, ins
, code
+ vmv
->live_range_start
, code
+ vmv
->live_range_end
, buf
, p
- buf
);
1805 emit_byte (w
, p
- buf
);
1806 emit_bytes (w
, buf
, p
- buf
);
1811 mono_debug_symfile_free_locals (locals_info
);
1813 /* Subprogram end */
1814 emit_uleb128 (w
, 0x0);
1818 emit_debug_info_end (w
);
1820 /* Emit unwind info */
1822 emit_fde (w
, w
->fde_index
, start_symbol
, end_symbol
, code
, code_size
, unwind_info
, TRUE
);
1826 /* Emit line number info */
1827 /* != could happen when using --regression */
1828 if (debug_info
&& (debug_info
->code_start
== code
))
1829 emit_line_number_info (w
, method
, start_symbol
, end_symbol
, code
, code_size
, debug_info
);
1832 mono_metadata_free_mh (header
);
1836 mono_dwarf_writer_emit_trampoline (MonoDwarfWriter
*w
, const char *tramp_name
, char *start_symbol
, char *end_symbol
, guint8
*code
, guint32 code_size
, GSList
*unwind_info
)
1838 emit_section_change (w
, ".debug_info", 0);
1841 emit_uleb128 (w
, ABBREV_SUBPROGRAM
);
1842 emit_string (w
, tramp_name
);
1843 emit_pointer_value (w
, code
);
1844 emit_pointer_value (w
, code
+ code_size
);
1847 emit_byte (w
, DW_OP_breg6
);
1850 /* Subprogram end */
1851 emit_uleb128 (w
, 0x0);
1853 emit_debug_info_end (w
);
1855 /* Emit unwind info */
1856 emit_fde (w
, w
->fde_index
, start_symbol
, end_symbol
, code
, code_size
, unwind_info
, FALSE
);
1859 #endif /* End of: !defined(DISABLE_AOT) && !defined(DISABLE_JIT) */