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/metadata/mono-debug-debugger.h>
25 #include <mono/utils/mono-compiler.h>
28 #include <mono/utils/freebsd-elf32.h>
29 #include <mono/utils/freebsd-elf64.h>
32 #include <mono/utils/freebsd-dwarf.h>
34 #define DW_AT_MIPS_linkage_name 0x2007
35 #define DW_LNE_set_prologue_end 0x0a
39 char *start_symbol
, *end_symbol
;
42 } MethodLineNumberInfo
;
44 struct _MonoDwarfWriter
47 GHashTable
*class_to_die
, *class_to_vtype_die
, *class_to_pointer_die
;
48 GHashTable
*class_to_reference_die
;
49 int fde_index
, tdie_index
, line_number_file_index
, line_number_dir_index
;
50 GHashTable
*file_to_index
, *index_to_file
, *dir_to_index
;
52 int il_file_line_index
, loclist_index
;
55 const char *temp_prefix
;
56 gboolean emit_line
, appending
, collect_line_info
;
62 emit_line_number_info (MonoDwarfWriter
*w
, MonoMethod
*method
,
63 char *start_symbol
, char *end_symbol
,
64 guint8
*code
, guint32 code_size
,
65 MonoDebugMethodJitInfo
*debug_info
);
68 * mono_dwarf_writer_create:
70 * Create a DWARF writer object. WRITER is the underlying image writer this
71 * writer will emit to. IL_FILE is the file where IL code will be dumped to for
72 * methods which have no line number info. It can be NULL.
73 * If APPENDING is TRUE, the output file will be in assembleable state after each
74 * call to the _emit_ functions. This is used for XDEBUG. If APPENDING is FALSE,
75 * a separate mono_dwarf_writer_close () call is needed to finish the emission of
79 mono_dwarf_writer_create (MonoImageWriter
*writer
, FILE *il_file
, int il_file_start_line
, gboolean appending
, gboolean emit_line_numbers
)
81 MonoDwarfWriter
*w
= g_new0 (MonoDwarfWriter
, 1);
84 * The appending flag is needed because we use subsections to order things in
85 * the debug info, and:
86 * - apple's assembler doesn't support them
87 * - the binary writer has problems with subsections+alignment
88 * So instead of subsections, we use the _close () function in AOT mode,
89 * which writes out things in order.
94 w
->il_file_line_index
= il_file_start_line
;
95 w
->appending
= appending
;
98 g_assert (mono_img_writer_subsections_supported (w
->w
));
103 if (!mono_img_writer_subsections_supported (w
->w
))
104 /* Can't emit line number info without subsections */
105 w
->emit_line
= FALSE
;
107 /* Collect line number info and emit it at once */
108 w
->collect_line_info
= TRUE
;
111 if (!emit_line_numbers
) {
112 w
->emit_line
= FALSE
;
113 w
->collect_line_info
= FALSE
;
116 w
->fp
= mono_img_writer_get_fp (w
->w
);
117 w
->temp_prefix
= mono_img_writer_get_temp_label_prefix (w
->w
);
119 w
->class_to_die
= g_hash_table_new (NULL
, NULL
);
120 w
->class_to_vtype_die
= g_hash_table_new (NULL
, NULL
);
121 w
->class_to_pointer_die
= g_hash_table_new (NULL
, NULL
);
122 w
->class_to_reference_die
= g_hash_table_new (NULL
, NULL
);
123 w
->cur_file_index
= -1;
129 mono_dwarf_writer_destroy (MonoDwarfWriter
*w
)
135 mono_dwarf_writer_get_il_file_line_index (MonoDwarfWriter
*w
)
137 return w
->il_file_line_index
;
140 /* Wrappers around the image writer functions */
143 emit_section_change (MonoDwarfWriter
*w
, const char *section_name
, int subsection_index
)
145 mono_img_writer_emit_section_change (w
->w
, section_name
, subsection_index
);
149 emit_push_section (MonoDwarfWriter
*w
, const char *section_name
, int subsection
)
151 mono_img_writer_emit_push_section (w
->w
, section_name
, subsection
);
155 emit_pop_section (MonoDwarfWriter
*w
)
157 mono_img_writer_emit_pop_section (w
->w
);
161 emit_label (MonoDwarfWriter
*w
, const char *name
)
163 mono_img_writer_emit_label (w
->w
, name
);
167 emit_bytes (MonoDwarfWriter
*w
, const guint8
* buf
, int size
)
169 mono_img_writer_emit_bytes (w
->w
, buf
, size
);
173 emit_string (MonoDwarfWriter
*w
, const char *value
)
175 mono_img_writer_emit_string (w
->w
, value
);
179 emit_line (MonoDwarfWriter
*w
)
181 mono_img_writer_emit_line (w
->w
);
185 emit_alignment (MonoDwarfWriter
*w
, int size
)
187 mono_img_writer_emit_alignment (w
->w
, size
);
191 emit_pointer_unaligned (MonoDwarfWriter
*w
, const char *target
)
193 mono_img_writer_emit_pointer_unaligned (w
->w
, target
);
197 emit_pointer (MonoDwarfWriter
*w
, const char *target
)
199 mono_img_writer_emit_pointer (w
->w
, target
);
203 emit_int16 (MonoDwarfWriter
*w
, int value
)
205 mono_img_writer_emit_int16 (w
->w
, value
);
209 emit_int32 (MonoDwarfWriter
*w
, int value
)
211 mono_img_writer_emit_int32 (w
->w
, value
);
215 emit_symbol_diff (MonoDwarfWriter
*w
, const char *end
, const char* start
, int offset
)
217 mono_img_writer_emit_symbol_diff (w
->w
, end
, start
, offset
);
221 emit_byte (MonoDwarfWriter
*w
, guint8 val
)
223 mono_img_writer_emit_byte (w
->w
, val
);
227 emit_escaped_string (MonoDwarfWriter
*w
, char *value
)
231 len
= strlen (value
);
232 for (i
= 0; i
< len
; ++i
) {
234 if (!(isalnum (c
))) {
256 mono_img_writer_emit_string (w
->w
, value
);
259 static G_GNUC_UNUSED
void
260 emit_uleb128 (MonoDwarfWriter
*w
, guint32 value
)
263 guint8 b
= value
& 0x7f;
265 if (value
!= 0) /* more bytes to come */
271 static G_GNUC_UNUSED
void
272 emit_sleb128 (MonoDwarfWriter
*w
, gint64 value
)
275 gboolean negative
= (value
< 0);
282 /* the following is unnecessary if the
283 * implementation of >>= uses an arithmetic rather
284 * than logical shift for a signed left operand
288 value
|= - ((gint64
)1 <<(size
- 7));
289 /* sign bit of byte is second high order bit (0x40) */
290 if ((value
== 0 && !(byte
& 0x40)) ||
291 (value
== -1 && (byte
& 0x40)))
299 static G_GNUC_UNUSED
void
300 encode_uleb128 (guint32 value
, guint8
*buf
, guint8
**endbuf
)
305 guint8 b
= value
& 0x7f;
307 if (value
!= 0) /* more bytes to come */
315 static G_GNUC_UNUSED
void
316 encode_sleb128 (gint32 value
, guint8
*buf
, guint8
**endbuf
)
319 gboolean negative
= (value
< 0);
327 /* the following is unnecessary if the
328 * implementation of >>= uses an arithmetic rather
329 * than logical shift for a signed left operand
333 value
|= - (1 <<(size
- 7));
334 /* sign bit of byte is second high order bit (0x40) */
335 if ((value
== 0 && !(byte
& 0x40)) ||
336 (value
== -1 && (byte
& 0x40)))
347 emit_dwarf_abbrev (MonoDwarfWriter
*w
, int code
, int tag
, gboolean has_child
,
348 int *attrs
, int attrs_len
)
352 emit_uleb128 (w
, code
);
353 emit_uleb128 (w
, tag
);
354 emit_byte (w
, has_child
);
356 for (i
= 0; i
< attrs_len
; i
++)
357 emit_uleb128 (w
, attrs
[i
]);
363 emit_cie (MonoDwarfWriter
*w
)
365 emit_section_change (w
, ".debug_frame", 0);
367 emit_alignment (w
, 8);
370 emit_symbol_diff (w
, ".Lcie0_end", ".Lcie0_start", 0); /* length */
371 emit_label (w
, ".Lcie0_start");
372 emit_int32 (w
, 0xffffffff); /* CIE id */
373 emit_byte (w
, 3); /* version */
374 emit_string (w
, ""); /* augmention */
375 emit_sleb128 (w
, 1); /* code alignment factor */
376 emit_sleb128 (w
, mono_unwind_get_dwarf_data_align ()); /* data alignment factor */
377 emit_uleb128 (w
, mono_unwind_get_dwarf_pc_reg ());
379 w
->cie_program
= w
->cie_program
;
380 if (w
->cie_program
) {
382 guint8
*uw_info
= mono_unwind_ops_encode (w
->cie_program
, &uw_info_len
);
383 emit_bytes (w
, uw_info
, uw_info_len
);
387 emit_alignment (w
, sizeof (gpointer
));
388 emit_label (w
, ".Lcie0_end");
392 emit_pointer_value (MonoDwarfWriter
*w
, gpointer ptr
)
394 gssize val
= (gssize
)ptr
;
395 emit_bytes (w
, (guint8
*)&val
, sizeof (gpointer
));
399 emit_fde (MonoDwarfWriter
*w
, int fde_index
, char *start_symbol
, char *end_symbol
,
400 guint8
*code
, guint32 code_size
, GSList
*unwind_ops
, gboolean use_cie
)
408 emit_section_change (w
, ".debug_frame", 0);
410 sprintf (symbol1
, ".Lfde%d_start", fde_index
);
411 sprintf (symbol2
, ".Lfde%d_end", fde_index
);
412 emit_symbol_diff (w
, symbol2
, symbol1
, 0); /* length */
413 emit_label (w
, symbol1
);
414 emit_int32 (w
, 0); /* CIE_pointer */
416 emit_pointer (w
, start_symbol
); /* initial_location */
418 emit_symbol_diff (w
, end_symbol
, start_symbol
, 0); /* address_range */
420 g_assert (code_size
);
421 emit_int32 (w
, code_size
);
424 emit_pointer_value (w
, code
);
425 emit_int32 (w
, code_size
);
427 #if SIZEOF_VOID_P == 8
428 /* Upper 32 bits of code size */
433 if (w
->cie_program
) {
434 // FIXME: Check that the ops really begin with the CIE program */
437 for (i
= 0; i
< g_slist_length (w
->cie_program
); ++i
)
442 /* Convert the list of MonoUnwindOps to the format used by DWARF */
443 uw_info
= mono_unwind_ops_encode_full (l
, &uw_info_len
, FALSE
);
444 emit_bytes (w
, uw_info
, uw_info_len
);
447 emit_alignment (w
, sizeof (mgreg_t
));
448 emit_label (w
, symbol2
);
452 #define ABBREV_COMPILE_UNIT 1
453 #define ABBREV_SUBPROGRAM 2
454 #define ABBREV_PARAM 3
455 #define ABBREV_BASE_TYPE 4
456 #define ABBREV_STRUCT_TYPE 5
457 #define ABBREV_DATA_MEMBER 6
458 #define ABBREV_TYPEDEF 7
459 #define ABBREV_ENUM_TYPE 8
460 #define ABBREV_ENUMERATOR 9
461 #define ABBREV_NAMESPACE 10
462 #define ABBREV_VARIABLE 11
463 #define ABBREV_VARIABLE_LOCLIST 12
464 #define ABBREV_POINTER_TYPE 13
465 #define ABBREV_REFERENCE_TYPE 14
466 #define ABBREV_PARAM_LOCLIST 15
467 #define ABBREV_INHERITANCE 16
468 #define ABBREV_STRUCT_TYPE_NOCHILDREN 17
469 #define ABBREV_TRAMP_SUBPROGRAM 18
471 static int compile_unit_attr
[] = {
472 DW_AT_producer
,DW_FORM_string
,
473 DW_AT_name
,DW_FORM_string
,
474 DW_AT_comp_dir
,DW_FORM_string
,
475 DW_AT_language
,DW_FORM_data1
,
476 DW_AT_low_pc
,DW_FORM_addr
,
477 DW_AT_high_pc
,DW_FORM_addr
,
478 DW_AT_stmt_list
,DW_FORM_data4
481 static int subprogram_attr
[] = {
482 DW_AT_name
, DW_FORM_string
,
483 DW_AT_MIPS_linkage_name
, DW_FORM_string
,
484 DW_AT_decl_file
, DW_FORM_udata
,
485 DW_AT_decl_line
, DW_FORM_udata
,
487 DW_AT_description
, DW_FORM_string
,
489 DW_AT_low_pc
, DW_FORM_addr
,
490 DW_AT_high_pc
, DW_FORM_addr
,
491 DW_AT_frame_base
, DW_FORM_block1
494 static int tramp_subprogram_attr
[] = {
495 DW_AT_name
, DW_FORM_string
,
496 DW_AT_low_pc
, DW_FORM_addr
,
497 DW_AT_high_pc
, DW_FORM_addr
,
500 static int param_attr
[] = {
501 DW_AT_name
, DW_FORM_string
,
502 DW_AT_type
, DW_FORM_ref4
,
503 DW_AT_location
, DW_FORM_block1
506 static int param_loclist_attr
[] = {
507 DW_AT_name
, DW_FORM_string
,
508 DW_AT_type
, DW_FORM_ref4
,
509 DW_AT_location
, DW_FORM_data4
512 static int base_type_attr
[] = {
513 DW_AT_byte_size
, DW_FORM_data1
,
514 DW_AT_encoding
, DW_FORM_data1
,
515 DW_AT_name
, DW_FORM_string
518 static int struct_type_attr
[] = {
519 DW_AT_name
, DW_FORM_string
,
520 DW_AT_byte_size
, DW_FORM_udata
,
523 static int data_member_attr
[] = {
524 DW_AT_name
, DW_FORM_string
,
525 DW_AT_type
, DW_FORM_ref4
,
526 DW_AT_data_member_location
, DW_FORM_block1
529 static int typedef_attr
[] = {
530 DW_AT_name
, DW_FORM_string
,
531 DW_AT_type
, DW_FORM_ref4
534 static int pointer_type_attr
[] = {
535 DW_AT_type
, DW_FORM_ref4
,
538 static int reference_type_attr
[] = {
539 DW_AT_type
, DW_FORM_ref4
,
542 static int enum_type_attr
[] = {
543 DW_AT_name
, DW_FORM_string
,
544 DW_AT_byte_size
, DW_FORM_udata
,
545 DW_AT_type
, DW_FORM_ref4
,
548 static int enumerator_attr
[] = {
549 DW_AT_name
, DW_FORM_string
,
550 DW_AT_const_value
, DW_FORM_sdata
,
553 static int namespace_attr
[] = {
554 DW_AT_name
, DW_FORM_string
,
557 static int variable_attr
[] = {
558 DW_AT_name
, DW_FORM_string
,
559 DW_AT_type
, DW_FORM_ref4
,
560 DW_AT_location
, DW_FORM_block1
563 static int variable_loclist_attr
[] = {
564 DW_AT_name
, DW_FORM_string
,
565 DW_AT_type
, DW_FORM_ref4
,
566 DW_AT_location
, DW_FORM_data4
569 static int inheritance_attr
[] = {
570 DW_AT_type
, DW_FORM_ref4
,
571 DW_AT_data_member_location
, DW_FORM_block1
574 typedef struct DwarfBasicType
{
575 const char *die_name
, *name
;
581 static DwarfBasicType basic_types
[] = {
582 { ".LDIE_I1", "sbyte", MONO_TYPE_I1
, 1, DW_ATE_signed
},
583 { ".LDIE_U1", "byte", MONO_TYPE_U1
, 1, DW_ATE_unsigned
},
584 { ".LDIE_I2", "short", MONO_TYPE_I2
, 2, DW_ATE_signed
},
585 { ".LDIE_U2", "ushort", MONO_TYPE_U2
, 2, DW_ATE_unsigned
},
586 { ".LDIE_I4", "int", MONO_TYPE_I4
, 4, DW_ATE_signed
},
587 { ".LDIE_U4", "uint", MONO_TYPE_U4
, 4, DW_ATE_unsigned
},
588 { ".LDIE_I8", "long", MONO_TYPE_I8
, 8, DW_ATE_signed
},
589 { ".LDIE_U8", "ulong", MONO_TYPE_U8
, 8, DW_ATE_unsigned
},
590 { ".LDIE_I", "intptr", MONO_TYPE_I
, SIZEOF_VOID_P
, DW_ATE_signed
},
591 { ".LDIE_U", "uintptr", MONO_TYPE_U
, SIZEOF_VOID_P
, DW_ATE_unsigned
},
592 { ".LDIE_R4", "float", MONO_TYPE_R4
, 4, DW_ATE_float
},
593 { ".LDIE_R8", "double", MONO_TYPE_R8
, 8, DW_ATE_float
},
594 { ".LDIE_BOOLEAN", "boolean", MONO_TYPE_BOOLEAN
, 1, DW_ATE_boolean
},
595 { ".LDIE_CHAR", "char", MONO_TYPE_CHAR
, 2, DW_ATE_unsigned_char
},
596 { ".LDIE_STRING", "string", MONO_TYPE_STRING
, sizeof (gpointer
), DW_ATE_address
},
597 { ".LDIE_OBJECT", "object", MONO_TYPE_OBJECT
, sizeof (gpointer
), DW_ATE_address
},
598 { ".LDIE_SZARRAY", "object", MONO_TYPE_SZARRAY
, sizeof (gpointer
), DW_ATE_address
},
601 /* Constants for encoding line number special opcodes */
602 #define OPCODE_BASE 13
604 #define LINE_RANGE 14
606 /* Subsections of the .debug_line section */
607 #define LINE_SUBSECTION_HEADER 1
608 #define LINE_SUBSECTION_INCLUDES 2
609 #define LINE_SUBSECTION_FILES 3
610 #define LINE_SUBSECTION_DATA 4
611 #define LINE_SUBSECTION_END 5
614 emit_line_number_file_name (MonoDwarfWriter
*w
, const char *name
,
615 gint64 last_mod_time
, gint64 file_size
)
619 char *basename
= NULL
;
621 if (!w
->file_to_index
)
622 w
->file_to_index
= g_hash_table_new (g_str_hash
, g_str_equal
);
624 index
= GPOINTER_TO_UINT (g_hash_table_lookup (w
->file_to_index
, name
));
628 if (g_path_is_absolute (name
)) {
629 char *dir
= g_path_get_dirname (name
);
631 if (!w
->dir_to_index
)
632 w
->dir_to_index
= g_hash_table_new (g_str_hash
, g_str_equal
);
634 dir_index
= GPOINTER_TO_UINT (g_hash_table_lookup (w
->dir_to_index
, dir
));
635 if (dir_index
== 0) {
636 emit_section_change (w
, ".debug_line", LINE_SUBSECTION_INCLUDES
);
637 emit_string (w
, dir
);
639 dir_index
= ++ w
->line_number_dir_index
;
640 g_hash_table_insert (w
->dir_to_index
, g_strdup (dir
), GUINT_TO_POINTER (dir_index
));
645 basename
= g_path_get_basename (name
);
650 emit_section_change (w
, ".debug_line", LINE_SUBSECTION_FILES
);
653 emit_string (w
, basename
);
655 emit_string (w
, name
);
656 emit_uleb128 (w
, dir_index
);
660 emit_section_change (w
, ".debug_line", LINE_SUBSECTION_DATA
);
665 index
= ++ w
->line_number_file_index
;
666 g_hash_table_insert (w
->file_to_index
, g_strdup (name
), GUINT_TO_POINTER (index
));
672 get_line_number_file_name (MonoDwarfWriter
*w
, const char *name
)
676 g_assert (w
->file_to_index
);
677 index
= GPOINTER_TO_UINT (g_hash_table_lookup (w
->file_to_index
, name
));
678 g_assert (index
> 0);
683 add_line_number_file_name (MonoDwarfWriter
*w
, const char *name
,
684 gint64 last_mod_time
, gint64 file_size
)
689 if (!w
->file_to_index
) {
690 w
->file_to_index
= g_hash_table_new (g_str_hash
, g_str_equal
);
691 w
->index_to_file
= g_hash_table_new (NULL
, NULL
);
694 index
= GPOINTER_TO_UINT (g_hash_table_lookup (w
->file_to_index
, name
));
697 index
= w
->line_number_file_index
;
698 w
->line_number_file_index
++;
699 copy
= g_strdup (name
);
700 g_hash_table_insert (w
->file_to_index
, copy
, GUINT_TO_POINTER (index
+ 1));
701 g_hash_table_insert (w
->index_to_file
, GUINT_TO_POINTER (index
+ 1), copy
);
707 mono_dwarf_escape_path (const char *name
)
709 if (strchr (name
, '\\')) {
714 s
= (char *)g_malloc0 ((len
+ 1) * 2);
716 for (i
= 0; i
< len
; ++i
) {
717 if (name
[i
] == '\\') {
726 return g_strdup (name
);
730 emit_all_line_number_info (MonoDwarfWriter
*w
)
733 GHashTable
*dir_to_index
, *index_to_dir
;
737 g_assert (w
->collect_line_info
);
739 add_line_number_file_name (w
, "<unknown>", 0, 0);
742 info_list
= g_slist_reverse (w
->line_info
);
743 for (l
= info_list
; l
; l
= l
->next
) {
744 MethodLineNumberInfo
*info
= (MethodLineNumberInfo
*)l
->data
;
745 MonoDebugMethodInfo
*minfo
;
746 GPtrArray
*source_file_list
;
749 minfo
= mono_debug_lookup_method (info
->method
);
753 mono_debug_get_seq_points (minfo
, NULL
, &source_file_list
, NULL
, NULL
, NULL
);
754 for (i
= 0; i
< source_file_list
->len
; ++i
) {
755 MonoDebugSourceInfo
*sinfo
= (MonoDebugSourceInfo
*)g_ptr_array_index (source_file_list
, i
);
756 add_line_number_file_name (w
, sinfo
->source_file
, 0, 0);
760 /* Preprocess files */
761 dir_to_index
= g_hash_table_new (g_str_hash
, g_str_equal
);
762 index_to_dir
= g_hash_table_new (NULL
, NULL
);
763 for (i
= 0; i
< w
->line_number_file_index
; ++i
) {
764 char *name
= (char *)g_hash_table_lookup (w
->index_to_file
, GUINT_TO_POINTER (i
+ 1));
768 if (g_path_is_absolute (name
)) {
769 char *dir
= g_path_get_dirname (name
);
771 dir_index
= GPOINTER_TO_UINT (g_hash_table_lookup (dir_to_index
, dir
));
772 if (dir_index
== 0) {
773 dir_index
= w
->line_number_dir_index
;
774 w
->line_number_dir_index
++;
775 copy
= g_strdup (dir
);
776 g_hash_table_insert (dir_to_index
, copy
, GUINT_TO_POINTER (dir_index
+ 1));
777 g_hash_table_insert (index_to_dir
, GUINT_TO_POINTER (dir_index
+ 1), copy
);
786 /* Line number info header */
787 emit_section_change (w
, ".debug_line", 0);
788 emit_label (w
, ".Ldebug_line_section_start");
789 emit_label (w
, ".Ldebug_line_start");
790 emit_symbol_diff (w
, ".Ldebug_line_end", ".", -4); /* length */
791 emit_int16 (w
, 0x2); /* version */
792 emit_symbol_diff (w
, ".Ldebug_line_header_end", ".", -4); /* header_length */
793 emit_byte (w
, 1); /* minimum_instruction_length */
794 emit_byte (w
, 1); /* default_is_stmt */
795 emit_byte (w
, LINE_BASE
); /* line_base */
796 emit_byte (w
, LINE_RANGE
); /* line_range */
797 emit_byte (w
, OPCODE_BASE
); /* opcode_base */
798 emit_byte (w
, 0); /* standard_opcode_lengths */
812 emit_section_change (w
, ".debug_line", 0);
813 for (i
= 0; i
< w
->line_number_dir_index
; ++i
) {
814 char *dir
= (char *)g_hash_table_lookup (index_to_dir
, GUINT_TO_POINTER (i
+ 1));
816 emit_string (w
, mono_dwarf_escape_path (dir
));
818 /* End of Includes */
822 for (i
= 0; i
< w
->line_number_file_index
; ++i
) {
823 char *name
= (char *)g_hash_table_lookup (w
->index_to_file
, GUINT_TO_POINTER (i
+ 1));
824 char *basename
= NULL
, *dir
;
827 if (g_path_is_absolute (name
)) {
828 dir
= g_path_get_dirname (name
);
830 dir_index
= GPOINTER_TO_UINT (g_hash_table_lookup (dir_to_index
, dir
));
831 basename
= g_path_get_basename (name
);
835 emit_string (w
, basename
);
837 emit_string (w
, mono_dwarf_escape_path (name
));
838 emit_uleb128 (w
, dir_index
);
846 emit_label (w
, ".Ldebug_line_header_end");
848 /* Emit line number table */
849 for (l
= info_list
; l
; l
= l
->next
) {
850 MethodLineNumberInfo
*info
= (MethodLineNumberInfo
*)l
->data
;
851 MonoDebugMethodJitInfo
*dmji
;
853 dmji
= mono_debug_find_method (info
->method
, mono_domain_get ());
856 emit_line_number_info (w
, info
->method
, info
->start_symbol
, info
->end_symbol
, info
->code
, info
->code_size
, dmji
);
857 mono_debug_free_method_jit_info (dmji
);
859 g_slist_free (info_list
);
863 emit_byte (w
, DW_LNE_end_sequence
);
865 emit_label (w
, ".Ldebug_line_end");
869 * Some assemblers like apple's do not support subsections, so we can't place
870 * .Ldebug_info_end at the end of the section using subsections. Instead, we
871 * define it every time something gets added to the .debug_info section.
872 * The apple assember seems to use the last definition.
875 emit_debug_info_end (MonoDwarfWriter
*w
)
877 /* This doesn't seem to work/required with recent iphone sdk versions */
879 if (!mono_img_writer_subsections_supported (w
->w
))
880 fprintf (w
->fp
, "\n.set %sdebug_info_end,.\n", w
->temp_prefix
);
885 mono_dwarf_writer_emit_base_info (MonoDwarfWriter
*w
, const char *cu_name
, GSList
*base_unwind_program
)
887 char *s
, *build_info
;
890 w
->cie_program
= base_unwind_program
;
892 emit_section_change (w
, ".debug_abbrev", 0);
893 emit_dwarf_abbrev (w
, ABBREV_COMPILE_UNIT
, DW_TAG_compile_unit
, TRUE
,
894 compile_unit_attr
, G_N_ELEMENTS (compile_unit_attr
));
895 emit_dwarf_abbrev (w
, ABBREV_SUBPROGRAM
, DW_TAG_subprogram
, TRUE
,
896 subprogram_attr
, G_N_ELEMENTS (subprogram_attr
));
897 emit_dwarf_abbrev (w
, ABBREV_PARAM
, DW_TAG_formal_parameter
, FALSE
,
898 param_attr
, G_N_ELEMENTS (param_attr
));
899 emit_dwarf_abbrev (w
, ABBREV_PARAM_LOCLIST
, DW_TAG_formal_parameter
, FALSE
,
900 param_loclist_attr
, G_N_ELEMENTS (param_loclist_attr
));
901 emit_dwarf_abbrev (w
, ABBREV_BASE_TYPE
, DW_TAG_base_type
, FALSE
,
902 base_type_attr
, G_N_ELEMENTS (base_type_attr
));
903 emit_dwarf_abbrev (w
, ABBREV_STRUCT_TYPE
, DW_TAG_class_type
, TRUE
,
904 struct_type_attr
, G_N_ELEMENTS (struct_type_attr
));
905 emit_dwarf_abbrev (w
, ABBREV_STRUCT_TYPE_NOCHILDREN
, DW_TAG_class_type
, FALSE
,
906 struct_type_attr
, G_N_ELEMENTS (struct_type_attr
));
907 emit_dwarf_abbrev (w
, ABBREV_DATA_MEMBER
, DW_TAG_member
, FALSE
,
908 data_member_attr
, G_N_ELEMENTS (data_member_attr
));
909 emit_dwarf_abbrev (w
, ABBREV_TYPEDEF
, DW_TAG_typedef
, FALSE
,
910 typedef_attr
, G_N_ELEMENTS (typedef_attr
));
911 emit_dwarf_abbrev (w
, ABBREV_ENUM_TYPE
, DW_TAG_enumeration_type
, TRUE
,
912 enum_type_attr
, G_N_ELEMENTS (enum_type_attr
));
913 emit_dwarf_abbrev (w
, ABBREV_ENUMERATOR
, DW_TAG_enumerator
, FALSE
,
914 enumerator_attr
, G_N_ELEMENTS (enumerator_attr
));
915 emit_dwarf_abbrev (w
, ABBREV_NAMESPACE
, DW_TAG_namespace
, TRUE
,
916 namespace_attr
, G_N_ELEMENTS (namespace_attr
));
917 emit_dwarf_abbrev (w
, ABBREV_VARIABLE
, DW_TAG_variable
, FALSE
,
918 variable_attr
, G_N_ELEMENTS (variable_attr
));
919 emit_dwarf_abbrev (w
, ABBREV_VARIABLE_LOCLIST
, DW_TAG_variable
, FALSE
,
920 variable_loclist_attr
, G_N_ELEMENTS (variable_loclist_attr
));
921 emit_dwarf_abbrev (w
, ABBREV_POINTER_TYPE
, DW_TAG_pointer_type
, FALSE
,
922 pointer_type_attr
, G_N_ELEMENTS (pointer_type_attr
));
923 emit_dwarf_abbrev (w
, ABBREV_REFERENCE_TYPE
, DW_TAG_reference_type
, FALSE
,
924 reference_type_attr
, G_N_ELEMENTS (reference_type_attr
));
925 emit_dwarf_abbrev (w
, ABBREV_INHERITANCE
, DW_TAG_inheritance
, FALSE
,
926 inheritance_attr
, G_N_ELEMENTS (inheritance_attr
));
927 emit_dwarf_abbrev (w
, ABBREV_TRAMP_SUBPROGRAM
, DW_TAG_subprogram
, FALSE
,
928 tramp_subprogram_attr
, G_N_ELEMENTS (tramp_subprogram_attr
));
931 emit_section_change (w
, ".debug_info", 0);
932 emit_label (w
, ".Ldebug_info_start");
933 emit_symbol_diff (w
, ".Ldebug_info_end", ".Ldebug_info_begin", 0); /* length */
934 emit_label (w
, ".Ldebug_info_begin");
935 emit_int16 (w
, 0x2); /* DWARF version 2 */
936 emit_int32 (w
, 0); /* .debug_abbrev offset */
937 emit_byte (w
, sizeof (gpointer
)); /* address size */
939 if (mono_img_writer_subsections_supported (w
->w
) && w
->appending
) {
940 /* Emit this into a separate section so it gets placed at the end */
941 emit_section_change (w
, ".debug_info", 1);
942 emit_byte (w
, 0); /* close COMPILE_UNIT */
943 emit_label (w
, ".Ldebug_info_end");
944 emit_section_change (w
, ".debug_info", 0);
947 /* Compilation unit */
948 emit_uleb128 (w
, ABBREV_COMPILE_UNIT
);
949 build_info
= mono_get_runtime_build_info ();
950 s
= g_strdup_printf ("Mono AOT Compiler %s", build_info
);
954 emit_string (w
, cu_name
);
956 emit_byte (w
, DW_LANG_C
);
957 emit_pointer_value (w
, 0);
958 emit_pointer_value (w
, 0);
959 /* offset into .debug_line section */
961 emit_symbol_diff (w
, ".Ldebug_line_start", ".Ldebug_line_section_start", 0);
963 emit_pointer_value (w
, 0);
966 for (i
= 0; i
< G_N_ELEMENTS (basic_types
); ++i
) {
967 emit_label (w
, basic_types
[i
].die_name
);
968 emit_uleb128 (w
, ABBREV_BASE_TYPE
);
969 emit_byte (w
, basic_types
[i
].size
);
970 emit_byte (w
, basic_types
[i
].encoding
);
971 emit_string (w
, basic_types
[i
].name
);
974 emit_debug_info_end (w
);
976 /* debug_loc section */
977 emit_section_change (w
, ".debug_loc", 0);
978 emit_label (w
, ".Ldebug_loc_start");
984 * mono_dwarf_writer_close:
986 * Finalize the emitted debugging info.
989 mono_dwarf_writer_close (MonoDwarfWriter
*w
)
992 emit_section_change (w
, ".debug_info", 0);
993 emit_byte (w
, 0); /* close COMPILE_UNIT */
994 emit_label (w
, ".Ldebug_info_end");
997 if (w
->collect_line_info
)
998 emit_all_line_number_info (w
);
1001 static void emit_type (MonoDwarfWriter
*w
, MonoType
*t
);
1002 static const char* get_type_die (MonoDwarfWriter
*w
, MonoType
*t
);
1005 get_class_die (MonoDwarfWriter
*w
, MonoClass
*klass
, gboolean vtype
)
1010 cache
= w
->class_to_vtype_die
;
1012 cache
= w
->class_to_die
;
1014 return (const char *)g_hash_table_lookup (cache
, klass
);
1017 /* Returns the local symbol pointing to the emitted debug info */
1019 emit_class_dwarf_info (MonoDwarfWriter
*w
, MonoClass
*klass
, gboolean vtype
)
1021 char *die
, *pointer_die
, *reference_die
;
1022 char *full_name
, *p
;
1024 MonoClassField
*field
;
1027 gboolean emit_namespace
= FALSE
, has_children
;
1031 cache
= w
->class_to_vtype_die
;
1033 cache
= w
->class_to_die
;
1035 die
= (char *)g_hash_table_lookup (cache
, klass
);
1039 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
) ||
1040 (klass
->byval_arg
.type
>= MONO_TYPE_BOOLEAN
&& klass
->byval_arg
.type
<= MONO_TYPE_R8
&& !vtype
)))
1044 * FIXME: gdb can't handle namespaces in languages it doesn't know about.
1047 if (klass->name_space && klass->name_space [0] != '\0')
1048 emit_namespace = TRUE;
1050 if (emit_namespace
) {
1051 emit_uleb128 (w
, ABBREV_NAMESPACE
);
1052 emit_string (w
, klass
->name_space
);
1055 full_name
= g_strdup_printf ("%s%s%s", klass
->name_space
, klass
->name_space
? "." : "", klass
->name
);
1057 * gdb doesn't support namespaces for non-C++ dwarf objects, so use _
1058 * to separate components.
1060 for (p
= full_name
; *p
; p
++)
1064 die
= g_strdup_printf (".LTDIE_%d", w
->tdie_index
);
1065 pointer_die
= g_strdup_printf (".LTDIE_%d_POINTER", w
->tdie_index
);
1066 reference_die
= g_strdup_printf (".LTDIE_%d_REFERENCE", w
->tdie_index
);
1069 g_hash_table_insert (w
->class_to_pointer_die
, klass
, pointer_die
);
1070 g_hash_table_insert (w
->class_to_reference_die
, klass
, reference_die
);
1071 g_hash_table_insert (cache
, klass
, die
);
1073 if (klass
->enumtype
) {
1074 int size
= mono_class_value_size (mono_class_from_mono_type (mono_class_enum_basetype (klass
)), NULL
);
1076 emit_label (w
, die
);
1078 emit_uleb128 (w
, ABBREV_ENUM_TYPE
);
1079 emit_string (w
, full_name
);
1080 emit_uleb128 (w
, size
);
1081 for (k
= 0; k
< G_N_ELEMENTS (basic_types
); ++k
)
1082 if (basic_types
[k
].type
== mono_class_enum_basetype (klass
)->type
)
1084 g_assert (k
< G_N_ELEMENTS (basic_types
));
1085 emit_symbol_diff (w
, basic_types
[k
].die_name
, ".Ldebug_info_start", 0);
1087 /* Emit enum values */
1089 while ((field
= mono_class_get_fields (klass
, &iter
))) {
1091 MonoTypeEnum def_type
;
1093 if (!(field
->type
->attrs
& FIELD_ATTRIBUTE_STATIC
))
1095 if (mono_field_is_deleted (field
))
1098 emit_uleb128 (w
, ABBREV_ENUMERATOR
);
1099 emit_string (w
, mono_field_get_name (field
));
1101 p
= mono_class_get_field_default_value (field
, &def_type
);
1102 /* len = */ mono_metadata_decode_blob_size (p
, &p
);
1103 switch (mono_class_enum_basetype (klass
)->type
) {
1106 case MONO_TYPE_BOOLEAN
:
1107 emit_sleb128 (w
, *p
);
1111 case MONO_TYPE_CHAR
:
1112 emit_sleb128 (w
, read16 (p
));
1116 emit_sleb128 (w
, read32 (p
));
1120 emit_sleb128 (w
, read64 (p
));
1124 #if SIZEOF_VOID_P == 8
1125 emit_sleb128 (w
, read64 (p
));
1127 emit_sleb128 (w
, read32 (p
));
1131 g_assert_not_reached ();
1135 has_children
= TRUE
;
1142 parent_die
= emit_class_dwarf_info (w
, klass
->parent
, FALSE
);
1146 /* Emit field types */
1148 while ((field
= mono_class_get_fields (klass
, &iter
))) {
1149 if (field
->type
->attrs
& FIELD_ATTRIBUTE_STATIC
)
1152 emit_type (w
, field
->type
);
1156 has_children
= parent_die
|| mono_class_get_fields (klass
, &iter
);
1158 emit_label (w
, die
);
1160 emit_uleb128 (w
, has_children
? ABBREV_STRUCT_TYPE
: ABBREV_STRUCT_TYPE_NOCHILDREN
);
1161 emit_string (w
, full_name
);
1162 emit_uleb128 (w
, klass
->instance_size
);
1165 emit_uleb128 (w
, ABBREV_INHERITANCE
);
1166 emit_symbol_diff (w
, parent_die
, ".Ldebug_info_start", 0);
1169 *p
++= DW_OP_plus_uconst
;
1170 encode_uleb128 (0, p
, &p
);
1171 emit_byte (w
, p
- buf
);
1172 emit_bytes (w
, buf
, p
- buf
);
1177 while ((field
= mono_class_get_fields (klass
, &iter
))) {
1178 if (field
->type
->attrs
& FIELD_ATTRIBUTE_STATIC
)
1181 fdie
= get_type_die (w
, field
->type
);
1183 emit_uleb128 (w
, ABBREV_DATA_MEMBER
);
1184 emit_string (w
, field
->name
);
1185 emit_symbol_diff (w
, fdie
, ".Ldebug_info_start", 0);
1188 *p
++= DW_OP_plus_uconst
;
1189 if (klass
->valuetype
&& vtype
)
1190 encode_uleb128 (field
->offset
- sizeof (MonoObject
), p
, &p
);
1192 encode_uleb128 (field
->offset
, p
, &p
);
1194 emit_byte (w
, p
- buf
);
1195 emit_bytes (w
, buf
, p
- buf
);
1202 emit_uleb128 (w
, 0x0);
1204 /* Add a typedef, so we can reference the type without a 'struct' in gdb */
1205 emit_uleb128 (w
, ABBREV_TYPEDEF
);
1206 emit_string (w
, full_name
);
1207 emit_symbol_diff (w
, die
, ".Ldebug_info_start", 0);
1209 /* Add a pointer type */
1210 emit_label (w
, pointer_die
);
1212 emit_uleb128 (w
, ABBREV_POINTER_TYPE
);
1213 emit_symbol_diff (w
, die
, ".Ldebug_info_start", 0);
1215 /* Add a reference type */
1216 emit_label (w
, reference_die
);
1218 emit_uleb128 (w
, ABBREV_REFERENCE_TYPE
);
1219 emit_symbol_diff (w
, die
, ".Ldebug_info_start", 0);
1223 if (emit_namespace
) {
1225 emit_uleb128 (w
, 0x0);
1231 static gboolean base_types_emitted
[64];
1234 get_type_die (MonoDwarfWriter
*w
, MonoType
*t
)
1236 MonoClass
*klass
= mono_class_from_mono_type (t
);
1241 if (t
->type
== MONO_TYPE_VALUETYPE
) {
1242 tdie
= (const char *)g_hash_table_lookup (w
->class_to_pointer_die
, klass
);
1245 tdie
= get_class_die (w
, klass
, FALSE
);
1246 /* Should return a pointer type to a reference */
1249 t
= &mono_defaults
.int_class
->byval_arg
;
1251 for (j
= 0; j
< G_N_ELEMENTS (basic_types
); ++j
)
1252 if (basic_types
[j
].type
== t
->type
)
1254 if (j
< G_N_ELEMENTS (basic_types
)) {
1255 tdie
= basic_types
[j
].die_name
;
1258 case MONO_TYPE_CLASS
:
1259 tdie
= (const char *)g_hash_table_lookup (w
->class_to_reference_die
, klass
);
1260 //tdie = ".LDIE_OBJECT";
1262 case MONO_TYPE_ARRAY
:
1263 tdie
= ".LDIE_OBJECT";
1265 case MONO_TYPE_VALUETYPE
:
1266 if (klass
->enumtype
)
1267 tdie
= get_class_die (w
, klass
, FALSE
);
1271 case MONO_TYPE_GENERICINST
:
1272 if (!MONO_TYPE_ISSTRUCT (t
)) {
1273 tdie
= (const char *)g_hash_table_lookup (w
->class_to_reference_die
, klass
);
1293 emit_type (MonoDwarfWriter
*w
, MonoType
*t
)
1295 MonoClass
*klass
= mono_class_from_mono_type (t
);
1300 if (t
->type
== MONO_TYPE_VALUETYPE
) {
1301 tdie
= emit_class_dwarf_info (w
, klass
, TRUE
);
1306 emit_class_dwarf_info (w
, klass
, FALSE
);
1309 t
= &mono_defaults
.int_class
->byval_arg
;
1311 for (j
= 0; j
< G_N_ELEMENTS (basic_types
); ++j
)
1312 if (basic_types
[j
].type
== t
->type
)
1314 if (j
< G_N_ELEMENTS (basic_types
)) {
1315 /* Emit a boxed version of base types */
1316 if (j
< 64 && !base_types_emitted
[j
]) {
1317 emit_class_dwarf_info (w
, klass
, FALSE
);
1318 base_types_emitted
[j
] = TRUE
;
1322 case MONO_TYPE_CLASS
:
1323 emit_class_dwarf_info (w
, klass
, FALSE
);
1325 case MONO_TYPE_ARRAY
:
1327 case MONO_TYPE_VALUETYPE
:
1328 if (klass
->enumtype
)
1329 emit_class_dwarf_info (w
, klass
, FALSE
);
1331 case MONO_TYPE_GENERICINST
:
1332 if (!MONO_TYPE_ISSTRUCT (t
))
1333 emit_class_dwarf_info (w
, klass
, FALSE
);
1344 emit_var_type (MonoDwarfWriter
*w
, MonoType
*t
)
1348 tdie
= get_type_die (w
, t
);
1350 emit_symbol_diff (w
, tdie
, ".Ldebug_info_start", 0);
1354 encode_var_location (MonoDwarfWriter
*w
, MonoInst
*ins
, guint8
*p
, guint8
**endp
)
1357 /* FIXME: This needs a location list, since the args can go from reg->stack */
1358 if (!ins
|| ins
->flags
& MONO_INST_IS_DEAD
) {
1359 /* gdb treats this as optimized out */
1360 } else if (ins
->opcode
== OP_REGVAR
) {
1361 *p
= DW_OP_reg0
+ mono_hw_reg_to_dwarf_reg (ins
->dreg
);
1363 } else if (ins
->opcode
== OP_REGOFFSET
) {
1364 *p
++= DW_OP_breg0
+ mono_hw_reg_to_dwarf_reg (ins
->inst_basereg
);
1365 encode_sleb128 (ins
->inst_offset
, p
, &p
);
1375 emit_loclist (MonoDwarfWriter
*w
, MonoInst
*ins
,
1376 guint8
*loclist_begin_addr
, guint8
*loclist_end_addr
,
1377 guint8
*expr
, guint32 expr_len
)
1381 emit_push_section (w
, ".debug_loc", 0);
1382 sprintf (label
, ".Lloclist_%d", w
->loclist_index
++ );
1383 emit_label (w
, label
);
1385 emit_pointer_value (w
, loclist_begin_addr
);
1386 emit_pointer_value (w
, loclist_end_addr
);
1387 emit_byte (w
, expr_len
% 256);
1388 emit_byte (w
, expr_len
/ 256);
1389 emit_bytes (w
, expr
, expr_len
);
1391 emit_pointer_value (w
, NULL
);
1392 emit_pointer_value (w
, NULL
);
1394 emit_pop_section (w
);
1395 emit_symbol_diff (w
, label
, ".Ldebug_loc_start", 0);
1399 * MonoDisHelper->tokener doesn't take an IP argument, and we can't add one since
1400 * it is a public header.
1402 static const guint8
*token_handler_ip
;
1405 token_handler (MonoDisHelper
*dh
, MonoMethod
*method
, guint32 token
)
1409 MonoMethod
*cmethod
;
1411 MonoClassField
*field
;
1412 gpointer data
= NULL
;
1414 if (method
->wrapper_type
)
1415 data
= mono_method_get_wrapper_data (method
, token
);
1417 switch (*token_handler_ip
) {
1421 if (method
->wrapper_type
) {
1422 klass
= (MonoClass
*)data
;
1424 klass
= mono_class_get_checked (method
->klass
->image
, token
, &error
);
1425 g_assert (mono_error_ok (&error
)); /* FIXME error handling */
1427 res
= g_strdup_printf ("<%s>", klass
->name
);
1432 if (method
->wrapper_type
) {
1433 cmethod
= (MonoMethod
*)data
;
1436 cmethod
= mono_get_method_checked (method
->klass
->image
, token
, NULL
, NULL
, &error
);
1438 g_error ("Could not load method due to %s", mono_error_get_message (&error
)); /* FIXME don't swallow the error */
1440 desc
= mono_method_full_name (cmethod
, TRUE
);
1441 res
= g_strdup_printf ("<%s>", desc
);
1445 if (method
->wrapper_type
) {
1446 desc
= mono_signature_get_desc ((MonoMethodSignature
*)data
, FALSE
);
1447 res
= g_strdup_printf ("<%s>", desc
);
1450 res
= g_strdup_printf ("<0x%08x>", token
);
1457 if (method
->wrapper_type
) {
1458 field
= (MonoClassField
*)data
;
1460 field
= mono_field_from_token_checked (method
->klass
->image
, token
, &klass
, NULL
, &error
);
1461 g_assert (mono_error_ok (&error
)); /* FIXME error handling */
1463 desc
= mono_field_full_name (field
);
1464 res
= g_strdup_printf ("<%s>", desc
);
1468 res
= g_strdup_printf ("<0x%08x>", token
);
1478 * Produce a disassembled form of the IL instruction at IP. This is an extension
1479 * of mono_disasm_code_one () which can disasm tokens, handle wrapper methods, and
1480 * CEE_MONO_ opcodes.
1483 disasm_ins (MonoMethod
*method
, const guchar
*ip
, const guint8
**endip
)
1487 MonoMethodHeader
*header
= mono_method_get_header (method
);
1489 memset (&dh
, 0, sizeof (dh
));
1491 dh
.label_format
= "IL_%04x: ";
1492 dh
.label_target
= "IL_%04x";
1493 dh
.tokener
= token_handler
;
1495 token_handler_ip
= ip
;
1496 if (*ip
== MONO_CUSTOM_PREFIX
) {
1501 case CEE_MONO_ICALL
: {
1502 MonoJitICallInfo
*info
;
1504 token
= read32 (ip
+ 2);
1505 data
= mono_method_get_wrapper_data (method
, token
);
1506 info
= mono_find_jit_icall_by_addr (data
);
1509 dis
= g_strdup_printf ("IL_%04x: mono_icall <%s>", (int)(ip
- header
->code
), info
->name
);
1513 case CEE_MONO_CLASSCONST
: {
1514 token
= read32 (ip
+ 2);
1515 data
= mono_method_get_wrapper_data (method
, token
);
1517 dis
= g_strdup_printf ("IL_%04x: mono_classconst <%s>", (int)(ip
- header
->code
), ((MonoClass
*)data
)->name
);
1522 dis
= mono_disasm_code_one (&dh
, method
, ip
, &ip
);
1525 dis
= mono_disasm_code_one (&dh
, method
, ip
, &ip
);
1527 token_handler_ip
= NULL
;
1530 mono_metadata_free_mh (header
);
1535 il_offset_from_address (MonoMethod
*method
, MonoDebugMethodJitInfo
*jit
,
1536 guint32 native_offset
)
1540 if (!jit
->line_numbers
)
1543 for (i
= jit
->num_line_numbers
- 1; i
>= 0; i
--) {
1544 MonoDebugLineNumberEntry lne
= jit
->line_numbers
[i
];
1546 if (lne
.native_offset
<= native_offset
)
1547 return lne
.il_offset
;
1553 static int max_special_addr_diff
= 0;
1556 emit_advance_op (MonoDwarfWriter
*w
, int line_diff
, int addr_diff
)
1560 /* Use a special opcode if possible */
1561 if (line_diff
- LINE_BASE
>= 0 && line_diff
- LINE_BASE
< LINE_RANGE
) {
1562 if (max_special_addr_diff
== 0)
1563 max_special_addr_diff
= (255 - OPCODE_BASE
) / LINE_RANGE
;
1565 if (addr_diff
> max_special_addr_diff
&& (addr_diff
< 2 * max_special_addr_diff
)) {
1566 emit_byte (w
, DW_LNS_const_add_pc
);
1567 addr_diff
-= max_special_addr_diff
;
1570 opcode
= (line_diff
- LINE_BASE
) + (LINE_RANGE
* addr_diff
) + OPCODE_BASE
;
1576 emit_byte (w
, opcode
);
1578 //printf ("large: %d %d %d\n", line_diff, addr_diff, max_special_addr_diff);
1579 emit_byte (w
, DW_LNS_advance_line
);
1580 emit_sleb128 (w
, line_diff
);
1581 emit_byte (w
, DW_LNS_advance_pc
);
1582 emit_sleb128 (w
, addr_diff
);
1583 emit_byte (w
, DW_LNS_copy
);
1588 compare_lne (MonoDebugLineNumberEntry
*a
, MonoDebugLineNumberEntry
*b
)
1590 if (a
->native_offset
== b
->native_offset
)
1591 return a
->il_offset
- b
->il_offset
;
1593 return a
->native_offset
- b
->native_offset
;
1597 emit_line_number_info (MonoDwarfWriter
*w
, MonoMethod
*method
,
1598 char *start_symbol
, char *end_symbol
,
1599 guint8
*code
, guint32 code_size
,
1600 MonoDebugMethodJitInfo
*debug_info
)
1602 guint32 prev_line
= 0;
1603 guint32 prev_native_offset
= 0;
1604 int i
, file_index
, il_offset
, prev_il_offset
;
1605 gboolean first
= TRUE
;
1606 MonoDebugSourceLocation
*loc
;
1607 char *prev_file_name
= NULL
;
1608 MonoMethodHeader
*header
= mono_method_get_header (method
);
1609 MonoDebugMethodInfo
*minfo
;
1610 MonoDebugLineNumberEntry
*ln_array
;
1611 int *native_to_il_offset
= NULL
;
1613 if (!w
->emit_line
) {
1614 mono_metadata_free_mh (header
);
1618 minfo
= mono_debug_lookup_method (method
);
1620 /* Compute the native->IL offset mapping */
1622 g_assert (code_size
);
1624 ln_array
= g_new0 (MonoDebugLineNumberEntry
, debug_info
->num_line_numbers
);
1625 memcpy (ln_array
, debug_info
->line_numbers
, debug_info
->num_line_numbers
* sizeof (MonoDebugLineNumberEntry
));
1627 qsort (ln_array
, debug_info
->num_line_numbers
, sizeof (MonoDebugLineNumberEntry
), (int (*)(const void *, const void *))compare_lne
);
1629 native_to_il_offset
= g_new0 (int, code_size
+ 1);
1631 for (i
= 0; i
< debug_info
->num_line_numbers
; ++i
) {
1633 MonoDebugLineNumberEntry
*lne
= &ln_array
[i
];
1636 for (j
= 0; j
< lne
->native_offset
; ++j
)
1637 native_to_il_offset
[j
] = -1;
1640 if (i
< debug_info
->num_line_numbers
- 1) {
1641 MonoDebugLineNumberEntry
*lne_next
= &ln_array
[i
+ 1];
1643 for (j
= lne
->native_offset
; j
< lne_next
->native_offset
; ++j
)
1644 native_to_il_offset
[j
] = lne
->il_offset
;
1646 for (j
= lne
->native_offset
; j
< code_size
; ++j
)
1647 native_to_il_offset
[j
] = lne
->il_offset
;
1653 prev_il_offset
= -1;
1655 w
->cur_file_index
= -1;
1656 for (i
= 0; i
< code_size
; ++i
) {
1657 int line_diff
, addr_diff
;
1662 if (!debug_info
->line_numbers
)
1665 if (native_to_il_offset
)
1666 il_offset
= native_to_il_offset
[i
];
1668 il_offset
= il_offset_from_address (method
, debug_info
, i
);
1670 il_offset = il_offset_from_address (method, debug_info, i);
1672 g_assert (il_offset == native_to_il_offset [i]);
1675 il_offset
= native_to_il_offset
[i
];
1679 if (il_offset
== prev_il_offset
)
1682 prev_il_offset
= il_offset
;
1684 loc
= mono_debug_symfile_lookup_location (minfo
, il_offset
);
1687 if (!loc
->source_file
) {
1688 mono_debug_symfile_free_location (loc
);
1692 line_diff
= (gint32
)loc
->row
- (gint32
)prev_line
;
1693 addr_diff
= i
- prev_native_offset
;
1696 emit_section_change (w
, ".debug_line", LINE_SUBSECTION_DATA
);
1699 emit_byte (w
, sizeof (gpointer
) + 1);
1700 emit_byte (w
, DW_LNE_set_address
);
1702 emit_pointer_unaligned (w
, start_symbol
);
1704 emit_pointer_value (w
, code
);
1708 if (loc
->row
!= prev_line
) {
1709 if (!prev_file_name
|| strcmp (loc
->source_file
, prev_file_name
) != 0) {
1710 /* Add an entry to the file table */
1711 /* FIXME: Avoid duplicates */
1712 if (w
->collect_line_info
)
1713 file_index
= get_line_number_file_name (w
, loc
->source_file
) + 1;
1715 file_index
= emit_line_number_file_name (w
, loc
->source_file
, 0, 0);
1716 g_free (prev_file_name
);
1717 prev_file_name
= g_strdup (loc
->source_file
);
1719 if (w
->cur_file_index
!= file_index
) {
1720 emit_byte (w
, DW_LNS_set_file
);
1721 emit_uleb128 (w
, file_index
);
1722 emit_byte (w
, DW_LNS_copy
);
1723 w
->cur_file_index
= file_index
;
1728 if (loc
->row
!= prev_line
) {
1729 if (prev_native_offset
== 0)
1730 emit_byte (w
, DW_LNE_set_prologue_end
);
1732 //printf ("X: %p(+0x%x) %d %s:%d(+%d)\n", code + i, addr_diff, loc->il_offset, loc->source_file, loc->row, line_diff);
1733 emit_advance_op (w
, line_diff
, addr_diff
);
1735 prev_line
= loc
->row
;
1736 prev_native_offset
= i
;
1739 mono_debug_symfile_free_location (loc
);
1743 g_free (native_to_il_offset
);
1744 g_free (prev_file_name
);
1747 emit_byte (w
, DW_LNS_advance_pc
);
1748 emit_sleb128 (w
, code_size
- prev_native_offset
);
1749 emit_byte (w
, DW_LNS_copy
);
1753 emit_byte (w
, DW_LNE_end_sequence
);
1754 } else if (!start_symbol
) {
1755 /* No debug info, XDEBUG mode */
1757 const guint8
*ip
= header
->code
;
1758 int prev_line
, prev_native_offset
;
1762 * Emit the IL code into a temporary file and emit line number info
1763 * referencing that file.
1766 name
= mono_method_full_name (method
, TRUE
);
1767 fprintf (w
->il_file
, "// %s\n", name
);
1768 w
->il_file_line_index
++;
1771 il_to_line
= g_new0 (int, header
->code_size
);
1773 emit_section_change (w
, ".debug_line", LINE_SUBSECTION_DATA
);
1775 emit_byte (w
, sizeof (gpointer
) + 1);
1776 emit_byte (w
, DW_LNE_set_address
);
1777 emit_pointer_value (w
, code
);
1779 // FIXME: Optimize this
1780 while (ip
< header
->code
+ header
->code_size
) {
1781 int il_offset
= ip
- header
->code
;
1784 w
->il_file_line_index
++;
1786 dis
= disasm_ins (method
, ip
, &ip
);
1787 fprintf (w
->il_file
, "%s\n", dis
);
1790 il_to_line
[il_offset
] = w
->il_file_line_index
;
1793 /* Emit line number info */
1795 prev_native_offset
= 0;
1796 for (i
= 0; i
< debug_info
->num_line_numbers
; ++i
) {
1797 MonoDebugLineNumberEntry
*lne
= &debug_info
->line_numbers
[i
];
1800 if (lne
->il_offset
>= header
->code_size
)
1802 line
= il_to_line
[lne
->il_offset
];
1805 * This seems to happen randomly, it looks like il_offset points
1806 * into the middle of an instruction.
1810 printf ("%s\n", mono_method_full_name (method, TRUE));
1811 printf ("%d %d\n", lne->il_offset, header->code_size);
1816 if (line
- prev_line
!= 0) {
1817 emit_advance_op (w
, line
- prev_line
, (gint32
)lne
->native_offset
- prev_native_offset
);
1820 prev_native_offset
= lne
->native_offset
;
1824 emit_byte (w
, DW_LNS_advance_pc
);
1825 emit_sleb128 (w
, code_size
- prev_native_offset
);
1826 emit_byte (w
, DW_LNS_copy
);
1830 emit_byte (w
, DW_LNE_end_sequence
);
1832 fflush (w
->il_file
);
1833 g_free (il_to_line
);
1835 mono_metadata_free_mh (header
);
1838 static MonoMethodVar
*
1839 find_vmv (MonoCompile
*cfg
, MonoInst
*ins
)
1844 for (j
= 0; j
< cfg
->num_varinfo
; ++j
) {
1845 if (cfg
->varinfo
[j
] == ins
)
1849 if (j
< cfg
->num_varinfo
) {
1850 return MONO_VARINFO (cfg
, j
);
1858 mono_dwarf_writer_emit_method (MonoDwarfWriter
*w
, MonoCompile
*cfg
, MonoMethod
*method
, char *start_symbol
, char *end_symbol
, char *linkage_name
,
1859 guint8
*code
, guint32 code_size
, MonoInst
**args
, MonoInst
**locals
, GSList
*unwind_info
, MonoDebugMethodJitInfo
*debug_info
)
1862 MonoMethodSignature
*sig
;
1863 MonoMethodHeader
*header
;
1865 MonoDebugLocalsInfo
*locals_info
;
1866 MonoDebugMethodInfo
*minfo
;
1867 MonoDebugSourceLocation
*loc
= NULL
;
1872 emit_section_change (w
, ".debug_info", 0);
1874 sig
= mono_method_signature (method
);
1875 header
= mono_method_get_header (method
);
1877 /* Parameter types */
1878 for (i
= 0; i
< sig
->param_count
+ sig
->hasthis
; ++i
) {
1881 if (i
== 0 && sig
->hasthis
) {
1882 if (method
->klass
->valuetype
)
1883 t
= &method
->klass
->this_arg
;
1885 t
= &method
->klass
->byval_arg
;
1887 t
= sig
->params
[i
- sig
->hasthis
];
1892 //emit_type (w, &mono_defaults.int32_class->byval_arg);
1895 for (i
= 0; i
< header
->num_locals
; ++i
) {
1896 emit_type (w
, header
->locals
[i
]);
1899 minfo
= mono_debug_lookup_method (method
);
1901 loc
= mono_debug_symfile_lookup_location (minfo
, 0);
1904 names
= g_new0 (char *, sig
->param_count
);
1905 mono_method_get_param_names (method
, (const char **) names
);
1907 emit_uleb128 (w
, ABBREV_SUBPROGRAM
);
1909 name
= mono_method_full_name (method
, FALSE
);
1910 emit_escaped_string (w
, name
);
1911 /* DW_AT_MIPS_linkage_name */
1913 emit_string (w
, linkage_name
);
1915 emit_string (w
, "");
1916 /* DW_AT_decl_file/DW_AT_decl_line */
1918 int file_index
= add_line_number_file_name (w
, loc
->source_file
, 0, 0);
1919 emit_uleb128 (w
, file_index
+ 1);
1920 emit_uleb128 (w
, loc
->row
);
1922 mono_debug_symfile_free_location (loc
);
1925 emit_uleb128 (w
, 0);
1926 emit_uleb128 (w
, 0);
1929 emit_string (w
, name
);
1933 emit_pointer_unaligned (w
, start_symbol
);
1934 emit_pointer_unaligned (w
, end_symbol
);
1936 emit_pointer_value (w
, code
);
1937 emit_pointer_value (w
, code
+ code_size
);
1941 emit_byte (w
, DW_OP_breg6
);
1945 for (i
= 0; i
< sig
->param_count
+ sig
->hasthis
; ++i
) {
1946 MonoInst
*arg
= args
? args
[i
] : NULL
;
1949 char pname_buf
[128];
1950 MonoMethodVar
*vmv
= NULL
;
1951 gboolean need_loclist
= FALSE
;
1953 vmv
= find_vmv (cfg
, arg
);
1954 if (code
&& vmv
&& (vmv
->live_range_start
|| vmv
->live_range_end
))
1955 need_loclist
= TRUE
;
1957 if (i
== 0 && sig
->hasthis
) {
1958 if (method
->klass
->valuetype
)
1959 t
= &method
->klass
->this_arg
;
1961 t
= &method
->klass
->byval_arg
;
1964 t
= sig
->params
[i
- sig
->hasthis
];
1965 pname
= names
[i
- sig
->hasthis
];
1968 emit_uleb128 (w
, need_loclist
? ABBREV_PARAM_LOCLIST
: ABBREV_PARAM
);
1970 if (pname
[0] == '\0') {
1971 sprintf (pname_buf
, "param%d", i
- sig
->hasthis
);
1974 emit_string (w
, pname
);
1976 if (!arg
|| arg
->flags
& MONO_INST_IS_DEAD
)
1977 emit_var_type (w
, &mono_defaults
.int32_class
->byval_arg
);
1979 emit_var_type (w
, t
);
1982 encode_var_location (w
, arg
, p
, &p
);
1984 vmv
->live_range_start
= 0;
1985 if (vmv
->live_range_end
== 0)
1986 /* FIXME: Uses made in calls are not recorded */
1987 vmv
->live_range_end
= code_size
;
1988 emit_loclist (w
, arg
, code
+ vmv
->live_range_start
, code
+ vmv
->live_range_end
, buf
, p
- buf
);
1990 emit_byte (w
, p
- buf
);
1991 emit_bytes (w
, buf
, p
- buf
);
1997 locals_info
= mono_debug_lookup_locals (method
);
1999 for (i
= 0; i
< header
->num_locals
; ++i
) {
2000 MonoInst
*ins
= locals
[i
];
2001 char name_buf
[128];
2003 MonoMethodVar
*vmv
= NULL
;
2004 gboolean need_loclist
= FALSE
;
2007 /* ins->dreg no longer contains the original vreg */
2008 vmv
= find_vmv (cfg
, ins
);
2010 if (vmv
->live_range_start
) {
2011 /* This variable has a precise live range */
2012 need_loclist
= TRUE
;
2016 emit_uleb128 (w
, need_loclist
? ABBREV_VARIABLE_LOCLIST
: ABBREV_VARIABLE
);
2020 for (j
= 0; j
< locals_info
->num_locals
; ++j
)
2021 if (locals_info
->locals
[j
].index
== i
)
2023 if (j
< locals_info
->num_locals
)
2024 lname
= locals_info
->locals
[j
].name
;
2027 emit_string (w
, lname
);
2029 sprintf (name_buf
, "V_%d", i
);
2030 emit_string (w
, name_buf
);
2033 if (!ins
|| ins
->flags
& MONO_INST_IS_DEAD
)
2034 emit_var_type (w
, &mono_defaults
.int32_class
->byval_arg
);
2036 emit_var_type (w
, header
->locals
[i
]);
2039 encode_var_location (w
, ins
, p
, &p
);
2042 if (vmv
->live_range_end
== 0)
2043 /* FIXME: Uses made in calls are not recorded */
2044 vmv
->live_range_end
= code_size
;
2045 emit_loclist (w
, ins
, code
+ vmv
->live_range_start
, code
+ vmv
->live_range_end
, buf
, p
- buf
);
2047 emit_byte (w
, p
- buf
);
2048 emit_bytes (w
, buf
, p
- buf
);
2053 mono_debug_free_locals (locals_info
);
2055 /* Subprogram end */
2056 emit_uleb128 (w
, 0x0);
2060 emit_debug_info_end (w
);
2062 /* Emit unwind info */
2064 emit_fde (w
, w
->fde_index
, start_symbol
, end_symbol
, code
, code_size
, unwind_info
, TRUE
);
2068 /* Emit line number info */
2069 /* != could happen when using --regression */
2070 if (debug_info
&& (debug_info
->code_start
== code
)) {
2071 if (w
->collect_line_info
) {
2072 MethodLineNumberInfo
*info
;
2074 /* Save the information needed to emit the line number info later at once */
2075 info
= g_new0 (MethodLineNumberInfo
, 1);
2076 info
->method
= method
;
2077 info
->start_symbol
= g_strdup (start_symbol
);
2078 info
->end_symbol
= g_strdup (end_symbol
);
2080 info
->code_size
= code_size
;
2081 w
->line_info
= g_slist_prepend (w
->line_info
, info
);
2083 emit_line_number_info (w
, method
, start_symbol
, end_symbol
, code
, code_size
, debug_info
);
2088 mono_metadata_free_mh (header
);
2092 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
)
2094 emit_section_change (w
, ".debug_info", 0);
2097 emit_uleb128 (w
, ABBREV_TRAMP_SUBPROGRAM
);
2098 emit_string (w
, tramp_name
);
2099 emit_pointer_value (w
, code
);
2100 emit_pointer_value (w
, code
+ code_size
);
2102 /* Subprogram end */
2103 emit_uleb128 (w
, 0x0);
2105 emit_debug_info_end (w
);
2107 /* Emit unwind info */
2108 emit_fde (w
, w
->fde_index
, start_symbol
, end_symbol
, code
, code_size
, unwind_info
, FALSE
);
2111 #endif /* End of: !defined(DISABLE_AOT) && !defined(DISABLE_JIT) */