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>
26 #ifndef PLATFORM_WIN32
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
, 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
->appending
= appending
;
78 g_assert (img_writer_subsections_supported (w
->w
));
80 w
->fp
= img_writer_get_fp (w
->w
);
81 w
->temp_prefix
= img_writer_get_temp_label_prefix (w
->w
);
87 mono_dwarf_writer_destroy (MonoDwarfWriter
*w
)
92 /* Wrappers around the image writer functions */
95 emit_section_change (MonoDwarfWriter
*w
, const char *section_name
, int subsection_index
)
97 img_writer_emit_section_change (w
->w
, section_name
, subsection_index
);
101 emit_push_section (MonoDwarfWriter
*w
, const char *section_name
, int subsection
)
103 img_writer_emit_push_section (w
->w
, section_name
, subsection
);
107 emit_pop_section (MonoDwarfWriter
*w
)
109 img_writer_emit_pop_section (w
->w
);
113 emit_local_symbol (MonoDwarfWriter
*w
, const char *name
, const char *end_label
, gboolean func
)
115 img_writer_emit_local_symbol (w
->w
, name
, end_label
, func
);
119 emit_label (MonoDwarfWriter
*w
, const char *name
)
121 img_writer_emit_label (w
->w
, name
);
125 emit_bytes (MonoDwarfWriter
*w
, const guint8
* buf
, int size
)
127 img_writer_emit_bytes (w
->w
, buf
, size
);
131 emit_string (MonoDwarfWriter
*w
, const char *value
)
133 img_writer_emit_string (w
->w
, value
);
137 emit_line (MonoDwarfWriter
*w
)
139 img_writer_emit_line (w
->w
);
143 emit_alignment (MonoDwarfWriter
*w
, int size
)
145 img_writer_emit_alignment (w
->w
, size
);
149 emit_pointer_unaligned (MonoDwarfWriter
*w
, const char *target
)
151 img_writer_emit_pointer_unaligned (w
->w
, target
);
155 emit_pointer (MonoDwarfWriter
*w
, const char *target
)
157 img_writer_emit_pointer (w
->w
, target
);
161 emit_int16 (MonoDwarfWriter
*w
, int value
)
163 img_writer_emit_int16 (w
->w
, value
);
167 emit_int32 (MonoDwarfWriter
*w
, int value
)
169 img_writer_emit_int32 (w
->w
, value
);
173 emit_symbol_diff (MonoDwarfWriter
*w
, const char *end
, const char* start
, int offset
)
175 img_writer_emit_symbol_diff (w
->w
, end
, start
, offset
);
179 emit_zero_bytes (MonoDwarfWriter
*w
, int num
)
181 img_writer_emit_zero_bytes (w
->w
, num
);
185 emit_byte (MonoDwarfWriter
*w
, guint8 val
)
187 img_writer_emit_byte (w
->w
, val
);
190 static G_GNUC_UNUSED
void
191 emit_uleb128 (MonoDwarfWriter
*w
, guint32 value
)
194 guint8 b
= value
& 0x7f;
196 if (value
!= 0) /* more bytes to come */
202 static G_GNUC_UNUSED
void
203 emit_sleb128 (MonoDwarfWriter
*w
, gint64 value
)
206 gboolean negative
= (value
< 0);
213 /* the following is unnecessary if the
214 * implementation of >>= uses an arithmetic rather
215 * than logical shift for a signed left operand
219 value
|= - ((gint64
)1 <<(size
- 7));
220 /* sign bit of byte is second high order bit (0x40) */
221 if ((value
== 0 && !(byte
& 0x40)) ||
222 (value
== -1 && (byte
& 0x40)))
230 static G_GNUC_UNUSED
void
231 encode_uleb128 (guint32 value
, guint8
*buf
, guint8
**endbuf
)
236 guint8 b
= value
& 0x7f;
238 if (value
!= 0) /* more bytes to come */
246 static G_GNUC_UNUSED
void
247 encode_sleb128 (gint32 value
, guint8
*buf
, guint8
**endbuf
)
250 gboolean negative
= (value
< 0);
258 /* the following is unnecessary if the
259 * implementation of >>= uses an arithmetic rather
260 * than logical shift for a signed left operand
264 value
|= - (1 <<(size
- 7));
265 /* sign bit of byte is second high order bit (0x40) */
266 if ((value
== 0 && !(byte
& 0x40)) ||
267 (value
== -1 && (byte
& 0x40)))
278 emit_dwarf_abbrev (MonoDwarfWriter
*w
, int code
, int tag
, gboolean has_child
,
279 int *attrs
, int attrs_len
)
283 emit_uleb128 (w
, code
);
284 emit_uleb128 (w
, tag
);
285 emit_byte (w
, has_child
);
287 for (i
= 0; i
< attrs_len
; i
++)
288 emit_uleb128 (w
, attrs
[i
]);
294 emit_cie (MonoDwarfWriter
*w
)
296 emit_section_change (w
, ".debug_frame", 0);
298 emit_alignment (w
, 8);
301 emit_symbol_diff (w
, ".Lcie0_end", ".Lcie0_start", 0); /* length */
302 emit_label (w
, ".Lcie0_start");
303 emit_int32 (w
, 0xffffffff); /* CIE id */
304 emit_byte (w
, 3); /* version */
305 emit_string (w
, ""); /* augmention */
306 emit_sleb128 (w
, 1); /* code alignment factor */
307 emit_sleb128 (w
, mono_unwind_get_dwarf_data_align ()); /* data alignment factor */
308 emit_uleb128 (w
, mono_unwind_get_dwarf_pc_reg ());
310 w
->cie_program
= w
->cie_program
;
311 if (w
->cie_program
) {
313 guint8
*uw_info
= mono_unwind_ops_encode (w
->cie_program
, &uw_info_len
);
314 emit_bytes (w
, uw_info
, uw_info_len
);
318 emit_alignment (w
, sizeof (gpointer
));
319 emit_label (w
, ".Lcie0_end");
323 emit_pointer_value (MonoDwarfWriter
*w
, gpointer ptr
)
325 gssize val
= (gssize
)ptr
;
326 emit_bytes (w
, (guint8
*)&val
, sizeof (gpointer
));
330 emit_fde (MonoDwarfWriter
*w
, int fde_index
, char *start_symbol
, char *end_symbol
,
331 guint8
*code
, guint32 code_size
, GSList
*unwind_ops
, gboolean use_cie
)
339 emit_section_change (w
, ".debug_frame", 0);
341 sprintf (symbol1
, ".Lfde%d_start", fde_index
);
342 sprintf (symbol2
, ".Lfde%d_end", fde_index
);
343 emit_symbol_diff (w
, symbol2
, symbol1
, 0); /* length */
344 emit_label (w
, symbol1
);
345 emit_int32 (w
, 0); /* CIE_pointer */
347 emit_pointer (w
, start_symbol
); /* initial_location */
349 emit_symbol_diff (w
, end_symbol
, start_symbol
, 0); /* address_range */
351 g_assert (code_size
);
352 emit_int32 (w
, code_size
);
355 emit_pointer_value (w
, code
);
356 emit_int32 (w
, code_size
);
358 #if SIZEOF_VOID_P == 8
359 /* Upper 32 bits of code size */
364 if (w
->cie_program
) {
365 // FIXME: Check that the ops really begin with the CIE program */
368 for (i
= 0; i
< g_slist_length (w
->cie_program
); ++i
)
372 /* Convert the list of MonoUnwindOps to the format used by DWARF */
373 uw_info
= mono_unwind_ops_encode (l
, &uw_info_len
);
374 emit_bytes (w
, uw_info
, uw_info_len
);
377 emit_alignment (w
, sizeof (mgreg_t
));
378 emit_label (w
, symbol2
);
382 #define ABBREV_COMPILE_UNIT 1
383 #define ABBREV_SUBPROGRAM 2
384 #define ABBREV_PARAM 3
385 #define ABBREV_BASE_TYPE 4
386 #define ABBREV_STRUCT_TYPE 5
387 #define ABBREV_DATA_MEMBER 6
388 #define ABBREV_TYPEDEF 7
389 #define ABBREV_ENUM_TYPE 8
390 #define ABBREV_ENUMERATOR 9
391 #define ABBREV_NAMESPACE 10
392 #define ABBREV_VARIABLE 11
393 #define ABBREV_VARIABLE_LOCLIST 12
394 #define ABBREV_POINTER_TYPE 13
395 #define ABBREV_REFERENCE_TYPE 14
396 #define ABBREV_PARAM_LOCLIST 15
397 #define ABBREV_INHERITANCE 16
398 #define ABBREV_STRUCT_TYPE_NOCHILDREN 17
400 static int compile_unit_attr
[] = {
401 DW_AT_producer
,DW_FORM_string
,
402 DW_AT_name
,DW_FORM_string
,
403 DW_AT_comp_dir
,DW_FORM_string
,
404 DW_AT_language
,DW_FORM_data1
,
405 DW_AT_low_pc
,DW_FORM_addr
,
406 DW_AT_high_pc
,DW_FORM_addr
,
407 DW_AT_stmt_list
,DW_FORM_data4
410 static int subprogram_attr
[] = {
411 DW_AT_name
, DW_FORM_string
,
412 DW_AT_low_pc
, DW_FORM_addr
,
413 DW_AT_high_pc
, DW_FORM_addr
,
414 DW_AT_frame_base
, DW_FORM_block1
417 static int param_attr
[] = {
418 DW_AT_name
, DW_FORM_string
,
419 DW_AT_type
, DW_FORM_ref4
,
420 DW_AT_location
, DW_FORM_block1
423 static int param_loclist_attr
[] = {
424 DW_AT_name
, DW_FORM_string
,
425 DW_AT_type
, DW_FORM_ref4
,
426 DW_AT_location
, DW_FORM_data4
429 static int base_type_attr
[] = {
430 DW_AT_byte_size
, DW_FORM_data1
,
431 DW_AT_encoding
, DW_FORM_data1
,
432 DW_AT_name
, DW_FORM_string
435 static int struct_type_attr
[] = {
436 DW_AT_name
, DW_FORM_string
,
437 DW_AT_byte_size
, DW_FORM_udata
,
440 static int data_member_attr
[] = {
441 DW_AT_name
, DW_FORM_string
,
442 DW_AT_type
, DW_FORM_ref4
,
443 DW_AT_data_member_location
, DW_FORM_block1
446 static int typedef_attr
[] = {
447 DW_AT_name
, DW_FORM_string
,
448 DW_AT_type
, DW_FORM_ref4
451 static int pointer_type_attr
[] = {
452 DW_AT_type
, DW_FORM_ref4
,
455 static int reference_type_attr
[] = {
456 DW_AT_type
, DW_FORM_ref4
,
459 static int enum_type_attr
[] = {
460 DW_AT_name
, DW_FORM_string
,
461 DW_AT_byte_size
, DW_FORM_udata
,
462 DW_AT_type
, DW_FORM_ref4
,
465 static int enumerator_attr
[] = {
466 DW_AT_name
, DW_FORM_string
,
467 DW_AT_const_value
, DW_FORM_sdata
,
470 static int namespace_attr
[] = {
471 DW_AT_name
, DW_FORM_string
,
474 static int variable_attr
[] = {
475 DW_AT_name
, DW_FORM_string
,
476 DW_AT_type
, DW_FORM_ref4
,
477 DW_AT_location
, DW_FORM_block1
480 static int variable_loclist_attr
[] = {
481 DW_AT_name
, DW_FORM_string
,
482 DW_AT_type
, DW_FORM_ref4
,
483 DW_AT_location
, DW_FORM_data4
486 static int inheritance_attr
[] = {
487 DW_AT_type
, DW_FORM_ref4
,
488 DW_AT_data_member_location
, DW_FORM_block1
491 typedef struct DwarfBasicType
{
492 const char *die_name
, *name
;
498 static DwarfBasicType basic_types
[] = {
499 { ".LDIE_I1", "sbyte", MONO_TYPE_I1
, 1, DW_ATE_signed
},
500 { ".LDIE_U1", "byte", MONO_TYPE_U1
, 1, DW_ATE_unsigned
},
501 { ".LDIE_I2", "short", MONO_TYPE_I2
, 2, DW_ATE_signed
},
502 { ".LDIE_U2", "ushort", MONO_TYPE_U2
, 2, DW_ATE_unsigned
},
503 { ".LDIE_I4", "int", MONO_TYPE_I4
, 4, DW_ATE_signed
},
504 { ".LDIE_U4", "uint", MONO_TYPE_U4
, 4, DW_ATE_unsigned
},
505 { ".LDIE_I8", "long", MONO_TYPE_I8
, 8, DW_ATE_signed
},
506 { ".LDIE_U8", "ulong", MONO_TYPE_U8
, 8, DW_ATE_unsigned
},
507 { ".LDIE_I", "intptr", MONO_TYPE_I
, SIZEOF_VOID_P
, DW_ATE_signed
},
508 { ".LDIE_U", "uintptr", MONO_TYPE_U
, SIZEOF_VOID_P
, DW_ATE_unsigned
},
509 { ".LDIE_R4", "float", MONO_TYPE_R4
, 4, DW_ATE_float
},
510 { ".LDIE_R8", "double", MONO_TYPE_R8
, 8, DW_ATE_float
},
511 { ".LDIE_BOOLEAN", "boolean", MONO_TYPE_BOOLEAN
, 1, DW_ATE_boolean
},
512 { ".LDIE_CHAR", "char", MONO_TYPE_CHAR
, 2, DW_ATE_unsigned_char
},
513 { ".LDIE_STRING", "string", MONO_TYPE_STRING
, sizeof (gpointer
), DW_ATE_address
},
514 { ".LDIE_OBJECT", "object", MONO_TYPE_OBJECT
, sizeof (gpointer
), DW_ATE_address
},
515 { ".LDIE_SZARRAY", "object", MONO_TYPE_SZARRAY
, sizeof (gpointer
), DW_ATE_address
},
518 /* Constants for encoding line number special opcodes */
519 #define OPCODE_BASE 13
521 #define LINE_RANGE 14
523 /* Subsections of the .debug_line section */
524 #define LINE_SUBSECTION_HEADER 1
525 #define LINE_SUBSECTION_INCLUDES 2
526 #define LINE_SUBSECTION_FILES 3
527 #define LINE_SUBSECTION_DATA 4
528 #define LINE_SUBSECTION_END 5
531 emit_line_number_file_name (MonoDwarfWriter
*w
, const char *name
,
532 gint64 last_mod_time
, gint64 file_size
)
536 char *basename
= NULL
;
538 if (!w
->file_to_index
)
539 w
->file_to_index
= g_hash_table_new (g_str_hash
, g_str_equal
);
541 index
= GPOINTER_TO_UINT (g_hash_table_lookup (w
->file_to_index
, name
));
545 if (g_path_is_absolute (name
)) {
546 char *dir
= g_path_get_dirname (name
);
548 if (!w
->dir_to_index
)
549 w
->dir_to_index
= g_hash_table_new (g_str_hash
, g_str_equal
);
551 dir_index
= GPOINTER_TO_UINT (g_hash_table_lookup (w
->dir_to_index
, dir
));
552 if (dir_index
== 0) {
553 emit_section_change (w
, ".debug_line", LINE_SUBSECTION_INCLUDES
);
554 emit_string (w
, dir
);
556 dir_index
= ++ w
->line_number_dir_index
;
557 g_hash_table_insert (w
->dir_to_index
, g_strdup (dir
), GUINT_TO_POINTER (dir_index
));
562 basename
= g_path_get_basename (name
);
567 emit_section_change (w
, ".debug_line", LINE_SUBSECTION_FILES
);
570 emit_string (w
, basename
);
572 emit_string (w
, name
);
573 emit_uleb128 (w
, dir_index
);
577 emit_section_change (w
, ".debug_line", LINE_SUBSECTION_DATA
);
582 index
= ++ w
->line_number_file_index
;
583 g_hash_table_insert (w
->file_to_index
, g_strdup (name
), GUINT_TO_POINTER (index
));
589 emit_line_number_info_begin (MonoDwarfWriter
*w
)
591 /* Line number info header */
593 * GAS seems to emit its own data to the end of the first subsection, so we use
594 * subsections 1, 2 etc:
595 * 1 - contains the header
596 * 2 - contains the file names
597 * 3 - contains the end of the header + the data
600 emit_section_change (w
, ".debug_line", 0);
601 emit_label (w
, ".Ldebug_line_section_start");
602 emit_section_change (w
, ".debug_line", LINE_SUBSECTION_HEADER
);
603 emit_label (w
, ".Ldebug_line_start");
604 emit_symbol_diff (w
, ".Ldebug_line_end", ".", -4); /* length */
605 emit_int16 (w
, 0x2); /* version */
606 emit_symbol_diff (w
, ".Ldebug_line_header_end", ".", -4); /* header_length */
607 emit_byte (w
, 1); /* minimum_instruction_length */
608 emit_byte (w
, 1); /* default_is_stmt */
609 emit_byte (w
, LINE_BASE
); /* line_base */
610 emit_byte (w
, LINE_RANGE
); /* line_range */
611 emit_byte (w
, OPCODE_BASE
); /* opcode_base */
612 emit_byte (w
, 0); /* standard_opcode_lengths */
626 emit_section_change (w
, ".debug_line", LINE_SUBSECTION_INCLUDES
);
628 /* End of Includes */
629 emit_section_change (w
, ".debug_line", LINE_SUBSECTION_FILES
);
633 emit_line_number_file_name (w
, "xdb.il", 0, 0);
636 emit_section_change (w
, ".debug_line", LINE_SUBSECTION_DATA
);
639 emit_label (w
, ".Ldebug_line_header_end");
641 /* Emit this into a separate subsection so it gets placed at the end */
642 emit_section_change (w
, ".debug_line", LINE_SUBSECTION_END
);
646 emit_byte (w
, DW_LNE_end_sequence
);
648 emit_label (w
, ".Ldebug_line_end");
652 * Some assemblers like apple's do not support subsections, so we can't place
653 * .Ldebug_info_end at the end of the section using subsections. Instead, we
654 * define it every time something gets added to the .debug_info section.
655 * The apple assember seems to use the last definition.
658 emit_debug_info_end (MonoDwarfWriter
*w
)
660 if (!img_writer_subsections_supported (w
->w
))
661 fprintf (w
->fp
, "\n.set %sdebug_info_end,.\n", w
->temp_prefix
);
665 mono_dwarf_writer_emit_base_info (MonoDwarfWriter
*w
, GSList
*base_unwind_program
)
667 char *s
, *build_info
;
670 if (!img_writer_subsections_supported (w
->w
))
671 /* Can't emit line number info without subsections */
672 w
->emit_line
= FALSE
;
676 w
->cie_program
= base_unwind_program
;
678 emit_section_change (w
, ".debug_abbrev", 0);
679 emit_dwarf_abbrev (w
, ABBREV_COMPILE_UNIT
, DW_TAG_compile_unit
, TRUE
,
680 compile_unit_attr
, G_N_ELEMENTS (compile_unit_attr
));
681 emit_dwarf_abbrev (w
, ABBREV_SUBPROGRAM
, DW_TAG_subprogram
, TRUE
,
682 subprogram_attr
, G_N_ELEMENTS (subprogram_attr
));
683 emit_dwarf_abbrev (w
, ABBREV_PARAM
, DW_TAG_formal_parameter
, FALSE
,
684 param_attr
, G_N_ELEMENTS (param_attr
));
685 emit_dwarf_abbrev (w
, ABBREV_PARAM_LOCLIST
, DW_TAG_formal_parameter
, FALSE
,
686 param_loclist_attr
, G_N_ELEMENTS (param_loclist_attr
));
687 emit_dwarf_abbrev (w
, ABBREV_BASE_TYPE
, DW_TAG_base_type
, FALSE
,
688 base_type_attr
, G_N_ELEMENTS (base_type_attr
));
689 emit_dwarf_abbrev (w
, ABBREV_STRUCT_TYPE
, DW_TAG_class_type
, TRUE
,
690 struct_type_attr
, G_N_ELEMENTS (struct_type_attr
));
691 emit_dwarf_abbrev (w
, ABBREV_STRUCT_TYPE_NOCHILDREN
, DW_TAG_class_type
, FALSE
,
692 struct_type_attr
, G_N_ELEMENTS (struct_type_attr
));
693 emit_dwarf_abbrev (w
, ABBREV_DATA_MEMBER
, DW_TAG_member
, FALSE
,
694 data_member_attr
, G_N_ELEMENTS (data_member_attr
));
695 emit_dwarf_abbrev (w
, ABBREV_TYPEDEF
, DW_TAG_typedef
, FALSE
,
696 typedef_attr
, G_N_ELEMENTS (typedef_attr
));
697 emit_dwarf_abbrev (w
, ABBREV_ENUM_TYPE
, DW_TAG_enumeration_type
, TRUE
,
698 enum_type_attr
, G_N_ELEMENTS (enum_type_attr
));
699 emit_dwarf_abbrev (w
, ABBREV_ENUMERATOR
, DW_TAG_enumerator
, FALSE
,
700 enumerator_attr
, G_N_ELEMENTS (enumerator_attr
));
701 emit_dwarf_abbrev (w
, ABBREV_NAMESPACE
, DW_TAG_namespace
, TRUE
,
702 namespace_attr
, G_N_ELEMENTS (namespace_attr
));
703 emit_dwarf_abbrev (w
, ABBREV_VARIABLE
, DW_TAG_variable
, FALSE
,
704 variable_attr
, G_N_ELEMENTS (variable_attr
));
705 emit_dwarf_abbrev (w
, ABBREV_VARIABLE_LOCLIST
, DW_TAG_variable
, FALSE
,
706 variable_loclist_attr
, G_N_ELEMENTS (variable_loclist_attr
));
707 emit_dwarf_abbrev (w
, ABBREV_POINTER_TYPE
, DW_TAG_pointer_type
, FALSE
,
708 pointer_type_attr
, G_N_ELEMENTS (pointer_type_attr
));
709 emit_dwarf_abbrev (w
, ABBREV_REFERENCE_TYPE
, DW_TAG_reference_type
, FALSE
,
710 reference_type_attr
, G_N_ELEMENTS (reference_type_attr
));
711 emit_dwarf_abbrev (w
, ABBREV_INHERITANCE
, DW_TAG_inheritance
, FALSE
,
712 inheritance_attr
, G_N_ELEMENTS (inheritance_attr
));
715 emit_section_change (w
, ".debug_info", 0);
716 emit_label (w
, ".Ldebug_info_start");
717 emit_symbol_diff (w
, ".Ldebug_info_end", ".Ldebug_info_begin", 0); /* length */
718 emit_label (w
, ".Ldebug_info_begin");
719 emit_int16 (w
, 0x2); /* DWARF version 2 */
720 emit_int32 (w
, 0); /* .debug_abbrev offset */
721 emit_byte (w
, sizeof (gpointer
)); /* address size */
723 if (img_writer_subsections_supported (w
->w
) && w
->appending
) {
724 /* Emit this into a separate section so it gets placed at the end */
725 emit_section_change (w
, ".debug_info", 1);
726 emit_byte (w
, 0); /* close COMPILE_UNIT */
727 emit_label (w
, ".Ldebug_info_end");
728 emit_section_change (w
, ".debug_info", 0);
731 /* Compilation unit */
732 emit_uleb128 (w
, ABBREV_COMPILE_UNIT
);
733 build_info
= mono_get_runtime_build_info ();
734 s
= g_strdup_printf ("Mono AOT Compiler %s", build_info
);
738 emit_string (w
, "JITted code");
740 emit_byte (w
, DW_LANG_C
);
741 emit_pointer_value (w
, 0);
742 emit_pointer_value (w
, 0);
743 /* offset into .debug_line section */
744 emit_symbol_diff (w
, ".Ldebug_line_start", ".Ldebug_line_section_start", 0);
747 for (i
= 0; i
< G_N_ELEMENTS (basic_types
); ++i
) {
748 emit_label (w
, basic_types
[i
].die_name
);
749 emit_uleb128 (w
, ABBREV_BASE_TYPE
);
750 emit_byte (w
, basic_types
[i
].size
);
751 emit_byte (w
, basic_types
[i
].encoding
);
752 emit_string (w
, basic_types
[i
].name
);
755 emit_debug_info_end (w
);
757 /* debug_loc section */
758 emit_section_change (w
, ".debug_loc", 0);
759 emit_label (w
, ".Ldebug_loc_start");
761 /* debug_line section */
763 * We emit some info even if emit_line is FALSE, as the
764 * apple linker seems to require a .debug_line section.
766 emit_line_number_info_begin (w
);
772 * mono_dwarf_writer_close:
774 * Finalize the emitted debugging info.
777 mono_dwarf_writer_close (MonoDwarfWriter
*w
)
780 emit_section_change (w
, ".debug_info", 0);
781 emit_byte (w
, 0); /* close COMPILE_UNIT */
782 emit_label (w
, ".Ldebug_info_end");
786 static const char* emit_type (MonoDwarfWriter
*w
, MonoType
*t
);
788 /* Returns the local symbol pointing to the emitted debug info */
790 emit_class_dwarf_info (MonoDwarfWriter
*w
, MonoClass
*klass
, gboolean vtype
)
792 char *die
, *pointer_die
, *reference_die
;
795 MonoClassField
*field
;
798 gboolean emit_namespace
= FALSE
, has_children
;
802 if (!w
->class_to_die
)
803 w
->class_to_die
= g_hash_table_new (NULL
, NULL
);
804 if (!w
->class_to_vtype_die
)
805 w
->class_to_vtype_die
= g_hash_table_new (NULL
, NULL
);
806 if (!w
->class_to_pointer_die
)
807 w
->class_to_pointer_die
= g_hash_table_new (NULL
, NULL
);
808 if (!w
->class_to_reference_die
)
809 w
->class_to_reference_die
= g_hash_table_new (NULL
, NULL
);
812 cache
= w
->class_to_vtype_die
;
814 cache
= w
->class_to_die
;
816 die
= g_hash_table_lookup (cache
, klass
);
820 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
)))
824 * FIXME: gdb can't handle namespaces in languages it doesn't know about.
827 if (klass->name_space && klass->name_space [0] != '\0')
828 emit_namespace = TRUE;
830 if (emit_namespace
) {
831 emit_uleb128 (w
, ABBREV_NAMESPACE
);
832 emit_string (w
, klass
->name_space
);
835 full_name
= g_strdup_printf ("%s%s%s", klass
->name_space
, klass
->name_space
? "." : "", klass
->name
);
837 * gdb doesn't support namespaces for non-C++ dwarf objects, so use _
838 * to separate components.
840 for (p
= full_name
; *p
; p
++)
844 die
= g_strdup_printf (".LTDIE_%d", w
->tdie_index
);
845 pointer_die
= g_strdup_printf (".LTDIE_%d_POINTER", w
->tdie_index
);
846 reference_die
= g_strdup_printf (".LTDIE_%d_REFERENCE", w
->tdie_index
);
849 g_hash_table_insert (w
->class_to_pointer_die
, klass
, pointer_die
);
850 g_hash_table_insert (w
->class_to_reference_die
, klass
, reference_die
);
851 g_hash_table_insert (cache
, klass
, die
);
853 if (klass
->enumtype
) {
854 int size
= mono_class_value_size (mono_class_from_mono_type (mono_class_enum_basetype (klass
)), NULL
);
858 emit_uleb128 (w
, ABBREV_ENUM_TYPE
);
859 emit_string (w
, full_name
);
860 emit_uleb128 (w
, size
);
861 for (k
= 0; k
< G_N_ELEMENTS (basic_types
); ++k
)
862 if (basic_types
[k
].type
== mono_class_enum_basetype (klass
)->type
)
864 g_assert (k
< G_N_ELEMENTS (basic_types
));
865 emit_symbol_diff (w
, basic_types
[k
].die_name
, ".Ldebug_info_start", 0);
867 /* Emit enum values */
869 while ((field
= mono_class_get_fields (klass
, &iter
))) {
872 MonoTypeEnum def_type
;
874 if (strcmp ("value__", mono_field_get_name (field
)) == 0)
876 if (mono_field_is_deleted (field
))
879 emit_uleb128 (w
, ABBREV_ENUMERATOR
);
880 emit_string (w
, mono_field_get_name (field
));
882 p
= mono_class_get_field_default_value (field
, &def_type
);
883 len
= mono_metadata_decode_blob_size (p
, &p
);
884 switch (mono_class_enum_basetype (klass
)->type
) {
887 case MONO_TYPE_BOOLEAN
:
888 emit_sleb128 (w
, *p
);
893 emit_sleb128 (w
, read16 (p
));
897 emit_sleb128 (w
, read32 (p
));
901 emit_sleb128 (w
, read64 (p
));
905 #if SIZEOF_VOID_P == 8
906 emit_sleb128 (w
, read64 (p
));
908 emit_sleb128 (w
, read32 (p
));
912 g_assert_not_reached ();
923 parent_die
= emit_class_dwarf_info (w
, klass
->parent
, FALSE
);
927 /* Emit field types */
929 while ((field
= mono_class_get_fields (klass
, &iter
))) {
930 if (field
->type
->attrs
& FIELD_ATTRIBUTE_STATIC
)
933 emit_type (w
, field
->type
);
937 has_children
= parent_die
|| mono_class_get_fields (klass
, &iter
);
941 emit_uleb128 (w
, has_children
? ABBREV_STRUCT_TYPE
: ABBREV_STRUCT_TYPE_NOCHILDREN
);
942 emit_string (w
, full_name
);
943 emit_uleb128 (w
, klass
->instance_size
);
946 emit_uleb128 (w
, ABBREV_INHERITANCE
);
947 emit_symbol_diff (w
, parent_die
, ".Ldebug_info_start", 0);
950 *p
++= DW_OP_plus_uconst
;
951 encode_uleb128 (0, p
, &p
);
952 emit_byte (w
, p
- buf
);
953 emit_bytes (w
, buf
, p
- buf
);
958 while ((field
= mono_class_get_fields (klass
, &iter
))) {
959 if (field
->type
->attrs
& FIELD_ATTRIBUTE_STATIC
)
962 fdie
= emit_type (w
, field
->type
);
964 emit_uleb128 (w
, ABBREV_DATA_MEMBER
);
965 emit_string (w
, field
->name
);
966 emit_symbol_diff (w
, fdie
, ".Ldebug_info_start", 0);
969 *p
++= DW_OP_plus_uconst
;
970 if (klass
->valuetype
&& vtype
)
971 encode_uleb128 (field
->offset
- sizeof (MonoObject
), p
, &p
);
973 encode_uleb128 (field
->offset
, p
, &p
);
975 emit_byte (w
, p
- buf
);
976 emit_bytes (w
, buf
, p
- buf
);
983 emit_uleb128 (w
, 0x0);
985 /* Add a typedef, so we can reference the type without a 'struct' in gdb */
986 emit_uleb128 (w
, ABBREV_TYPEDEF
);
987 emit_string (w
, full_name
);
988 emit_symbol_diff (w
, die
, ".Ldebug_info_start", 0);
990 /* Add a pointer type */
991 emit_label (w
, pointer_die
);
993 emit_uleb128 (w
, ABBREV_POINTER_TYPE
);
994 emit_symbol_diff (w
, die
, ".Ldebug_info_start", 0);
996 /* Add a reference type */
997 emit_label (w
, reference_die
);
999 emit_uleb128 (w
, ABBREV_REFERENCE_TYPE
);
1000 emit_symbol_diff (w
, die
, ".Ldebug_info_start", 0);
1004 if (emit_namespace
) {
1006 emit_uleb128 (w
, 0x0);
1013 emit_type (MonoDwarfWriter
*w
, MonoType
*t
)
1015 MonoClass
*klass
= mono_class_from_mono_type (t
);
1020 if (t
->type
== MONO_TYPE_VALUETYPE
) {
1021 tdie
= emit_class_dwarf_info (w
, klass
, TRUE
);
1023 return g_hash_table_lookup (w
->class_to_pointer_die
, klass
);
1026 tdie
= emit_class_dwarf_info (w
, klass
, FALSE
);
1027 /* Should return a pointer type to a reference */
1030 t
= &mono_defaults
.int_class
->byval_arg
;
1032 for (j
= 0; j
< G_N_ELEMENTS (basic_types
); ++j
)
1033 if (basic_types
[j
].type
== t
->type
)
1035 if (j
< G_N_ELEMENTS (basic_types
))
1036 tdie
= basic_types
[j
].die_name
;
1039 case MONO_TYPE_CLASS
:
1040 emit_class_dwarf_info (w
, klass
, FALSE
);
1041 tdie
= g_hash_table_lookup (w
->class_to_reference_die
, klass
);
1042 //tdie = ".LDIE_OBJECT";
1044 case MONO_TYPE_ARRAY
:
1045 tdie
= ".LDIE_OBJECT";
1047 case MONO_TYPE_VALUETYPE
:
1048 if (klass
->enumtype
)
1049 tdie
= emit_class_dwarf_info (w
, klass
, FALSE
);
1053 case MONO_TYPE_GENERICINST
:
1054 if (!MONO_TYPE_ISSTRUCT (t
)) {
1055 emit_class_dwarf_info (w
, klass
, FALSE
);
1056 tdie
= g_hash_table_lookup (w
->class_to_reference_die
, klass
);
1071 emit_var_type (MonoDwarfWriter
*w
, MonoType
*t
)
1075 tdie
= emit_type (w
, t
);
1077 emit_symbol_diff (w
, tdie
, ".Ldebug_info_start", 0);
1081 encode_var_location (MonoDwarfWriter
*w
, MonoInst
*ins
, guint8
*p
, guint8
**endp
)
1084 /* FIXME: This needs a location list, since the args can go from reg->stack */
1085 if (!ins
|| ins
->flags
& MONO_INST_IS_DEAD
) {
1086 /* gdb treats this as optimized out */
1087 } else if (ins
->opcode
== OP_REGVAR
) {
1088 *p
= DW_OP_reg0
+ mono_hw_reg_to_dwarf_reg (ins
->dreg
);
1090 } else if (ins
->opcode
== OP_REGOFFSET
) {
1091 *p
++= DW_OP_breg0
+ mono_hw_reg_to_dwarf_reg (ins
->inst_basereg
);
1092 encode_sleb128 (ins
->inst_offset
, p
, &p
);
1102 emit_loclist (MonoDwarfWriter
*w
, MonoInst
*ins
,
1103 guint8
*loclist_begin_addr
, guint8
*loclist_end_addr
,
1104 guint8
*expr
, guint32 expr_len
)
1108 emit_push_section (w
, ".debug_loc", 0);
1109 sprintf (label
, ".Lloclist_%d", w
->loclist_index
++ );
1110 emit_label (w
, label
);
1112 emit_pointer_value (w
, loclist_begin_addr
);
1113 emit_pointer_value (w
, loclist_end_addr
);
1114 emit_byte (w
, expr_len
% 256);
1115 emit_byte (w
, expr_len
/ 256);
1116 emit_bytes (w
, expr
, expr_len
);
1118 emit_pointer_value (w
, NULL
);
1119 emit_pointer_value (w
, NULL
);
1121 emit_pop_section (w
);
1122 emit_symbol_diff (w
, label
, ".Ldebug_loc_start", 0);
1126 * MonoDisHelper->tokener doesn't take an IP argument, and we can't add one since
1127 * it is a public header.
1129 static const guint8
*token_handler_ip
;
1132 token_handler (MonoDisHelper
*dh
, MonoMethod
*method
, guint32 token
)
1135 MonoMethod
*cmethod
;
1137 MonoClassField
*field
;
1138 gpointer data
= NULL
;
1140 if (method
->wrapper_type
)
1141 data
= mono_method_get_wrapper_data (method
, token
);
1143 switch (*token_handler_ip
) {
1147 if (method
->wrapper_type
)
1150 klass
= mono_class_get_full (method
->klass
->image
, token
, NULL
);
1151 res
= g_strdup_printf ("<%s>", klass
->name
);
1156 if (method
->wrapper_type
)
1159 cmethod
= mono_get_method_full (method
->klass
->image
, token
, NULL
, NULL
);
1160 desc
= mono_method_full_name (cmethod
, TRUE
);
1161 res
= g_strdup_printf ("<%s>", desc
);
1165 if (method
->wrapper_type
) {
1166 desc
= mono_signature_get_desc (data
, FALSE
);
1167 res
= g_strdup_printf ("<%s>", desc
);
1170 res
= g_strdup_printf ("<0x%08x>", token
);
1177 if (method
->wrapper_type
)
1180 field
= mono_field_from_token (method
->klass
->image
, token
, &klass
, NULL
);
1181 desc
= mono_field_full_name (field
);
1182 res
= g_strdup_printf ("<%s>", desc
);
1186 res
= g_strdup_printf ("<0x%08x>", token
);
1196 * Produce a disassembled form of the IL instruction at IP. This is an extension
1197 * of mono_disasm_code_one () which can disasm tokens, handle wrapper methods, and
1198 * CEE_MONO_ opcodes.
1201 disasm_ins (MonoMethod
*method
, const guchar
*ip
, const guint8
**endip
)
1205 MonoMethodHeader
*header
= mono_method_get_header (method
);
1207 memset (&dh
, 0, sizeof (dh
));
1209 dh
.label_format
= "IL_%04x: ";
1210 dh
.label_target
= "IL_%04x";
1211 dh
.tokener
= token_handler
;
1213 token_handler_ip
= ip
;
1214 if (*ip
== MONO_CUSTOM_PREFIX
) {
1219 case CEE_MONO_ICALL
: {
1220 MonoJitICallInfo
*info
;
1222 token
= read32 (ip
+ 2);
1223 data
= mono_method_get_wrapper_data (method
, token
);
1224 info
= mono_find_jit_icall_by_addr (data
);
1227 dis
= g_strdup_printf ("IL_%04x: mono_icall <%s>", (int)(ip
- header
->code
), info
->name
);
1231 case CEE_MONO_CLASSCONST
: {
1232 token
= read32 (ip
+ 2);
1233 data
= mono_method_get_wrapper_data (method
, token
);
1235 dis
= g_strdup_printf ("IL_%04x: mono_classconst <%s>", (int)(ip
- header
->code
), ((MonoClass
*)data
)->name
);
1240 dis
= mono_disasm_code_one (&dh
, method
, ip
, &ip
);
1243 dis
= mono_disasm_code_one (&dh
, method
, ip
, &ip
);
1245 token_handler_ip
= NULL
;
1252 il_offset_from_address (MonoMethod
*method
, MonoDebugMethodJitInfo
*jit
,
1253 guint32 native_offset
)
1257 if (!jit
->line_numbers
)
1260 for (i
= jit
->num_line_numbers
- 1; i
>= 0; i
--) {
1261 MonoDebugLineNumberEntry lne
= jit
->line_numbers
[i
];
1263 if (lne
.native_offset
<= native_offset
)
1264 return lne
.il_offset
;
1270 static int max_special_addr_diff
= 0;
1273 emit_advance_op (MonoDwarfWriter
*w
, int line_diff
, int addr_diff
)
1277 /* Use a special opcode if possible */
1278 if (line_diff
- LINE_BASE
>= 0 && line_diff
- LINE_BASE
< LINE_RANGE
) {
1279 if (max_special_addr_diff
== 0)
1280 max_special_addr_diff
= (255 - OPCODE_BASE
) / LINE_RANGE
;
1282 if (addr_diff
> max_special_addr_diff
&& (addr_diff
< 2 * max_special_addr_diff
)) {
1283 emit_byte (w
, DW_LNS_const_add_pc
);
1284 addr_diff
-= max_special_addr_diff
;
1287 opcode
= (line_diff
- LINE_BASE
) + (LINE_RANGE
* addr_diff
) + OPCODE_BASE
;
1293 emit_byte (w
, opcode
);
1295 emit_byte (w
, DW_LNS_advance_line
);
1296 emit_sleb128 (w
, line_diff
);
1297 emit_byte (w
, DW_LNS_advance_pc
);
1298 emit_sleb128 (w
, addr_diff
);
1299 emit_byte (w
, DW_LNS_copy
);
1304 compare_lne (MonoDebugLineNumberEntry
*a
, MonoDebugLineNumberEntry
*b
)
1306 if (a
->native_offset
== b
->native_offset
)
1307 return a
->il_offset
- b
->il_offset
;
1309 return a
->native_offset
- b
->native_offset
;
1313 emit_line_number_info (MonoDwarfWriter
*w
, MonoMethod
*method
,
1314 char *start_symbol
, char *end_symbol
,
1315 guint8
*code
, guint32 code_size
,
1316 MonoDebugMethodJitInfo
*debug_info
)
1318 guint32 prev_line
= 0;
1319 guint32 prev_native_offset
= 0;
1320 int i
, file_index
, il_offset
, prev_il_offset
;
1321 gboolean first
= TRUE
;
1322 MonoDebugSourceLocation
*loc
;
1323 char *prev_file_name
= NULL
;
1324 MonoMethodHeader
*header
= mono_method_get_header (method
);
1325 MonoDebugMethodInfo
*minfo
;
1327 int *native_to_il_offset
= NULL
;
1332 minfo
= mono_debug_lookup_method (method
);
1334 /* Compute the native->IL offset mapping */
1336 g_assert (code_size
);
1338 #ifndef _EGLIB_MAJOR
1339 ln_array
= g_array_sized_new (FALSE
, FALSE
, sizeof (MonoDebugLineNumberEntry
),
1340 debug_info
->num_line_numbers
);
1341 g_array_append_vals (ln_array
, debug_info
->line_numbers
, debug_info
->num_line_numbers
);
1342 g_array_sort (ln_array
, (GCompareFunc
)compare_lne
);
1343 native_to_il_offset
= g_new0 (int, code_size
+ 1);
1345 for (i
= 0; i
< debug_info
->num_line_numbers
; ++i
) {
1347 MonoDebugLineNumberEntry lne
= g_array_index (ln_array
, MonoDebugLineNumberEntry
, i
);
1350 for (j
= 0; j
< lne
.native_offset
; ++j
)
1351 native_to_il_offset
[j
] = -1;
1354 if (i
< debug_info
->num_line_numbers
- 1) {
1355 MonoDebugLineNumberEntry lne_next
= g_array_index (ln_array
, MonoDebugLineNumberEntry
, i
+ 1);
1357 for (j
= lne
.native_offset
; j
< lne_next
.native_offset
; ++j
)
1358 native_to_il_offset
[j
] = lne
.il_offset
;
1360 for (j
= lne
.native_offset
; j
< code_size
; ++j
)
1361 native_to_il_offset
[j
] = lne
.il_offset
;
1364 g_array_free (ln_array
, TRUE
);
1368 prev_il_offset
= -1;
1370 for (i
= 0; i
< code_size
; ++i
) {
1374 if (!debug_info
->line_numbers
)
1377 if (native_to_il_offset
)
1378 il_offset
= native_to_il_offset
[i
];
1380 il_offset
= il_offset_from_address (method
, debug_info
, i
);
1382 il_offset = il_offset_from_address (method, debug_info, i);
1384 g_assert (il_offset == native_to_il_offset [i]);
1387 il_offset
= native_to_il_offset
[i
];
1391 if (il_offset
== prev_il_offset
)
1394 prev_il_offset
= il_offset
;
1396 loc
= mono_debug_symfile_lookup_location (minfo
, il_offset
);
1399 int line_diff
= (gint32
)loc
->row
- (gint32
)prev_line
;
1400 int addr_diff
= i
- prev_native_offset
;
1403 emit_section_change (w
, ".debug_line", LINE_SUBSECTION_DATA
);
1406 emit_byte (w
, sizeof (gpointer
) + 1);
1407 emit_byte (w
, DW_LNE_set_address
);
1409 emit_pointer_unaligned (w
, start_symbol
);
1411 emit_pointer_value (w
, code
);
1414 * The prolog+initlocals region does not have a line number, this
1415 * makes them belong to the first line of the method.
1417 emit_byte (w
, DW_LNS_advance_line
);
1418 emit_sleb128 (w
, (gint32
)loc
->row
- (gint32
)prev_line
);
1419 prev_line
= loc
->row
;
1422 if (loc
->row
!= prev_line
) {
1423 if (!prev_file_name
|| strcmp (loc
->source_file
, prev_file_name
) != 0) {
1424 /* Add an entry to the file table */
1425 /* FIXME: Avoid duplicates */
1426 file_index
= emit_line_number_file_name (w
, loc
->source_file
, 0, 0);
1427 g_free (prev_file_name
);
1428 prev_file_name
= g_strdup (loc
->source_file
);
1430 emit_byte (w
, DW_LNS_set_file
);
1431 emit_uleb128 (w
, file_index
);
1432 emit_byte (w
, DW_LNS_copy
);
1435 //printf ("X: %p(+0x%x) %d %s:%d(+%d)\n", code + i, addr_diff, loc->il_offset, loc->source_file, loc->row, line_diff);
1437 emit_advance_op (w
, line_diff
, addr_diff
);
1439 prev_line
= loc
->row
;
1440 prev_native_offset
= i
;
1448 g_free (prev_file_name
);
1451 emit_byte (w
, DW_LNS_advance_pc
);
1452 emit_sleb128 (w
, code_size
- prev_native_offset
);
1453 emit_byte (w
, DW_LNS_copy
);
1457 emit_byte (w
, DW_LNE_end_sequence
);
1458 } else if (!start_symbol
) {
1459 /* No debug info, XDEBUG mode */
1461 const guint8
*ip
= header
->code
;
1462 int prev_line
, prev_native_offset
;
1466 * Emit the IL code into a temporary file and emit line number info
1467 * referencing that file.
1470 name
= mono_method_full_name (method
, TRUE
);
1471 fprintf (w
->il_file
, "// %s\n", name
);
1472 w
->il_file_line_index
++;
1475 il_to_line
= g_new0 (int, header
->code_size
);
1477 emit_section_change (w
, ".debug_line", LINE_SUBSECTION_DATA
);
1479 emit_byte (w
, sizeof (gpointer
) + 1);
1480 emit_byte (w
, DW_LNE_set_address
);
1481 emit_pointer_value (w
, code
);
1483 // FIXME: Optimize this
1484 while (ip
< header
->code
+ header
->code_size
) {
1485 int il_offset
= ip
- header
->code
;
1488 w
->il_file_line_index
++;
1490 dis
= disasm_ins (method
, ip
, &ip
);
1491 fprintf (w
->il_file
, "%s\n", dis
);
1494 il_to_line
[il_offset
] = w
->il_file_line_index
;
1497 /* Emit line number info */
1499 prev_native_offset
= 0;
1500 for (i
= 0; i
< debug_info
->num_line_numbers
; ++i
) {
1501 MonoDebugLineNumberEntry
*lne
= &debug_info
->line_numbers
[i
];
1504 if (lne
->il_offset
>= header
->code_size
)
1506 line
= il_to_line
[lne
->il_offset
];
1509 * This seems to happen randomly, it looks like il_offset points
1510 * into the middle of an instruction.
1514 printf ("%s\n", mono_method_full_name (method, TRUE));
1515 printf ("%d %d\n", lne->il_offset, header->code_size);
1520 if (line
- prev_line
!= 0) {
1521 emit_advance_op (w
, line
- prev_line
, (gint32
)lne
->native_offset
- prev_native_offset
);
1524 prev_native_offset
= lne
->native_offset
;
1528 emit_byte (w
, DW_LNS_advance_pc
);
1529 emit_sleb128 (w
, code_size
- prev_native_offset
);
1530 emit_byte (w
, DW_LNS_copy
);
1534 emit_byte (w
, DW_LNE_end_sequence
);
1536 fflush (w
->il_file
);
1537 g_free (il_to_line
);
1541 static MonoMethodVar
*
1542 find_vmv (MonoCompile
*cfg
, MonoInst
*ins
)
1547 for (j
= 0; j
< cfg
->num_varinfo
; ++j
) {
1548 if (cfg
->varinfo
[j
] == ins
)
1552 if (j
< cfg
->num_varinfo
) {
1553 return MONO_VARINFO (cfg
, j
);
1561 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
)
1564 MonoMethodSignature
*sig
;
1565 MonoMethodHeader
*header
;
1566 char **names
, **tdies
, **local_tdies
;
1573 emit_section_change (w
, ".debug_info", 0);
1575 sig
= mono_method_signature (method
);
1576 header
= mono_method_get_header (method
);
1578 /* Parameter types */
1579 tdies
= g_new0 (char *, sig
->param_count
+ sig
->hasthis
);
1580 for (i
= 0; i
< sig
->param_count
+ sig
->hasthis
; ++i
) {
1583 if (i
== 0 && sig
->hasthis
) {
1584 if (method
->klass
->valuetype
)
1585 t
= &method
->klass
->this_arg
;
1587 t
= &method
->klass
->byval_arg
;
1589 t
= sig
->params
[i
- sig
->hasthis
];
1596 local_tdies
= g_new0 (char *, header
->num_locals
);
1597 for (i
= 0; i
< header
->num_locals
; ++i
) {
1598 emit_type (w
, header
->locals
[i
]);
1602 names
= g_new0 (char *, sig
->param_count
);
1603 mono_method_get_param_names (method
, (const char **) names
);
1605 emit_uleb128 (w
, ABBREV_SUBPROGRAM
);
1606 name
= mono_method_full_name (method
, FALSE
);
1607 emit_string (w
, name
);
1610 emit_pointer_unaligned (w
, start_symbol
);
1611 emit_pointer_unaligned (w
, end_symbol
);
1613 emit_pointer_value (w
, code
);
1614 emit_pointer_value (w
, code
+ code_size
);
1618 emit_byte (w
, DW_OP_breg6
);
1622 for (i
= 0; i
< sig
->param_count
+ sig
->hasthis
; ++i
) {
1623 MonoInst
*arg
= args
? args
[i
] : NULL
;
1626 char pname_buf
[128];
1627 MonoMethodVar
*vmv
= NULL
;
1628 gboolean need_loclist
= FALSE
;
1630 vmv
= find_vmv (cfg
, arg
);
1631 if (code
&& vmv
&& (vmv
->live_range_start
|| vmv
->live_range_end
))
1632 need_loclist
= TRUE
;
1634 if (i
== 0 && sig
->hasthis
) {
1635 if (method
->klass
->valuetype
)
1636 t
= &method
->klass
->this_arg
;
1638 t
= &method
->klass
->byval_arg
;
1641 t
= sig
->params
[i
- sig
->hasthis
];
1642 pname
= names
[i
- sig
->hasthis
];
1645 emit_uleb128 (w
, need_loclist
? ABBREV_PARAM_LOCLIST
: ABBREV_PARAM
);
1647 if (pname
[0] == '\0') {
1648 sprintf (pname_buf
, "param%d", i
- sig
->hasthis
);
1651 emit_string (w
, pname
);
1653 if (!arg
|| arg
->flags
& MONO_INST_IS_DEAD
)
1654 emit_var_type (w
, &mono_defaults
.int32_class
->byval_arg
);
1656 emit_var_type (w
, t
);
1659 encode_var_location (w
, arg
, p
, &p
);
1661 vmv
->live_range_start
= 0;
1662 if (vmv
->live_range_end
== 0)
1663 /* FIXME: Uses made in calls are not recorded */
1664 vmv
->live_range_end
= code_size
;
1665 emit_loclist (w
, arg
, code
+ vmv
->live_range_start
, code
+ vmv
->live_range_end
, buf
, p
- buf
);
1667 emit_byte (w
, p
- buf
);
1668 emit_bytes (w
, buf
, p
- buf
);
1674 num_locals
= mono_debug_lookup_locals (method
, &local_names
, &local_indexes
);
1676 for (i
= 0; i
< header
->num_locals
; ++i
) {
1677 MonoInst
*ins
= locals
[i
];
1678 char name_buf
[128];
1680 MonoMethodVar
*vmv
= NULL
;
1681 gboolean need_loclist
= FALSE
;
1683 /* ins->dreg no longer contains the original vreg */
1684 vmv
= find_vmv (cfg
, ins
);
1686 if (vmv
->live_range_start
) {
1687 /* This variable has a precise live range */
1688 need_loclist
= TRUE
;
1692 emit_uleb128 (w
, need_loclist
? ABBREV_VARIABLE_LOCLIST
: ABBREV_VARIABLE
);
1694 for (j
= 0; j
< num_locals
; ++j
)
1695 if (local_indexes
[j
] == i
)
1697 if (j
< num_locals
) {
1698 emit_string (w
, local_names
[j
]);
1700 sprintf (name_buf
, "V_%d", i
);
1701 emit_string (w
, name_buf
);
1704 if (!ins
|| ins
->flags
& MONO_INST_IS_DEAD
)
1705 emit_var_type (w
, &mono_defaults
.int32_class
->byval_arg
);
1707 emit_var_type (w
, header
->locals
[i
]);
1710 encode_var_location (w
, ins
, p
, &p
);
1713 if (vmv
->live_range_end
== 0)
1714 /* FIXME: Uses made in calls are not recorded */
1715 vmv
->live_range_end
= code_size
;
1716 emit_loclist (w
, ins
, code
+ vmv
->live_range_start
, code
+ vmv
->live_range_end
, buf
, p
- buf
);
1718 emit_byte (w
, p
- buf
);
1719 emit_bytes (w
, buf
, p
- buf
);
1723 g_free (local_names
);
1724 g_free (local_indexes
);
1726 /* Subprogram end */
1727 emit_uleb128 (w
, 0x0);
1731 emit_debug_info_end (w
);
1733 /* Emit unwind info */
1735 emit_fde (w
, w
->fde_index
, start_symbol
, end_symbol
, code
, code_size
, unwind_info
, TRUE
);
1739 /* Emit line number info */
1740 /* != could happen when using --regression */
1741 if (debug_info
&& (debug_info
->code_start
== code
))
1742 emit_line_number_info (w
, method
, start_symbol
, end_symbol
, code
, code_size
, debug_info
);
1748 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
)
1750 emit_section_change (w
, ".debug_info", 0);
1753 emit_uleb128 (w
, ABBREV_SUBPROGRAM
);
1754 emit_string (w
, tramp_name
);
1755 emit_pointer_value (w
, code
);
1756 emit_pointer_value (w
, code
+ code_size
);
1759 emit_byte (w
, DW_OP_breg6
);
1762 /* Subprogram end */
1763 emit_uleb128 (w
, 0x0);
1765 emit_debug_info_end (w
);
1767 /* Emit unwind info */
1768 emit_fde (w
, w
->fde_index
, start_symbol
, end_symbol
, code
, code_size
, unwind_info
, FALSE
);
1771 #endif /* End of: !defined(DISABLE_AOT) && !defined(DISABLE_JIT) */