2 * dwarfwriter.c: Creation of DWARF debug information
5 * Zoltan Varga (vargaz@gmail.com)
7 * (C) 2008-2009 Novell, Inc.
12 #if !defined(DISABLE_AOT) && !defined(DISABLE_JIT)
13 #include "dwarfwriter.h"
15 #include <sys/types.h>
22 #include <mono/metadata/mono-endian.h>
23 #include <mono/metadata/debug-mono-symfile.h>
24 #include <mono/utils/mono-compiler.h>
27 #include <mono/utils/freebsd-elf32.h>
28 #include <mono/utils/freebsd-elf64.h>
31 #include <mono/utils/freebsd-dwarf.h>
35 char *start_symbol
, *end_symbol
;
38 } MethodLineNumberInfo
;
40 struct _MonoDwarfWriter
43 GHashTable
*class_to_die
, *class_to_vtype_die
, *class_to_pointer_die
;
44 GHashTable
*class_to_reference_die
;
45 int fde_index
, tdie_index
, line_number_file_index
, line_number_dir_index
;
46 GHashTable
*file_to_index
, *index_to_file
, *dir_to_index
;
48 int il_file_line_index
, loclist_index
;
51 const char *temp_prefix
;
52 gboolean emit_line
, appending
, collect_line_info
;
58 emit_line_number_info (MonoDwarfWriter
*w
, MonoMethod
*method
,
59 char *start_symbol
, char *end_symbol
,
60 guint8
*code
, guint32 code_size
,
61 MonoDebugMethodJitInfo
*debug_info
);
64 * mono_dwarf_writer_create:
66 * Create a DWARF writer object. WRITER is the underlying image writer this
67 * writer will emit to. IL_FILE is the file where IL code will be dumped to for
68 * methods which have no line number info. It can be NULL.
69 * If APPENDING is TRUE, the output file will be in assembleable state after each
70 * call to the _emit_ functions. This is used for XDEBUG. If APPENDING is FALSE,
71 * a separate mono_dwarf_writer_close () call is needed to finish the emission of
75 mono_dwarf_writer_create (MonoImageWriter
*writer
, FILE *il_file
, int il_file_start_line
, gboolean appending
, gboolean emit_line_numbers
)
77 MonoDwarfWriter
*w
= g_new0 (MonoDwarfWriter
, 1);
80 * The appending flag is needed because we use subsections to order things in
81 * the debug info, and:
82 * - apple's assembler doesn't support them
83 * - the binary writer has problems with subsections+alignment
84 * So instead of subsections, we use the _close () function in AOT mode,
85 * which writes out things in order.
90 w
->il_file_line_index
= il_file_start_line
;
91 w
->appending
= appending
;
94 g_assert (img_writer_subsections_supported (w
->w
));
99 if (!img_writer_subsections_supported (w
->w
))
100 /* Can't emit line number info without subsections */
101 w
->emit_line
= FALSE
;
103 /* Collect line number info and emit it at once */
104 w
->collect_line_info
= TRUE
;
107 if (!emit_line_numbers
) {
108 w
->emit_line
= FALSE
;
109 w
->collect_line_info
= FALSE
;
112 w
->fp
= img_writer_get_fp (w
->w
);
113 w
->temp_prefix
= img_writer_get_temp_label_prefix (w
->w
);
115 w
->class_to_die
= g_hash_table_new (NULL
, NULL
);
116 w
->class_to_vtype_die
= g_hash_table_new (NULL
, NULL
);
117 w
->class_to_pointer_die
= g_hash_table_new (NULL
, NULL
);
118 w
->class_to_reference_die
= g_hash_table_new (NULL
, NULL
);
119 w
->cur_file_index
= -1;
125 mono_dwarf_writer_destroy (MonoDwarfWriter
*w
)
131 mono_dwarf_writer_get_il_file_line_index (MonoDwarfWriter
*w
)
133 return w
->il_file_line_index
;
136 /* Wrappers around the image writer functions */
139 emit_section_change (MonoDwarfWriter
*w
, const char *section_name
, int subsection_index
)
141 img_writer_emit_section_change (w
->w
, section_name
, subsection_index
);
145 emit_push_section (MonoDwarfWriter
*w
, const char *section_name
, int subsection
)
147 img_writer_emit_push_section (w
->w
, section_name
, subsection
);
151 emit_pop_section (MonoDwarfWriter
*w
)
153 img_writer_emit_pop_section (w
->w
);
157 emit_local_symbol (MonoDwarfWriter
*w
, const char *name
, const char *end_label
, gboolean func
)
159 img_writer_emit_local_symbol (w
->w
, name
, end_label
, func
);
163 emit_label (MonoDwarfWriter
*w
, const char *name
)
165 img_writer_emit_label (w
->w
, name
);
169 emit_bytes (MonoDwarfWriter
*w
, const guint8
* buf
, int size
)
171 img_writer_emit_bytes (w
->w
, buf
, size
);
175 emit_string (MonoDwarfWriter
*w
, const char *value
)
177 img_writer_emit_string (w
->w
, value
);
181 emit_line (MonoDwarfWriter
*w
)
183 img_writer_emit_line (w
->w
);
187 emit_alignment (MonoDwarfWriter
*w
, int size
)
189 img_writer_emit_alignment (w
->w
, size
);
193 emit_pointer_unaligned (MonoDwarfWriter
*w
, const char *target
)
195 img_writer_emit_pointer_unaligned (w
->w
, target
);
199 emit_pointer (MonoDwarfWriter
*w
, const char *target
)
201 img_writer_emit_pointer (w
->w
, target
);
205 emit_int16 (MonoDwarfWriter
*w
, int value
)
207 img_writer_emit_int16 (w
->w
, value
);
211 emit_int32 (MonoDwarfWriter
*w
, int value
)
213 img_writer_emit_int32 (w
->w
, value
);
217 emit_symbol_diff (MonoDwarfWriter
*w
, const char *end
, const char* start
, int offset
)
219 img_writer_emit_symbol_diff (w
->w
, end
, start
, offset
);
223 emit_zero_bytes (MonoDwarfWriter
*w
, int num
)
225 img_writer_emit_zero_bytes (w
->w
, num
);
229 emit_byte (MonoDwarfWriter
*w
, guint8 val
)
231 img_writer_emit_byte (w
->w
, val
);
234 static G_GNUC_UNUSED
void
235 emit_uleb128 (MonoDwarfWriter
*w
, guint32 value
)
238 guint8 b
= value
& 0x7f;
240 if (value
!= 0) /* more bytes to come */
246 static G_GNUC_UNUSED
void
247 emit_sleb128 (MonoDwarfWriter
*w
, gint64 value
)
250 gboolean negative
= (value
< 0);
257 /* the following is unnecessary if the
258 * implementation of >>= uses an arithmetic rather
259 * than logical shift for a signed left operand
263 value
|= - ((gint64
)1 <<(size
- 7));
264 /* sign bit of byte is second high order bit (0x40) */
265 if ((value
== 0 && !(byte
& 0x40)) ||
266 (value
== -1 && (byte
& 0x40)))
274 static G_GNUC_UNUSED
void
275 encode_uleb128 (guint32 value
, guint8
*buf
, guint8
**endbuf
)
280 guint8 b
= value
& 0x7f;
282 if (value
!= 0) /* more bytes to come */
290 static G_GNUC_UNUSED
void
291 encode_sleb128 (gint32 value
, guint8
*buf
, guint8
**endbuf
)
294 gboolean negative
= (value
< 0);
302 /* the following is unnecessary if the
303 * implementation of >>= uses an arithmetic rather
304 * than logical shift for a signed left operand
308 value
|= - (1 <<(size
- 7));
309 /* sign bit of byte is second high order bit (0x40) */
310 if ((value
== 0 && !(byte
& 0x40)) ||
311 (value
== -1 && (byte
& 0x40)))
322 emit_dwarf_abbrev (MonoDwarfWriter
*w
, int code
, int tag
, gboolean has_child
,
323 int *attrs
, int attrs_len
)
327 emit_uleb128 (w
, code
);
328 emit_uleb128 (w
, tag
);
329 emit_byte (w
, has_child
);
331 for (i
= 0; i
< attrs_len
; i
++)
332 emit_uleb128 (w
, attrs
[i
]);
338 emit_cie (MonoDwarfWriter
*w
)
340 emit_section_change (w
, ".debug_frame", 0);
342 emit_alignment (w
, 8);
345 emit_symbol_diff (w
, ".Lcie0_end", ".Lcie0_start", 0); /* length */
346 emit_label (w
, ".Lcie0_start");
347 emit_int32 (w
, 0xffffffff); /* CIE id */
348 emit_byte (w
, 3); /* version */
349 emit_string (w
, ""); /* augmention */
350 emit_sleb128 (w
, 1); /* code alignment factor */
351 emit_sleb128 (w
, mono_unwind_get_dwarf_data_align ()); /* data alignment factor */
352 emit_uleb128 (w
, mono_unwind_get_dwarf_pc_reg ());
354 w
->cie_program
= w
->cie_program
;
355 if (w
->cie_program
) {
357 guint8
*uw_info
= mono_unwind_ops_encode (w
->cie_program
, &uw_info_len
);
358 emit_bytes (w
, uw_info
, uw_info_len
);
362 emit_alignment (w
, sizeof (gpointer
));
363 emit_label (w
, ".Lcie0_end");
367 emit_pointer_value (MonoDwarfWriter
*w
, gpointer ptr
)
369 gssize val
= (gssize
)ptr
;
370 emit_bytes (w
, (guint8
*)&val
, sizeof (gpointer
));
374 emit_fde (MonoDwarfWriter
*w
, int fde_index
, char *start_symbol
, char *end_symbol
,
375 guint8
*code
, guint32 code_size
, GSList
*unwind_ops
, gboolean use_cie
)
383 emit_section_change (w
, ".debug_frame", 0);
385 sprintf (symbol1
, ".Lfde%d_start", fde_index
);
386 sprintf (symbol2
, ".Lfde%d_end", fde_index
);
387 emit_symbol_diff (w
, symbol2
, symbol1
, 0); /* length */
388 emit_label (w
, symbol1
);
389 emit_int32 (w
, 0); /* CIE_pointer */
391 emit_pointer (w
, start_symbol
); /* initial_location */
393 emit_symbol_diff (w
, end_symbol
, start_symbol
, 0); /* address_range */
395 g_assert (code_size
);
396 emit_int32 (w
, code_size
);
399 emit_pointer_value (w
, code
);
400 emit_int32 (w
, code_size
);
402 #if SIZEOF_VOID_P == 8
403 /* Upper 32 bits of code size */
408 if (w
->cie_program
) {
409 // FIXME: Check that the ops really begin with the CIE program */
412 for (i
= 0; i
< g_slist_length (w
->cie_program
); ++i
)
417 /* Convert the list of MonoUnwindOps to the format used by DWARF */
418 uw_info
= mono_unwind_ops_encode (l
, &uw_info_len
);
419 emit_bytes (w
, uw_info
, uw_info_len
);
422 emit_alignment (w
, sizeof (mgreg_t
));
423 emit_label (w
, symbol2
);
427 #define ABBREV_COMPILE_UNIT 1
428 #define ABBREV_SUBPROGRAM 2
429 #define ABBREV_PARAM 3
430 #define ABBREV_BASE_TYPE 4
431 #define ABBREV_STRUCT_TYPE 5
432 #define ABBREV_DATA_MEMBER 6
433 #define ABBREV_TYPEDEF 7
434 #define ABBREV_ENUM_TYPE 8
435 #define ABBREV_ENUMERATOR 9
436 #define ABBREV_NAMESPACE 10
437 #define ABBREV_VARIABLE 11
438 #define ABBREV_VARIABLE_LOCLIST 12
439 #define ABBREV_POINTER_TYPE 13
440 #define ABBREV_REFERENCE_TYPE 14
441 #define ABBREV_PARAM_LOCLIST 15
442 #define ABBREV_INHERITANCE 16
443 #define ABBREV_STRUCT_TYPE_NOCHILDREN 17
444 #define ABBREV_TRAMP_SUBPROGRAM 18
446 static int compile_unit_attr
[] = {
447 DW_AT_producer
,DW_FORM_string
,
448 DW_AT_name
,DW_FORM_string
,
449 DW_AT_comp_dir
,DW_FORM_string
,
450 DW_AT_language
,DW_FORM_data1
,
451 DW_AT_low_pc
,DW_FORM_addr
,
452 DW_AT_high_pc
,DW_FORM_addr
,
453 DW_AT_stmt_list
,DW_FORM_data4
456 static int subprogram_attr
[] = {
457 DW_AT_name
, DW_FORM_string
,
459 DW_AT_description
, DW_FORM_string
,
461 DW_AT_low_pc
, DW_FORM_addr
,
462 DW_AT_high_pc
, DW_FORM_addr
,
463 DW_AT_frame_base
, DW_FORM_block1
466 static int tramp_subprogram_attr
[] = {
467 DW_AT_name
, DW_FORM_string
,
468 DW_AT_low_pc
, DW_FORM_addr
,
469 DW_AT_high_pc
, DW_FORM_addr
,
472 static int param_attr
[] = {
473 DW_AT_name
, DW_FORM_string
,
474 DW_AT_type
, DW_FORM_ref4
,
475 DW_AT_location
, DW_FORM_block1
478 static int param_loclist_attr
[] = {
479 DW_AT_name
, DW_FORM_string
,
480 DW_AT_type
, DW_FORM_ref4
,
481 DW_AT_location
, DW_FORM_data4
484 static int base_type_attr
[] = {
485 DW_AT_byte_size
, DW_FORM_data1
,
486 DW_AT_encoding
, DW_FORM_data1
,
487 DW_AT_name
, DW_FORM_string
490 static int struct_type_attr
[] = {
491 DW_AT_name
, DW_FORM_string
,
492 DW_AT_byte_size
, DW_FORM_udata
,
495 static int data_member_attr
[] = {
496 DW_AT_name
, DW_FORM_string
,
497 DW_AT_type
, DW_FORM_ref4
,
498 DW_AT_data_member_location
, DW_FORM_block1
501 static int typedef_attr
[] = {
502 DW_AT_name
, DW_FORM_string
,
503 DW_AT_type
, DW_FORM_ref4
506 static int pointer_type_attr
[] = {
507 DW_AT_type
, DW_FORM_ref4
,
510 static int reference_type_attr
[] = {
511 DW_AT_type
, DW_FORM_ref4
,
514 static int enum_type_attr
[] = {
515 DW_AT_name
, DW_FORM_string
,
516 DW_AT_byte_size
, DW_FORM_udata
,
517 DW_AT_type
, DW_FORM_ref4
,
520 static int enumerator_attr
[] = {
521 DW_AT_name
, DW_FORM_string
,
522 DW_AT_const_value
, DW_FORM_sdata
,
525 static int namespace_attr
[] = {
526 DW_AT_name
, DW_FORM_string
,
529 static int variable_attr
[] = {
530 DW_AT_name
, DW_FORM_string
,
531 DW_AT_type
, DW_FORM_ref4
,
532 DW_AT_location
, DW_FORM_block1
535 static int variable_loclist_attr
[] = {
536 DW_AT_name
, DW_FORM_string
,
537 DW_AT_type
, DW_FORM_ref4
,
538 DW_AT_location
, DW_FORM_data4
541 static int inheritance_attr
[] = {
542 DW_AT_type
, DW_FORM_ref4
,
543 DW_AT_data_member_location
, DW_FORM_block1
546 typedef struct DwarfBasicType
{
547 const char *die_name
, *name
;
553 static DwarfBasicType basic_types
[] = {
554 { ".LDIE_I1", "sbyte", MONO_TYPE_I1
, 1, DW_ATE_signed
},
555 { ".LDIE_U1", "byte", MONO_TYPE_U1
, 1, DW_ATE_unsigned
},
556 { ".LDIE_I2", "short", MONO_TYPE_I2
, 2, DW_ATE_signed
},
557 { ".LDIE_U2", "ushort", MONO_TYPE_U2
, 2, DW_ATE_unsigned
},
558 { ".LDIE_I4", "int", MONO_TYPE_I4
, 4, DW_ATE_signed
},
559 { ".LDIE_U4", "uint", MONO_TYPE_U4
, 4, DW_ATE_unsigned
},
560 { ".LDIE_I8", "long", MONO_TYPE_I8
, 8, DW_ATE_signed
},
561 { ".LDIE_U8", "ulong", MONO_TYPE_U8
, 8, DW_ATE_unsigned
},
562 { ".LDIE_I", "intptr", MONO_TYPE_I
, SIZEOF_VOID_P
, DW_ATE_signed
},
563 { ".LDIE_U", "uintptr", MONO_TYPE_U
, SIZEOF_VOID_P
, DW_ATE_unsigned
},
564 { ".LDIE_R4", "float", MONO_TYPE_R4
, 4, DW_ATE_float
},
565 { ".LDIE_R8", "double", MONO_TYPE_R8
, 8, DW_ATE_float
},
566 { ".LDIE_BOOLEAN", "boolean", MONO_TYPE_BOOLEAN
, 1, DW_ATE_boolean
},
567 { ".LDIE_CHAR", "char", MONO_TYPE_CHAR
, 2, DW_ATE_unsigned_char
},
568 { ".LDIE_STRING", "string", MONO_TYPE_STRING
, sizeof (gpointer
), DW_ATE_address
},
569 { ".LDIE_OBJECT", "object", MONO_TYPE_OBJECT
, sizeof (gpointer
), DW_ATE_address
},
570 { ".LDIE_SZARRAY", "object", MONO_TYPE_SZARRAY
, sizeof (gpointer
), DW_ATE_address
},
573 /* Constants for encoding line number special opcodes */
574 #define OPCODE_BASE 13
576 #define LINE_RANGE 14
578 /* Subsections of the .debug_line section */
579 #define LINE_SUBSECTION_HEADER 1
580 #define LINE_SUBSECTION_INCLUDES 2
581 #define LINE_SUBSECTION_FILES 3
582 #define LINE_SUBSECTION_DATA 4
583 #define LINE_SUBSECTION_END 5
586 emit_line_number_file_name (MonoDwarfWriter
*w
, const char *name
,
587 gint64 last_mod_time
, gint64 file_size
)
591 char *basename
= NULL
;
593 if (!w
->file_to_index
)
594 w
->file_to_index
= g_hash_table_new (g_str_hash
, g_str_equal
);
596 index
= GPOINTER_TO_UINT (g_hash_table_lookup (w
->file_to_index
, name
));
600 if (g_path_is_absolute (name
)) {
601 char *dir
= g_path_get_dirname (name
);
603 if (!w
->dir_to_index
)
604 w
->dir_to_index
= g_hash_table_new (g_str_hash
, g_str_equal
);
606 dir_index
= GPOINTER_TO_UINT (g_hash_table_lookup (w
->dir_to_index
, dir
));
607 if (dir_index
== 0) {
608 emit_section_change (w
, ".debug_line", LINE_SUBSECTION_INCLUDES
);
609 emit_string (w
, dir
);
611 dir_index
= ++ w
->line_number_dir_index
;
612 g_hash_table_insert (w
->dir_to_index
, g_strdup (dir
), GUINT_TO_POINTER (dir_index
));
617 basename
= g_path_get_basename (name
);
622 emit_section_change (w
, ".debug_line", LINE_SUBSECTION_FILES
);
625 emit_string (w
, basename
);
627 emit_string (w
, name
);
628 emit_uleb128 (w
, dir_index
);
632 emit_section_change (w
, ".debug_line", LINE_SUBSECTION_DATA
);
637 index
= ++ w
->line_number_file_index
;
638 g_hash_table_insert (w
->file_to_index
, g_strdup (name
), GUINT_TO_POINTER (index
));
644 get_line_number_file_name (MonoDwarfWriter
*w
, const char *name
)
648 g_assert (w
->file_to_index
);
649 index
= GPOINTER_TO_UINT (g_hash_table_lookup (w
->file_to_index
, name
));
650 g_assert (index
> 0);
655 add_line_number_file_name (MonoDwarfWriter
*w
, const char *name
,
656 gint64 last_mod_time
, gint64 file_size
)
661 if (!w
->file_to_index
) {
662 w
->file_to_index
= g_hash_table_new (g_str_hash
, g_str_equal
);
663 w
->index_to_file
= g_hash_table_new (NULL
, NULL
);
666 index
= GPOINTER_TO_UINT (g_hash_table_lookup (w
->file_to_index
, name
));
669 index
= w
->line_number_file_index
;
670 w
->line_number_file_index
++;
671 copy
= g_strdup (name
);
672 g_hash_table_insert (w
->file_to_index
, copy
, GUINT_TO_POINTER (index
+ 1));
673 g_hash_table_insert (w
->index_to_file
, GUINT_TO_POINTER (index
+ 1), copy
);
679 mono_dwarf_escape_path (const char *name
)
681 if (strchr (name
, '\\')) {
686 s
= g_malloc0 ((len
+ 1) * 2);
688 for (i
= 0; i
< len
; ++i
) {
689 if (name
[i
] == '\\') {
698 return g_strdup (name
);
702 emit_all_line_number_info (MonoDwarfWriter
*w
)
705 GHashTable
*dir_to_index
, *index_to_dir
;
709 g_assert (w
->collect_line_info
);
711 add_line_number_file_name (w
, "<unknown>", 0, 0);
714 info_list
= g_slist_reverse (w
->line_info
);
715 for (l
= info_list
; l
; l
= l
->next
) {
716 MethodLineNumberInfo
*info
= l
->data
;
717 MonoDebugMethodInfo
*minfo
;
719 GPtrArray
*source_file_list
;
722 minfo
= mono_debug_lookup_method (info
->method
);
726 mono_debug_symfile_get_line_numbers_full (minfo
, &source_file
, &source_file_list
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
);
727 for (i
= 0; i
< source_file_list
->len
; ++i
) {
728 MonoDebugSourceInfo
*sinfo
= g_ptr_array_index (source_file_list
, i
);
729 add_line_number_file_name (w
, sinfo
->source_file
, 0, 0);
733 /* Preprocess files */
734 dir_to_index
= g_hash_table_new (g_str_hash
, g_str_equal
);
735 index_to_dir
= g_hash_table_new (NULL
, NULL
);
736 for (i
= 0; i
< w
->line_number_file_index
; ++i
) {
737 char *name
= g_hash_table_lookup (w
->index_to_file
, GUINT_TO_POINTER (i
+ 1));
741 if (g_path_is_absolute (name
)) {
742 char *dir
= g_path_get_dirname (name
);
744 dir_index
= GPOINTER_TO_UINT (g_hash_table_lookup (dir_to_index
, dir
));
745 if (dir_index
== 0) {
746 dir_index
= w
->line_number_dir_index
;
747 w
->line_number_dir_index
++;
748 copy
= g_strdup (dir
);
749 g_hash_table_insert (dir_to_index
, copy
, GUINT_TO_POINTER (dir_index
+ 1));
750 g_hash_table_insert (index_to_dir
, GUINT_TO_POINTER (dir_index
+ 1), copy
);
759 /* Line number info header */
760 emit_section_change (w
, ".debug_line", 0);
761 emit_label (w
, ".Ldebug_line_section_start");
762 emit_label (w
, ".Ldebug_line_start");
763 emit_symbol_diff (w
, ".Ldebug_line_end", ".", -4); /* length */
764 emit_int16 (w
, 0x2); /* version */
765 emit_symbol_diff (w
, ".Ldebug_line_header_end", ".", -4); /* header_length */
766 emit_byte (w
, 1); /* minimum_instruction_length */
767 emit_byte (w
, 1); /* default_is_stmt */
768 emit_byte (w
, LINE_BASE
); /* line_base */
769 emit_byte (w
, LINE_RANGE
); /* line_range */
770 emit_byte (w
, OPCODE_BASE
); /* opcode_base */
771 emit_byte (w
, 0); /* standard_opcode_lengths */
785 emit_section_change (w
, ".debug_line", 0);
786 for (i
= 0; i
< w
->line_number_dir_index
; ++i
) {
787 char *dir
= g_hash_table_lookup (index_to_dir
, GUINT_TO_POINTER (i
+ 1));
789 emit_string (w
, mono_dwarf_escape_path (dir
));
791 /* End of Includes */
795 for (i
= 0; i
< w
->line_number_file_index
; ++i
) {
796 char *name
= g_hash_table_lookup (w
->index_to_file
, GUINT_TO_POINTER (i
+ 1));
797 char *basename
= NULL
, *dir
;
800 if (g_path_is_absolute (name
)) {
801 dir
= g_path_get_dirname (name
);
803 dir_index
= GPOINTER_TO_UINT (g_hash_table_lookup (dir_to_index
, dir
));
804 basename
= g_path_get_basename (name
);
808 emit_string (w
, basename
);
810 emit_string (w
, mono_dwarf_escape_path (name
));
811 emit_uleb128 (w
, dir_index
);
819 emit_label (w
, ".Ldebug_line_header_end");
821 /* Emit line number table */
822 for (l
= info_list
; l
; l
= l
->next
) {
823 MethodLineNumberInfo
*info
= l
->data
;
824 MonoDebugMethodJitInfo
*dmji
;
826 dmji
= mono_debug_find_method (info
->method
, mono_domain_get ());;
827 emit_line_number_info (w
, info
->method
, info
->start_symbol
, info
->end_symbol
, info
->code
, info
->code_size
, dmji
);
828 mono_debug_free_method_jit_info (dmji
);
830 g_slist_free (info_list
);
834 emit_byte (w
, DW_LNE_end_sequence
);
836 emit_label (w
, ".Ldebug_line_end");
840 * Some assemblers like apple's do not support subsections, so we can't place
841 * .Ldebug_info_end at the end of the section using subsections. Instead, we
842 * define it every time something gets added to the .debug_info section.
843 * The apple assember seems to use the last definition.
846 emit_debug_info_end (MonoDwarfWriter
*w
)
848 /* This doesn't seem to work/required with recent iphone sdk versions */
850 if (!img_writer_subsections_supported (w
->w
))
851 fprintf (w
->fp
, "\n.set %sdebug_info_end,.\n", w
->temp_prefix
);
856 mono_dwarf_writer_emit_base_info (MonoDwarfWriter
*w
, const char *cu_name
, GSList
*base_unwind_program
)
858 char *s
, *build_info
;
861 w
->cie_program
= base_unwind_program
;
863 emit_section_change (w
, ".debug_abbrev", 0);
864 emit_dwarf_abbrev (w
, ABBREV_COMPILE_UNIT
, DW_TAG_compile_unit
, TRUE
,
865 compile_unit_attr
, G_N_ELEMENTS (compile_unit_attr
));
866 emit_dwarf_abbrev (w
, ABBREV_SUBPROGRAM
, DW_TAG_subprogram
, TRUE
,
867 subprogram_attr
, G_N_ELEMENTS (subprogram_attr
));
868 emit_dwarf_abbrev (w
, ABBREV_PARAM
, DW_TAG_formal_parameter
, FALSE
,
869 param_attr
, G_N_ELEMENTS (param_attr
));
870 emit_dwarf_abbrev (w
, ABBREV_PARAM_LOCLIST
, DW_TAG_formal_parameter
, FALSE
,
871 param_loclist_attr
, G_N_ELEMENTS (param_loclist_attr
));
872 emit_dwarf_abbrev (w
, ABBREV_BASE_TYPE
, DW_TAG_base_type
, FALSE
,
873 base_type_attr
, G_N_ELEMENTS (base_type_attr
));
874 emit_dwarf_abbrev (w
, ABBREV_STRUCT_TYPE
, DW_TAG_class_type
, TRUE
,
875 struct_type_attr
, G_N_ELEMENTS (struct_type_attr
));
876 emit_dwarf_abbrev (w
, ABBREV_STRUCT_TYPE_NOCHILDREN
, DW_TAG_class_type
, FALSE
,
877 struct_type_attr
, G_N_ELEMENTS (struct_type_attr
));
878 emit_dwarf_abbrev (w
, ABBREV_DATA_MEMBER
, DW_TAG_member
, FALSE
,
879 data_member_attr
, G_N_ELEMENTS (data_member_attr
));
880 emit_dwarf_abbrev (w
, ABBREV_TYPEDEF
, DW_TAG_typedef
, FALSE
,
881 typedef_attr
, G_N_ELEMENTS (typedef_attr
));
882 emit_dwarf_abbrev (w
, ABBREV_ENUM_TYPE
, DW_TAG_enumeration_type
, TRUE
,
883 enum_type_attr
, G_N_ELEMENTS (enum_type_attr
));
884 emit_dwarf_abbrev (w
, ABBREV_ENUMERATOR
, DW_TAG_enumerator
, FALSE
,
885 enumerator_attr
, G_N_ELEMENTS (enumerator_attr
));
886 emit_dwarf_abbrev (w
, ABBREV_NAMESPACE
, DW_TAG_namespace
, TRUE
,
887 namespace_attr
, G_N_ELEMENTS (namespace_attr
));
888 emit_dwarf_abbrev (w
, ABBREV_VARIABLE
, DW_TAG_variable
, FALSE
,
889 variable_attr
, G_N_ELEMENTS (variable_attr
));
890 emit_dwarf_abbrev (w
, ABBREV_VARIABLE_LOCLIST
, DW_TAG_variable
, FALSE
,
891 variable_loclist_attr
, G_N_ELEMENTS (variable_loclist_attr
));
892 emit_dwarf_abbrev (w
, ABBREV_POINTER_TYPE
, DW_TAG_pointer_type
, FALSE
,
893 pointer_type_attr
, G_N_ELEMENTS (pointer_type_attr
));
894 emit_dwarf_abbrev (w
, ABBREV_REFERENCE_TYPE
, DW_TAG_reference_type
, FALSE
,
895 reference_type_attr
, G_N_ELEMENTS (reference_type_attr
));
896 emit_dwarf_abbrev (w
, ABBREV_INHERITANCE
, DW_TAG_inheritance
, FALSE
,
897 inheritance_attr
, G_N_ELEMENTS (inheritance_attr
));
898 emit_dwarf_abbrev (w
, ABBREV_TRAMP_SUBPROGRAM
, DW_TAG_subprogram
, FALSE
,
899 tramp_subprogram_attr
, G_N_ELEMENTS (tramp_subprogram_attr
));
902 emit_section_change (w
, ".debug_info", 0);
903 emit_label (w
, ".Ldebug_info_start");
904 emit_symbol_diff (w
, ".Ldebug_info_end", ".Ldebug_info_begin", 0); /* length */
905 emit_label (w
, ".Ldebug_info_begin");
906 emit_int16 (w
, 0x2); /* DWARF version 2 */
907 emit_int32 (w
, 0); /* .debug_abbrev offset */
908 emit_byte (w
, sizeof (gpointer
)); /* address size */
910 if (img_writer_subsections_supported (w
->w
) && w
->appending
) {
911 /* Emit this into a separate section so it gets placed at the end */
912 emit_section_change (w
, ".debug_info", 1);
913 emit_byte (w
, 0); /* close COMPILE_UNIT */
914 emit_label (w
, ".Ldebug_info_end");
915 emit_section_change (w
, ".debug_info", 0);
918 /* Compilation unit */
919 emit_uleb128 (w
, ABBREV_COMPILE_UNIT
);
920 build_info
= mono_get_runtime_build_info ();
921 s
= g_strdup_printf ("Mono AOT Compiler %s", build_info
);
925 emit_string (w
, cu_name
);
927 emit_byte (w
, DW_LANG_C
);
928 emit_pointer_value (w
, 0);
929 emit_pointer_value (w
, 0);
930 /* offset into .debug_line section */
932 emit_symbol_diff (w
, ".Ldebug_line_start", ".Ldebug_line_section_start", 0);
934 emit_pointer_value (w
, 0);
937 for (i
= 0; i
< G_N_ELEMENTS (basic_types
); ++i
) {
938 emit_label (w
, basic_types
[i
].die_name
);
939 emit_uleb128 (w
, ABBREV_BASE_TYPE
);
940 emit_byte (w
, basic_types
[i
].size
);
941 emit_byte (w
, basic_types
[i
].encoding
);
942 emit_string (w
, basic_types
[i
].name
);
945 emit_debug_info_end (w
);
947 /* debug_loc section */
948 emit_section_change (w
, ".debug_loc", 0);
949 emit_label (w
, ".Ldebug_loc_start");
955 * mono_dwarf_writer_close:
957 * Finalize the emitted debugging info.
960 mono_dwarf_writer_close (MonoDwarfWriter
*w
)
963 emit_section_change (w
, ".debug_info", 0);
964 emit_byte (w
, 0); /* close COMPILE_UNIT */
965 emit_label (w
, ".Ldebug_info_end");
968 if (w
->collect_line_info
)
969 emit_all_line_number_info (w
);
972 static void emit_type (MonoDwarfWriter
*w
, MonoType
*t
);
973 static const char* get_type_die (MonoDwarfWriter
*w
, MonoType
*t
);
976 get_class_die (MonoDwarfWriter
*w
, MonoClass
*klass
, gboolean vtype
)
981 cache
= w
->class_to_vtype_die
;
983 cache
= w
->class_to_die
;
985 return g_hash_table_lookup (cache
, klass
);
988 /* Returns the local symbol pointing to the emitted debug info */
990 emit_class_dwarf_info (MonoDwarfWriter
*w
, MonoClass
*klass
, gboolean vtype
)
992 char *die
, *pointer_die
, *reference_die
;
995 MonoClassField
*field
;
998 gboolean emit_namespace
= FALSE
, has_children
;
1002 cache
= w
->class_to_vtype_die
;
1004 cache
= w
->class_to_die
;
1006 die
= g_hash_table_lookup (cache
, klass
);
1010 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
) ||
1011 (klass
->byval_arg
.type
>= MONO_TYPE_BOOLEAN
&& klass
->byval_arg
.type
<= MONO_TYPE_R8
&& !vtype
)))
1015 * FIXME: gdb can't handle namespaces in languages it doesn't know about.
1018 if (klass->name_space && klass->name_space [0] != '\0')
1019 emit_namespace = TRUE;
1021 if (emit_namespace
) {
1022 emit_uleb128 (w
, ABBREV_NAMESPACE
);
1023 emit_string (w
, klass
->name_space
);
1026 full_name
= g_strdup_printf ("%s%s%s", klass
->name_space
, klass
->name_space
? "." : "", klass
->name
);
1028 * gdb doesn't support namespaces for non-C++ dwarf objects, so use _
1029 * to separate components.
1031 for (p
= full_name
; *p
; p
++)
1035 die
= g_strdup_printf (".LTDIE_%d", w
->tdie_index
);
1036 pointer_die
= g_strdup_printf (".LTDIE_%d_POINTER", w
->tdie_index
);
1037 reference_die
= g_strdup_printf (".LTDIE_%d_REFERENCE", w
->tdie_index
);
1040 g_hash_table_insert (w
->class_to_pointer_die
, klass
, pointer_die
);
1041 g_hash_table_insert (w
->class_to_reference_die
, klass
, reference_die
);
1042 g_hash_table_insert (cache
, klass
, die
);
1044 if (klass
->enumtype
) {
1045 int size
= mono_class_value_size (mono_class_from_mono_type (mono_class_enum_basetype (klass
)), NULL
);
1047 emit_label (w
, die
);
1049 emit_uleb128 (w
, ABBREV_ENUM_TYPE
);
1050 emit_string (w
, full_name
);
1051 emit_uleb128 (w
, size
);
1052 for (k
= 0; k
< G_N_ELEMENTS (basic_types
); ++k
)
1053 if (basic_types
[k
].type
== mono_class_enum_basetype (klass
)->type
)
1055 g_assert (k
< G_N_ELEMENTS (basic_types
));
1056 emit_symbol_diff (w
, basic_types
[k
].die_name
, ".Ldebug_info_start", 0);
1058 /* Emit enum values */
1060 while ((field
= mono_class_get_fields (klass
, &iter
))) {
1063 MonoTypeEnum def_type
;
1065 if (strcmp ("value__", mono_field_get_name (field
)) == 0)
1067 if (mono_field_is_deleted (field
))
1070 emit_uleb128 (w
, ABBREV_ENUMERATOR
);
1071 emit_string (w
, mono_field_get_name (field
));
1073 p
= mono_class_get_field_default_value (field
, &def_type
);
1074 len
= mono_metadata_decode_blob_size (p
, &p
);
1075 switch (mono_class_enum_basetype (klass
)->type
) {
1078 case MONO_TYPE_BOOLEAN
:
1079 emit_sleb128 (w
, *p
);
1083 case MONO_TYPE_CHAR
:
1084 emit_sleb128 (w
, read16 (p
));
1088 emit_sleb128 (w
, read32 (p
));
1092 emit_sleb128 (w
, read64 (p
));
1096 #if SIZEOF_VOID_P == 8
1097 emit_sleb128 (w
, read64 (p
));
1099 emit_sleb128 (w
, read32 (p
));
1103 g_assert_not_reached ();
1107 has_children
= TRUE
;
1114 parent_die
= emit_class_dwarf_info (w
, klass
->parent
, FALSE
);
1118 /* Emit field types */
1120 while ((field
= mono_class_get_fields (klass
, &iter
))) {
1121 if (field
->type
->attrs
& FIELD_ATTRIBUTE_STATIC
)
1124 emit_type (w
, field
->type
);
1128 has_children
= parent_die
|| mono_class_get_fields (klass
, &iter
);
1130 emit_label (w
, die
);
1132 emit_uleb128 (w
, has_children
? ABBREV_STRUCT_TYPE
: ABBREV_STRUCT_TYPE_NOCHILDREN
);
1133 emit_string (w
, full_name
);
1134 emit_uleb128 (w
, klass
->instance_size
);
1137 emit_uleb128 (w
, ABBREV_INHERITANCE
);
1138 emit_symbol_diff (w
, parent_die
, ".Ldebug_info_start", 0);
1141 *p
++= DW_OP_plus_uconst
;
1142 encode_uleb128 (0, p
, &p
);
1143 emit_byte (w
, p
- buf
);
1144 emit_bytes (w
, buf
, p
- buf
);
1149 while ((field
= mono_class_get_fields (klass
, &iter
))) {
1150 if (field
->type
->attrs
& FIELD_ATTRIBUTE_STATIC
)
1153 fdie
= get_type_die (w
, field
->type
);
1155 emit_uleb128 (w
, ABBREV_DATA_MEMBER
);
1156 emit_string (w
, field
->name
);
1157 emit_symbol_diff (w
, fdie
, ".Ldebug_info_start", 0);
1160 *p
++= DW_OP_plus_uconst
;
1161 if (klass
->valuetype
&& vtype
)
1162 encode_uleb128 (field
->offset
- sizeof (MonoObject
), p
, &p
);
1164 encode_uleb128 (field
->offset
, p
, &p
);
1166 emit_byte (w
, p
- buf
);
1167 emit_bytes (w
, buf
, p
- buf
);
1174 emit_uleb128 (w
, 0x0);
1176 /* Add a typedef, so we can reference the type without a 'struct' in gdb */
1177 emit_uleb128 (w
, ABBREV_TYPEDEF
);
1178 emit_string (w
, full_name
);
1179 emit_symbol_diff (w
, die
, ".Ldebug_info_start", 0);
1181 /* Add a pointer type */
1182 emit_label (w
, pointer_die
);
1184 emit_uleb128 (w
, ABBREV_POINTER_TYPE
);
1185 emit_symbol_diff (w
, die
, ".Ldebug_info_start", 0);
1187 /* Add a reference type */
1188 emit_label (w
, reference_die
);
1190 emit_uleb128 (w
, ABBREV_REFERENCE_TYPE
);
1191 emit_symbol_diff (w
, die
, ".Ldebug_info_start", 0);
1195 if (emit_namespace
) {
1197 emit_uleb128 (w
, 0x0);
1203 static gboolean base_types_emitted
[64];
1206 get_type_die (MonoDwarfWriter
*w
, MonoType
*t
)
1208 MonoClass
*klass
= mono_class_from_mono_type (t
);
1213 if (t
->type
== MONO_TYPE_VALUETYPE
) {
1214 tdie
= g_hash_table_lookup (w
->class_to_pointer_die
, klass
);
1217 tdie
= get_class_die (w
, klass
, FALSE
);
1218 /* Should return a pointer type to a reference */
1221 t
= &mono_defaults
.int_class
->byval_arg
;
1223 for (j
= 0; j
< G_N_ELEMENTS (basic_types
); ++j
)
1224 if (basic_types
[j
].type
== t
->type
)
1226 if (j
< G_N_ELEMENTS (basic_types
)) {
1227 tdie
= basic_types
[j
].die_name
;
1230 case MONO_TYPE_CLASS
:
1231 tdie
= g_hash_table_lookup (w
->class_to_reference_die
, klass
);
1232 //tdie = ".LDIE_OBJECT";
1234 case MONO_TYPE_ARRAY
:
1235 tdie
= ".LDIE_OBJECT";
1237 case MONO_TYPE_VALUETYPE
:
1238 if (klass
->enumtype
)
1239 tdie
= get_class_die (w
, klass
, FALSE
);
1243 case MONO_TYPE_GENERICINST
:
1244 if (!MONO_TYPE_ISSTRUCT (t
)) {
1245 tdie
= g_hash_table_lookup (w
->class_to_reference_die
, klass
);
1265 emit_type (MonoDwarfWriter
*w
, MonoType
*t
)
1267 MonoClass
*klass
= mono_class_from_mono_type (t
);
1272 if (t
->type
== MONO_TYPE_VALUETYPE
) {
1273 tdie
= emit_class_dwarf_info (w
, klass
, TRUE
);
1278 emit_class_dwarf_info (w
, klass
, FALSE
);
1281 t
= &mono_defaults
.int_class
->byval_arg
;
1283 for (j
= 0; j
< G_N_ELEMENTS (basic_types
); ++j
)
1284 if (basic_types
[j
].type
== t
->type
)
1286 if (j
< G_N_ELEMENTS (basic_types
)) {
1287 /* Emit a boxed version of base types */
1288 if (j
< 64 && !base_types_emitted
[j
]) {
1289 emit_class_dwarf_info (w
, klass
, FALSE
);
1290 base_types_emitted
[j
] = TRUE
;
1294 case MONO_TYPE_CLASS
:
1295 emit_class_dwarf_info (w
, klass
, FALSE
);
1297 case MONO_TYPE_ARRAY
:
1299 case MONO_TYPE_VALUETYPE
:
1300 if (klass
->enumtype
)
1301 emit_class_dwarf_info (w
, klass
, FALSE
);
1303 case MONO_TYPE_GENERICINST
:
1304 if (!MONO_TYPE_ISSTRUCT (t
))
1305 emit_class_dwarf_info (w
, klass
, FALSE
);
1316 emit_var_type (MonoDwarfWriter
*w
, MonoType
*t
)
1320 tdie
= get_type_die (w
, t
);
1322 emit_symbol_diff (w
, tdie
, ".Ldebug_info_start", 0);
1326 encode_var_location (MonoDwarfWriter
*w
, MonoInst
*ins
, guint8
*p
, guint8
**endp
)
1329 /* FIXME: This needs a location list, since the args can go from reg->stack */
1330 if (!ins
|| ins
->flags
& MONO_INST_IS_DEAD
) {
1331 /* gdb treats this as optimized out */
1332 } else if (ins
->opcode
== OP_REGVAR
) {
1333 *p
= DW_OP_reg0
+ mono_hw_reg_to_dwarf_reg (ins
->dreg
);
1335 } else if (ins
->opcode
== OP_REGOFFSET
) {
1336 *p
++= DW_OP_breg0
+ mono_hw_reg_to_dwarf_reg (ins
->inst_basereg
);
1337 encode_sleb128 (ins
->inst_offset
, p
, &p
);
1347 emit_loclist (MonoDwarfWriter
*w
, MonoInst
*ins
,
1348 guint8
*loclist_begin_addr
, guint8
*loclist_end_addr
,
1349 guint8
*expr
, guint32 expr_len
)
1353 emit_push_section (w
, ".debug_loc", 0);
1354 sprintf (label
, ".Lloclist_%d", w
->loclist_index
++ );
1355 emit_label (w
, label
);
1357 emit_pointer_value (w
, loclist_begin_addr
);
1358 emit_pointer_value (w
, loclist_end_addr
);
1359 emit_byte (w
, expr_len
% 256);
1360 emit_byte (w
, expr_len
/ 256);
1361 emit_bytes (w
, expr
, expr_len
);
1363 emit_pointer_value (w
, NULL
);
1364 emit_pointer_value (w
, NULL
);
1366 emit_pop_section (w
);
1367 emit_symbol_diff (w
, label
, ".Ldebug_loc_start", 0);
1371 * MonoDisHelper->tokener doesn't take an IP argument, and we can't add one since
1372 * it is a public header.
1374 static const guint8
*token_handler_ip
;
1377 token_handler (MonoDisHelper
*dh
, MonoMethod
*method
, guint32 token
)
1380 MonoMethod
*cmethod
;
1382 MonoClassField
*field
;
1383 gpointer data
= NULL
;
1385 if (method
->wrapper_type
)
1386 data
= mono_method_get_wrapper_data (method
, token
);
1388 switch (*token_handler_ip
) {
1392 if (method
->wrapper_type
)
1395 klass
= mono_class_get_full (method
->klass
->image
, token
, NULL
);
1396 res
= g_strdup_printf ("<%s>", klass
->name
);
1401 if (method
->wrapper_type
)
1404 cmethod
= mono_get_method_full (method
->klass
->image
, token
, NULL
, NULL
);
1405 desc
= mono_method_full_name (cmethod
, TRUE
);
1406 res
= g_strdup_printf ("<%s>", desc
);
1410 if (method
->wrapper_type
) {
1411 desc
= mono_signature_get_desc (data
, FALSE
);
1412 res
= g_strdup_printf ("<%s>", desc
);
1415 res
= g_strdup_printf ("<0x%08x>", token
);
1422 if (method
->wrapper_type
)
1425 field
= mono_field_from_token (method
->klass
->image
, token
, &klass
, NULL
);
1426 desc
= mono_field_full_name (field
);
1427 res
= g_strdup_printf ("<%s>", desc
);
1431 res
= g_strdup_printf ("<0x%08x>", token
);
1441 * Produce a disassembled form of the IL instruction at IP. This is an extension
1442 * of mono_disasm_code_one () which can disasm tokens, handle wrapper methods, and
1443 * CEE_MONO_ opcodes.
1446 disasm_ins (MonoMethod
*method
, const guchar
*ip
, const guint8
**endip
)
1450 MonoMethodHeader
*header
= mono_method_get_header (method
);
1452 memset (&dh
, 0, sizeof (dh
));
1454 dh
.label_format
= "IL_%04x: ";
1455 dh
.label_target
= "IL_%04x";
1456 dh
.tokener
= token_handler
;
1458 token_handler_ip
= ip
;
1459 if (*ip
== MONO_CUSTOM_PREFIX
) {
1464 case CEE_MONO_ICALL
: {
1465 MonoJitICallInfo
*info
;
1467 token
= read32 (ip
+ 2);
1468 data
= mono_method_get_wrapper_data (method
, token
);
1469 info
= mono_find_jit_icall_by_addr (data
);
1472 dis
= g_strdup_printf ("IL_%04x: mono_icall <%s>", (int)(ip
- header
->code
), info
->name
);
1476 case CEE_MONO_CLASSCONST
: {
1477 token
= read32 (ip
+ 2);
1478 data
= mono_method_get_wrapper_data (method
, token
);
1480 dis
= g_strdup_printf ("IL_%04x: mono_classconst <%s>", (int)(ip
- header
->code
), ((MonoClass
*)data
)->name
);
1485 dis
= mono_disasm_code_one (&dh
, method
, ip
, &ip
);
1488 dis
= mono_disasm_code_one (&dh
, method
, ip
, &ip
);
1490 token_handler_ip
= NULL
;
1493 mono_metadata_free_mh (header
);
1498 il_offset_from_address (MonoMethod
*method
, MonoDebugMethodJitInfo
*jit
,
1499 guint32 native_offset
)
1503 if (!jit
->line_numbers
)
1506 for (i
= jit
->num_line_numbers
- 1; i
>= 0; i
--) {
1507 MonoDebugLineNumberEntry lne
= jit
->line_numbers
[i
];
1509 if (lne
.native_offset
<= native_offset
)
1510 return lne
.il_offset
;
1516 static int max_special_addr_diff
= 0;
1519 emit_advance_op (MonoDwarfWriter
*w
, int line_diff
, int addr_diff
)
1523 /* Use a special opcode if possible */
1524 if (line_diff
- LINE_BASE
>= 0 && line_diff
- LINE_BASE
< LINE_RANGE
) {
1525 if (max_special_addr_diff
== 0)
1526 max_special_addr_diff
= (255 - OPCODE_BASE
) / LINE_RANGE
;
1528 if (addr_diff
> max_special_addr_diff
&& (addr_diff
< 2 * max_special_addr_diff
)) {
1529 emit_byte (w
, DW_LNS_const_add_pc
);
1530 addr_diff
-= max_special_addr_diff
;
1533 opcode
= (line_diff
- LINE_BASE
) + (LINE_RANGE
* addr_diff
) + OPCODE_BASE
;
1539 emit_byte (w
, opcode
);
1541 //printf ("large: %d %d %d\n", line_diff, addr_diff, max_special_addr_diff);
1542 emit_byte (w
, DW_LNS_advance_line
);
1543 emit_sleb128 (w
, line_diff
);
1544 emit_byte (w
, DW_LNS_advance_pc
);
1545 emit_sleb128 (w
, addr_diff
);
1546 emit_byte (w
, DW_LNS_copy
);
1551 compare_lne (MonoDebugLineNumberEntry
*a
, MonoDebugLineNumberEntry
*b
)
1553 if (a
->native_offset
== b
->native_offset
)
1554 return a
->il_offset
- b
->il_offset
;
1556 return a
->native_offset
- b
->native_offset
;
1560 emit_line_number_info (MonoDwarfWriter
*w
, MonoMethod
*method
,
1561 char *start_symbol
, char *end_symbol
,
1562 guint8
*code
, guint32 code_size
,
1563 MonoDebugMethodJitInfo
*debug_info
)
1565 guint32 prev_line
= 0;
1566 guint32 prev_native_offset
= 0;
1567 int i
, file_index
, il_offset
, prev_il_offset
;
1568 gboolean first
= TRUE
;
1569 MonoDebugSourceLocation
*loc
;
1570 char *prev_file_name
= NULL
;
1571 MonoMethodHeader
*header
= mono_method_get_header (method
);
1572 MonoDebugMethodInfo
*minfo
;
1573 MonoDebugLineNumberEntry
*ln_array
;
1574 int *native_to_il_offset
= NULL
;
1576 if (!w
->emit_line
) {
1577 mono_metadata_free_mh (header
);
1581 minfo
= mono_debug_lookup_method (method
);
1583 /* Compute the native->IL offset mapping */
1585 g_assert (code_size
);
1587 ln_array
= g_new0 (MonoDebugLineNumberEntry
, debug_info
->num_line_numbers
);
1588 memcpy (ln_array
, debug_info
->line_numbers
, debug_info
->num_line_numbers
* sizeof (MonoDebugLineNumberEntry
));
1590 qsort (ln_array
, debug_info
->num_line_numbers
, sizeof (MonoDebugLineNumberEntry
), (gpointer
)compare_lne
);
1592 native_to_il_offset
= g_new0 (int, code_size
+ 1);
1594 for (i
= 0; i
< debug_info
->num_line_numbers
; ++i
) {
1596 MonoDebugLineNumberEntry
*lne
= &ln_array
[i
];
1599 for (j
= 0; j
< lne
->native_offset
; ++j
)
1600 native_to_il_offset
[j
] = -1;
1603 if (i
< debug_info
->num_line_numbers
- 1) {
1604 MonoDebugLineNumberEntry
*lne_next
= &ln_array
[i
+ 1];
1606 for (j
= lne
->native_offset
; j
< lne_next
->native_offset
; ++j
)
1607 native_to_il_offset
[j
] = lne
->il_offset
;
1609 for (j
= lne
->native_offset
; j
< code_size
; ++j
)
1610 native_to_il_offset
[j
] = lne
->il_offset
;
1616 prev_il_offset
= -1;
1618 w
->cur_file_index
= -1;
1619 for (i
= 0; i
< code_size
; ++i
) {
1620 int line_diff
, addr_diff
;
1625 if (!debug_info
->line_numbers
)
1628 if (native_to_il_offset
)
1629 il_offset
= native_to_il_offset
[i
];
1631 il_offset
= il_offset_from_address (method
, debug_info
, i
);
1633 il_offset = il_offset_from_address (method, debug_info, i);
1635 g_assert (il_offset == native_to_il_offset [i]);
1638 il_offset
= native_to_il_offset
[i
];
1642 if (il_offset
== prev_il_offset
)
1645 prev_il_offset
= il_offset
;
1647 loc
= mono_debug_symfile_lookup_location (minfo
, il_offset
);
1648 if (!(loc
&& loc
->source_file
))
1651 line_diff
= (gint32
)loc
->row
- (gint32
)prev_line
;
1652 addr_diff
= i
- prev_native_offset
;
1655 emit_section_change (w
, ".debug_line", LINE_SUBSECTION_DATA
);
1658 emit_byte (w
, sizeof (gpointer
) + 1);
1659 emit_byte (w
, DW_LNE_set_address
);
1661 emit_pointer_unaligned (w
, start_symbol
);
1663 emit_pointer_value (w
, code
);
1666 * The prolog+initlocals region does not have a line number, this
1667 * makes them belong to the first line of the method.
1669 emit_byte (w
, DW_LNS_advance_line
);
1670 //printf ("FIRST: %d %d %d\n", prev_line, loc->row, il_offset);
1671 emit_sleb128 (w
, (gint32
)loc
->row
- (gint32
)prev_line
);
1675 if (loc
->row
!= prev_line
) {
1676 if (!prev_file_name
|| strcmp (loc
->source_file
, prev_file_name
) != 0) {
1677 /* Add an entry to the file table */
1678 /* FIXME: Avoid duplicates */
1679 if (w
->collect_line_info
)
1680 file_index
= get_line_number_file_name (w
, loc
->source_file
) + 1;
1682 file_index
= emit_line_number_file_name (w
, loc
->source_file
, 0, 0);
1683 g_free (prev_file_name
);
1684 prev_file_name
= g_strdup (loc
->source_file
);
1686 if (w
->cur_file_index
!= file_index
) {
1687 emit_byte (w
, DW_LNS_set_file
);
1688 emit_uleb128 (w
, file_index
);
1689 emit_byte (w
, DW_LNS_copy
);
1690 w
->cur_file_index
= file_index
;
1695 if (loc
->row
!= prev_line
&& !first
) {
1696 //printf ("X: %p(+0x%x) %d %s:%d(+%d)\n", code + i, addr_diff, loc->il_offset, loc->source_file, loc->row, line_diff);
1697 emit_advance_op (w
, line_diff
, addr_diff
);
1699 prev_line
= loc
->row
;
1700 prev_native_offset
= i
;
1703 mono_debug_symfile_free_location (loc
);
1707 g_free (native_to_il_offset
);
1708 g_free (prev_file_name
);
1711 emit_byte (w
, DW_LNS_advance_pc
);
1712 emit_sleb128 (w
, code_size
- prev_native_offset
);
1713 emit_byte (w
, DW_LNS_copy
);
1717 emit_byte (w
, DW_LNE_end_sequence
);
1718 } else if (!start_symbol
) {
1719 /* No debug info, XDEBUG mode */
1721 const guint8
*ip
= header
->code
;
1722 int prev_line
, prev_native_offset
;
1726 * Emit the IL code into a temporary file and emit line number info
1727 * referencing that file.
1730 name
= mono_method_full_name (method
, TRUE
);
1731 fprintf (w
->il_file
, "// %s\n", name
);
1732 w
->il_file_line_index
++;
1735 il_to_line
= g_new0 (int, header
->code_size
);
1737 emit_section_change (w
, ".debug_line", LINE_SUBSECTION_DATA
);
1739 emit_byte (w
, sizeof (gpointer
) + 1);
1740 emit_byte (w
, DW_LNE_set_address
);
1741 emit_pointer_value (w
, code
);
1743 // FIXME: Optimize this
1744 while (ip
< header
->code
+ header
->code_size
) {
1745 int il_offset
= ip
- header
->code
;
1748 w
->il_file_line_index
++;
1750 dis
= disasm_ins (method
, ip
, &ip
);
1751 fprintf (w
->il_file
, "%s\n", dis
);
1754 il_to_line
[il_offset
] = w
->il_file_line_index
;
1757 /* Emit line number info */
1759 prev_native_offset
= 0;
1760 for (i
= 0; i
< debug_info
->num_line_numbers
; ++i
) {
1761 MonoDebugLineNumberEntry
*lne
= &debug_info
->line_numbers
[i
];
1764 if (lne
->il_offset
>= header
->code_size
)
1766 line
= il_to_line
[lne
->il_offset
];
1769 * This seems to happen randomly, it looks like il_offset points
1770 * into the middle of an instruction.
1774 printf ("%s\n", mono_method_full_name (method, TRUE));
1775 printf ("%d %d\n", lne->il_offset, header->code_size);
1780 if (line
- prev_line
!= 0) {
1781 emit_advance_op (w
, line
- prev_line
, (gint32
)lne
->native_offset
- prev_native_offset
);
1784 prev_native_offset
= lne
->native_offset
;
1788 emit_byte (w
, DW_LNS_advance_pc
);
1789 emit_sleb128 (w
, code_size
- prev_native_offset
);
1790 emit_byte (w
, DW_LNS_copy
);
1794 emit_byte (w
, DW_LNE_end_sequence
);
1796 fflush (w
->il_file
);
1797 g_free (il_to_line
);
1799 mono_metadata_free_mh (header
);
1802 static MonoMethodVar
*
1803 find_vmv (MonoCompile
*cfg
, MonoInst
*ins
)
1808 for (j
= 0; j
< cfg
->num_varinfo
; ++j
) {
1809 if (cfg
->varinfo
[j
] == ins
)
1813 if (j
< cfg
->num_varinfo
) {
1814 return MONO_VARINFO (cfg
, j
);
1822 mono_dwarf_writer_emit_method (MonoDwarfWriter
*w
, MonoCompile
*cfg
, MonoMethod
*method
, char *start_symbol
, char *end_symbol
, guint8
*code
, guint32 code_size
, MonoInst
**args
, MonoInst
**locals
, GSList
*unwind_info
, MonoDebugMethodJitInfo
*debug_info
)
1825 MonoMethodSignature
*sig
;
1826 MonoMethodHeader
*header
;
1828 MonoDebugLocalsInfo
*locals_info
;
1833 emit_section_change (w
, ".debug_info", 0);
1835 sig
= mono_method_signature (method
);
1836 header
= mono_method_get_header (method
);
1838 /* Parameter types */
1839 for (i
= 0; i
< sig
->param_count
+ sig
->hasthis
; ++i
) {
1842 if (i
== 0 && sig
->hasthis
) {
1843 if (method
->klass
->valuetype
)
1844 t
= &method
->klass
->this_arg
;
1846 t
= &method
->klass
->byval_arg
;
1848 t
= sig
->params
[i
- sig
->hasthis
];
1853 //emit_type (w, &mono_defaults.int32_class->byval_arg);
1856 for (i
= 0; i
< header
->num_locals
; ++i
) {
1857 emit_type (w
, header
->locals
[i
]);
1861 names
= g_new0 (char *, sig
->param_count
);
1862 mono_method_get_param_names (method
, (const char **) names
);
1864 emit_uleb128 (w
, ABBREV_SUBPROGRAM
);
1865 name
= mono_method_full_name (method
, FALSE
);
1866 emit_string (w
, name
);
1868 emit_string (w
, name
);
1872 emit_pointer_unaligned (w
, start_symbol
);
1873 emit_pointer_unaligned (w
, end_symbol
);
1875 emit_pointer_value (w
, code
);
1876 emit_pointer_value (w
, code
+ code_size
);
1880 emit_byte (w
, DW_OP_breg6
);
1884 for (i
= 0; i
< sig
->param_count
+ sig
->hasthis
; ++i
) {
1885 MonoInst
*arg
= args
? args
[i
] : NULL
;
1888 char pname_buf
[128];
1889 MonoMethodVar
*vmv
= NULL
;
1890 gboolean need_loclist
= FALSE
;
1892 vmv
= find_vmv (cfg
, arg
);
1893 if (code
&& vmv
&& (vmv
->live_range_start
|| vmv
->live_range_end
))
1894 need_loclist
= TRUE
;
1896 if (i
== 0 && sig
->hasthis
) {
1897 if (method
->klass
->valuetype
)
1898 t
= &method
->klass
->this_arg
;
1900 t
= &method
->klass
->byval_arg
;
1903 t
= sig
->params
[i
- sig
->hasthis
];
1904 pname
= names
[i
- sig
->hasthis
];
1907 emit_uleb128 (w
, need_loclist
? ABBREV_PARAM_LOCLIST
: ABBREV_PARAM
);
1909 if (pname
[0] == '\0') {
1910 sprintf (pname_buf
, "param%d", i
- sig
->hasthis
);
1913 emit_string (w
, pname
);
1915 if (!arg
|| arg
->flags
& MONO_INST_IS_DEAD
)
1916 emit_var_type (w
, &mono_defaults
.int32_class
->byval_arg
);
1918 emit_var_type (w
, t
);
1921 encode_var_location (w
, arg
, p
, &p
);
1923 vmv
->live_range_start
= 0;
1924 if (vmv
->live_range_end
== 0)
1925 /* FIXME: Uses made in calls are not recorded */
1926 vmv
->live_range_end
= code_size
;
1927 emit_loclist (w
, arg
, code
+ vmv
->live_range_start
, code
+ vmv
->live_range_end
, buf
, p
- buf
);
1929 emit_byte (w
, p
- buf
);
1930 emit_bytes (w
, buf
, p
- buf
);
1936 locals_info
= mono_debug_lookup_locals (method
);
1938 for (i
= 0; i
< header
->num_locals
; ++i
) {
1939 MonoInst
*ins
= locals
[i
];
1940 char name_buf
[128];
1942 MonoMethodVar
*vmv
= NULL
;
1943 gboolean need_loclist
= FALSE
;
1946 /* ins->dreg no longer contains the original vreg */
1947 vmv
= find_vmv (cfg
, ins
);
1949 if (vmv
->live_range_start
) {
1950 /* This variable has a precise live range */
1951 need_loclist
= TRUE
;
1955 emit_uleb128 (w
, need_loclist
? ABBREV_VARIABLE_LOCLIST
: ABBREV_VARIABLE
);
1959 for (j
= 0; j
< locals_info
->num_locals
; ++j
)
1960 if (locals_info
->locals
[j
].index
== i
)
1962 if (j
< locals_info
->num_locals
)
1963 lname
= locals_info
->locals
[j
].name
;
1966 emit_string (w
, lname
);
1968 sprintf (name_buf
, "V_%d", i
);
1969 emit_string (w
, name_buf
);
1972 if (!ins
|| ins
->flags
& MONO_INST_IS_DEAD
)
1973 emit_var_type (w
, &mono_defaults
.int32_class
->byval_arg
);
1975 emit_var_type (w
, header
->locals
[i
]);
1978 encode_var_location (w
, ins
, p
, &p
);
1981 if (vmv
->live_range_end
== 0)
1982 /* FIXME: Uses made in calls are not recorded */
1983 vmv
->live_range_end
= code_size
;
1984 emit_loclist (w
, ins
, code
+ vmv
->live_range_start
, code
+ vmv
->live_range_end
, buf
, p
- buf
);
1986 emit_byte (w
, p
- buf
);
1987 emit_bytes (w
, buf
, p
- buf
);
1992 mono_debug_symfile_free_locals (locals_info
);
1994 /* Subprogram end */
1995 emit_uleb128 (w
, 0x0);
1999 emit_debug_info_end (w
);
2001 /* Emit unwind info */
2003 emit_fde (w
, w
->fde_index
, start_symbol
, end_symbol
, code
, code_size
, unwind_info
, TRUE
);
2007 /* Emit line number info */
2008 /* != could happen when using --regression */
2009 if (debug_info
&& (debug_info
->code_start
== code
)) {
2010 if (w
->collect_line_info
) {
2011 MethodLineNumberInfo
*info
;
2013 /* Save the information needed to emit the line number info later at once */
2014 info
= g_new0 (MethodLineNumberInfo
, 1);
2015 info
->method
= method
;
2016 info
->start_symbol
= g_strdup (start_symbol
);
2017 info
->end_symbol
= g_strdup (end_symbol
);
2019 info
->code_size
= code_size
;
2020 w
->line_info
= g_slist_prepend (w
->line_info
, info
);
2022 emit_line_number_info (w
, method
, start_symbol
, end_symbol
, code
, code_size
, debug_info
);
2027 mono_metadata_free_mh (header
);
2031 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
)
2033 emit_section_change (w
, ".debug_info", 0);
2036 emit_uleb128 (w
, ABBREV_TRAMP_SUBPROGRAM
);
2037 emit_string (w
, tramp_name
);
2038 emit_pointer_value (w
, code
);
2039 emit_pointer_value (w
, code
+ code_size
);
2041 /* Subprogram end */
2042 emit_uleb128 (w
, 0x0);
2044 emit_debug_info_end (w
);
2046 /* Emit unwind info */
2047 emit_fde (w
, w
->fde_index
, start_symbol
, end_symbol
, code
, code_size
, unwind_info
, FALSE
);
2050 #endif /* End of: !defined(DISABLE_AOT) && !defined(DISABLE_JIT) */