3 * Creation of DWARF debug information
6 * Zoltan Varga (vargaz@gmail.com)
8 * (C) 2008-2009 Novell, Inc.
12 #include <mono/utils/mono-compiler.h>
14 #if !defined(DISABLE_AOT) && !defined(DISABLE_JIT)
15 #include "dwarfwriter.h"
17 #include <sys/types.h>
24 #include <mono/metadata/mono-endian.h>
25 #include <mono/metadata/debug-internals.h>
26 #include <mono/metadata/abi-details.h>
29 #include <mono/utils/freebsd-elf32.h>
30 #include <mono/utils/freebsd-elf64.h>
33 #include <mono/utils/freebsd-dwarf.h>
35 #define DW_AT_MIPS_linkage_name 0x2007
36 #define DW_LNE_set_prologue_end 0x0a
40 char *start_symbol
, *end_symbol
;
43 } MethodLineNumberInfo
;
45 struct _MonoDwarfWriter
48 GHashTable
*class_to_die
, *class_to_vtype_die
, *class_to_pointer_die
;
49 GHashTable
*class_to_reference_die
;
50 int fde_index
, tdie_index
, line_number_file_index
, line_number_dir_index
;
51 GHashTable
*file_to_index
, *index_to_file
, *dir_to_index
;
53 int il_file_line_index
, loclist_index
;
56 const char *temp_prefix
;
63 emit_line_number_info (MonoDwarfWriter
*w
, MonoMethod
*method
,
64 char *start_symbol
, char *end_symbol
,
65 guint8
*code
, guint32 code_size
,
66 MonoDebugMethodJitInfo
*debug_info
);
69 * mono_dwarf_writer_create:
71 * Create a DWARF writer object. WRITER is the underlying image writer this
72 * writer will emit to. IL_FILE is the file where IL code will be dumped to for
73 * methods which have no line number info. It can be NULL.
76 mono_dwarf_writer_create (MonoImageWriter
*writer
, FILE *il_file
, int il_file_start_line
, gboolean emit_line_numbers
)
78 MonoDwarfWriter
*w
= g_new0 (MonoDwarfWriter
, 1);
82 w
->il_file_line_index
= il_file_start_line
;
84 w
->emit_line
= emit_line_numbers
;
86 w
->fp
= mono_img_writer_get_fp (w
->w
);
87 w
->temp_prefix
= mono_img_writer_get_temp_label_prefix (w
->w
);
89 w
->class_to_die
= g_hash_table_new (NULL
, NULL
);
90 w
->class_to_vtype_die
= g_hash_table_new (NULL
, NULL
);
91 w
->class_to_pointer_die
= g_hash_table_new (NULL
, NULL
);
92 w
->class_to_reference_die
= g_hash_table_new (NULL
, NULL
);
93 w
->cur_file_index
= -1;
99 mono_dwarf_writer_destroy (MonoDwarfWriter
*w
)
105 mono_dwarf_writer_get_il_file_line_index (MonoDwarfWriter
*w
)
107 return w
->il_file_line_index
;
110 /* Wrappers around the image writer functions */
113 emit_section_change (MonoDwarfWriter
*w
, const char *section_name
, int subsection_index
)
115 mono_img_writer_emit_section_change (w
->w
, section_name
, subsection_index
);
119 emit_push_section (MonoDwarfWriter
*w
, const char *section_name
, int subsection
)
121 mono_img_writer_emit_push_section (w
->w
, section_name
, subsection
);
125 emit_pop_section (MonoDwarfWriter
*w
)
127 mono_img_writer_emit_pop_section (w
->w
);
131 emit_label (MonoDwarfWriter
*w
, const char *name
)
133 mono_img_writer_emit_label (w
->w
, name
);
137 emit_bytes (MonoDwarfWriter
*w
, const guint8
* buf
, int size
)
139 mono_img_writer_emit_bytes (w
->w
, buf
, size
);
143 emit_string (MonoDwarfWriter
*w
, const char *value
)
145 mono_img_writer_emit_string (w
->w
, value
);
149 emit_line (MonoDwarfWriter
*w
)
151 mono_img_writer_emit_line (w
->w
);
155 emit_alignment (MonoDwarfWriter
*w
, int size
)
157 mono_img_writer_emit_alignment (w
->w
, size
);
161 emit_pointer_unaligned (MonoDwarfWriter
*w
, const char *target
)
163 mono_img_writer_emit_pointer_unaligned (w
->w
, target
);
167 emit_pointer (MonoDwarfWriter
*w
, const char *target
)
169 mono_img_writer_emit_pointer (w
->w
, target
);
173 emit_int16 (MonoDwarfWriter
*w
, int value
)
175 mono_img_writer_emit_int16 (w
->w
, value
);
179 emit_int32 (MonoDwarfWriter
*w
, int value
)
181 mono_img_writer_emit_int32 (w
->w
, value
);
185 emit_symbol (MonoDwarfWriter
*w
, const char *symbol
)
187 mono_img_writer_emit_symbol (w
->w
, symbol
);
191 emit_symbol_diff (MonoDwarfWriter
*w
, const char *end
, const char* start
, int offset
)
193 mono_img_writer_emit_symbol_diff (w
->w
, end
, start
, offset
);
197 emit_byte (MonoDwarfWriter
*w
, guint8 val
)
199 mono_img_writer_emit_byte (w
->w
, val
);
203 emit_escaped_string (MonoDwarfWriter
*w
, char *value
)
207 len
= strlen (value
);
208 for (i
= 0; i
< len
; ++i
) {
210 if (!(isalnum (c
))) {
232 mono_img_writer_emit_string (w
->w
, value
);
235 static G_GNUC_UNUSED
void
236 emit_uleb128 (MonoDwarfWriter
*w
, guint32 value
)
239 guint8 b
= value
& 0x7f;
241 if (value
!= 0) /* more bytes to come */
247 static G_GNUC_UNUSED
void
248 emit_sleb128 (MonoDwarfWriter
*w
, gint64 value
)
251 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
|= - ((gint64
)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)))
275 static G_GNUC_UNUSED
void
276 encode_uleb128 (guint32 value
, guint8
*buf
, guint8
**endbuf
)
281 guint8 b
= value
& 0x7f;
283 if (value
!= 0) /* more bytes to come */
291 static G_GNUC_UNUSED
void
292 encode_sleb128 (gint32 value
, guint8
*buf
, guint8
**endbuf
)
295 gboolean negative
= (value
< 0);
303 /* the following is unnecessary if the
304 * implementation of >>= uses an arithmetic rather
305 * than logical shift for a signed left operand
309 value
|= - (1 <<(size
- 7));
310 /* sign bit of byte is second high order bit (0x40) */
311 if ((value
== 0 && !(byte
& 0x40)) ||
312 (value
== -1 && (byte
& 0x40)))
323 emit_dwarf_abbrev (MonoDwarfWriter
*w
, int code
, int tag
, gboolean has_child
,
324 int *attrs
, int attrs_len
)
328 emit_uleb128 (w
, code
);
329 emit_uleb128 (w
, tag
);
330 emit_byte (w
, has_child
);
332 for (i
= 0; i
< attrs_len
; i
++)
333 emit_uleb128 (w
, attrs
[i
]);
339 emit_cie (MonoDwarfWriter
*w
)
341 emit_section_change (w
, ".debug_frame", 0);
343 emit_alignment (w
, 8);
346 emit_symbol_diff (w
, ".Lcie0_end", ".Lcie0_start", 0); /* length */
347 emit_label (w
, ".Lcie0_start");
348 emit_int32 (w
, 0xffffffff); /* CIE id */
349 emit_byte (w
, 3); /* version */
350 emit_string (w
, ""); /* augmention */
351 emit_sleb128 (w
, 1); /* code alignment factor */
352 emit_sleb128 (w
, mono_unwind_get_dwarf_data_align ()); /* data alignment factor */
353 emit_uleb128 (w
, mono_unwind_get_dwarf_pc_reg ());
355 w
->cie_program
= w
->cie_program
;
356 if (w
->cie_program
) {
358 guint8
*uw_info
= mono_unwind_ops_encode (w
->cie_program
, &uw_info_len
);
359 emit_bytes (w
, uw_info
, uw_info_len
);
363 emit_alignment (w
, sizeof (target_mgreg_t
));
364 emit_label (w
, ".Lcie0_end");
368 emit_pointer_value (MonoDwarfWriter
*w
, gpointer ptr
)
370 gssize val
= (gssize
)ptr
;
371 emit_bytes (w
, (guint8
*)&val
, sizeof (target_mgreg_t
));
375 emit_fde (MonoDwarfWriter
*w
, int fde_index
, char *start_symbol
, char *end_symbol
,
376 guint8
*code
, guint32 code_size
, GSList
*unwind_ops
, gboolean use_cie
)
384 emit_section_change (w
, ".debug_frame", 0);
386 sprintf (symbol1
, ".Lfde%d_start", fde_index
);
387 sprintf (symbol2
, ".Lfde%d_end", fde_index
);
388 emit_symbol_diff (w
, symbol2
, symbol1
, 0); /* length */
389 emit_label (w
, symbol1
);
390 emit_int32 (w
, 0); /* CIE_pointer */
392 emit_pointer (w
, start_symbol
); /* initial_location */
394 emit_symbol_diff (w
, end_symbol
, start_symbol
, 0); /* address_range */
396 g_assert (code_size
);
397 emit_int32 (w
, code_size
);
400 emit_pointer_value (w
, code
);
401 emit_int32 (w
, code_size
);
403 #if TARGET_SIZEOF_VOID_P == 8
404 /* Upper 32 bits of code size */
409 if (w
->cie_program
) {
410 // FIXME: Check that the ops really begin with the CIE program */
413 for (i
= 0; i
< g_slist_length (w
->cie_program
); ++i
)
418 /* Convert the list of MonoUnwindOps to the format used by DWARF */
419 uw_info
= mono_unwind_ops_encode_full (l
, &uw_info_len
, FALSE
);
420 emit_bytes (w
, uw_info
, uw_info_len
);
423 emit_alignment (w
, sizeof (target_mgreg_t
));
424 emit_label (w
, symbol2
);
428 #define ABBREV_COMPILE_UNIT 1
429 #define ABBREV_SUBPROGRAM 2
430 #define ABBREV_PARAM 3
431 #define ABBREV_BASE_TYPE 4
432 #define ABBREV_STRUCT_TYPE 5
433 #define ABBREV_DATA_MEMBER 6
434 #define ABBREV_TYPEDEF 7
435 #define ABBREV_ENUM_TYPE 8
436 #define ABBREV_ENUMERATOR 9
437 #define ABBREV_NAMESPACE 10
438 #define ABBREV_VARIABLE 11
439 #define ABBREV_VARIABLE_LOCLIST 12
440 #define ABBREV_POINTER_TYPE 13
441 #define ABBREV_REFERENCE_TYPE 14
442 #define ABBREV_PARAM_LOCLIST 15
443 #define ABBREV_INHERITANCE 16
444 #define ABBREV_STRUCT_TYPE_NOCHILDREN 17
445 #define ABBREV_TRAMP_SUBPROGRAM 18
447 static int compile_unit_attr
[] = {
448 DW_AT_producer
,DW_FORM_string
,
449 DW_AT_name
,DW_FORM_string
,
450 DW_AT_comp_dir
,DW_FORM_string
,
451 DW_AT_language
,DW_FORM_data1
,
452 DW_AT_low_pc
,DW_FORM_addr
,
453 DW_AT_high_pc
,DW_FORM_addr
,
454 DW_AT_stmt_list
,DW_FORM_data4
457 static int subprogram_attr
[] = {
458 DW_AT_name
, DW_FORM_string
,
459 DW_AT_MIPS_linkage_name
, DW_FORM_string
,
460 DW_AT_decl_file
, DW_FORM_udata
,
461 DW_AT_decl_line
, DW_FORM_udata
,
463 DW_AT_description
, DW_FORM_string
,
465 DW_AT_low_pc
, DW_FORM_addr
,
466 DW_AT_high_pc
, DW_FORM_addr
,
467 DW_AT_frame_base
, DW_FORM_block1
470 static int tramp_subprogram_attr
[] = {
471 DW_AT_name
, DW_FORM_string
,
472 DW_AT_low_pc
, DW_FORM_addr
,
473 DW_AT_high_pc
, DW_FORM_addr
,
476 static int param_attr
[] = {
477 DW_AT_name
, DW_FORM_string
,
478 DW_AT_type
, DW_FORM_ref4
,
479 DW_AT_location
, DW_FORM_block1
482 static int param_loclist_attr
[] = {
483 DW_AT_name
, DW_FORM_string
,
484 DW_AT_type
, DW_FORM_ref4
,
485 DW_AT_location
, DW_FORM_data4
488 static int base_type_attr
[] = {
489 DW_AT_byte_size
, DW_FORM_data1
,
490 DW_AT_encoding
, DW_FORM_data1
,
491 DW_AT_name
, DW_FORM_string
494 static int struct_type_attr
[] = {
495 DW_AT_name
, DW_FORM_string
,
496 DW_AT_byte_size
, DW_FORM_udata
,
499 static int data_member_attr
[] = {
500 DW_AT_name
, DW_FORM_string
,
501 DW_AT_type
, DW_FORM_ref4
,
502 DW_AT_data_member_location
, DW_FORM_block1
505 static int typedef_attr
[] = {
506 DW_AT_name
, DW_FORM_string
,
507 DW_AT_type
, DW_FORM_ref4
510 static int pointer_type_attr
[] = {
511 DW_AT_type
, DW_FORM_ref4
,
514 static int reference_type_attr
[] = {
515 DW_AT_type
, DW_FORM_ref4
,
518 static int enum_type_attr
[] = {
519 DW_AT_name
, DW_FORM_string
,
520 DW_AT_byte_size
, DW_FORM_udata
,
521 DW_AT_type
, DW_FORM_ref4
,
524 static int enumerator_attr
[] = {
525 DW_AT_name
, DW_FORM_string
,
526 DW_AT_const_value
, DW_FORM_sdata
,
529 static int namespace_attr
[] = {
530 DW_AT_name
, DW_FORM_string
,
533 static int variable_attr
[] = {
534 DW_AT_name
, DW_FORM_string
,
535 DW_AT_type
, DW_FORM_ref4
,
536 DW_AT_location
, DW_FORM_block1
539 static int variable_loclist_attr
[] = {
540 DW_AT_name
, DW_FORM_string
,
541 DW_AT_type
, DW_FORM_ref4
,
542 DW_AT_location
, DW_FORM_data4
545 static int inheritance_attr
[] = {
546 DW_AT_type
, DW_FORM_ref4
,
547 DW_AT_data_member_location
, DW_FORM_block1
550 typedef struct DwarfBasicType
{
551 const char *die_name
, *name
;
557 static DwarfBasicType basic_types
[] = {
558 { ".LDIE_I1", "sbyte", MONO_TYPE_I1
, 1, DW_ATE_signed
},
559 { ".LDIE_U1", "byte", MONO_TYPE_U1
, 1, DW_ATE_unsigned
},
560 { ".LDIE_I2", "short", MONO_TYPE_I2
, 2, DW_ATE_signed
},
561 { ".LDIE_U2", "ushort", MONO_TYPE_U2
, 2, DW_ATE_unsigned
},
562 { ".LDIE_I4", "int", MONO_TYPE_I4
, 4, DW_ATE_signed
},
563 { ".LDIE_U4", "uint", MONO_TYPE_U4
, 4, DW_ATE_unsigned
},
564 { ".LDIE_I8", "long", MONO_TYPE_I8
, 8, DW_ATE_signed
},
565 { ".LDIE_U8", "ulong", MONO_TYPE_U8
, 8, DW_ATE_unsigned
},
566 { ".LDIE_I", "intptr", MONO_TYPE_I
, TARGET_SIZEOF_VOID_P
, DW_ATE_signed
},
567 { ".LDIE_U", "uintptr", MONO_TYPE_U
, TARGET_SIZEOF_VOID_P
, DW_ATE_unsigned
},
568 { ".LDIE_R4", "float", MONO_TYPE_R4
, 4, DW_ATE_float
},
569 { ".LDIE_R8", "double", MONO_TYPE_R8
, 8, DW_ATE_float
},
570 { ".LDIE_BOOLEAN", "boolean", MONO_TYPE_BOOLEAN
, 1, DW_ATE_boolean
},
571 { ".LDIE_CHAR", "char", MONO_TYPE_CHAR
, 2, DW_ATE_unsigned_char
},
572 { ".LDIE_STRING", "string", MONO_TYPE_STRING
, sizeof (target_mgreg_t
), DW_ATE_address
},
573 { ".LDIE_OBJECT", "object", MONO_TYPE_OBJECT
, sizeof (target_mgreg_t
), DW_ATE_address
},
574 { ".LDIE_SZARRAY", "object", MONO_TYPE_SZARRAY
, sizeof (target_mgreg_t
), DW_ATE_address
},
577 /* Constants for encoding line number special opcodes */
578 #define OPCODE_BASE 13
580 #define LINE_RANGE 14
583 get_line_number_file_name (MonoDwarfWriter
*w
, const char *name
)
587 g_assert (w
->file_to_index
);
588 index
= GPOINTER_TO_UINT (g_hash_table_lookup (w
->file_to_index
, name
));
589 g_assert (index
> 0);
594 add_line_number_file_name (MonoDwarfWriter
*w
, const char *name
,
595 gint64 last_mod_time
, gint64 file_size
)
600 if (!w
->file_to_index
) {
601 w
->file_to_index
= g_hash_table_new (g_str_hash
, g_str_equal
);
602 w
->index_to_file
= g_hash_table_new (NULL
, NULL
);
605 index
= GPOINTER_TO_UINT (g_hash_table_lookup (w
->file_to_index
, name
));
608 index
= w
->line_number_file_index
;
609 w
->line_number_file_index
++;
610 copy
= g_strdup (name
);
611 g_hash_table_insert (w
->file_to_index
, copy
, GUINT_TO_POINTER (index
+ 1));
612 g_hash_table_insert (w
->index_to_file
, GUINT_TO_POINTER (index
+ 1), copy
);
618 mono_dwarf_escape_path (const char *name
)
620 if (strchr (name
, '\\')) {
625 s
= (char *)g_malloc0 ((len
+ 1) * 2);
627 for (i
= 0; i
< len
; ++i
) {
628 if (name
[i
] == '\\') {
637 return g_strdup (name
);
641 emit_all_line_number_info (MonoDwarfWriter
*w
)
644 GHashTable
*dir_to_index
, *index_to_dir
;
648 add_line_number_file_name (w
, "<unknown>", 0, 0);
651 info_list
= g_slist_reverse (w
->line_info
);
652 for (l
= info_list
; l
; l
= l
->next
) {
653 MethodLineNumberInfo
*info
= (MethodLineNumberInfo
*)l
->data
;
654 MonoDebugMethodInfo
*minfo
;
655 GPtrArray
*source_file_list
;
658 minfo
= mono_debug_lookup_method (info
->method
);
662 mono_debug_get_seq_points (minfo
, NULL
, &source_file_list
, NULL
, NULL
, NULL
);
663 for (i
= 0; i
< source_file_list
->len
; ++i
) {
664 MonoDebugSourceInfo
*sinfo
= (MonoDebugSourceInfo
*)g_ptr_array_index (source_file_list
, i
);
665 add_line_number_file_name (w
, sinfo
->source_file
, 0, 0);
669 /* Preprocess files */
670 dir_to_index
= g_hash_table_new (g_str_hash
, g_str_equal
);
671 index_to_dir
= g_hash_table_new (NULL
, NULL
);
672 for (i
= 0; i
< w
->line_number_file_index
; ++i
) {
673 char *name
= (char *)g_hash_table_lookup (w
->index_to_file
, GUINT_TO_POINTER (i
+ 1));
677 if (g_path_is_absolute (name
)) {
678 char *dir
= g_path_get_dirname (name
);
680 dir_index
= GPOINTER_TO_UINT (g_hash_table_lookup (dir_to_index
, dir
));
681 if (dir_index
== 0) {
682 dir_index
= w
->line_number_dir_index
;
683 w
->line_number_dir_index
++;
684 copy
= g_strdup (dir
);
685 g_hash_table_insert (dir_to_index
, copy
, GUINT_TO_POINTER (dir_index
+ 1));
686 g_hash_table_insert (index_to_dir
, GUINT_TO_POINTER (dir_index
+ 1), copy
);
695 /* Line number info header */
696 emit_section_change (w
, ".debug_line", 0);
697 emit_label (w
, ".Ldebug_line_section_start");
698 emit_label (w
, ".Ldebug_line_start");
699 emit_symbol_diff (w
, ".Ldebug_line_end", ".", -4); /* length */
700 emit_int16 (w
, 0x2); /* version */
701 emit_symbol_diff (w
, ".Ldebug_line_header_end", ".", -4); /* header_length */
702 emit_byte (w
, 1); /* minimum_instruction_length */
703 emit_byte (w
, 1); /* default_is_stmt */
704 emit_byte (w
, LINE_BASE
); /* line_base */
705 emit_byte (w
, LINE_RANGE
); /* line_range */
706 emit_byte (w
, OPCODE_BASE
); /* opcode_base */
707 emit_byte (w
, 0); /* standard_opcode_lengths */
721 emit_section_change (w
, ".debug_line", 0);
722 for (i
= 0; i
< w
->line_number_dir_index
; ++i
) {
723 char *dir
= (char *)g_hash_table_lookup (index_to_dir
, GUINT_TO_POINTER (i
+ 1));
725 emit_string (w
, mono_dwarf_escape_path (dir
));
727 /* End of Includes */
731 for (i
= 0; i
< w
->line_number_file_index
; ++i
) {
732 char *name
= (char *)g_hash_table_lookup (w
->index_to_file
, GUINT_TO_POINTER (i
+ 1));
733 char *basename
= NULL
, *dir
;
736 if (g_path_is_absolute (name
)) {
737 dir
= g_path_get_dirname (name
);
739 dir_index
= GPOINTER_TO_UINT (g_hash_table_lookup (dir_to_index
, dir
));
740 basename
= g_path_get_basename (name
);
744 emit_string (w
, basename
);
746 emit_string (w
, mono_dwarf_escape_path (name
));
747 emit_uleb128 (w
, dir_index
);
755 emit_label (w
, ".Ldebug_line_header_end");
757 /* Emit line number table */
758 for (l
= info_list
; l
; l
= l
->next
) {
759 MethodLineNumberInfo
*info
= (MethodLineNumberInfo
*)l
->data
;
760 MonoDebugMethodJitInfo
*dmji
;
762 dmji
= mono_debug_find_method (info
->method
, mono_domain_get ());
765 emit_line_number_info (w
, info
->method
, info
->start_symbol
, info
->end_symbol
, info
->code
, info
->code_size
, dmji
);
766 mono_debug_free_method_jit_info (dmji
);
768 g_slist_free (info_list
);
772 emit_byte (w
, DW_LNE_end_sequence
);
774 emit_label (w
, ".Ldebug_line_end");
778 * Some assemblers like apple's do not support subsections, so we can't place
779 * .Ldebug_info_end at the end of the section using subsections. Instead, we
780 * define it every time something gets added to the .debug_info section.
781 * The apple assember seems to use the last definition.
784 emit_debug_info_end (MonoDwarfWriter
*w
)
786 /* This doesn't seem to work/required with recent iphone sdk versions */
788 if (!mono_img_writer_subsections_supported (w
->w
))
789 fprintf (w
->fp
, "\n.set %sdebug_info_end,.\n", w
->temp_prefix
);
794 mono_dwarf_writer_emit_base_info (MonoDwarfWriter
*w
, const char *cu_name
, GSList
*base_unwind_program
)
796 char *s
, *build_info
;
800 emit_section_change (w
, ".debug_line", 0);
801 emit_label (w
, ".Ldebug_line_section_start");
802 emit_label (w
, ".Ldebug_line_start");
805 w
->cie_program
= base_unwind_program
;
807 emit_section_change (w
, ".debug_abbrev", 0);
808 emit_label (w
, ".Ldebug_abbrev_start");
809 emit_dwarf_abbrev (w
, ABBREV_COMPILE_UNIT
, DW_TAG_compile_unit
, TRUE
,
810 compile_unit_attr
, G_N_ELEMENTS (compile_unit_attr
));
811 emit_dwarf_abbrev (w
, ABBREV_SUBPROGRAM
, DW_TAG_subprogram
, TRUE
,
812 subprogram_attr
, G_N_ELEMENTS (subprogram_attr
));
813 emit_dwarf_abbrev (w
, ABBREV_PARAM
, DW_TAG_formal_parameter
, FALSE
,
814 param_attr
, G_N_ELEMENTS (param_attr
));
815 emit_dwarf_abbrev (w
, ABBREV_PARAM_LOCLIST
, DW_TAG_formal_parameter
, FALSE
,
816 param_loclist_attr
, G_N_ELEMENTS (param_loclist_attr
));
817 emit_dwarf_abbrev (w
, ABBREV_BASE_TYPE
, DW_TAG_base_type
, FALSE
,
818 base_type_attr
, G_N_ELEMENTS (base_type_attr
));
819 emit_dwarf_abbrev (w
, ABBREV_STRUCT_TYPE
, DW_TAG_class_type
, TRUE
,
820 struct_type_attr
, G_N_ELEMENTS (struct_type_attr
));
821 emit_dwarf_abbrev (w
, ABBREV_STRUCT_TYPE_NOCHILDREN
, DW_TAG_class_type
, FALSE
,
822 struct_type_attr
, G_N_ELEMENTS (struct_type_attr
));
823 emit_dwarf_abbrev (w
, ABBREV_DATA_MEMBER
, DW_TAG_member
, FALSE
,
824 data_member_attr
, G_N_ELEMENTS (data_member_attr
));
825 emit_dwarf_abbrev (w
, ABBREV_TYPEDEF
, DW_TAG_typedef
, FALSE
,
826 typedef_attr
, G_N_ELEMENTS (typedef_attr
));
827 emit_dwarf_abbrev (w
, ABBREV_ENUM_TYPE
, DW_TAG_enumeration_type
, TRUE
,
828 enum_type_attr
, G_N_ELEMENTS (enum_type_attr
));
829 emit_dwarf_abbrev (w
, ABBREV_ENUMERATOR
, DW_TAG_enumerator
, FALSE
,
830 enumerator_attr
, G_N_ELEMENTS (enumerator_attr
));
831 emit_dwarf_abbrev (w
, ABBREV_NAMESPACE
, DW_TAG_namespace
, TRUE
,
832 namespace_attr
, G_N_ELEMENTS (namespace_attr
));
833 emit_dwarf_abbrev (w
, ABBREV_VARIABLE
, DW_TAG_variable
, FALSE
,
834 variable_attr
, G_N_ELEMENTS (variable_attr
));
835 emit_dwarf_abbrev (w
, ABBREV_VARIABLE_LOCLIST
, DW_TAG_variable
, FALSE
,
836 variable_loclist_attr
, G_N_ELEMENTS (variable_loclist_attr
));
837 emit_dwarf_abbrev (w
, ABBREV_POINTER_TYPE
, DW_TAG_pointer_type
, FALSE
,
838 pointer_type_attr
, G_N_ELEMENTS (pointer_type_attr
));
839 emit_dwarf_abbrev (w
, ABBREV_REFERENCE_TYPE
, DW_TAG_reference_type
, FALSE
,
840 reference_type_attr
, G_N_ELEMENTS (reference_type_attr
));
841 emit_dwarf_abbrev (w
, ABBREV_INHERITANCE
, DW_TAG_inheritance
, FALSE
,
842 inheritance_attr
, G_N_ELEMENTS (inheritance_attr
));
843 emit_dwarf_abbrev (w
, ABBREV_TRAMP_SUBPROGRAM
, DW_TAG_subprogram
, FALSE
,
844 tramp_subprogram_attr
, G_N_ELEMENTS (tramp_subprogram_attr
));
847 emit_section_change (w
, ".debug_info", 0);
848 emit_label (w
, ".Ldebug_info_start");
849 emit_symbol_diff (w
, ".Ldebug_info_end", ".Ldebug_info_begin", 0); /* length */
850 emit_label (w
, ".Ldebug_info_begin");
851 emit_int16 (w
, 0x2); /* DWARF version 2 */
852 #if !defined(TARGET_MACH)
853 emit_symbol (w
, ".Ldebug_abbrev_start"); /* .debug_abbrev offset */
855 emit_int32 (w
, 0); /* .debug_abbrev offset */
857 emit_byte (w
, sizeof (target_mgreg_t
)); /* address size */
859 /* Compilation unit */
860 emit_uleb128 (w
, ABBREV_COMPILE_UNIT
);
861 build_info
= mono_get_runtime_build_info ();
862 s
= g_strdup_printf ("Mono AOT Compiler %s", build_info
);
866 emit_string (w
, cu_name
);
868 emit_byte (w
, DW_LANG_C
);
869 emit_pointer_value (w
, 0);
870 emit_pointer_value (w
, 0);
871 /* offset into .debug_line section */
872 emit_symbol_diff (w
, ".Ldebug_line_start", ".Ldebug_line_section_start", 0);
875 for (i
= 0; i
< G_N_ELEMENTS (basic_types
); ++i
) {
876 emit_label (w
, basic_types
[i
].die_name
);
877 emit_uleb128 (w
, ABBREV_BASE_TYPE
);
878 emit_byte (w
, basic_types
[i
].size
);
879 emit_byte (w
, basic_types
[i
].encoding
);
880 emit_string (w
, basic_types
[i
].name
);
883 emit_debug_info_end (w
);
885 /* debug_loc section */
886 emit_section_change (w
, ".debug_loc", 0);
887 emit_label (w
, ".Ldebug_loc_start");
893 * mono_dwarf_writer_close:
895 * Finalize the emitted debugging info.
898 mono_dwarf_writer_close (MonoDwarfWriter
*w
)
900 emit_section_change (w
, ".debug_info", 0);
901 emit_byte (w
, 0); /* close COMPILE_UNIT */
902 emit_label (w
, ".Ldebug_info_end");
905 emit_all_line_number_info (w
);
908 static void emit_type (MonoDwarfWriter
*w
, MonoType
*t
);
909 static const char* get_type_die (MonoDwarfWriter
*w
, MonoType
*t
);
912 get_class_die (MonoDwarfWriter
*w
, MonoClass
*klass
, gboolean vtype
)
917 cache
= w
->class_to_vtype_die
;
919 cache
= w
->class_to_die
;
921 return (const char *)g_hash_table_lookup (cache
, klass
);
924 /* Returns the local symbol pointing to the emitted debug info */
926 emit_class_dwarf_info (MonoDwarfWriter
*w
, MonoClass
*klass
, gboolean vtype
)
928 char *die
, *pointer_die
, *reference_die
;
931 MonoClassField
*field
;
934 gboolean emit_namespace
= FALSE
, has_children
;
938 cache
= w
->class_to_vtype_die
;
940 cache
= w
->class_to_die
;
942 die
= (char *)g_hash_table_lookup (cache
, klass
);
946 if (!((m_class_get_byval_arg (klass
)->type
== MONO_TYPE_CLASS
) || (m_class_get_byval_arg (klass
)->type
== MONO_TYPE_OBJECT
) || m_class_get_byval_arg (klass
)->type
== MONO_TYPE_GENERICINST
|| m_class_is_enumtype (klass
) || (m_class_get_byval_arg (klass
)->type
== MONO_TYPE_VALUETYPE
&& vtype
) ||
947 (m_class_get_byval_arg (klass
)->type
>= MONO_TYPE_BOOLEAN
&& m_class_get_byval_arg (klass
)->type
<= MONO_TYPE_R8
&& !vtype
)))
951 * FIXME: gdb can't handle namespaces in languages it doesn't know about.
954 if (klass->name_space && klass->name_space [0] != '\0')
955 emit_namespace = TRUE;
957 if (emit_namespace
) {
958 emit_uleb128 (w
, ABBREV_NAMESPACE
);
959 emit_string (w
, m_class_get_name_space (klass
));
962 full_name
= g_strdup_printf ("%s%s%s", m_class_get_name_space (klass
), m_class_get_name_space (klass
) ? "." : "", m_class_get_name (klass
));
964 * gdb doesn't support namespaces for non-C++ dwarf objects, so use _
965 * to separate components.
967 for (p
= full_name
; *p
; p
++)
971 die
= g_strdup_printf (".LTDIE_%d", w
->tdie_index
);
972 pointer_die
= g_strdup_printf (".LTDIE_%d_POINTER", w
->tdie_index
);
973 reference_die
= g_strdup_printf (".LTDIE_%d_REFERENCE", w
->tdie_index
);
976 g_hash_table_insert (w
->class_to_pointer_die
, klass
, pointer_die
);
977 g_hash_table_insert (w
->class_to_reference_die
, klass
, reference_die
);
978 g_hash_table_insert (cache
, klass
, die
);
980 if (m_class_is_enumtype (klass
)) {
981 int size
= mono_class_value_size (mono_class_from_mono_type_internal (mono_class_enum_basetype_internal (klass
)), NULL
);
985 emit_uleb128 (w
, ABBREV_ENUM_TYPE
);
986 emit_string (w
, full_name
);
987 emit_uleb128 (w
, size
);
988 for (k
= 0; k
< G_N_ELEMENTS (basic_types
); ++k
)
989 if (basic_types
[k
].type
== mono_class_enum_basetype_internal (klass
)->type
)
991 g_assert (k
< G_N_ELEMENTS (basic_types
));
992 emit_symbol_diff (w
, basic_types
[k
].die_name
, ".Ldebug_info_start", 0);
994 /* Emit enum values */
996 while ((field
= mono_class_get_fields_internal (klass
, &iter
))) {
998 MonoTypeEnum def_type
;
1000 if (!(field
->type
->attrs
& FIELD_ATTRIBUTE_STATIC
))
1002 if (mono_field_is_deleted (field
))
1005 emit_uleb128 (w
, ABBREV_ENUMERATOR
);
1006 emit_string (w
, mono_field_get_name (field
));
1008 p
= mono_class_get_field_default_value (field
, &def_type
);
1009 /* len = */ mono_metadata_decode_blob_size (p
, &p
);
1010 switch (mono_class_enum_basetype_internal (klass
)->type
) {
1013 case MONO_TYPE_BOOLEAN
:
1014 emit_sleb128 (w
, *p
);
1018 case MONO_TYPE_CHAR
:
1019 emit_sleb128 (w
, read16 (p
));
1023 emit_sleb128 (w
, read32 (p
));
1027 emit_sleb128 (w
, read64 (p
));
1031 #if TARGET_SIZEOF_VOID_P == 8
1032 emit_sleb128 (w
, read64 (p
));
1034 emit_sleb128 (w
, read32 (p
));
1038 g_assert_not_reached ();
1042 has_children
= TRUE
;
1048 if (m_class_get_parent (klass
))
1049 parent_die
= emit_class_dwarf_info (w
, m_class_get_parent (klass
), FALSE
);
1053 /* Emit field types */
1055 while ((field
= mono_class_get_fields_internal (klass
, &iter
))) {
1056 if (field
->type
->attrs
& FIELD_ATTRIBUTE_STATIC
)
1059 emit_type (w
, field
->type
);
1063 has_children
= parent_die
|| mono_class_get_fields_internal (klass
, &iter
);
1065 emit_label (w
, die
);
1067 emit_uleb128 (w
, has_children
? ABBREV_STRUCT_TYPE
: ABBREV_STRUCT_TYPE_NOCHILDREN
);
1068 emit_string (w
, full_name
);
1069 emit_uleb128 (w
, m_class_get_instance_size (klass
));
1072 emit_uleb128 (w
, ABBREV_INHERITANCE
);
1073 emit_symbol_diff (w
, parent_die
, ".Ldebug_info_start", 0);
1076 *p
++= DW_OP_plus_uconst
;
1077 encode_uleb128 (0, p
, &p
);
1078 emit_byte (w
, p
- buf
);
1079 emit_bytes (w
, buf
, p
- buf
);
1084 while ((field
= mono_class_get_fields_internal (klass
, &iter
))) {
1085 if (field
->type
->attrs
& FIELD_ATTRIBUTE_STATIC
)
1088 fdie
= get_type_die (w
, field
->type
);
1090 emit_uleb128 (w
, ABBREV_DATA_MEMBER
);
1091 emit_string (w
, field
->name
);
1092 emit_symbol_diff (w
, fdie
, ".Ldebug_info_start", 0);
1095 *p
++= DW_OP_plus_uconst
;
1096 if (m_class_is_valuetype (klass
) && vtype
)
1097 encode_uleb128 (field
->offset
- MONO_ABI_SIZEOF (MonoObject
), p
, &p
);
1099 encode_uleb128 (field
->offset
, p
, &p
);
1101 emit_byte (w
, p
- buf
);
1102 emit_bytes (w
, buf
, p
- buf
);
1109 emit_uleb128 (w
, 0x0);
1111 /* Add a typedef, so we can reference the type without a 'struct' in gdb */
1112 emit_uleb128 (w
, ABBREV_TYPEDEF
);
1113 emit_string (w
, full_name
);
1114 emit_symbol_diff (w
, die
, ".Ldebug_info_start", 0);
1116 /* Add a pointer type */
1117 emit_label (w
, pointer_die
);
1119 emit_uleb128 (w
, ABBREV_POINTER_TYPE
);
1120 emit_symbol_diff (w
, die
, ".Ldebug_info_start", 0);
1122 /* Add a reference type */
1123 emit_label (w
, reference_die
);
1125 emit_uleb128 (w
, ABBREV_REFERENCE_TYPE
);
1126 emit_symbol_diff (w
, die
, ".Ldebug_info_start", 0);
1130 if (emit_namespace
) {
1132 emit_uleb128 (w
, 0x0);
1138 static gboolean base_types_emitted
[64];
1141 get_type_die (MonoDwarfWriter
*w
, MonoType
*t
)
1143 MonoClass
*klass
= mono_class_from_mono_type_internal (t
);
1148 if (t
->type
== MONO_TYPE_VALUETYPE
) {
1149 tdie
= (const char *)g_hash_table_lookup (w
->class_to_pointer_die
, klass
);
1152 tdie
= get_class_die (w
, klass
, FALSE
);
1153 /* Should return a pointer type to a reference */
1156 t
= mono_get_int_type ();
1158 for (j
= 0; j
< G_N_ELEMENTS (basic_types
); ++j
)
1159 if (basic_types
[j
].type
== t
->type
)
1161 if (j
< G_N_ELEMENTS (basic_types
)) {
1162 tdie
= basic_types
[j
].die_name
;
1165 case MONO_TYPE_CLASS
:
1166 tdie
= (const char *)g_hash_table_lookup (w
->class_to_reference_die
, klass
);
1167 //tdie = ".LDIE_OBJECT";
1169 case MONO_TYPE_ARRAY
:
1170 tdie
= ".LDIE_OBJECT";
1172 case MONO_TYPE_VALUETYPE
:
1173 if (m_class_is_enumtype (klass
))
1174 tdie
= get_class_die (w
, klass
, FALSE
);
1178 case MONO_TYPE_GENERICINST
:
1179 if (!MONO_TYPE_ISSTRUCT (t
)) {
1180 tdie
= (const char *)g_hash_table_lookup (w
->class_to_reference_die
, klass
);
1200 emit_type (MonoDwarfWriter
*w
, MonoType
*t
)
1202 MonoClass
*klass
= mono_class_from_mono_type_internal (t
);
1207 if (t
->type
== MONO_TYPE_VALUETYPE
) {
1208 tdie
= emit_class_dwarf_info (w
, klass
, TRUE
);
1213 emit_class_dwarf_info (w
, klass
, FALSE
);
1216 t
= mono_get_int_type ();
1218 for (j
= 0; j
< G_N_ELEMENTS (basic_types
); ++j
)
1219 if (basic_types
[j
].type
== t
->type
)
1221 if (j
< G_N_ELEMENTS (basic_types
)) {
1222 /* Emit a boxed version of base types */
1223 if (j
< 64 && !base_types_emitted
[j
]) {
1224 emit_class_dwarf_info (w
, klass
, FALSE
);
1225 base_types_emitted
[j
] = TRUE
;
1229 case MONO_TYPE_CLASS
:
1230 emit_class_dwarf_info (w
, klass
, FALSE
);
1232 case MONO_TYPE_ARRAY
:
1234 case MONO_TYPE_VALUETYPE
:
1235 if (m_class_is_enumtype (klass
))
1236 emit_class_dwarf_info (w
, klass
, FALSE
);
1238 case MONO_TYPE_GENERICINST
:
1239 if (!MONO_TYPE_ISSTRUCT (t
))
1240 emit_class_dwarf_info (w
, klass
, FALSE
);
1251 emit_var_type (MonoDwarfWriter
*w
, MonoType
*t
)
1255 tdie
= get_type_die (w
, t
);
1257 emit_symbol_diff (w
, tdie
, ".Ldebug_info_start", 0);
1261 encode_var_location (MonoDwarfWriter
*w
, MonoInst
*ins
, guint8
*p
, guint8
**endp
)
1264 /* FIXME: This needs a location list, since the args can go from reg->stack */
1265 if (!ins
|| ins
->flags
& MONO_INST_IS_DEAD
) {
1266 /* gdb treats this as optimized out */
1267 } else if (ins
->opcode
== OP_REGVAR
) {
1268 *p
= DW_OP_reg0
+ mono_hw_reg_to_dwarf_reg (ins
->dreg
);
1270 } else if (ins
->opcode
== OP_REGOFFSET
) {
1271 *p
++= DW_OP_breg0
+ mono_hw_reg_to_dwarf_reg (ins
->inst_basereg
);
1272 encode_sleb128 (ins
->inst_offset
, p
, &p
);
1282 emit_loclist (MonoDwarfWriter
*w
, MonoInst
*ins
,
1283 guint8
*loclist_begin_addr
, guint8
*loclist_end_addr
,
1284 guint8
*expr
, guint32 expr_len
)
1288 emit_push_section (w
, ".debug_loc", 0);
1289 sprintf (label
, ".Lloclist_%d", w
->loclist_index
++ );
1290 emit_label (w
, label
);
1292 emit_pointer_value (w
, loclist_begin_addr
);
1293 emit_pointer_value (w
, loclist_end_addr
);
1294 emit_byte (w
, expr_len
% 256);
1295 emit_byte (w
, expr_len
/ 256);
1296 emit_bytes (w
, expr
, expr_len
);
1298 emit_pointer_value (w
, NULL
);
1299 emit_pointer_value (w
, NULL
);
1301 emit_pop_section (w
);
1302 emit_symbol_diff (w
, label
, ".Ldebug_loc_start", 0);
1306 * MonoDisHelper->tokener doesn't take an IP argument, and we can't add one since
1307 * it is a public header.
1309 static const guint8
*token_handler_ip
;
1312 token_handler (MonoDisHelper
*dh
, MonoMethod
*method
, guint32 token
)
1316 MonoMethod
*cmethod
;
1318 MonoClassField
*field
;
1319 gpointer data
= NULL
;
1321 if (method
->wrapper_type
)
1322 data
= mono_method_get_wrapper_data (method
, token
);
1324 switch (*token_handler_ip
) {
1328 if (method
->wrapper_type
) {
1329 klass
= (MonoClass
*)data
;
1331 klass
= mono_class_get_checked (m_class_get_image (method
->klass
), token
, error
);
1332 g_assert (is_ok (error
)); /* FIXME error handling */
1334 res
= g_strdup_printf ("<%s>", m_class_get_name (klass
));
1339 if (method
->wrapper_type
) {
1340 cmethod
= (MonoMethod
*)data
;
1343 cmethod
= mono_get_method_checked (m_class_get_image (method
->klass
), token
, NULL
, NULL
, error
);
1345 g_error ("Could not load method due to %s", mono_error_get_message (error
)); /* FIXME don't swallow the error */
1347 desc
= mono_method_full_name (cmethod
, TRUE
);
1348 res
= g_strdup_printf ("<%s>", desc
);
1352 if (method
->wrapper_type
) {
1353 desc
= mono_signature_get_desc ((MonoMethodSignature
*)data
, FALSE
);
1354 res
= g_strdup_printf ("<%s>", desc
);
1357 res
= g_strdup_printf ("<0x%08x>", token
);
1364 if (method
->wrapper_type
) {
1365 field
= (MonoClassField
*)data
;
1367 field
= mono_field_from_token_checked (m_class_get_image (method
->klass
), token
, &klass
, NULL
, error
);
1368 g_assert (is_ok (error
)); /* FIXME error handling */
1370 desc
= mono_field_full_name (field
);
1371 res
= g_strdup_printf ("<%s>", desc
);
1375 res
= g_strdup_printf ("<0x%08x>", token
);
1385 * Produce a disassembled form of the IL instruction at IP. This is an extension
1386 * of mono_disasm_code_one () which can disasm tokens, handle wrapper methods, and
1387 * CEE_MONO_ opcodes.
1390 disasm_ins (MonoMethod
*method
, const guchar
*ip
, const guint8
**endip
)
1395 MonoMethodHeader
*header
= mono_method_get_header_checked (method
, error
);
1396 mono_error_assert_ok (error
); /* FIXME don't swallow the error */
1398 memset (&dh
, 0, sizeof (dh
));
1400 dh
.label_format
= "IL_%04x: ";
1401 dh
.label_target
= "IL_%04x";
1402 dh
.tokener
= token_handler
;
1404 token_handler_ip
= ip
;
1405 if (*ip
== MONO_CUSTOM_PREFIX
) {
1410 case CEE_MONO_ICALL
: {
1411 MonoJitICallInfo
const * const info
= mono_find_jit_icall_info ((MonoJitICallId
)read32 (ip
+ 2));
1412 dis
= g_strdup_printf ("IL_%04x: mono_icall <%s>", (int)(ip
- header
->code
), info
->name
);
1416 case CEE_MONO_CLASSCONST
: {
1417 token
= read32 (ip
+ 2);
1418 data
= mono_method_get_wrapper_data (method
, token
);
1420 dis
= g_strdup_printf ("IL_%04x: mono_classconst <%s>", (int)(ip
- header
->code
), m_class_get_name ((MonoClass
*)data
));
1425 dis
= mono_disasm_code_one (&dh
, method
, ip
, &ip
);
1428 dis
= mono_disasm_code_one (&dh
, method
, ip
, &ip
);
1430 token_handler_ip
= NULL
;
1433 mono_metadata_free_mh (header
);
1438 il_offset_from_address (MonoMethod
*method
, MonoDebugMethodJitInfo
*jit
,
1439 guint32 native_offset
)
1443 if (!jit
->line_numbers
)
1446 for (i
= jit
->num_line_numbers
- 1; i
>= 0; i
--) {
1447 MonoDebugLineNumberEntry lne
= jit
->line_numbers
[i
];
1449 if (lne
.native_offset
<= native_offset
)
1450 return lne
.il_offset
;
1456 static int max_special_addr_diff
= 0;
1459 emit_advance_op (MonoDwarfWriter
*w
, int line_diff
, int addr_diff
)
1463 /* Use a special opcode if possible */
1464 if (line_diff
- LINE_BASE
>= 0 && line_diff
- LINE_BASE
< LINE_RANGE
) {
1465 if (max_special_addr_diff
== 0)
1466 max_special_addr_diff
= (255 - OPCODE_BASE
) / LINE_RANGE
;
1468 if (addr_diff
> max_special_addr_diff
&& (addr_diff
< 2 * max_special_addr_diff
)) {
1469 emit_byte (w
, DW_LNS_const_add_pc
);
1470 addr_diff
-= max_special_addr_diff
;
1473 opcode
= (line_diff
- LINE_BASE
) + (LINE_RANGE
* addr_diff
) + OPCODE_BASE
;
1479 emit_byte (w
, opcode
);
1481 //printf ("large: %d %d %d\n", line_diff, addr_diff, max_special_addr_diff);
1482 emit_byte (w
, DW_LNS_advance_line
);
1483 emit_sleb128 (w
, line_diff
);
1484 emit_byte (w
, DW_LNS_advance_pc
);
1485 emit_sleb128 (w
, addr_diff
);
1486 emit_byte (w
, DW_LNS_copy
);
1491 compare_lne (MonoDebugLineNumberEntry
*a
, MonoDebugLineNumberEntry
*b
)
1493 if (a
->native_offset
== b
->native_offset
)
1494 return a
->il_offset
- b
->il_offset
;
1496 return a
->native_offset
- b
->native_offset
;
1500 emit_line_number_info (MonoDwarfWriter
*w
, MonoMethod
*method
,
1501 char *start_symbol
, char *end_symbol
,
1502 guint8
*code
, guint32 code_size
,
1503 MonoDebugMethodJitInfo
*debug_info
)
1506 guint32 prev_line
= 0;
1507 guint32 prev_native_offset
= 0;
1508 int i
, file_index
, il_offset
, prev_il_offset
;
1509 gboolean first
= TRUE
;
1510 MonoDebugSourceLocation
*loc
;
1511 char *prev_file_name
= NULL
;
1512 MonoMethodHeader
*header
= mono_method_get_header_checked (method
, error
);
1513 MonoDebugMethodInfo
*minfo
;
1514 MonoDebugLineNumberEntry
*ln_array
;
1515 int *native_to_il_offset
= NULL
;
1517 mono_error_assert_ok (error
); /* FIXME don't swallow the error */
1519 if (!w
->emit_line
) {
1520 mono_metadata_free_mh (header
);
1524 minfo
= mono_debug_lookup_method (method
);
1526 /* Compute the native->IL offset mapping */
1528 g_assert (code_size
);
1530 ln_array
= g_new0 (MonoDebugLineNumberEntry
, debug_info
->num_line_numbers
);
1531 memcpy (ln_array
, debug_info
->line_numbers
, debug_info
->num_line_numbers
* sizeof (MonoDebugLineNumberEntry
));
1533 mono_qsort (ln_array
, debug_info
->num_line_numbers
, sizeof (MonoDebugLineNumberEntry
), (int (*)(const void *, const void *))compare_lne
);
1535 native_to_il_offset
= g_new0 (int, code_size
+ 1);
1537 for (i
= 0; i
< debug_info
->num_line_numbers
; ++i
) {
1539 MonoDebugLineNumberEntry
*lne
= &ln_array
[i
];
1542 for (j
= 0; j
< lne
->native_offset
; ++j
)
1543 native_to_il_offset
[j
] = -1;
1546 if (i
< debug_info
->num_line_numbers
- 1) {
1547 MonoDebugLineNumberEntry
*lne_next
= &ln_array
[i
+ 1];
1549 for (j
= lne
->native_offset
; j
< lne_next
->native_offset
; ++j
)
1550 native_to_il_offset
[j
] = lne
->il_offset
;
1552 for (j
= lne
->native_offset
; j
< code_size
; ++j
)
1553 native_to_il_offset
[j
] = lne
->il_offset
;
1559 prev_il_offset
= -1;
1561 w
->cur_file_index
= -1;
1562 for (i
= 0; i
< code_size
; ++i
) {
1563 int line_diff
, addr_diff
;
1568 if (!debug_info
->line_numbers
)
1571 if (native_to_il_offset
)
1572 il_offset
= native_to_il_offset
[i
];
1574 il_offset
= il_offset_from_address (method
, debug_info
, i
);
1576 il_offset = il_offset_from_address (method, debug_info, i);
1578 g_assert (il_offset == native_to_il_offset [i]);
1581 il_offset
= native_to_il_offset
[i
];
1585 if (il_offset
== prev_il_offset
)
1588 prev_il_offset
= il_offset
;
1590 loc
= mono_debug_method_lookup_location (minfo
, il_offset
);
1593 if (!loc
->source_file
) {
1594 mono_debug_free_source_location (loc
);
1598 line_diff
= (gint32
)loc
->row
- (gint32
)prev_line
;
1599 addr_diff
= i
- prev_native_offset
;
1602 emit_section_change (w
, ".debug_line", 0);
1605 emit_byte (w
, sizeof (target_mgreg_t
) + 1);
1606 emit_byte (w
, DW_LNE_set_address
);
1608 emit_pointer_unaligned (w
, start_symbol
);
1610 emit_pointer_value (w
, code
);
1614 if (loc
->row
!= prev_line
) {
1615 if (!prev_file_name
|| strcmp (loc
->source_file
, prev_file_name
) != 0) {
1616 /* Add an entry to the file table */
1617 /* FIXME: Avoid duplicates */
1618 file_index
= get_line_number_file_name (w
, loc
->source_file
) + 1;
1619 g_free (prev_file_name
);
1620 prev_file_name
= g_strdup (loc
->source_file
);
1622 if (w
->cur_file_index
!= file_index
) {
1623 emit_byte (w
, DW_LNS_set_file
);
1624 emit_uleb128 (w
, file_index
);
1625 emit_byte (w
, DW_LNS_copy
);
1626 w
->cur_file_index
= file_index
;
1631 if (loc
->row
!= prev_line
) {
1632 if (prev_native_offset
== 0)
1633 emit_byte (w
, DW_LNE_set_prologue_end
);
1635 //printf ("X: %p(+0x%x) %d %s:%d(+%d)\n", code + i, addr_diff, loc->il_offset, loc->source_file, loc->row, line_diff);
1636 emit_advance_op (w
, line_diff
, addr_diff
);
1638 prev_line
= loc
->row
;
1639 prev_native_offset
= i
;
1642 mono_debug_free_source_location (loc
);
1646 g_free (native_to_il_offset
);
1647 g_free (prev_file_name
);
1650 emit_byte (w
, DW_LNS_advance_pc
);
1651 emit_sleb128 (w
, code_size
- prev_native_offset
);
1652 emit_byte (w
, DW_LNS_copy
);
1656 emit_byte (w
, DW_LNE_end_sequence
);
1657 } else if (!start_symbol
) {
1658 /* No debug info, XDEBUG mode */
1660 const guint8
*ip
= header
->code
;
1661 int prev_line
, prev_native_offset
;
1665 * Emit the IL code into a temporary file and emit line number info
1666 * referencing that file.
1669 name
= mono_method_full_name (method
, TRUE
);
1670 fprintf (w
->il_file
, "// %s\n", name
);
1671 w
->il_file_line_index
++;
1674 il_to_line
= g_new0 (int, header
->code_size
);
1676 emit_section_change (w
, ".debug_line", 0);
1678 emit_byte (w
, sizeof (target_mgreg_t
) + 1);
1679 emit_byte (w
, DW_LNE_set_address
);
1680 emit_pointer_value (w
, code
);
1682 // FIXME: Optimize this
1683 while (ip
< header
->code
+ header
->code_size
) {
1684 int il_offset
= ip
- header
->code
;
1687 w
->il_file_line_index
++;
1689 dis
= disasm_ins (method
, ip
, &ip
);
1690 fprintf (w
->il_file
, "%s\n", dis
);
1693 il_to_line
[il_offset
] = w
->il_file_line_index
;
1696 /* Emit line number info */
1698 prev_native_offset
= 0;
1699 for (i
= 0; i
< debug_info
->num_line_numbers
; ++i
) {
1700 MonoDebugLineNumberEntry
*lne
= &debug_info
->line_numbers
[i
];
1703 if (lne
->il_offset
>= header
->code_size
)
1705 line
= il_to_line
[lne
->il_offset
];
1708 * This seems to happen randomly, it looks like il_offset points
1709 * into the middle of an instruction.
1713 printf ("%s\n", mono_method_full_name (method, TRUE));
1714 printf ("%d %d\n", lne->il_offset, header->code_size);
1719 if (line
- prev_line
!= 0) {
1720 emit_advance_op (w
, line
- prev_line
, (gint32
)lne
->native_offset
- prev_native_offset
);
1723 prev_native_offset
= lne
->native_offset
;
1727 emit_byte (w
, DW_LNS_advance_pc
);
1728 emit_sleb128 (w
, code_size
- prev_native_offset
);
1729 emit_byte (w
, DW_LNS_copy
);
1733 emit_byte (w
, DW_LNE_end_sequence
);
1735 fflush (w
->il_file
);
1736 g_free (il_to_line
);
1738 mono_metadata_free_mh (header
);
1741 static MonoMethodVar
*
1742 find_vmv (MonoCompile
*cfg
, MonoInst
*ins
)
1747 for (j
= 0; j
< cfg
->num_varinfo
; ++j
) {
1748 if (cfg
->varinfo
[j
] == ins
)
1752 if (j
< cfg
->num_varinfo
) {
1753 return MONO_VARINFO (cfg
, j
);
1761 mono_dwarf_writer_emit_method (MonoDwarfWriter
*w
, MonoCompile
*cfg
, MonoMethod
*method
, char *start_symbol
, char *end_symbol
, char *linkage_name
,
1762 guint8
*code
, guint32 code_size
, MonoInst
**args
, MonoInst
**locals
, GSList
*unwind_info
, MonoDebugMethodJitInfo
*debug_info
)
1766 MonoMethodSignature
*sig
;
1767 MonoMethodHeader
*header
;
1769 MonoDebugLocalsInfo
*locals_info
;
1770 MonoDebugMethodInfo
*minfo
;
1771 MonoDebugSourceLocation
*loc
= NULL
;
1776 emit_section_change (w
, ".debug_info", 0);
1778 sig
= mono_method_signature_internal (method
);
1779 header
= mono_method_get_header_checked (method
, error
);
1780 mono_error_assert_ok (error
); /* FIXME don't swallow the error */
1782 /* Parameter types */
1783 for (i
= 0; i
< sig
->param_count
+ sig
->hasthis
; ++i
) {
1786 if (i
== 0 && sig
->hasthis
) {
1787 if (m_class_is_valuetype (method
->klass
))
1788 t
= m_class_get_this_arg (method
->klass
);
1790 t
= m_class_get_byval_arg (method
->klass
);
1792 t
= sig
->params
[i
- sig
->hasthis
];
1797 //emit_type (w, mono_get_int32_type ());
1800 for (i
= 0; i
< header
->num_locals
; ++i
) {
1801 emit_type (w
, header
->locals
[i
]);
1804 minfo
= mono_debug_lookup_method (method
);
1806 loc
= mono_debug_method_lookup_location (minfo
, 0);
1809 names
= g_new0 (char *, sig
->param_count
);
1810 mono_method_get_param_names (method
, (const char **) names
);
1812 emit_uleb128 (w
, ABBREV_SUBPROGRAM
);
1814 name
= mono_method_full_name (method
, FALSE
);
1815 emit_escaped_string (w
, name
);
1816 /* DW_AT_MIPS_linkage_name */
1818 emit_string (w
, linkage_name
);
1820 emit_string (w
, "");
1821 /* DW_AT_decl_file/DW_AT_decl_line */
1823 int file_index
= add_line_number_file_name (w
, loc
->source_file
, 0, 0);
1824 emit_uleb128 (w
, file_index
+ 1);
1825 emit_uleb128 (w
, loc
->row
);
1827 mono_debug_free_source_location (loc
);
1830 emit_uleb128 (w
, 0);
1831 emit_uleb128 (w
, 0);
1834 emit_string (w
, name
);
1838 emit_pointer_unaligned (w
, start_symbol
);
1839 emit_pointer_unaligned (w
, end_symbol
);
1841 emit_pointer_value (w
, code
);
1842 emit_pointer_value (w
, code
+ code_size
);
1846 emit_byte (w
, DW_OP_breg6
);
1850 for (i
= 0; i
< sig
->param_count
+ sig
->hasthis
; ++i
) {
1851 MonoInst
*arg
= args
? args
[i
] : NULL
;
1854 char pname_buf
[128];
1855 MonoMethodVar
*vmv
= NULL
;
1856 gboolean need_loclist
= FALSE
;
1858 vmv
= find_vmv (cfg
, arg
);
1859 if (code
&& vmv
&& (vmv
->live_range_start
|| vmv
->live_range_end
))
1860 need_loclist
= TRUE
;
1862 if (i
== 0 && sig
->hasthis
) {
1863 if (m_class_is_valuetype (method
->klass
))
1864 t
= m_class_get_this_arg (method
->klass
);
1866 t
= m_class_get_byval_arg (method
->klass
);
1869 t
= sig
->params
[i
- sig
->hasthis
];
1870 pname
= names
[i
- sig
->hasthis
];
1873 emit_uleb128 (w
, need_loclist
? ABBREV_PARAM_LOCLIST
: ABBREV_PARAM
);
1875 if (pname
[0] == '\0') {
1876 sprintf (pname_buf
, "param%d", i
- sig
->hasthis
);
1879 emit_string (w
, pname
);
1881 if (!arg
|| arg
->flags
& MONO_INST_IS_DEAD
)
1882 emit_var_type (w
, mono_get_int32_type ());
1884 emit_var_type (w
, t
);
1887 encode_var_location (w
, arg
, p
, &p
);
1889 vmv
->live_range_start
= 0;
1890 if (vmv
->live_range_end
== 0)
1891 /* FIXME: Uses made in calls are not recorded */
1892 vmv
->live_range_end
= code_size
;
1893 emit_loclist (w
, arg
, code
+ vmv
->live_range_start
, code
+ vmv
->live_range_end
, buf
, p
- buf
);
1895 emit_byte (w
, p
- buf
);
1896 emit_bytes (w
, buf
, p
- buf
);
1902 locals_info
= mono_debug_lookup_locals (method
);
1904 for (i
= 0; i
< header
->num_locals
; ++i
) {
1905 MonoInst
*ins
= locals
[i
];
1906 char name_buf
[128];
1908 MonoMethodVar
*vmv
= NULL
;
1909 gboolean need_loclist
= FALSE
;
1912 /* ins->dreg no longer contains the original vreg */
1913 vmv
= find_vmv (cfg
, ins
);
1915 if (vmv
->live_range_start
) {
1916 /* This variable has a precise live range */
1917 need_loclist
= TRUE
;
1921 emit_uleb128 (w
, need_loclist
? ABBREV_VARIABLE_LOCLIST
: ABBREV_VARIABLE
);
1925 for (j
= 0; j
< locals_info
->num_locals
; ++j
)
1926 if (locals_info
->locals
[j
].index
== i
)
1928 if (j
< locals_info
->num_locals
)
1929 lname
= locals_info
->locals
[j
].name
;
1932 emit_string (w
, lname
);
1934 sprintf (name_buf
, "V_%d", i
);
1935 emit_string (w
, name_buf
);
1938 if (!ins
|| ins
->flags
& MONO_INST_IS_DEAD
)
1939 emit_var_type (w
, mono_get_int32_type ());
1941 emit_var_type (w
, header
->locals
[i
]);
1944 encode_var_location (w
, ins
, p
, &p
);
1947 if (vmv
->live_range_end
== 0)
1948 /* FIXME: Uses made in calls are not recorded */
1949 vmv
->live_range_end
= code_size
;
1950 emit_loclist (w
, ins
, code
+ vmv
->live_range_start
, code
+ vmv
->live_range_end
, buf
, p
- buf
);
1952 emit_byte (w
, p
- buf
);
1953 emit_bytes (w
, buf
, p
- buf
);
1958 mono_debug_free_locals (locals_info
);
1960 /* Subprogram end */
1961 emit_uleb128 (w
, 0x0);
1965 emit_debug_info_end (w
);
1967 /* Emit unwind info */
1969 emit_fde (w
, w
->fde_index
, start_symbol
, end_symbol
, code
, code_size
, unwind_info
, TRUE
);
1973 /* Save the information needed to emit the line number info later at once */
1974 /* != could happen when using --regression */
1975 if (debug_info
&& (debug_info
->code_start
== code
)) {
1976 MethodLineNumberInfo
*info
;
1978 info
= g_new0 (MethodLineNumberInfo
, 1);
1979 info
->method
= method
;
1980 info
->start_symbol
= g_strdup (start_symbol
);
1981 info
->end_symbol
= g_strdup (end_symbol
);
1983 info
->code_size
= code_size
;
1984 w
->line_info
= g_slist_prepend (w
->line_info
, info
);
1988 mono_metadata_free_mh (header
);
1992 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
)
1994 emit_section_change (w
, ".debug_info", 0);
1997 emit_uleb128 (w
, ABBREV_TRAMP_SUBPROGRAM
);
1998 emit_string (w
, tramp_name
);
1999 emit_pointer_value (w
, code
);
2000 emit_pointer_value (w
, code
+ code_size
);
2002 /* Subprogram end */
2003 emit_uleb128 (w
, 0x0);
2005 emit_debug_info_end (w
);
2007 /* Emit unwind info */
2008 emit_fde (w
, w
->fde_index
, start_symbol
, end_symbol
, code
, code_size
, unwind_info
, FALSE
);
2012 #else /* !defined(DISABLE_AOT) && !defined(DISABLE_JIT) */
2014 MONO_EMPTY_SOURCE_FILE (dwarfwriter
);
2016 #endif /* End of: !defined(DISABLE_AOT) && !defined(DISABLE_JIT) */