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
);
88 mono_dwarf_writer_destroy (MonoDwarfWriter
*w
)
94 mono_dwarf_writer_get_il_file_line_index (MonoDwarfWriter
*w
)
96 return w
->il_file_line_index
;
99 /* Wrappers around the image writer functions */
102 emit_section_change (MonoDwarfWriter
*w
, const char *section_name
, int subsection_index
)
104 img_writer_emit_section_change (w
->w
, section_name
, subsection_index
);
108 emit_push_section (MonoDwarfWriter
*w
, const char *section_name
, int subsection
)
110 img_writer_emit_push_section (w
->w
, section_name
, subsection
);
114 emit_pop_section (MonoDwarfWriter
*w
)
116 img_writer_emit_pop_section (w
->w
);
120 emit_local_symbol (MonoDwarfWriter
*w
, const char *name
, const char *end_label
, gboolean func
)
122 img_writer_emit_local_symbol (w
->w
, name
, end_label
, func
);
126 emit_label (MonoDwarfWriter
*w
, const char *name
)
128 img_writer_emit_label (w
->w
, name
);
132 emit_bytes (MonoDwarfWriter
*w
, const guint8
* buf
, int size
)
134 img_writer_emit_bytes (w
->w
, buf
, size
);
138 emit_string (MonoDwarfWriter
*w
, const char *value
)
140 img_writer_emit_string (w
->w
, value
);
144 emit_line (MonoDwarfWriter
*w
)
146 img_writer_emit_line (w
->w
);
150 emit_alignment (MonoDwarfWriter
*w
, int size
)
152 img_writer_emit_alignment (w
->w
, size
);
156 emit_pointer_unaligned (MonoDwarfWriter
*w
, const char *target
)
158 img_writer_emit_pointer_unaligned (w
->w
, target
);
162 emit_pointer (MonoDwarfWriter
*w
, const char *target
)
164 img_writer_emit_pointer (w
->w
, target
);
168 emit_int16 (MonoDwarfWriter
*w
, int value
)
170 img_writer_emit_int16 (w
->w
, value
);
174 emit_int32 (MonoDwarfWriter
*w
, int value
)
176 img_writer_emit_int32 (w
->w
, value
);
180 emit_symbol_diff (MonoDwarfWriter
*w
, const char *end
, const char* start
, int offset
)
182 img_writer_emit_symbol_diff (w
->w
, end
, start
, offset
);
186 emit_zero_bytes (MonoDwarfWriter
*w
, int num
)
188 img_writer_emit_zero_bytes (w
->w
, num
);
192 emit_byte (MonoDwarfWriter
*w
, guint8 val
)
194 img_writer_emit_byte (w
->w
, val
);
197 static G_GNUC_UNUSED
void
198 emit_uleb128 (MonoDwarfWriter
*w
, guint32 value
)
201 guint8 b
= value
& 0x7f;
203 if (value
!= 0) /* more bytes to come */
209 static G_GNUC_UNUSED
void
210 emit_sleb128 (MonoDwarfWriter
*w
, gint64 value
)
213 gboolean negative
= (value
< 0);
220 /* the following is unnecessary if the
221 * implementation of >>= uses an arithmetic rather
222 * than logical shift for a signed left operand
226 value
|= - ((gint64
)1 <<(size
- 7));
227 /* sign bit of byte is second high order bit (0x40) */
228 if ((value
== 0 && !(byte
& 0x40)) ||
229 (value
== -1 && (byte
& 0x40)))
237 static G_GNUC_UNUSED
void
238 encode_uleb128 (guint32 value
, guint8
*buf
, guint8
**endbuf
)
243 guint8 b
= value
& 0x7f;
245 if (value
!= 0) /* more bytes to come */
253 static G_GNUC_UNUSED
void
254 encode_sleb128 (gint32 value
, guint8
*buf
, guint8
**endbuf
)
257 gboolean negative
= (value
< 0);
265 /* the following is unnecessary if the
266 * implementation of >>= uses an arithmetic rather
267 * than logical shift for a signed left operand
271 value
|= - (1 <<(size
- 7));
272 /* sign bit of byte is second high order bit (0x40) */
273 if ((value
== 0 && !(byte
& 0x40)) ||
274 (value
== -1 && (byte
& 0x40)))
285 emit_dwarf_abbrev (MonoDwarfWriter
*w
, int code
, int tag
, gboolean has_child
,
286 int *attrs
, int attrs_len
)
290 emit_uleb128 (w
, code
);
291 emit_uleb128 (w
, tag
);
292 emit_byte (w
, has_child
);
294 for (i
= 0; i
< attrs_len
; i
++)
295 emit_uleb128 (w
, attrs
[i
]);
301 emit_cie (MonoDwarfWriter
*w
)
303 emit_section_change (w
, ".debug_frame", 0);
305 emit_alignment (w
, 8);
308 emit_symbol_diff (w
, ".Lcie0_end", ".Lcie0_start", 0); /* length */
309 emit_label (w
, ".Lcie0_start");
310 emit_int32 (w
, 0xffffffff); /* CIE id */
311 emit_byte (w
, 3); /* version */
312 emit_string (w
, ""); /* augmention */
313 emit_sleb128 (w
, 1); /* code alignment factor */
314 emit_sleb128 (w
, mono_unwind_get_dwarf_data_align ()); /* data alignment factor */
315 emit_uleb128 (w
, mono_unwind_get_dwarf_pc_reg ());
317 w
->cie_program
= w
->cie_program
;
318 if (w
->cie_program
) {
320 guint8
*uw_info
= mono_unwind_ops_encode (w
->cie_program
, &uw_info_len
);
321 emit_bytes (w
, uw_info
, uw_info_len
);
325 emit_alignment (w
, sizeof (gpointer
));
326 emit_label (w
, ".Lcie0_end");
330 emit_pointer_value (MonoDwarfWriter
*w
, gpointer ptr
)
332 gssize val
= (gssize
)ptr
;
333 emit_bytes (w
, (guint8
*)&val
, sizeof (gpointer
));
337 emit_fde (MonoDwarfWriter
*w
, int fde_index
, char *start_symbol
, char *end_symbol
,
338 guint8
*code
, guint32 code_size
, GSList
*unwind_ops
, gboolean use_cie
)
346 emit_section_change (w
, ".debug_frame", 0);
348 sprintf (symbol1
, ".Lfde%d_start", fde_index
);
349 sprintf (symbol2
, ".Lfde%d_end", fde_index
);
350 emit_symbol_diff (w
, symbol2
, symbol1
, 0); /* length */
351 emit_label (w
, symbol1
);
352 emit_int32 (w
, 0); /* CIE_pointer */
354 emit_pointer (w
, start_symbol
); /* initial_location */
356 emit_symbol_diff (w
, end_symbol
, start_symbol
, 0); /* address_range */
358 g_assert (code_size
);
359 emit_int32 (w
, code_size
);
362 emit_pointer_value (w
, code
);
363 emit_int32 (w
, code_size
);
365 #if SIZEOF_VOID_P == 8
366 /* Upper 32 bits of code size */
371 if (w
->cie_program
) {
372 // FIXME: Check that the ops really begin with the CIE program */
375 for (i
= 0; i
< g_slist_length (w
->cie_program
); ++i
)
379 /* Convert the list of MonoUnwindOps to the format used by DWARF */
380 uw_info
= mono_unwind_ops_encode (l
, &uw_info_len
);
381 emit_bytes (w
, uw_info
, uw_info_len
);
384 emit_alignment (w
, sizeof (mgreg_t
));
385 emit_label (w
, symbol2
);
389 #define ABBREV_COMPILE_UNIT 1
390 #define ABBREV_SUBPROGRAM 2
391 #define ABBREV_PARAM 3
392 #define ABBREV_BASE_TYPE 4
393 #define ABBREV_STRUCT_TYPE 5
394 #define ABBREV_DATA_MEMBER 6
395 #define ABBREV_TYPEDEF 7
396 #define ABBREV_ENUM_TYPE 8
397 #define ABBREV_ENUMERATOR 9
398 #define ABBREV_NAMESPACE 10
399 #define ABBREV_VARIABLE 11
400 #define ABBREV_VARIABLE_LOCLIST 12
401 #define ABBREV_POINTER_TYPE 13
402 #define ABBREV_REFERENCE_TYPE 14
403 #define ABBREV_PARAM_LOCLIST 15
404 #define ABBREV_INHERITANCE 16
405 #define ABBREV_STRUCT_TYPE_NOCHILDREN 17
407 static int compile_unit_attr
[] = {
408 DW_AT_producer
,DW_FORM_string
,
409 DW_AT_name
,DW_FORM_string
,
410 DW_AT_comp_dir
,DW_FORM_string
,
411 DW_AT_language
,DW_FORM_data1
,
412 DW_AT_low_pc
,DW_FORM_addr
,
413 DW_AT_high_pc
,DW_FORM_addr
,
414 DW_AT_stmt_list
,DW_FORM_data4
417 static int subprogram_attr
[] = {
418 DW_AT_name
, DW_FORM_string
,
419 DW_AT_low_pc
, DW_FORM_addr
,
420 DW_AT_high_pc
, DW_FORM_addr
,
421 DW_AT_frame_base
, DW_FORM_block1
424 static int param_attr
[] = {
425 DW_AT_name
, DW_FORM_string
,
426 DW_AT_type
, DW_FORM_ref4
,
427 DW_AT_location
, DW_FORM_block1
430 static int param_loclist_attr
[] = {
431 DW_AT_name
, DW_FORM_string
,
432 DW_AT_type
, DW_FORM_ref4
,
433 DW_AT_location
, DW_FORM_data4
436 static int base_type_attr
[] = {
437 DW_AT_byte_size
, DW_FORM_data1
,
438 DW_AT_encoding
, DW_FORM_data1
,
439 DW_AT_name
, DW_FORM_string
442 static int struct_type_attr
[] = {
443 DW_AT_name
, DW_FORM_string
,
444 DW_AT_byte_size
, DW_FORM_udata
,
447 static int data_member_attr
[] = {
448 DW_AT_name
, DW_FORM_string
,
449 DW_AT_type
, DW_FORM_ref4
,
450 DW_AT_data_member_location
, DW_FORM_block1
453 static int typedef_attr
[] = {
454 DW_AT_name
, DW_FORM_string
,
455 DW_AT_type
, DW_FORM_ref4
458 static int pointer_type_attr
[] = {
459 DW_AT_type
, DW_FORM_ref4
,
462 static int reference_type_attr
[] = {
463 DW_AT_type
, DW_FORM_ref4
,
466 static int enum_type_attr
[] = {
467 DW_AT_name
, DW_FORM_string
,
468 DW_AT_byte_size
, DW_FORM_udata
,
469 DW_AT_type
, DW_FORM_ref4
,
472 static int enumerator_attr
[] = {
473 DW_AT_name
, DW_FORM_string
,
474 DW_AT_const_value
, DW_FORM_sdata
,
477 static int namespace_attr
[] = {
478 DW_AT_name
, DW_FORM_string
,
481 static int variable_attr
[] = {
482 DW_AT_name
, DW_FORM_string
,
483 DW_AT_type
, DW_FORM_ref4
,
484 DW_AT_location
, DW_FORM_block1
487 static int variable_loclist_attr
[] = {
488 DW_AT_name
, DW_FORM_string
,
489 DW_AT_type
, DW_FORM_ref4
,
490 DW_AT_location
, DW_FORM_data4
493 static int inheritance_attr
[] = {
494 DW_AT_type
, DW_FORM_ref4
,
495 DW_AT_data_member_location
, DW_FORM_block1
498 typedef struct DwarfBasicType
{
499 const char *die_name
, *name
;
505 static DwarfBasicType basic_types
[] = {
506 { ".LDIE_I1", "sbyte", MONO_TYPE_I1
, 1, DW_ATE_signed
},
507 { ".LDIE_U1", "byte", MONO_TYPE_U1
, 1, DW_ATE_unsigned
},
508 { ".LDIE_I2", "short", MONO_TYPE_I2
, 2, DW_ATE_signed
},
509 { ".LDIE_U2", "ushort", MONO_TYPE_U2
, 2, DW_ATE_unsigned
},
510 { ".LDIE_I4", "int", MONO_TYPE_I4
, 4, DW_ATE_signed
},
511 { ".LDIE_U4", "uint", MONO_TYPE_U4
, 4, DW_ATE_unsigned
},
512 { ".LDIE_I8", "long", MONO_TYPE_I8
, 8, DW_ATE_signed
},
513 { ".LDIE_U8", "ulong", MONO_TYPE_U8
, 8, DW_ATE_unsigned
},
514 { ".LDIE_I", "intptr", MONO_TYPE_I
, SIZEOF_VOID_P
, DW_ATE_signed
},
515 { ".LDIE_U", "uintptr", MONO_TYPE_U
, SIZEOF_VOID_P
, DW_ATE_unsigned
},
516 { ".LDIE_R4", "float", MONO_TYPE_R4
, 4, DW_ATE_float
},
517 { ".LDIE_R8", "double", MONO_TYPE_R8
, 8, DW_ATE_float
},
518 { ".LDIE_BOOLEAN", "boolean", MONO_TYPE_BOOLEAN
, 1, DW_ATE_boolean
},
519 { ".LDIE_CHAR", "char", MONO_TYPE_CHAR
, 2, DW_ATE_unsigned_char
},
520 { ".LDIE_STRING", "string", MONO_TYPE_STRING
, sizeof (gpointer
), DW_ATE_address
},
521 { ".LDIE_OBJECT", "object", MONO_TYPE_OBJECT
, sizeof (gpointer
), DW_ATE_address
},
522 { ".LDIE_SZARRAY", "object", MONO_TYPE_SZARRAY
, sizeof (gpointer
), DW_ATE_address
},
525 /* Constants for encoding line number special opcodes */
526 #define OPCODE_BASE 13
528 #define LINE_RANGE 14
530 /* Subsections of the .debug_line section */
531 #define LINE_SUBSECTION_HEADER 1
532 #define LINE_SUBSECTION_INCLUDES 2
533 #define LINE_SUBSECTION_FILES 3
534 #define LINE_SUBSECTION_DATA 4
535 #define LINE_SUBSECTION_END 5
538 emit_line_number_file_name (MonoDwarfWriter
*w
, const char *name
,
539 gint64 last_mod_time
, gint64 file_size
)
543 char *basename
= NULL
;
545 if (!w
->file_to_index
)
546 w
->file_to_index
= g_hash_table_new (g_str_hash
, g_str_equal
);
548 index
= GPOINTER_TO_UINT (g_hash_table_lookup (w
->file_to_index
, name
));
552 if (g_path_is_absolute (name
)) {
553 char *dir
= g_path_get_dirname (name
);
555 if (!w
->dir_to_index
)
556 w
->dir_to_index
= g_hash_table_new (g_str_hash
, g_str_equal
);
558 dir_index
= GPOINTER_TO_UINT (g_hash_table_lookup (w
->dir_to_index
, dir
));
559 if (dir_index
== 0) {
560 emit_section_change (w
, ".debug_line", LINE_SUBSECTION_INCLUDES
);
561 emit_string (w
, dir
);
563 dir_index
= ++ w
->line_number_dir_index
;
564 g_hash_table_insert (w
->dir_to_index
, g_strdup (dir
), GUINT_TO_POINTER (dir_index
));
569 basename
= g_path_get_basename (name
);
574 emit_section_change (w
, ".debug_line", LINE_SUBSECTION_FILES
);
577 emit_string (w
, basename
);
579 emit_string (w
, name
);
580 emit_uleb128 (w
, dir_index
);
584 emit_section_change (w
, ".debug_line", LINE_SUBSECTION_DATA
);
589 index
= ++ w
->line_number_file_index
;
590 g_hash_table_insert (w
->file_to_index
, g_strdup (name
), GUINT_TO_POINTER (index
));
596 emit_line_number_info_begin (MonoDwarfWriter
*w
)
598 /* Line number info header */
600 * GAS seems to emit its own data to the end of the first subsection, so we use
601 * subsections 1, 2 etc:
602 * 1 - contains the header
603 * 2 - contains the file names
604 * 3 - contains the end of the header + the data
607 emit_section_change (w
, ".debug_line", 0);
608 emit_label (w
, ".Ldebug_line_section_start");
609 emit_section_change (w
, ".debug_line", LINE_SUBSECTION_HEADER
);
610 emit_label (w
, ".Ldebug_line_start");
611 emit_symbol_diff (w
, ".Ldebug_line_end", ".", -4); /* length */
612 emit_int16 (w
, 0x2); /* version */
613 emit_symbol_diff (w
, ".Ldebug_line_header_end", ".", -4); /* header_length */
614 emit_byte (w
, 1); /* minimum_instruction_length */
615 emit_byte (w
, 1); /* default_is_stmt */
616 emit_byte (w
, LINE_BASE
); /* line_base */
617 emit_byte (w
, LINE_RANGE
); /* line_range */
618 emit_byte (w
, OPCODE_BASE
); /* opcode_base */
619 emit_byte (w
, 0); /* standard_opcode_lengths */
633 emit_section_change (w
, ".debug_line", LINE_SUBSECTION_INCLUDES
);
635 /* End of Includes */
636 emit_section_change (w
, ".debug_line", LINE_SUBSECTION_FILES
);
640 emit_line_number_file_name (w
, "xdb.il", 0, 0);
643 emit_section_change (w
, ".debug_line", LINE_SUBSECTION_DATA
);
646 emit_label (w
, ".Ldebug_line_header_end");
648 /* Emit this into a separate subsection so it gets placed at the end */
649 emit_section_change (w
, ".debug_line", LINE_SUBSECTION_END
);
653 emit_byte (w
, DW_LNE_end_sequence
);
655 emit_label (w
, ".Ldebug_line_end");
659 * Some assemblers like apple's do not support subsections, so we can't place
660 * .Ldebug_info_end at the end of the section using subsections. Instead, we
661 * define it every time something gets added to the .debug_info section.
662 * The apple assember seems to use the last definition.
665 emit_debug_info_end (MonoDwarfWriter
*w
)
667 /* This doesn't seem to work/required with recent iphone sdk versions */
669 if (!img_writer_subsections_supported (w
->w
))
670 fprintf (w
->fp
, "\n.set %sdebug_info_end,.\n", w
->temp_prefix
);
675 mono_dwarf_writer_emit_base_info (MonoDwarfWriter
*w
, GSList
*base_unwind_program
)
677 char *s
, *build_info
;
680 if (!img_writer_subsections_supported (w
->w
))
681 /* Can't emit line number info without subsections */
682 w
->emit_line
= FALSE
;
686 w
->cie_program
= base_unwind_program
;
688 emit_section_change (w
, ".debug_abbrev", 0);
689 emit_dwarf_abbrev (w
, ABBREV_COMPILE_UNIT
, DW_TAG_compile_unit
, TRUE
,
690 compile_unit_attr
, G_N_ELEMENTS (compile_unit_attr
));
691 emit_dwarf_abbrev (w
, ABBREV_SUBPROGRAM
, DW_TAG_subprogram
, TRUE
,
692 subprogram_attr
, G_N_ELEMENTS (subprogram_attr
));
693 emit_dwarf_abbrev (w
, ABBREV_PARAM
, DW_TAG_formal_parameter
, FALSE
,
694 param_attr
, G_N_ELEMENTS (param_attr
));
695 emit_dwarf_abbrev (w
, ABBREV_PARAM_LOCLIST
, DW_TAG_formal_parameter
, FALSE
,
696 param_loclist_attr
, G_N_ELEMENTS (param_loclist_attr
));
697 emit_dwarf_abbrev (w
, ABBREV_BASE_TYPE
, DW_TAG_base_type
, FALSE
,
698 base_type_attr
, G_N_ELEMENTS (base_type_attr
));
699 emit_dwarf_abbrev (w
, ABBREV_STRUCT_TYPE
, DW_TAG_class_type
, TRUE
,
700 struct_type_attr
, G_N_ELEMENTS (struct_type_attr
));
701 emit_dwarf_abbrev (w
, ABBREV_STRUCT_TYPE_NOCHILDREN
, DW_TAG_class_type
, FALSE
,
702 struct_type_attr
, G_N_ELEMENTS (struct_type_attr
));
703 emit_dwarf_abbrev (w
, ABBREV_DATA_MEMBER
, DW_TAG_member
, FALSE
,
704 data_member_attr
, G_N_ELEMENTS (data_member_attr
));
705 emit_dwarf_abbrev (w
, ABBREV_TYPEDEF
, DW_TAG_typedef
, FALSE
,
706 typedef_attr
, G_N_ELEMENTS (typedef_attr
));
707 emit_dwarf_abbrev (w
, ABBREV_ENUM_TYPE
, DW_TAG_enumeration_type
, TRUE
,
708 enum_type_attr
, G_N_ELEMENTS (enum_type_attr
));
709 emit_dwarf_abbrev (w
, ABBREV_ENUMERATOR
, DW_TAG_enumerator
, FALSE
,
710 enumerator_attr
, G_N_ELEMENTS (enumerator_attr
));
711 emit_dwarf_abbrev (w
, ABBREV_NAMESPACE
, DW_TAG_namespace
, TRUE
,
712 namespace_attr
, G_N_ELEMENTS (namespace_attr
));
713 emit_dwarf_abbrev (w
, ABBREV_VARIABLE
, DW_TAG_variable
, FALSE
,
714 variable_attr
, G_N_ELEMENTS (variable_attr
));
715 emit_dwarf_abbrev (w
, ABBREV_VARIABLE_LOCLIST
, DW_TAG_variable
, FALSE
,
716 variable_loclist_attr
, G_N_ELEMENTS (variable_loclist_attr
));
717 emit_dwarf_abbrev (w
, ABBREV_POINTER_TYPE
, DW_TAG_pointer_type
, FALSE
,
718 pointer_type_attr
, G_N_ELEMENTS (pointer_type_attr
));
719 emit_dwarf_abbrev (w
, ABBREV_REFERENCE_TYPE
, DW_TAG_reference_type
, FALSE
,
720 reference_type_attr
, G_N_ELEMENTS (reference_type_attr
));
721 emit_dwarf_abbrev (w
, ABBREV_INHERITANCE
, DW_TAG_inheritance
, FALSE
,
722 inheritance_attr
, G_N_ELEMENTS (inheritance_attr
));
725 emit_section_change (w
, ".debug_info", 0);
726 emit_label (w
, ".Ldebug_info_start");
727 emit_symbol_diff (w
, ".Ldebug_info_end", ".Ldebug_info_begin", 0); /* length */
728 emit_label (w
, ".Ldebug_info_begin");
729 emit_int16 (w
, 0x2); /* DWARF version 2 */
730 emit_int32 (w
, 0); /* .debug_abbrev offset */
731 emit_byte (w
, sizeof (gpointer
)); /* address size */
733 if (img_writer_subsections_supported (w
->w
) && w
->appending
) {
734 /* Emit this into a separate section so it gets placed at the end */
735 emit_section_change (w
, ".debug_info", 1);
736 emit_byte (w
, 0); /* close COMPILE_UNIT */
737 emit_label (w
, ".Ldebug_info_end");
738 emit_section_change (w
, ".debug_info", 0);
741 /* Compilation unit */
742 emit_uleb128 (w
, ABBREV_COMPILE_UNIT
);
743 build_info
= mono_get_runtime_build_info ();
744 s
= g_strdup_printf ("Mono AOT Compiler %s", build_info
);
748 emit_string (w
, "JITted code");
750 emit_byte (w
, DW_LANG_C
);
751 emit_pointer_value (w
, 0);
752 emit_pointer_value (w
, 0);
753 /* offset into .debug_line section */
754 emit_symbol_diff (w
, ".Ldebug_line_start", ".Ldebug_line_section_start", 0);
757 for (i
= 0; i
< G_N_ELEMENTS (basic_types
); ++i
) {
758 emit_label (w
, basic_types
[i
].die_name
);
759 emit_uleb128 (w
, ABBREV_BASE_TYPE
);
760 emit_byte (w
, basic_types
[i
].size
);
761 emit_byte (w
, basic_types
[i
].encoding
);
762 emit_string (w
, basic_types
[i
].name
);
765 emit_debug_info_end (w
);
767 /* debug_loc section */
768 emit_section_change (w
, ".debug_loc", 0);
769 emit_label (w
, ".Ldebug_loc_start");
771 /* debug_line section */
773 * We emit some info even if emit_line is FALSE, as the
774 * apple linker seems to require a .debug_line section.
776 emit_line_number_info_begin (w
);
782 * mono_dwarf_writer_close:
784 * Finalize the emitted debugging info.
787 mono_dwarf_writer_close (MonoDwarfWriter
*w
)
790 emit_section_change (w
, ".debug_info", 0);
791 emit_byte (w
, 0); /* close COMPILE_UNIT */
792 emit_label (w
, ".Ldebug_info_end");
796 static const char* emit_type (MonoDwarfWriter
*w
, MonoType
*t
);
798 /* Returns the local symbol pointing to the emitted debug info */
800 emit_class_dwarf_info (MonoDwarfWriter
*w
, MonoClass
*klass
, gboolean vtype
)
802 char *die
, *pointer_die
, *reference_die
;
805 MonoClassField
*field
;
808 gboolean emit_namespace
= FALSE
, has_children
;
812 if (!w
->class_to_die
)
813 w
->class_to_die
= g_hash_table_new (NULL
, NULL
);
814 if (!w
->class_to_vtype_die
)
815 w
->class_to_vtype_die
= g_hash_table_new (NULL
, NULL
);
816 if (!w
->class_to_pointer_die
)
817 w
->class_to_pointer_die
= g_hash_table_new (NULL
, NULL
);
818 if (!w
->class_to_reference_die
)
819 w
->class_to_reference_die
= g_hash_table_new (NULL
, NULL
);
822 cache
= w
->class_to_vtype_die
;
824 cache
= w
->class_to_die
;
826 die
= g_hash_table_lookup (cache
, klass
);
830 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
)))
834 * FIXME: gdb can't handle namespaces in languages it doesn't know about.
837 if (klass->name_space && klass->name_space [0] != '\0')
838 emit_namespace = TRUE;
840 if (emit_namespace
) {
841 emit_uleb128 (w
, ABBREV_NAMESPACE
);
842 emit_string (w
, klass
->name_space
);
845 full_name
= g_strdup_printf ("%s%s%s", klass
->name_space
, klass
->name_space
? "." : "", klass
->name
);
847 * gdb doesn't support namespaces for non-C++ dwarf objects, so use _
848 * to separate components.
850 for (p
= full_name
; *p
; p
++)
854 die
= g_strdup_printf (".LTDIE_%d", w
->tdie_index
);
855 pointer_die
= g_strdup_printf (".LTDIE_%d_POINTER", w
->tdie_index
);
856 reference_die
= g_strdup_printf (".LTDIE_%d_REFERENCE", w
->tdie_index
);
859 g_hash_table_insert (w
->class_to_pointer_die
, klass
, pointer_die
);
860 g_hash_table_insert (w
->class_to_reference_die
, klass
, reference_die
);
861 g_hash_table_insert (cache
, klass
, die
);
863 if (klass
->enumtype
) {
864 int size
= mono_class_value_size (mono_class_from_mono_type (mono_class_enum_basetype (klass
)), NULL
);
868 emit_uleb128 (w
, ABBREV_ENUM_TYPE
);
869 emit_string (w
, full_name
);
870 emit_uleb128 (w
, size
);
871 for (k
= 0; k
< G_N_ELEMENTS (basic_types
); ++k
)
872 if (basic_types
[k
].type
== mono_class_enum_basetype (klass
)->type
)
874 g_assert (k
< G_N_ELEMENTS (basic_types
));
875 emit_symbol_diff (w
, basic_types
[k
].die_name
, ".Ldebug_info_start", 0);
877 /* Emit enum values */
879 while ((field
= mono_class_get_fields (klass
, &iter
))) {
882 MonoTypeEnum def_type
;
884 if (strcmp ("value__", mono_field_get_name (field
)) == 0)
886 if (mono_field_is_deleted (field
))
889 emit_uleb128 (w
, ABBREV_ENUMERATOR
);
890 emit_string (w
, mono_field_get_name (field
));
892 p
= mono_class_get_field_default_value (field
, &def_type
);
893 len
= mono_metadata_decode_blob_size (p
, &p
);
894 switch (mono_class_enum_basetype (klass
)->type
) {
897 case MONO_TYPE_BOOLEAN
:
898 emit_sleb128 (w
, *p
);
903 emit_sleb128 (w
, read16 (p
));
907 emit_sleb128 (w
, read32 (p
));
911 emit_sleb128 (w
, read64 (p
));
915 #if SIZEOF_VOID_P == 8
916 emit_sleb128 (w
, read64 (p
));
918 emit_sleb128 (w
, read32 (p
));
922 g_assert_not_reached ();
933 parent_die
= emit_class_dwarf_info (w
, klass
->parent
, FALSE
);
937 /* Emit field types */
939 while ((field
= mono_class_get_fields (klass
, &iter
))) {
940 if (field
->type
->attrs
& FIELD_ATTRIBUTE_STATIC
)
943 emit_type (w
, field
->type
);
947 has_children
= parent_die
|| mono_class_get_fields (klass
, &iter
);
951 emit_uleb128 (w
, has_children
? ABBREV_STRUCT_TYPE
: ABBREV_STRUCT_TYPE_NOCHILDREN
);
952 emit_string (w
, full_name
);
953 emit_uleb128 (w
, klass
->instance_size
);
956 emit_uleb128 (w
, ABBREV_INHERITANCE
);
957 emit_symbol_diff (w
, parent_die
, ".Ldebug_info_start", 0);
960 *p
++= DW_OP_plus_uconst
;
961 encode_uleb128 (0, p
, &p
);
962 emit_byte (w
, p
- buf
);
963 emit_bytes (w
, buf
, p
- buf
);
968 while ((field
= mono_class_get_fields (klass
, &iter
))) {
969 if (field
->type
->attrs
& FIELD_ATTRIBUTE_STATIC
)
972 fdie
= emit_type (w
, field
->type
);
974 emit_uleb128 (w
, ABBREV_DATA_MEMBER
);
975 emit_string (w
, field
->name
);
976 emit_symbol_diff (w
, fdie
, ".Ldebug_info_start", 0);
979 *p
++= DW_OP_plus_uconst
;
980 if (klass
->valuetype
&& vtype
)
981 encode_uleb128 (field
->offset
- sizeof (MonoObject
), p
, &p
);
983 encode_uleb128 (field
->offset
, p
, &p
);
985 emit_byte (w
, p
- buf
);
986 emit_bytes (w
, buf
, p
- buf
);
993 emit_uleb128 (w
, 0x0);
995 /* Add a typedef, so we can reference the type without a 'struct' in gdb */
996 emit_uleb128 (w
, ABBREV_TYPEDEF
);
997 emit_string (w
, full_name
);
998 emit_symbol_diff (w
, die
, ".Ldebug_info_start", 0);
1000 /* Add a pointer type */
1001 emit_label (w
, pointer_die
);
1003 emit_uleb128 (w
, ABBREV_POINTER_TYPE
);
1004 emit_symbol_diff (w
, die
, ".Ldebug_info_start", 0);
1006 /* Add a reference type */
1007 emit_label (w
, reference_die
);
1009 emit_uleb128 (w
, ABBREV_REFERENCE_TYPE
);
1010 emit_symbol_diff (w
, die
, ".Ldebug_info_start", 0);
1014 if (emit_namespace
) {
1016 emit_uleb128 (w
, 0x0);
1023 emit_type (MonoDwarfWriter
*w
, MonoType
*t
)
1025 MonoClass
*klass
= mono_class_from_mono_type (t
);
1030 if (t
->type
== MONO_TYPE_VALUETYPE
) {
1031 tdie
= emit_class_dwarf_info (w
, klass
, TRUE
);
1033 return g_hash_table_lookup (w
->class_to_pointer_die
, klass
);
1036 tdie
= emit_class_dwarf_info (w
, klass
, FALSE
);
1037 /* Should return a pointer type to a reference */
1040 t
= &mono_defaults
.int_class
->byval_arg
;
1042 for (j
= 0; j
< G_N_ELEMENTS (basic_types
); ++j
)
1043 if (basic_types
[j
].type
== t
->type
)
1045 if (j
< G_N_ELEMENTS (basic_types
))
1046 tdie
= basic_types
[j
].die_name
;
1049 case MONO_TYPE_CLASS
:
1050 emit_class_dwarf_info (w
, klass
, FALSE
);
1051 tdie
= g_hash_table_lookup (w
->class_to_reference_die
, klass
);
1052 //tdie = ".LDIE_OBJECT";
1054 case MONO_TYPE_ARRAY
:
1055 tdie
= ".LDIE_OBJECT";
1057 case MONO_TYPE_VALUETYPE
:
1058 if (klass
->enumtype
)
1059 tdie
= emit_class_dwarf_info (w
, klass
, FALSE
);
1063 case MONO_TYPE_GENERICINST
:
1064 if (!MONO_TYPE_ISSTRUCT (t
)) {
1065 emit_class_dwarf_info (w
, klass
, FALSE
);
1066 tdie
= g_hash_table_lookup (w
->class_to_reference_die
, klass
);
1084 emit_var_type (MonoDwarfWriter
*w
, MonoType
*t
)
1088 tdie
= emit_type (w
, t
);
1090 emit_symbol_diff (w
, tdie
, ".Ldebug_info_start", 0);
1094 encode_var_location (MonoDwarfWriter
*w
, MonoInst
*ins
, guint8
*p
, guint8
**endp
)
1097 /* FIXME: This needs a location list, since the args can go from reg->stack */
1098 if (!ins
|| ins
->flags
& MONO_INST_IS_DEAD
) {
1099 /* gdb treats this as optimized out */
1100 } else if (ins
->opcode
== OP_REGVAR
) {
1101 *p
= DW_OP_reg0
+ mono_hw_reg_to_dwarf_reg (ins
->dreg
);
1103 } else if (ins
->opcode
== OP_REGOFFSET
) {
1104 *p
++= DW_OP_breg0
+ mono_hw_reg_to_dwarf_reg (ins
->inst_basereg
);
1105 encode_sleb128 (ins
->inst_offset
, p
, &p
);
1115 emit_loclist (MonoDwarfWriter
*w
, MonoInst
*ins
,
1116 guint8
*loclist_begin_addr
, guint8
*loclist_end_addr
,
1117 guint8
*expr
, guint32 expr_len
)
1121 emit_push_section (w
, ".debug_loc", 0);
1122 sprintf (label
, ".Lloclist_%d", w
->loclist_index
++ );
1123 emit_label (w
, label
);
1125 emit_pointer_value (w
, loclist_begin_addr
);
1126 emit_pointer_value (w
, loclist_end_addr
);
1127 emit_byte (w
, expr_len
% 256);
1128 emit_byte (w
, expr_len
/ 256);
1129 emit_bytes (w
, expr
, expr_len
);
1131 emit_pointer_value (w
, NULL
);
1132 emit_pointer_value (w
, NULL
);
1134 emit_pop_section (w
);
1135 emit_symbol_diff (w
, label
, ".Ldebug_loc_start", 0);
1139 * MonoDisHelper->tokener doesn't take an IP argument, and we can't add one since
1140 * it is a public header.
1142 static const guint8
*token_handler_ip
;
1145 token_handler (MonoDisHelper
*dh
, MonoMethod
*method
, guint32 token
)
1148 MonoMethod
*cmethod
;
1150 MonoClassField
*field
;
1151 gpointer data
= NULL
;
1153 if (method
->wrapper_type
)
1154 data
= mono_method_get_wrapper_data (method
, token
);
1156 switch (*token_handler_ip
) {
1160 if (method
->wrapper_type
)
1163 klass
= mono_class_get_full (method
->klass
->image
, token
, NULL
);
1164 res
= g_strdup_printf ("<%s>", klass
->name
);
1169 if (method
->wrapper_type
)
1172 cmethod
= mono_get_method_full (method
->klass
->image
, token
, NULL
, NULL
);
1173 desc
= mono_method_full_name (cmethod
, TRUE
);
1174 res
= g_strdup_printf ("<%s>", desc
);
1178 if (method
->wrapper_type
) {
1179 desc
= mono_signature_get_desc (data
, FALSE
);
1180 res
= g_strdup_printf ("<%s>", desc
);
1183 res
= g_strdup_printf ("<0x%08x>", token
);
1190 if (method
->wrapper_type
)
1193 field
= mono_field_from_token (method
->klass
->image
, token
, &klass
, NULL
);
1194 desc
= mono_field_full_name (field
);
1195 res
= g_strdup_printf ("<%s>", desc
);
1199 res
= g_strdup_printf ("<0x%08x>", token
);
1209 * Produce a disassembled form of the IL instruction at IP. This is an extension
1210 * of mono_disasm_code_one () which can disasm tokens, handle wrapper methods, and
1211 * CEE_MONO_ opcodes.
1214 disasm_ins (MonoMethod
*method
, const guchar
*ip
, const guint8
**endip
)
1218 MonoMethodHeader
*header
= mono_method_get_header (method
);
1220 memset (&dh
, 0, sizeof (dh
));
1222 dh
.label_format
= "IL_%04x: ";
1223 dh
.label_target
= "IL_%04x";
1224 dh
.tokener
= token_handler
;
1226 token_handler_ip
= ip
;
1227 if (*ip
== MONO_CUSTOM_PREFIX
) {
1232 case CEE_MONO_ICALL
: {
1233 MonoJitICallInfo
*info
;
1235 token
= read32 (ip
+ 2);
1236 data
= mono_method_get_wrapper_data (method
, token
);
1237 info
= mono_find_jit_icall_by_addr (data
);
1240 dis
= g_strdup_printf ("IL_%04x: mono_icall <%s>", (int)(ip
- header
->code
), info
->name
);
1244 case CEE_MONO_CLASSCONST
: {
1245 token
= read32 (ip
+ 2);
1246 data
= mono_method_get_wrapper_data (method
, token
);
1248 dis
= g_strdup_printf ("IL_%04x: mono_classconst <%s>", (int)(ip
- header
->code
), ((MonoClass
*)data
)->name
);
1253 dis
= mono_disasm_code_one (&dh
, method
, ip
, &ip
);
1256 dis
= mono_disasm_code_one (&dh
, method
, ip
, &ip
);
1258 token_handler_ip
= NULL
;
1261 mono_metadata_free_mh (header
);
1266 il_offset_from_address (MonoMethod
*method
, MonoDebugMethodJitInfo
*jit
,
1267 guint32 native_offset
)
1271 if (!jit
->line_numbers
)
1274 for (i
= jit
->num_line_numbers
- 1; i
>= 0; i
--) {
1275 MonoDebugLineNumberEntry lne
= jit
->line_numbers
[i
];
1277 if (lne
.native_offset
<= native_offset
)
1278 return lne
.il_offset
;
1284 static int max_special_addr_diff
= 0;
1287 emit_advance_op (MonoDwarfWriter
*w
, int line_diff
, int addr_diff
)
1291 /* Use a special opcode if possible */
1292 if (line_diff
- LINE_BASE
>= 0 && line_diff
- LINE_BASE
< LINE_RANGE
) {
1293 if (max_special_addr_diff
== 0)
1294 max_special_addr_diff
= (255 - OPCODE_BASE
) / LINE_RANGE
;
1296 if (addr_diff
> max_special_addr_diff
&& (addr_diff
< 2 * max_special_addr_diff
)) {
1297 emit_byte (w
, DW_LNS_const_add_pc
);
1298 addr_diff
-= max_special_addr_diff
;
1301 opcode
= (line_diff
- LINE_BASE
) + (LINE_RANGE
* addr_diff
) + OPCODE_BASE
;
1307 emit_byte (w
, opcode
);
1309 emit_byte (w
, DW_LNS_advance_line
);
1310 emit_sleb128 (w
, line_diff
);
1311 emit_byte (w
, DW_LNS_advance_pc
);
1312 emit_sleb128 (w
, addr_diff
);
1313 emit_byte (w
, DW_LNS_copy
);
1318 compare_lne (MonoDebugLineNumberEntry
*a
, MonoDebugLineNumberEntry
*b
)
1320 if (a
->native_offset
== b
->native_offset
)
1321 return a
->il_offset
- b
->il_offset
;
1323 return a
->native_offset
- b
->native_offset
;
1327 emit_line_number_info (MonoDwarfWriter
*w
, MonoMethod
*method
,
1328 char *start_symbol
, char *end_symbol
,
1329 guint8
*code
, guint32 code_size
,
1330 MonoDebugMethodJitInfo
*debug_info
)
1332 guint32 prev_line
= 0;
1333 guint32 prev_native_offset
= 0;
1334 int i
, file_index
, il_offset
, prev_il_offset
;
1335 gboolean first
= TRUE
;
1336 MonoDebugSourceLocation
*loc
;
1337 char *prev_file_name
= NULL
;
1338 MonoMethodHeader
*header
= mono_method_get_header (method
);
1339 MonoDebugMethodInfo
*minfo
;
1341 int *native_to_il_offset
= NULL
;
1343 if (!w
->emit_line
) {
1344 mono_metadata_free_mh (header
);
1348 minfo
= mono_debug_lookup_method (method
);
1350 /* Compute the native->IL offset mapping */
1352 g_assert (code_size
);
1355 mono_metadata_free_mh (header
);
1356 /* g_array is not implemented in eglib */
1359 ln_array
= g_array_sized_new (FALSE
, FALSE
, sizeof (MonoDebugLineNumberEntry
),
1360 debug_info
->num_line_numbers
);
1361 g_array_append_vals (ln_array
, debug_info
->line_numbers
, debug_info
->num_line_numbers
);
1362 g_array_sort (ln_array
, (GCompareFunc
)compare_lne
);
1363 native_to_il_offset
= g_new0 (int, code_size
+ 1);
1365 for (i
= 0; i
< debug_info
->num_line_numbers
; ++i
) {
1367 MonoDebugLineNumberEntry lne
= g_array_index (ln_array
, MonoDebugLineNumberEntry
, i
);
1370 for (j
= 0; j
< lne
.native_offset
; ++j
)
1371 native_to_il_offset
[j
] = -1;
1374 if (i
< debug_info
->num_line_numbers
- 1) {
1375 MonoDebugLineNumberEntry lne_next
= g_array_index (ln_array
, MonoDebugLineNumberEntry
, i
+ 1);
1377 for (j
= lne
.native_offset
; j
< lne_next
.native_offset
; ++j
)
1378 native_to_il_offset
[j
] = lne
.il_offset
;
1380 for (j
= lne
.native_offset
; j
< code_size
; ++j
)
1381 native_to_il_offset
[j
] = lne
.il_offset
;
1384 g_array_free (ln_array
, TRUE
);
1388 prev_il_offset
= -1;
1390 for (i
= 0; i
< code_size
; ++i
) {
1394 if (!debug_info
->line_numbers
)
1397 if (native_to_il_offset
)
1398 il_offset
= native_to_il_offset
[i
];
1400 il_offset
= il_offset_from_address (method
, debug_info
, i
);
1402 il_offset = il_offset_from_address (method, debug_info, i);
1404 g_assert (il_offset == native_to_il_offset [i]);
1407 il_offset
= native_to_il_offset
[i
];
1411 if (il_offset
== prev_il_offset
)
1414 prev_il_offset
= il_offset
;
1416 loc
= mono_debug_symfile_lookup_location (minfo
, il_offset
);
1418 // Added the loc->source_file check as otherwise we can
1419 // crash, see the sample in bug 553191 that makes this code
1420 // crash when we call strcmp on loc->source_file below
1421 if (loc
&& loc
->source_file
) {
1422 int line_diff
= (gint32
)loc
->row
- (gint32
)prev_line
;
1423 int addr_diff
= i
- prev_native_offset
;
1426 emit_section_change (w
, ".debug_line", LINE_SUBSECTION_DATA
);
1429 emit_byte (w
, sizeof (gpointer
) + 1);
1430 emit_byte (w
, DW_LNE_set_address
);
1432 emit_pointer_unaligned (w
, start_symbol
);
1434 emit_pointer_value (w
, code
);
1437 * The prolog+initlocals region does not have a line number, this
1438 * makes them belong to the first line of the method.
1440 emit_byte (w
, DW_LNS_advance_line
);
1441 emit_sleb128 (w
, (gint32
)loc
->row
- (gint32
)prev_line
);
1442 prev_line
= loc
->row
;
1445 if (loc
->row
!= prev_line
) {
1446 if (!prev_file_name
|| strcmp (loc
->source_file
, prev_file_name
) != 0) {
1447 /* Add an entry to the file table */
1448 /* FIXME: Avoid duplicates */
1449 file_index
= emit_line_number_file_name (w
, loc
->source_file
, 0, 0);
1450 g_free (prev_file_name
);
1451 prev_file_name
= g_strdup (loc
->source_file
);
1453 emit_byte (w
, DW_LNS_set_file
);
1454 emit_uleb128 (w
, file_index
);
1455 emit_byte (w
, DW_LNS_copy
);
1458 //printf ("X: %p(+0x%x) %d %s:%d(+%d)\n", code + i, addr_diff, loc->il_offset, loc->source_file, loc->row, line_diff);
1460 emit_advance_op (w
, line_diff
, addr_diff
);
1462 prev_line
= loc
->row
;
1463 prev_native_offset
= i
;
1471 g_free (prev_file_name
);
1474 emit_byte (w
, DW_LNS_advance_pc
);
1475 emit_sleb128 (w
, code_size
- prev_native_offset
);
1476 emit_byte (w
, DW_LNS_copy
);
1480 emit_byte (w
, DW_LNE_end_sequence
);
1481 } else if (!start_symbol
) {
1482 /* No debug info, XDEBUG mode */
1484 const guint8
*ip
= header
->code
;
1485 int prev_line
, prev_native_offset
;
1489 * Emit the IL code into a temporary file and emit line number info
1490 * referencing that file.
1493 name
= mono_method_full_name (method
, TRUE
);
1494 fprintf (w
->il_file
, "// %s\n", name
);
1495 w
->il_file_line_index
++;
1498 il_to_line
= g_new0 (int, header
->code_size
);
1500 emit_section_change (w
, ".debug_line", LINE_SUBSECTION_DATA
);
1502 emit_byte (w
, sizeof (gpointer
) + 1);
1503 emit_byte (w
, DW_LNE_set_address
);
1504 emit_pointer_value (w
, code
);
1506 // FIXME: Optimize this
1507 while (ip
< header
->code
+ header
->code_size
) {
1508 int il_offset
= ip
- header
->code
;
1511 w
->il_file_line_index
++;
1513 dis
= disasm_ins (method
, ip
, &ip
);
1514 fprintf (w
->il_file
, "%s\n", dis
);
1517 il_to_line
[il_offset
] = w
->il_file_line_index
;
1520 /* Emit line number info */
1522 prev_native_offset
= 0;
1523 for (i
= 0; i
< debug_info
->num_line_numbers
; ++i
) {
1524 MonoDebugLineNumberEntry
*lne
= &debug_info
->line_numbers
[i
];
1527 if (lne
->il_offset
>= header
->code_size
)
1529 line
= il_to_line
[lne
->il_offset
];
1532 * This seems to happen randomly, it looks like il_offset points
1533 * into the middle of an instruction.
1537 printf ("%s\n", mono_method_full_name (method, TRUE));
1538 printf ("%d %d\n", lne->il_offset, header->code_size);
1543 if (line
- prev_line
!= 0) {
1544 emit_advance_op (w
, line
- prev_line
, (gint32
)lne
->native_offset
- prev_native_offset
);
1547 prev_native_offset
= lne
->native_offset
;
1551 emit_byte (w
, DW_LNS_advance_pc
);
1552 emit_sleb128 (w
, code_size
- prev_native_offset
);
1553 emit_byte (w
, DW_LNS_copy
);
1557 emit_byte (w
, DW_LNE_end_sequence
);
1559 fflush (w
->il_file
);
1560 g_free (il_to_line
);
1562 mono_metadata_free_mh (header
);
1565 static MonoMethodVar
*
1566 find_vmv (MonoCompile
*cfg
, MonoInst
*ins
)
1571 for (j
= 0; j
< cfg
->num_varinfo
; ++j
) {
1572 if (cfg
->varinfo
[j
] == ins
)
1576 if (j
< cfg
->num_varinfo
) {
1577 return MONO_VARINFO (cfg
, j
);
1585 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
)
1588 MonoMethodSignature
*sig
;
1589 MonoMethodHeader
*header
;
1590 char **names
, **tdies
, **local_tdies
;
1597 emit_section_change (w
, ".debug_info", 0);
1599 sig
= mono_method_signature (method
);
1600 header
= mono_method_get_header (method
);
1602 /* Parameter types */
1603 tdies
= g_new0 (char *, sig
->param_count
+ sig
->hasthis
);
1604 for (i
= 0; i
< sig
->param_count
+ sig
->hasthis
; ++i
) {
1607 if (i
== 0 && sig
->hasthis
) {
1608 if (method
->klass
->valuetype
)
1609 t
= &method
->klass
->this_arg
;
1611 t
= &method
->klass
->byval_arg
;
1613 t
= sig
->params
[i
- sig
->hasthis
];
1620 local_tdies
= g_new0 (char *, header
->num_locals
);
1621 for (i
= 0; i
< header
->num_locals
; ++i
) {
1622 emit_type (w
, header
->locals
[i
]);
1626 names
= g_new0 (char *, sig
->param_count
);
1627 mono_method_get_param_names (method
, (const char **) names
);
1629 emit_uleb128 (w
, ABBREV_SUBPROGRAM
);
1630 name
= mono_method_full_name (method
, FALSE
);
1631 emit_string (w
, name
);
1634 emit_pointer_unaligned (w
, start_symbol
);
1635 emit_pointer_unaligned (w
, end_symbol
);
1637 emit_pointer_value (w
, code
);
1638 emit_pointer_value (w
, code
+ code_size
);
1642 emit_byte (w
, DW_OP_breg6
);
1646 for (i
= 0; i
< sig
->param_count
+ sig
->hasthis
; ++i
) {
1647 MonoInst
*arg
= args
? args
[i
] : NULL
;
1650 char pname_buf
[128];
1651 MonoMethodVar
*vmv
= NULL
;
1652 gboolean need_loclist
= FALSE
;
1654 vmv
= find_vmv (cfg
, arg
);
1655 if (code
&& vmv
&& (vmv
->live_range_start
|| vmv
->live_range_end
))
1656 need_loclist
= TRUE
;
1658 if (i
== 0 && sig
->hasthis
) {
1659 if (method
->klass
->valuetype
)
1660 t
= &method
->klass
->this_arg
;
1662 t
= &method
->klass
->byval_arg
;
1665 t
= sig
->params
[i
- sig
->hasthis
];
1666 pname
= names
[i
- sig
->hasthis
];
1669 emit_uleb128 (w
, need_loclist
? ABBREV_PARAM_LOCLIST
: ABBREV_PARAM
);
1671 if (pname
[0] == '\0') {
1672 sprintf (pname_buf
, "param%d", i
- sig
->hasthis
);
1675 emit_string (w
, pname
);
1677 if (!arg
|| arg
->flags
& MONO_INST_IS_DEAD
)
1678 emit_var_type (w
, &mono_defaults
.int32_class
->byval_arg
);
1680 emit_var_type (w
, t
);
1683 encode_var_location (w
, arg
, p
, &p
);
1685 vmv
->live_range_start
= 0;
1686 if (vmv
->live_range_end
== 0)
1687 /* FIXME: Uses made in calls are not recorded */
1688 vmv
->live_range_end
= code_size
;
1689 emit_loclist (w
, arg
, code
+ vmv
->live_range_start
, code
+ vmv
->live_range_end
, buf
, p
- buf
);
1691 emit_byte (w
, p
- buf
);
1692 emit_bytes (w
, buf
, p
- buf
);
1698 num_locals
= mono_debug_lookup_locals (method
, &local_names
, &local_indexes
);
1700 for (i
= 0; i
< header
->num_locals
; ++i
) {
1701 MonoInst
*ins
= locals
[i
];
1702 char name_buf
[128];
1704 MonoMethodVar
*vmv
= NULL
;
1705 gboolean need_loclist
= FALSE
;
1707 /* ins->dreg no longer contains the original vreg */
1708 vmv
= find_vmv (cfg
, ins
);
1710 if (vmv
->live_range_start
) {
1711 /* This variable has a precise live range */
1712 need_loclist
= TRUE
;
1716 emit_uleb128 (w
, need_loclist
? ABBREV_VARIABLE_LOCLIST
: ABBREV_VARIABLE
);
1718 for (j
= 0; j
< num_locals
; ++j
)
1719 if (local_indexes
[j
] == i
)
1721 if (j
< num_locals
) {
1722 emit_string (w
, local_names
[j
]);
1724 sprintf (name_buf
, "V_%d", i
);
1725 emit_string (w
, name_buf
);
1728 if (!ins
|| ins
->flags
& MONO_INST_IS_DEAD
)
1729 emit_var_type (w
, &mono_defaults
.int32_class
->byval_arg
);
1731 emit_var_type (w
, header
->locals
[i
]);
1734 encode_var_location (w
, ins
, p
, &p
);
1737 if (vmv
->live_range_end
== 0)
1738 /* FIXME: Uses made in calls are not recorded */
1739 vmv
->live_range_end
= code_size
;
1740 emit_loclist (w
, ins
, code
+ vmv
->live_range_start
, code
+ vmv
->live_range_end
, buf
, p
- buf
);
1742 emit_byte (w
, p
- buf
);
1743 emit_bytes (w
, buf
, p
- buf
);
1747 g_free (local_names
);
1748 g_free (local_indexes
);
1750 /* Subprogram end */
1751 emit_uleb128 (w
, 0x0);
1755 emit_debug_info_end (w
);
1757 /* Emit unwind info */
1759 emit_fde (w
, w
->fde_index
, start_symbol
, end_symbol
, code
, code_size
, unwind_info
, TRUE
);
1763 /* Emit line number info */
1764 /* != could happen when using --regression */
1765 if (debug_info
&& (debug_info
->code_start
== code
))
1766 emit_line_number_info (w
, method
, start_symbol
, end_symbol
, code
, code_size
, debug_info
);
1769 mono_metadata_free_mh (header
);
1773 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
)
1775 emit_section_change (w
, ".debug_info", 0);
1778 emit_uleb128 (w
, ABBREV_SUBPROGRAM
);
1779 emit_string (w
, tramp_name
);
1780 emit_pointer_value (w
, code
);
1781 emit_pointer_value (w
, code
+ code_size
);
1784 emit_byte (w
, DW_OP_breg6
);
1787 /* Subprogram end */
1788 emit_uleb128 (w
, 0x0);
1790 emit_debug_info_end (w
);
1792 /* Emit unwind info */
1793 emit_fde (w
, w
->fde_index
, start_symbol
, end_symbol
, code
, code_size
, unwind_info
, FALSE
);
1796 #endif /* End of: !defined(DISABLE_AOT) && !defined(DISABLE_JIT) */