?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2010-04-06 Rodrigo Kumpera <rkumpera@novell.com>
[mono.git] / mono / mini / dwarfwriter.c
blobb7fd550089d4ebe2299cfe4db614fe875b3d1c30
1 /*
2 * dwarfwriter.c: Creation of DWARF debug information
3 *
4 * Author:
5 * Zoltan Varga (vargaz@gmail.com)
6 *
7 * (C) 2008-2009 Novell, Inc.
8 */
9
10 #include "config.h"
11
12 #if !defined(DISABLE_AOT) && !defined(DISABLE_JIT)
13 #include "dwarfwriter.h"
14
15 #include <sys/types.h>
16 #include <ctype.h>
17 #include <string.h>
18 #ifdef HAVE_STDINT_H
19 #include <stdint.h>
20 #endif
21
22 #include <mono/metadata/mono-endian.h>
23 #include <mono/metadata/debug-mono-symfile.h>
24 #include <mono/utils/mono-compiler.h>
25
26 #ifndef HOST_WIN32
27 #include <mono/utils/freebsd-elf32.h>
28 #include <mono/utils/freebsd-elf64.h>
29 #endif
30
31 #include <mono/utils/freebsd-dwarf.h>
32
33 struct _MonoDwarfWriter
34 {
35 MonoImageWriter *w;
36 GHashTable *class_to_die, *class_to_vtype_die, *class_to_pointer_die;
37 GHashTable *class_to_reference_die;
38 int fde_index, tdie_index, line_number_file_index, line_number_dir_index;
39 GHashTable *file_to_index, *dir_to_index;
40 FILE *il_file;
41 int il_file_line_index, loclist_index;
42 GSList *cie_program;
43 FILE *fp;
44 const char *temp_prefix;
45 gboolean emit_line, appending;
46 };
47
48 /*
49 * mono_dwarf_writer_create:
50 *
51 * Create a DWARF writer object. WRITER is the underlying image writer this
52 * writer will emit to. IL_FILE is the file where IL code will be dumped to for
53 * methods which have no line number info. It can be NULL.
54 * If APPENDING is TRUE, the output file will be in assembleable state after each
55 * call to the _emit_ functions. This is used for XDEBUG. If APPENDING is FALSE,
56 * a separate mono_dwarf_writer_close () call is needed to finish the emission of
57 * debug information.
58 */
59 MonoDwarfWriter*
60 mono_dwarf_writer_create (MonoImageWriter *writer, FILE *il_file, int il_file_start_line, gboolean appending)
61 {
62 MonoDwarfWriter *w = g_new0 (MonoDwarfWriter, 1);
63
64 /*
65 * The appending flag is needed because we use subsections to order things in
66 * the debug info, and:
67 * - apple's assembler doesn't support them
68 * - the binary writer has problems with subsections+alignment
69 * So instead of subsections, we use the _close () function in AOT mode,
70 * which writes out things in order.
71 */
72
73 w->w = writer;
74 w->il_file = il_file;
75 w->il_file_line_index = il_file_start_line;
76 w->appending = appending;
77
78 if (appending)
79 g_assert (img_writer_subsections_supported (w->w));
80
81 w->fp = img_writer_get_fp (w->w);
82 w->temp_prefix = img_writer_get_temp_label_prefix (w->w);
83
84 return w;
85 }
86
87 void
88 mono_dwarf_writer_destroy (MonoDwarfWriter *w)
89 {
90 g_free (w);
91 }
92
93 int
94 mono_dwarf_writer_get_il_file_line_index (MonoDwarfWriter *w)
95 {
96 return w->il_file_line_index;
97 }
98
99 /* Wrappers around the image writer functions */
100
101 static inline void
102 emit_section_change (MonoDwarfWriter *w, const char *section_name, int subsection_index)
103 {
104 img_writer_emit_section_change (w->w, section_name, subsection_index);
105 }
106
107 static inline void
108 emit_push_section (MonoDwarfWriter *w, const char *section_name, int subsection)
109 {
110 img_writer_emit_push_section (w->w, section_name, subsection);
111 }
112
113 static inline void
114 emit_pop_section (MonoDwarfWriter *w)
115 {
116 img_writer_emit_pop_section (w->w);
117 }
118
119 static inline void
120 emit_local_symbol (MonoDwarfWriter *w, const char *name, const char *end_label, gboolean func)
121 {
122 img_writer_emit_local_symbol (w->w, name, end_label, func);
123 }
124
125 static inline void
126 emit_label (MonoDwarfWriter *w, const char *name)
127 {
128 img_writer_emit_label (w->w, name);
129 }
130
131 static inline void
132 emit_bytes (MonoDwarfWriter *w, const guint8* buf, int size)
133 {
134 img_writer_emit_bytes (w->w, buf, size);
135 }
136
137 static inline void
138 emit_string (MonoDwarfWriter *w, const char *value)
139 {
140 img_writer_emit_string (w->w, value);
141 }
142
143 static inline void
144 emit_line (MonoDwarfWriter *w)
145 {
146 img_writer_emit_line (w->w);
147 }
148
149 static inline void
150 emit_alignment (MonoDwarfWriter *w, int size)
151 {
152 img_writer_emit_alignment (w->w, size);
153 }
154
155 static inline void
156 emit_pointer_unaligned (MonoDwarfWriter *w, const char *target)
157 {
158 img_writer_emit_pointer_unaligned (w->w, target);
159 }
160
161 static inline void
162 emit_pointer (MonoDwarfWriter *w, const char *target)
163 {
164 img_writer_emit_pointer (w->w, target);
165 }
166
167 static inline void
168 emit_int16 (MonoDwarfWriter *w, int value)
169 {
170 img_writer_emit_int16 (w->w, value);
171 }
172
173 static inline void
174 emit_int32 (MonoDwarfWriter *w, int value)
175 {
176 img_writer_emit_int32 (w->w, value);
177 }
178
179 static inline void
180 emit_symbol_diff (MonoDwarfWriter *w, const char *end, const char* start, int offset)
181 {
182 img_writer_emit_symbol_diff (w->w, end, start, offset);
183 }
184
185 static inline void
186 emit_zero_bytes (MonoDwarfWriter *w, int num)
187 {
188 img_writer_emit_zero_bytes (w->w, num);
189 }
190
191 static inline void
192 emit_byte (MonoDwarfWriter *w, guint8 val)
193 {
194 img_writer_emit_byte (w->w, val);
195 }
196
197 static G_GNUC_UNUSED void
198 emit_uleb128 (MonoDwarfWriter *w, guint32 value)
199 {
200 do {
201 guint8 b = value & 0x7f;
202 value >>= 7;
203 if (value != 0) /* more bytes to come */
204 b |= 0x80;
205 emit_byte (w, b);
206 } while (value);
207 }
208
209 static G_GNUC_UNUSED void
210 emit_sleb128 (MonoDwarfWriter *w, gint64 value)
211 {
212 gboolean more = 1;
213 gboolean negative = (value < 0);
214 guint32 size = 64;
215 guint8 byte;
216
217 while (more) {
218 byte = value & 0x7f;
219 value >>= 7;
220 /* the following is unnecessary if the
221 * implementation of >>= uses an arithmetic rather
222 * than logical shift for a signed left operand
223 */
224 if (negative)
225 /* sign extend */
226 value |= - ((gint64)1 <<(size - 7));
227 /* sign bit of byte is second high order bit (0x40) */
228 if ((value == 0 && !(byte & 0x40)) ||
229 (value == -1 && (byte & 0x40)))
230 more = 0;
231 else
232 byte |= 0x80;
233 emit_byte (w, byte);
234 }
235 }
236
237 static G_GNUC_UNUSED void
238 encode_uleb128 (guint32 value, guint8 *buf, guint8 **endbuf)
239 {
240 guint8 *p = buf;
241
242 do {
243 guint8 b = value & 0x7f;
244 value >>= 7;
245 if (value != 0) /* more bytes to come */
246 b |= 0x80;
247 *p ++ = b;
248 } while (value);
249
250 *endbuf = p;
251 }
252
253 static G_GNUC_UNUSED void
254 encode_sleb128 (gint32 value, guint8 *buf, guint8 **endbuf)
255 {
256 gboolean more = 1;
257 gboolean negative = (value < 0);
258 guint32 size = 32;
259 guint8 byte;
260 guint8 *p = buf;
261
262 while (more) {
263 byte = value & 0x7f;
264 value >>= 7;
265 /* the following is unnecessary if the
266 * implementation of >>= uses an arithmetic rather
267 * than logical shift for a signed left operand
268 */
269 if (negative)
270 /* sign extend */
271 value |= - (1 <<(size - 7));
272 /* sign bit of byte is second high order bit (0x40) */
273 if ((value == 0 && !(byte & 0x40)) ||
274 (value == -1 && (byte & 0x40)))
275 more = 0;
276 else
277 byte |= 0x80;
278 *p ++= byte;
279 }
280
281 *endbuf = p;
282 }
283
284 static void
285 emit_dwarf_abbrev (MonoDwarfWriter *w, int code, int tag, gboolean has_child,
286 int *attrs, int attrs_len)
287 {
288 int i;
289
290 emit_uleb128 (w, code);
291 emit_uleb128 (w, tag);
292 emit_byte (w, has_child);
293
294 for (i = 0; i < attrs_len; i++)
295 emit_uleb128 (w, attrs [i]);
296 emit_uleb128 (w, 0);
297 emit_uleb128 (w, 0);
298 }
299
300 static void
301 emit_cie (MonoDwarfWriter *w)
302 {
303 emit_section_change (w, ".debug_frame", 0);
304
305 emit_alignment (w, 8);
306
307 /* Emit a CIE */
308 emit_symbol_diff (w, ".Lcie0_end", ".Lcie0_start", 0); /* length */
309 emit_label (w, ".Lcie0_start");
310 emit_int32 (w, 0xffffffff); /* CIE id */
311 emit_byte (w, 3); /* version */
312 emit_string (w, ""); /* augmention */
313 emit_sleb128 (w, 1); /* code alignment factor */
314 emit_sleb128 (w, mono_unwind_get_dwarf_data_align ()); /* data alignment factor */
315 emit_uleb128 (w, mono_unwind_get_dwarf_pc_reg ());
316
317 w->cie_program = w->cie_program;
318 if (w->cie_program) {
319 guint32 uw_info_len;
320 guint8 *uw_info = mono_unwind_ops_encode (w->cie_program, &uw_info_len);
321 emit_bytes (w, uw_info, uw_info_len);
322 g_free (uw_info);
323 }
324
325 emit_alignment (w, sizeof (gpointer));
326 emit_label (w, ".Lcie0_end");
327 }
328
329 static void
330 emit_pointer_value (MonoDwarfWriter *w, gpointer ptr)
331 {
332 gssize val = (gssize)ptr;
333 emit_bytes (w, (guint8*)&val, sizeof (gpointer));
334 }
335
336 static void
337 emit_fde (MonoDwarfWriter *w, int fde_index, char *start_symbol, char *end_symbol,
338 guint8 *code, guint32 code_size, GSList *unwind_ops, gboolean use_cie)
339 {
340 char symbol1 [128];
341 char symbol2 [128];
342 GSList *l;
343 guint8 *uw_info;
344 guint32 uw_info_len;
345
346 emit_section_change (w, ".debug_frame", 0);
347
348 sprintf (symbol1, ".Lfde%d_start", fde_index);
349 sprintf (symbol2, ".Lfde%d_end", fde_index);
350 emit_symbol_diff (w, symbol2, symbol1, 0); /* length */
351 emit_label (w, symbol1);
352 emit_int32 (w, 0); /* CIE_pointer */
353 if (start_symbol) {
354 emit_pointer (w, start_symbol); /* initial_location */
355 if (end_symbol)
356 emit_symbol_diff (w, end_symbol, start_symbol, 0); /* address_range */
357 else {
358 g_assert (code_size);
359 emit_int32 (w, code_size);
360 }
361 } else {
362 emit_pointer_value (w, code);
363 emit_int32 (w, code_size);
364 }
365 #if SIZEOF_VOID_P == 8
366 /* Upper 32 bits of code size */
367 emit_int32 (w, 0);
368 #endif
369
370 l = unwind_ops;
371 if (w->cie_program) {
372 // FIXME: Check that the ops really begin with the CIE program */
373 int i;
374
375 for (i = 0; i < g_slist_length (w->cie_program); ++i)
376 l = l->next;
377 }
378
379 /* Convert the list of MonoUnwindOps to the format used by DWARF */
380 uw_info = mono_unwind_ops_encode (l, &uw_info_len);
381 emit_bytes (w, uw_info, uw_info_len);
382 g_free (uw_info);
383
384 emit_alignment (w, sizeof (mgreg_t));
385 emit_label (w, symbol2);
386 }
387
388 /* Abbrevations */
389 #define ABBREV_COMPILE_UNIT 1
390 #define ABBREV_SUBPROGRAM 2
391 #define ABBREV_PARAM 3
392 #define ABBREV_BASE_TYPE 4
393 #define ABBREV_STRUCT_TYPE 5
394 #define ABBREV_DATA_MEMBER 6
395 #define ABBREV_TYPEDEF 7
396 #define ABBREV_ENUM_TYPE 8
397 #define ABBREV_ENUMERATOR 9
398 #define ABBREV_NAMESPACE 10
399 #define ABBREV_VARIABLE 11
400 #define ABBREV_VARIABLE_LOCLIST 12
401 #define ABBREV_POINTER_TYPE 13
402 #define ABBREV_REFERENCE_TYPE 14
403 #define ABBREV_PARAM_LOCLIST 15
404 #define ABBREV_INHERITANCE 16
405 #define ABBREV_STRUCT_TYPE_NOCHILDREN 17
406
407 static int compile_unit_attr [] = {
408 DW_AT_producer ,DW_FORM_string,
409 DW_AT_name ,DW_FORM_string,
410 DW_AT_comp_dir ,DW_FORM_string,
411 DW_AT_language ,DW_FORM_data1,
412 DW_AT_low_pc ,DW_FORM_addr,
413 DW_AT_high_pc ,DW_FORM_addr,
414 DW_AT_stmt_list ,DW_FORM_data4
415 };
416
417 static int subprogram_attr [] = {
418 DW_AT_name , DW_FORM_string,
419 DW_AT_low_pc , DW_FORM_addr,
420 DW_AT_high_pc , DW_FORM_addr,
421 DW_AT_frame_base , DW_FORM_block1
422 };
423
424 static int param_attr [] = {
425 DW_AT_name, DW_FORM_string,
426 DW_AT_type, DW_FORM_ref4,
427 DW_AT_location, DW_FORM_block1
428 };
429
430 static int param_loclist_attr [] = {
431 DW_AT_name, DW_FORM_string,
432 DW_AT_type, DW_FORM_ref4,
433 DW_AT_location, DW_FORM_data4
434 };
435
436 static int base_type_attr [] = {
437 DW_AT_byte_size, DW_FORM_data1,
438 DW_AT_encoding, DW_FORM_data1,
439 DW_AT_name, DW_FORM_string
440 };
441
442 static int struct_type_attr [] = {
443 DW_AT_name, DW_FORM_string,
444 DW_AT_byte_size, DW_FORM_udata,
445 };
446
447 static int data_member_attr [] = {
448 DW_AT_name, DW_FORM_string,
449 DW_AT_type, DW_FORM_ref4,
450 DW_AT_data_member_location, DW_FORM_block1
451 };
452
453 static int typedef_attr [] = {
454 DW_AT_name, DW_FORM_string,
455 DW_AT_type, DW_FORM_ref4
456 };
457
458 static int pointer_type_attr [] = {
459 DW_AT_type, DW_FORM_ref4,
460 };
461
462 static int reference_type_attr [] = {
463 DW_AT_type, DW_FORM_ref4,
464 };
465
466 static int enum_type_attr [] = {
467 DW_AT_name, DW_FORM_string,
468 DW_AT_byte_size, DW_FORM_udata,
469 DW_AT_type, DW_FORM_ref4,
470 };
471
472 static int enumerator_attr [] = {
473 DW_AT_name, DW_FORM_string,
474 DW_AT_const_value, DW_FORM_sdata,
475 };
476
477 static int namespace_attr [] = {
478 DW_AT_name, DW_FORM_string,
479 };
480
481 static int variable_attr [] = {
482 DW_AT_name, DW_FORM_string,
483 DW_AT_type, DW_FORM_ref4,
484 DW_AT_location, DW_FORM_block1
485 };
486
487 static int variable_loclist_attr [] = {
488 DW_AT_name, DW_FORM_string,
489 DW_AT_type, DW_FORM_ref4,
490 DW_AT_location, DW_FORM_data4
491 };
492
493 static int inheritance_attr [] = {
494 DW_AT_type, DW_FORM_ref4,
495 DW_AT_data_member_location, DW_FORM_block1
496 };
497
498 typedef struct DwarfBasicType {
499 const char *die_name, *name;
500 int type;
501 int size;
502 int encoding;
503 } DwarfBasicType;
504
505 static DwarfBasicType basic_types [] = {
506 { ".LDIE_I1", "sbyte", MONO_TYPE_I1, 1, DW_ATE_signed },
507 { ".LDIE_U1", "byte", MONO_TYPE_U1, 1, DW_ATE_unsigned },
508 { ".LDIE_I2", "short", MONO_TYPE_I2, 2, DW_ATE_signed },
509 { ".LDIE_U2", "ushort", MONO_TYPE_U2, 2, DW_ATE_unsigned },
510 { ".LDIE_I4", "int", MONO_TYPE_I4, 4, DW_ATE_signed },
511 { ".LDIE_U4", "uint", MONO_TYPE_U4, 4, DW_ATE_unsigned },
512 { ".LDIE_I8", "long", MONO_TYPE_I8, 8, DW_ATE_signed },
513 { ".LDIE_U8", "ulong", MONO_TYPE_U8, 8, DW_ATE_unsigned },
514 { ".LDIE_I", "intptr", MONO_TYPE_I, SIZEOF_VOID_P, DW_ATE_signed },
515 { ".LDIE_U", "uintptr", MONO_TYPE_U, SIZEOF_VOID_P, DW_ATE_unsigned },
516 { ".LDIE_R4", "float", MONO_TYPE_R4, 4, DW_ATE_float },
517 { ".LDIE_R8", "double", MONO_TYPE_R8, 8, DW_ATE_float },
518 { ".LDIE_BOOLEAN", "boolean", MONO_TYPE_BOOLEAN, 1, DW_ATE_boolean },
519 { ".LDIE_CHAR", "char", MONO_TYPE_CHAR, 2, DW_ATE_unsigned_char },
520 { ".LDIE_STRING", "string", MONO_TYPE_STRING, sizeof (gpointer), DW_ATE_address },
521 { ".LDIE_OBJECT", "object", MONO_TYPE_OBJECT, sizeof (gpointer), DW_ATE_address },
522 { ".LDIE_SZARRAY", "object", MONO_TYPE_SZARRAY, sizeof (gpointer), DW_ATE_address },
523 };
524
525 /* Constants for encoding line number special opcodes */
526 #define OPCODE_BASE 13
527 #define LINE_BASE -5
528 #define LINE_RANGE 14
529
530 /* Subsections of the .debug_line section */
531 #define LINE_SUBSECTION_HEADER 1
532 #define LINE_SUBSECTION_INCLUDES 2
533 #define LINE_SUBSECTION_FILES 3
534 #define LINE_SUBSECTION_DATA 4
535 #define LINE_SUBSECTION_END 5
536
537 static int
538 emit_line_number_file_name (MonoDwarfWriter *w, const char *name,
539 gint64 last_mod_time, gint64 file_size)
540 {
541 int index;
542 int dir_index;
543 char *basename = NULL;
544
545 if (!w->file_to_index)
546 w->file_to_index = g_hash_table_new (g_str_hash, g_str_equal);
547
548 index = GPOINTER_TO_UINT (g_hash_table_lookup (w->file_to_index, name));
549 if (index > 0)
550 return index;
551
552 if (g_path_is_absolute (name)) {
553 char *dir = g_path_get_dirname (name);
554
555 if (!w->dir_to_index)
556 w->dir_to_index = g_hash_table_new (g_str_hash, g_str_equal);
557
558 dir_index = GPOINTER_TO_UINT (g_hash_table_lookup (w->dir_to_index, dir));
559 if (dir_index == 0) {
560 emit_section_change (w, ".debug_line", LINE_SUBSECTION_INCLUDES);
561 emit_string (w, dir);
562
563 dir_index = ++ w->line_number_dir_index;
564 g_hash_table_insert (w->dir_to_index, g_strdup (dir), GUINT_TO_POINTER (dir_index));
565 }
566
567 g_free (dir);
568
569 basename = g_path_get_basename (name);
570 } else {
571 dir_index = 0;
572 }
573
574 emit_section_change (w, ".debug_line", LINE_SUBSECTION_FILES);
575
576 if (basename)
577 emit_string (w, basename);
578 else
579 emit_string (w, name);
580 emit_uleb128 (w, dir_index);
581 emit_byte (w, 0);
582 emit_byte (w, 0);
583
584 emit_section_change (w, ".debug_line", LINE_SUBSECTION_DATA);
585
586 if (basename)
587 g_free (basename);
588
589 index = ++ w->line_number_file_index;
590 g_hash_table_insert (w->file_to_index, g_strdup (name), GUINT_TO_POINTER (index));
591
592 return index;
593 }
594
595 static void
596 emit_line_number_info_begin (MonoDwarfWriter *w)
597 {
598 /* Line number info header */
599 /*
600 * GAS seems to emit its own data to the end of the first subsection, so we use
601 * subsections 1, 2 etc:
602 * 1 - contains the header
603 * 2 - contains the file names
604 * 3 - contains the end of the header + the data
605 * 4 - the end symbol
606 */
607 emit_section_change (w, ".debug_line", 0);
608 emit_label (w, ".Ldebug_line_section_start");
609 emit_section_change (w, ".debug_line", LINE_SUBSECTION_HEADER);
610 emit_label (w, ".Ldebug_line_start");
611 emit_symbol_diff (w, ".Ldebug_line_end", ".", -4); /* length */
612 emit_int16 (w, 0x2); /* version */
613 emit_symbol_diff (w, ".Ldebug_line_header_end", ".", -4); /* header_length */
614 emit_byte (w, 1); /* minimum_instruction_length */
615 emit_byte (w, 1); /* default_is_stmt */
616 emit_byte (w, LINE_BASE); /* line_base */
617 emit_byte (w, LINE_RANGE); /* line_range */
618 emit_byte (w, OPCODE_BASE); /* opcode_base */
619 emit_byte (w, 0); /* standard_opcode_lengths */
620 emit_byte (w, 1);
621 emit_byte (w, 1);
622 emit_byte (w, 1);
623 emit_byte (w, 1);
624 emit_byte (w, 0);
625 emit_byte (w, 0);
626 emit_byte (w, 0);
627 emit_byte (w, 1);
628 emit_byte (w, 0);
629 emit_byte (w, 0);
630 emit_byte (w, 1);
631
632 /* Includes */
633 emit_section_change (w, ".debug_line", LINE_SUBSECTION_INCLUDES);
634
635 /* End of Includes */
636 emit_section_change (w, ".debug_line", LINE_SUBSECTION_FILES);
637 emit_byte (w, 0);
638
639 /* Files */
640 emit_line_number_file_name (w, "xdb.il", 0, 0);
641
642 /* End of Files */
643 emit_section_change (w, ".debug_line", LINE_SUBSECTION_DATA);
644 emit_byte (w, 0);
645
646 emit_label (w, ".Ldebug_line_header_end");
647
648 /* Emit this into a separate subsection so it gets placed at the end */
649 emit_section_change (w, ".debug_line", LINE_SUBSECTION_END);
650
651 emit_byte (w, 0);
652 emit_byte (w, 1);
653 emit_byte (w, DW_LNE_end_sequence);
654
655 emit_label (w, ".Ldebug_line_end");
656 }
657
658 /*
659 * Some assemblers like apple's do not support subsections, so we can't place
660 * .Ldebug_info_end at the end of the section using subsections. Instead, we
661 * define it every time something gets added to the .debug_info section.
662 * The apple assember seems to use the last definition.
663 */
664 static void
665 emit_debug_info_end (MonoDwarfWriter *w)
666 {
667 /* This doesn't seem to work/required with recent iphone sdk versions */
668 #if 0
669 if (!img_writer_subsections_supported (w->w))
670 fprintf (w->fp, "\n.set %sdebug_info_end,.\n", w->temp_prefix);
671 #endif
672 }
673
674 void
675 mono_dwarf_writer_emit_base_info (MonoDwarfWriter *w, GSList *base_unwind_program)
676 {
677 char *s, *build_info;
678 int i;
679
680 if (!img_writer_subsections_supported (w->w))
681 /* Can't emit line number info without subsections */
682 w->emit_line = FALSE;
683 else
684 w->emit_line = TRUE;
685
686 w->cie_program = base_unwind_program;
687
688 emit_section_change (w, ".debug_abbrev", 0);
689 emit_dwarf_abbrev (w, ABBREV_COMPILE_UNIT, DW_TAG_compile_unit, TRUE,
690 compile_unit_attr, G_N_ELEMENTS (compile_unit_attr));
691 emit_dwarf_abbrev (w, ABBREV_SUBPROGRAM, DW_TAG_subprogram, TRUE,
692 subprogram_attr, G_N_ELEMENTS (subprogram_attr));
693 emit_dwarf_abbrev (w, ABBREV_PARAM, DW_TAG_formal_parameter, FALSE,
694 param_attr, G_N_ELEMENTS (param_attr));
695 emit_dwarf_abbrev (w, ABBREV_PARAM_LOCLIST, DW_TAG_formal_parameter, FALSE,
696 param_loclist_attr, G_N_ELEMENTS (param_loclist_attr));
697 emit_dwarf_abbrev (w, ABBREV_BASE_TYPE, DW_TAG_base_type, FALSE,
698 base_type_attr, G_N_ELEMENTS (base_type_attr));
699 emit_dwarf_abbrev (w, ABBREV_STRUCT_TYPE, DW_TAG_class_type, TRUE,
700 struct_type_attr, G_N_ELEMENTS (struct_type_attr));
701 emit_dwarf_abbrev (w, ABBREV_STRUCT_TYPE_NOCHILDREN, DW_TAG_class_type, FALSE,
702 struct_type_attr, G_N_ELEMENTS (struct_type_attr));
703 emit_dwarf_abbrev (w, ABBREV_DATA_MEMBER, DW_TAG_member, FALSE,
704 data_member_attr, G_N_ELEMENTS (data_member_attr));
705 emit_dwarf_abbrev (w, ABBREV_TYPEDEF, DW_TAG_typedef, FALSE,
706 typedef_attr, G_N_ELEMENTS (typedef_attr));
707 emit_dwarf_abbrev (w, ABBREV_ENUM_TYPE, DW_TAG_enumeration_type, TRUE,
708 enum_type_attr, G_N_ELEMENTS (enum_type_attr));
709 emit_dwarf_abbrev (w, ABBREV_ENUMERATOR, DW_TAG_enumerator, FALSE,
710 enumerator_attr, G_N_ELEMENTS (enumerator_attr));
711 emit_dwarf_abbrev (w, ABBREV_NAMESPACE, DW_TAG_namespace, TRUE,
712 namespace_attr, G_N_ELEMENTS (namespace_attr));
713 emit_dwarf_abbrev (w, ABBREV_VARIABLE, DW_TAG_variable, FALSE,
714 variable_attr, G_N_ELEMENTS (variable_attr));
715 emit_dwarf_abbrev (w, ABBREV_VARIABLE_LOCLIST, DW_TAG_variable, FALSE,
716 variable_loclist_attr, G_N_ELEMENTS (variable_loclist_attr));
717 emit_dwarf_abbrev (w, ABBREV_POINTER_TYPE, DW_TAG_pointer_type, FALSE,
718 pointer_type_attr, G_N_ELEMENTS (pointer_type_attr));
719 emit_dwarf_abbrev (w, ABBREV_REFERENCE_TYPE, DW_TAG_reference_type, FALSE,
720 reference_type_attr, G_N_ELEMENTS (reference_type_attr));
721 emit_dwarf_abbrev (w, ABBREV_INHERITANCE, DW_TAG_inheritance, FALSE,
722 inheritance_attr, G_N_ELEMENTS (inheritance_attr));
723 emit_byte (w, 0);
724
725 emit_section_change (w, ".debug_info", 0);
726 emit_label (w, ".Ldebug_info_start");
727 emit_symbol_diff (w, ".Ldebug_info_end", ".Ldebug_info_begin", 0); /* length */
728 emit_label (w, ".Ldebug_info_begin");
729 emit_int16 (w, 0x2); /* DWARF version 2 */
730 emit_int32 (w, 0); /* .debug_abbrev offset */
731 emit_byte (w, sizeof (gpointer)); /* address size */
732
733 if (img_writer_subsections_supported (w->w) && w->appending) {
734 /* Emit this into a separate section so it gets placed at the end */
735 emit_section_change (w, ".debug_info", 1);
736 emit_byte (w, 0); /* close COMPILE_UNIT */
737 emit_label (w, ".Ldebug_info_end");
738 emit_section_change (w, ".debug_info", 0);
739 }
740
741 /* Compilation unit */
742 emit_uleb128 (w, ABBREV_COMPILE_UNIT);
743 build_info = mono_get_runtime_build_info ();
744 s = g_strdup_printf ("Mono AOT Compiler %s", build_info);
745 emit_string (w, s);
746 g_free (build_info);
747 g_free (s);
748 emit_string (w, "JITted code");
749 emit_string (w, "");
750 emit_byte (w, DW_LANG_C);
751 emit_pointer_value (w, 0);
752 emit_pointer_value (w, 0);
753 /* offset into .debug_line section */
754 emit_symbol_diff (w, ".Ldebug_line_start", ".Ldebug_line_section_start", 0);
755
756 /* Base types */
757 for (i = 0; i < G_N_ELEMENTS (basic_types); ++i) {
758 emit_label (w, basic_types [i].die_name);
759 emit_uleb128 (w, ABBREV_BASE_TYPE);
760 emit_byte (w, basic_types [i].size);
761 emit_byte (w, basic_types [i].encoding);
762 emit_string (w, basic_types [i].name);
763 }
764
765 emit_debug_info_end (w);
766
767 /* debug_loc section */
768 emit_section_change (w, ".debug_loc", 0);
769 emit_label (w, ".Ldebug_loc_start");
770
771 /* debug_line section */
772 /*
773 * We emit some info even if emit_line is FALSE, as the
774 * apple linker seems to require a .debug_line section.
775 */
776 emit_line_number_info_begin (w);
777
778 emit_cie (w);
779 }
780
781 /*
782 * mono_dwarf_writer_close:
783 *
784 * Finalize the emitted debugging info.
785 */
786 void
787 mono_dwarf_writer_close (MonoDwarfWriter *w)
788 {
789 if (!w->appending) {
790 emit_section_change (w, ".debug_info", 0);
791 emit_byte (w, 0); /* close COMPILE_UNIT */
792 emit_label (w, ".Ldebug_info_end");
793 }
794 }
795
796 static const char* emit_type (MonoDwarfWriter *w, MonoType *t);
797
798 /* Returns the local symbol pointing to the emitted debug info */
799 static char*
800 emit_class_dwarf_info (MonoDwarfWriter *w, MonoClass *klass, gboolean vtype)
801 {
802 char *die, *pointer_die, *reference_die;
803 char *full_name, *p;
804 gpointer iter;
805 MonoClassField *field;
806 const char *fdie;
807 int k;
808 gboolean emit_namespace = FALSE, has_children;
809 GHashTable *cache;
810
811 // FIXME: Appdomains
812 if (!w->class_to_die)
813 w->class_to_die = g_hash_table_new (NULL, NULL);
814 if (!w->class_to_vtype_die)
815 w->class_to_vtype_die = g_hash_table_new (NULL, NULL);
816 if (!w->class_to_pointer_die)
817 w->class_to_pointer_die = g_hash_table_new (NULL, NULL);
818 if (!w->class_to_reference_die)
819 w->class_to_reference_die = g_hash_table_new (NULL, NULL);
820
821 if (vtype)
822 cache = w->class_to_vtype_die;
823 else
824 cache = w->class_to_die;
825
826 die = g_hash_table_lookup (cache, klass);
827 if (die)
828 return die;
829
830 if (!((klass->byval_arg.type == MONO_TYPE_CLASS) || (klass->byval_arg.type == MONO_TYPE_OBJECT) || klass->byval_arg.type == MONO_TYPE_GENERICINST || klass->enumtype || (klass->byval_arg.type == MONO_TYPE_VALUETYPE && vtype)))
831 return NULL;
832
833 /*
834 * FIXME: gdb can't handle namespaces in languages it doesn't know about.
835 */
836 /*
837 if (klass->name_space && klass->name_space [0] != '\0')
838 emit_namespace = TRUE;
839 */
840 if (emit_namespace) {
841 emit_uleb128 (w, ABBREV_NAMESPACE);
842 emit_string (w, klass->name_space);
843 }
844
845 full_name = g_strdup_printf ("%s%s%s", klass->name_space, klass->name_space ? "." : "", klass->name);
846 /*
847 * gdb doesn't support namespaces for non-C++ dwarf objects, so use _
848 * to separate components.
849 */
850 for (p = full_name; *p; p ++)
851 if (*p == '.')
852 *p = '_';
853
854 die = g_strdup_printf (".LTDIE_%d", w->tdie_index);
855 pointer_die = g_strdup_printf (".LTDIE_%d_POINTER", w->tdie_index);
856 reference_die = g_strdup_printf (".LTDIE_%d_REFERENCE", w->tdie_index);
857 w->tdie_index ++;
858
859 g_hash_table_insert (w->class_to_pointer_die, klass, pointer_die);
860 g_hash_table_insert (w->class_to_reference_die, klass, reference_die);
861 g_hash_table_insert (cache, klass, die);
862
863 if (klass->enumtype) {
864 int size = mono_class_value_size (mono_class_from_mono_type (mono_class_enum_basetype (klass)), NULL);
865
866 emit_label (w, die);
867
868 emit_uleb128 (w, ABBREV_ENUM_TYPE);
869 emit_string (w, full_name);
870 emit_uleb128 (w, size);
871 for (k = 0; k < G_N_ELEMENTS (basic_types); ++k)
872 if (basic_types [k].type == mono_class_enum_basetype (klass)->type)
873 break;
874 g_assert (k < G_N_ELEMENTS (basic_types));
875 emit_symbol_diff (w, basic_types [k].die_name, ".Ldebug_info_start", 0);
876
877 /* Emit enum values */
878 iter = NULL;
879 while ((field = mono_class_get_fields (klass, &iter))) {
880 const char *p;
881 int len;
882 MonoTypeEnum def_type;
883
884 if (strcmp ("value__", mono_field_get_name (field)) == 0)
885 continue;
886 if (mono_field_is_deleted (field))
887 continue;
888
889 emit_uleb128 (w, ABBREV_ENUMERATOR);
890 emit_string (w, mono_field_get_name (field));
891
892 p = mono_class_get_field_default_value (field, &def_type);
893 len = mono_metadata_decode_blob_size (p, &p);
894 switch (mono_class_enum_basetype (klass)->type) {
895 case MONO_TYPE_U1:
896 case MONO_TYPE_I1:
897 case MONO_TYPE_BOOLEAN:
898 emit_sleb128 (w, *p);
899 break;
900 case MONO_TYPE_U2:
901 case MONO_TYPE_I2:
902 case MONO_TYPE_CHAR:
903 emit_sleb128 (w, read16 (p));
904 break;
905 case MONO_TYPE_U4:
906 case MONO_TYPE_I4:
907 emit_sleb128 (w, read32 (p));
908 break;
909 case MONO_TYPE_U8:
910 case MONO_TYPE_I8:
911 emit_sleb128 (w, read64 (p));
912 break;
913 case MONO_TYPE_I:
914 case MONO_TYPE_U:
915 #if SIZEOF_VOID_P == 8
916 emit_sleb128 (w, read64 (p));
917 #else
918 emit_sleb128 (w, read32 (p));
919 #endif
920 break;
921 default:
922 g_assert_not_reached ();
923 }
924 }
925
926 has_children = TRUE;
927 } else {
928 guint8 buf [128];
929 guint8 *p;
930 char *parent_die;
931
932 if (klass->parent)
933 parent_die = emit_class_dwarf_info (w, klass->parent, FALSE);
934 else
935 parent_die = NULL;
936
937 /* Emit field types */
938 iter = NULL;
939 while ((field = mono_class_get_fields (klass, &iter))) {
940 if (field->type->attrs & FIELD_ATTRIBUTE_STATIC)
941 continue;
942
943 emit_type (w, field->type);
944 }
945
946 iter = NULL;
947 has_children = parent_die || mono_class_get_fields (klass, &iter);
948
949 emit_label (w, die);
950
951 emit_uleb128 (w, has_children ? ABBREV_STRUCT_TYPE : ABBREV_STRUCT_TYPE_NOCHILDREN);
952 emit_string (w, full_name);
953 emit_uleb128 (w, klass->instance_size);
954
955 if (parent_die) {
956 emit_uleb128 (w, ABBREV_INHERITANCE);
957 emit_symbol_diff (w, parent_die, ".Ldebug_info_start", 0);
958
959 p = buf;
960 *p ++= DW_OP_plus_uconst;
961 encode_uleb128 (0, p, &p);
962 emit_byte (w, p - buf);
963 emit_bytes (w, buf, p - buf);
964 }
965
966 /* Emit fields */
967 iter = NULL;
968 while ((field = mono_class_get_fields (klass, &iter))) {
969 if (field->type->attrs & FIELD_ATTRIBUTE_STATIC)
970 continue;
971
972 fdie = emit_type (w, field->type);
973 if (fdie) {
974 emit_uleb128 (w, ABBREV_DATA_MEMBER);
975 emit_string (w, field->name);
976 emit_symbol_diff (w, fdie, ".Ldebug_info_start", 0);
977 /* location */
978 p = buf;
979 *p ++= DW_OP_plus_uconst;
980 if (klass->valuetype && vtype)
981 encode_uleb128 (field->offset - sizeof (MonoObject), p, &p);
982 else
983 encode_uleb128 (field->offset, p, &p);
984
985 emit_byte (w, p - buf);
986 emit_bytes (w, buf, p - buf);
987 }
988 }
989 }
990
991 /* Type end */
992 if (has_children)
993 emit_uleb128 (w, 0x0);
994
995 /* Add a typedef, so we can reference the type without a 'struct' in gdb */
996 emit_uleb128 (w, ABBREV_TYPEDEF);
997 emit_string (w, full_name);
998 emit_symbol_diff (w, die, ".Ldebug_info_start", 0);
999
1000 /* Add a pointer type */
1001 emit_label (w, pointer_die);
1002
1003 emit_uleb128 (w, ABBREV_POINTER_TYPE);
1004 emit_symbol_diff (w, die, ".Ldebug_info_start", 0);
1005
1006 /* Add a reference type */
1007 emit_label (w, reference_die);
1008
1009 emit_uleb128 (w, ABBREV_REFERENCE_TYPE);
1010 emit_symbol_diff (w, die, ".Ldebug_info_start", 0);
1011
1012 g_free (full_name);
1013
1014 if (emit_namespace) {
1015 /* Namespace end */
1016 emit_uleb128 (w, 0x0);
1017 }
1018
1019 return die;
1020 }
1021
1022 static const char*
1023 emit_type (MonoDwarfWriter *w, MonoType *t)
1024 {
1025 MonoClass *klass = mono_class_from_mono_type (t);
1026 int j;
1027 const char *tdie;
1028
1029 if (t->byref) {
1030 if (t->type == MONO_TYPE_VALUETYPE) {
1031 tdie = emit_class_dwarf_info (w, klass, TRUE);
1032 if (tdie)
1033 return g_hash_table_lookup (w->class_to_pointer_die, klass);
1034 }
1035 else {
1036 tdie = emit_class_dwarf_info (w, klass, FALSE);
1037 /* Should return a pointer type to a reference */
1038 }
1039 // FIXME:
1040 t = &mono_defaults.int_class->byval_arg;
1041 }
1042 for (j = 0; j < G_N_ELEMENTS (basic_types); ++j)
1043 if (basic_types [j].type == t->type)
1044 break;
1045 if (j < G_N_ELEMENTS (basic_types))
1046 tdie = basic_types [j].die_name;
1047 else {
1048 switch (t->type) {
1049 case MONO_TYPE_CLASS:
1050 emit_class_dwarf_info (w, klass, FALSE);
1051 tdie = g_hash_table_lookup (w->class_to_reference_die, klass);
1052 //tdie = ".LDIE_OBJECT";
1053 break;
1054 case MONO_TYPE_ARRAY:
1055 tdie = ".LDIE_OBJECT";
1056 break;
1057 case MONO_TYPE_VALUETYPE:
1058 if (klass->enumtype)
1059 tdie = emit_class_dwarf_info (w, klass, FALSE);
1060 else
1061 tdie = ".LDIE_I4";
1062 break;
1063 case MONO_TYPE_GENERICINST:
1064 if (!MONO_TYPE_ISSTRUCT (t)) {
1065 emit_class_dwarf_info (w, klass, FALSE);
1066 tdie = g_hash_table_lookup (w->class_to_reference_die, klass);
1067 } else {
1068 tdie = ".LDIE_I4";
1069 }
1070 break;
1071 case MONO_TYPE_PTR:
1072 tdie = ".LDIE_I";
1073 break;
1074 default:
1075 tdie = ".LDIE_I4";
1076 break;
1077 }
1078 }
1079
1080 return tdie;
1081 }
1082
1083 static void
1084 emit_var_type (MonoDwarfWriter *w, MonoType *t)
1085 {
1086 const char *tdie;
1087
1088 tdie = emit_type (w, t);
1089
1090 emit_symbol_diff (w, tdie, ".Ldebug_info_start", 0);
1091 }
1092
1093 static void
1094 encode_var_location (MonoDwarfWriter *w, MonoInst *ins, guint8 *p, guint8 **endp)
1095 {
1096 /* location */
1097 /* FIXME: This needs a location list, since the args can go from reg->stack */
1098 if (!ins || ins->flags & MONO_INST_IS_DEAD) {
1099 /* gdb treats this as optimized out */
1100 } else if (ins->opcode == OP_REGVAR) {
1101 *p = DW_OP_reg0 + mono_hw_reg_to_dwarf_reg (ins->dreg);
1102 p ++;
1103 } else if (ins->opcode == OP_REGOFFSET) {
1104 *p ++= DW_OP_breg0 + mono_hw_reg_to_dwarf_reg (ins->inst_basereg);
1105 encode_sleb128 (ins->inst_offset, p, &p);
1106 } else {
1107 // FIXME:
1108 *p ++ = DW_OP_reg0;
1109 }
1110
1111 *endp = p;
1112 }
1113
1114 static void
1115 emit_loclist (MonoDwarfWriter *w, MonoInst *ins,
1116 guint8 *loclist_begin_addr, guint8 *loclist_end_addr,
1117 guint8 *expr, guint32 expr_len)
1118 {
1119 char label [128];
1120
1121 emit_push_section (w, ".debug_loc", 0);
1122 sprintf (label, ".Lloclist_%d", w->loclist_index ++ );
1123 emit_label (w, label);
1124
1125 emit_pointer_value (w, loclist_begin_addr);
1126 emit_pointer_value (w, loclist_end_addr);
1127 emit_byte (w, expr_len % 256);
1128 emit_byte (w, expr_len / 256);
1129 emit_bytes (w, expr, expr_len);
1130
1131 emit_pointer_value (w, NULL);
1132 emit_pointer_value (w, NULL);
1133
1134 emit_pop_section (w);
1135 emit_symbol_diff (w, label, ".Ldebug_loc_start", 0);
1136 }
1137
1138 /*
1139 * MonoDisHelper->tokener doesn't take an IP argument, and we can't add one since
1140 * it is a public header.
1141 */
1142 static const guint8 *token_handler_ip;
1143
1144 static char*
1145 token_handler (MonoDisHelper *dh, MonoMethod *method, guint32 token)
1146 {
1147 char *res, *desc;
1148 MonoMethod *cmethod;
1149 MonoClass *klass;
1150 MonoClassField *field;
1151 gpointer data = NULL;
1152
1153 if (method->wrapper_type)
1154 data = mono_method_get_wrapper_data (method, token);
1155
1156 switch (*token_handler_ip) {
1157 case CEE_ISINST:
1158 case CEE_CASTCLASS:
1159 case CEE_LDELEMA:
1160 if (method->wrapper_type)
1161 klass = data;
1162 else
1163 klass = mono_class_get_full (method->klass->image, token, NULL);
1164 res = g_strdup_printf ("<%s>", klass->name);
1165 break;
1166 case CEE_NEWOBJ:
1167 case CEE_CALL:
1168 case CEE_CALLVIRT:
1169 if (method->wrapper_type)
1170 cmethod = data;
1171 else
1172 cmethod = mono_get_method_full (method->klass->image, token, NULL, NULL);
1173 desc = mono_method_full_name (cmethod, TRUE);
1174 res = g_strdup_printf ("<%s>", desc);
1175 g_free (desc);
1176 break;
1177 case CEE_CALLI:
1178 if (method->wrapper_type) {
1179 desc = mono_signature_get_desc (data, FALSE);
1180 res = g_strdup_printf ("<%s>", desc);
1181 g_free (desc);
1182 } else {
1183 res = g_strdup_printf ("<0x%08x>", token);
1184 }
1185 break;
1186 case CEE_LDFLD:
1187 case CEE_LDSFLD:
1188 case CEE_STFLD:
1189 case CEE_STSFLD:
1190 if (method->wrapper_type)
1191 field = data;
1192 else
1193 field = mono_field_from_token (method->klass->image, token, &klass, NULL);
1194 desc = mono_field_full_name (field);
1195 res = g_strdup_printf ("<%s>", desc);
1196 g_free (desc);
1197 break;
1198 default:
1199 res = g_strdup_printf ("<0x%08x>", token);
1200 break;
1201 }
1202
1203 return res;
1204 }
1205
1206 /*
1207 * disasm_ins:
1208 *
1209 * Produce a disassembled form of the IL instruction at IP. This is an extension
1210 * of mono_disasm_code_one () which can disasm tokens, handle wrapper methods, and
1211 * CEE_MONO_ opcodes.
1212 */
1213 static char*
1214 disasm_ins (MonoMethod *method, const guchar *ip, const guint8 **endip)
1215 {
1216 char *dis;
1217 MonoDisHelper dh;
1218 MonoMethodHeader *header = mono_method_get_header (method);
1219
1220 memset (&dh, 0, sizeof (dh));
1221 dh.newline = "";
1222 dh.label_format = "IL_%04x: ";
1223 dh.label_target = "IL_%04x";
1224 dh.tokener = token_handler;
1225
1226 token_handler_ip = ip;
1227 if (*ip == MONO_CUSTOM_PREFIX) {
1228 guint32 token;
1229 gpointer data;
1230
1231 switch (ip [1]) {
1232 case CEE_MONO_ICALL: {
1233 MonoJitICallInfo *info;
1234
1235 token = read32 (ip + 2);
1236 data = mono_method_get_wrapper_data (method, token);
1237 info = mono_find_jit_icall_by_addr (data);
1238 g_assert (info);
1239
1240 dis = g_strdup_printf ("IL_%04x: mono_icall <%s>", (int)(ip - header->code), info->name);
1241 ip += 6;
1242 break;
1243 }
1244 case CEE_MONO_CLASSCONST: {
1245 token = read32 (ip + 2);
1246 data = mono_method_get_wrapper_data (method, token);
1247
1248 dis = g_strdup_printf ("IL_%04x: mono_classconst <%s>", (int)(ip - header->code), ((MonoClass*)data)->name);
1249 ip += 6;
1250 break;
1251 }
1252 default:
1253 dis = mono_disasm_code_one (&dh, method, ip, &ip);
1254 }
1255 } else {
1256 dis = mono_disasm_code_one (&dh, method, ip, &ip);
1257 }
1258 token_handler_ip = NULL;
1259
1260 *endip = ip;
1261 mono_metadata_free_mh (header);
1262 return dis;
1263 }
1264
1265 static gint32
1266 il_offset_from_address (MonoMethod *method, MonoDebugMethodJitInfo *jit,
1267 guint32 native_offset)
1268 {
1269 int i;
1270
1271 if (!jit->line_numbers)
1272 return -1;
1273
1274 for (i = jit->num_line_numbers - 1; i >= 0; i--) {
1275 MonoDebugLineNumberEntry lne = jit->line_numbers [i];
1276
1277 if (lne.native_offset <= native_offset)
1278 return lne.il_offset;
1279 }
1280
1281 return -1;
1282 }
1283
1284 static int max_special_addr_diff = 0;
1285
1286 static inline void
1287 emit_advance_op (MonoDwarfWriter *w, int line_diff, int addr_diff)
1288 {
1289 gint64 opcode = 0;
1290
1291 /* Use a special opcode if possible */
1292 if (line_diff - LINE_BASE >= 0 && line_diff - LINE_BASE < LINE_RANGE) {
1293 if (max_special_addr_diff == 0)
1294 max_special_addr_diff = (255 - OPCODE_BASE) / LINE_RANGE;
1295
1296 if (addr_diff > max_special_addr_diff && (addr_diff < 2 * max_special_addr_diff)) {
1297 emit_byte (w, DW_LNS_const_add_pc);
1298 addr_diff -= max_special_addr_diff;
1299 }
1300
1301 opcode = (line_diff - LINE_BASE) + (LINE_RANGE * addr_diff) + OPCODE_BASE;
1302 if (opcode > 255)
1303 opcode = 0;
1304 }
1305
1306 if (opcode != 0) {
1307 emit_byte (w, opcode);
1308 } else {
1309 emit_byte (w, DW_LNS_advance_line);
1310 emit_sleb128 (w, line_diff);
1311 emit_byte (w, DW_LNS_advance_pc);
1312 emit_sleb128 (w, addr_diff);
1313 emit_byte (w, DW_LNS_copy);
1314 }
1315 }
1316
1317 static gint
1318 compare_lne (MonoDebugLineNumberEntry *a, MonoDebugLineNumberEntry *b)
1319 {
1320 if (a->native_offset == b->native_offset)
1321 return a->il_offset - b->il_offset;
1322 else
1323 return a->native_offset - b->native_offset;
1324 }
1325
1326 static void
1327 emit_line_number_info (MonoDwarfWriter *w, MonoMethod *method,
1328 char *start_symbol, char *end_symbol,
1329 guint8 *code, guint32 code_size,
1330 MonoDebugMethodJitInfo *debug_info)
1331 {
1332 guint32 prev_line = 0;
1333 guint32 prev_native_offset = 0;
1334 int i, file_index, il_offset, prev_il_offset;
1335 gboolean first = TRUE;
1336 MonoDebugSourceLocation *loc;
1337 char *prev_file_name = NULL;
1338 MonoMethodHeader *header = mono_method_get_header (method);
1339 MonoDebugMethodInfo *minfo;
1340 GArray *ln_array;
1341 int *native_to_il_offset = NULL;
1342
1343 if (!w->emit_line) {
1344 mono_metadata_free_mh (header);
1345 return;
1346 }
1347
1348 minfo = mono_debug_lookup_method (method);
1349
1350 /* Compute the native->IL offset mapping */
1351
1352 g_assert (code_size);
1353
1354 #ifdef _EGLIB_MAJOR
1355 mono_metadata_free_mh (header);
1356 /* g_array is not implemented in eglib */
1357 return;
1358 #else
1359 ln_array = g_array_sized_new (FALSE, FALSE, sizeof (MonoDebugLineNumberEntry),
1360 debug_info->num_line_numbers);
1361 g_array_append_vals (ln_array, debug_info->line_numbers, debug_info->num_line_numbers);
1362 g_array_sort (ln_array, (GCompareFunc)compare_lne);
1363 native_to_il_offset = g_new0 (int, code_size + 1);
1364
1365 for (i = 0; i < debug_info->num_line_numbers; ++i) {
1366 int j;
1367 MonoDebugLineNumberEntry lne = g_array_index (ln_array, MonoDebugLineNumberEntry, i);
1368
1369 if (i == 0) {
1370 for (j = 0; j < lne.native_offset; ++j)
1371 native_to_il_offset [j] = -1;
1372 }
1373
1374 if (i < debug_info->num_line_numbers - 1) {
1375 MonoDebugLineNumberEntry lne_next = g_array_index (ln_array, MonoDebugLineNumberEntry, i + 1);
1376
1377 for (j = lne.native_offset; j < lne_next.native_offset; ++j)
1378 native_to_il_offset [j] = lne.il_offset;
1379 } else {
1380 for (j = lne.native_offset; j < code_size; ++j)
1381 native_to_il_offset [j] = lne.il_offset;
1382 }
1383 }
1384 g_array_free (ln_array, TRUE);
1385 #endif
1386
1387 prev_line = 1;
1388 prev_il_offset = -1;
1389
1390 for (i = 0; i < code_size; ++i) {
1391 if (!minfo)
1392 continue;
1393
1394 if (!debug_info->line_numbers)
1395 continue;
1396
1397 if (native_to_il_offset)
1398 il_offset = native_to_il_offset [i];
1399 else
1400 il_offset = il_offset_from_address (method, debug_info, i);
1401 /*
1402 il_offset = il_offset_from_address (method, debug_info, i);
1403
1404 g_assert (il_offset == native_to_il_offset [i]);
1405 */
1406
1407 il_offset = native_to_il_offset [i];
1408 if (il_offset < 0)
1409 continue;
1410
1411 if (il_offset == prev_il_offset)
1412 continue;
1413
1414 prev_il_offset = il_offset;
1415
1416 loc = mono_debug_symfile_lookup_location (minfo, il_offset);
1417
1418 // Added the loc->source_file check as otherwise we can
1419 // crash, see the sample in bug 553191 that makes this code
1420 // crash when we call strcmp on loc->source_file below
1421 if (loc && loc->source_file) {
1422 int line_diff = (gint32)loc->row - (gint32)prev_line;
1423 int addr_diff = i - prev_native_offset;
1424
1425 if (first) {
1426 emit_section_change (w, ".debug_line", LINE_SUBSECTION_DATA);
1427
1428 emit_byte (w, 0);
1429 emit_byte (w, sizeof (gpointer) + 1);
1430 emit_byte (w, DW_LNE_set_address);
1431 if (start_symbol)
1432 emit_pointer_unaligned (w, start_symbol);
1433 else
1434 emit_pointer_value (w, code);
1435
1436 /*
1437 * The prolog+initlocals region does not have a line number, this
1438 * makes them belong to the first line of the method.
1439 */
1440 emit_byte (w, DW_LNS_advance_line);
1441 emit_sleb128 (w, (gint32)loc->row - (gint32)prev_line);
1442 prev_line = loc->row;
1443 }
1444
1445 if (loc->row != prev_line) {
1446 if (!prev_file_name || strcmp (loc->source_file, prev_file_name) != 0) {
1447 /* Add an entry to the file table */
1448 /* FIXME: Avoid duplicates */
1449 file_index = emit_line_number_file_name (w, loc->source_file, 0, 0);
1450 g_free (prev_file_name);
1451 prev_file_name = g_strdup (loc->source_file);
1452
1453 emit_byte (w, DW_LNS_set_file);
1454 emit_uleb128 (w, file_index);
1455 emit_byte (w, DW_LNS_copy);
1456 }
1457
1458 //printf ("X: %p(+0x%x) %d %s:%d(+%d)\n", code + i, addr_diff, loc->il_offset, loc->source_file, loc->row, line_diff);
1459
1460 emit_advance_op (w, line_diff, addr_diff);
1461
1462 prev_line = loc->row;
1463 prev_native_offset = i;
1464 }
1465
1466 first = FALSE;
1467 g_free (loc);
1468 }
1469 }
1470
1471 g_free (prev_file_name);
1472
1473 if (!first) {
1474 emit_byte (w, DW_LNS_advance_pc);
1475 emit_sleb128 (w, code_size - prev_native_offset);
1476 emit_byte (w, DW_LNS_copy);
1477
1478 emit_byte (w, 0);
1479 emit_byte (w, 1);
1480 emit_byte (w, DW_LNE_end_sequence);
1481 } else if (!start_symbol) {
1482 /* No debug info, XDEBUG mode */
1483 char *name, *dis;
1484 const guint8 *ip = header->code;
1485 int prev_line, prev_native_offset;
1486 int *il_to_line;
1487
1488 /*
1489 * Emit the IL code into a temporary file and emit line number info
1490 * referencing that file.
1491 */
1492
1493 name = mono_method_full_name (method, TRUE);
1494 fprintf (w->il_file, "// %s\n", name);
1495 w->il_file_line_index ++;
1496 g_free (name);
1497
1498 il_to_line = g_new0 (int, header->code_size);
1499
1500 emit_section_change (w, ".debug_line", LINE_SUBSECTION_DATA);
1501 emit_byte (w, 0);
1502 emit_byte (w, sizeof (gpointer) + 1);
1503 emit_byte (w, DW_LNE_set_address);
1504 emit_pointer_value (w, code);
1505
1506 // FIXME: Optimize this
1507 while (ip < header->code + header->code_size) {
1508 int il_offset = ip - header->code;
1509
1510 /* Emit IL */
1511 w->il_file_line_index ++;
1512
1513 dis = disasm_ins (method, ip, &ip);
1514 fprintf (w->il_file, "%s\n", dis);
1515 g_free (dis);
1516
1517 il_to_line [il_offset] = w->il_file_line_index;
1518 }
1519
1520 /* Emit line number info */
1521 prev_line = 1;
1522 prev_native_offset = 0;
1523 for (i = 0; i < debug_info->num_line_numbers; ++i) {
1524 MonoDebugLineNumberEntry *lne = &debug_info->line_numbers [i];
1525 int line;
1526
1527 if (lne->il_offset >= header->code_size)
1528 continue;
1529 line = il_to_line [lne->il_offset];
1530 if (!line) {
1531 /*
1532 * This seems to happen randomly, it looks like il_offset points
1533 * into the middle of an instruction.
1534 */
1535 continue;
1536 /*
1537 printf ("%s\n", mono_method_full_name (method, TRUE));
1538 printf ("%d %d\n", lne->il_offset, header->code_size);
1539 g_assert (line);
1540 */
1541 }
1542
1543 if (line - prev_line != 0) {
1544 emit_advance_op (w, line - prev_line, (gint32)lne->native_offset - prev_native_offset);
1545
1546 prev_line = line;
1547 prev_native_offset = lne->native_offset;
1548 }
1549 }
1550
1551 emit_byte (w, DW_LNS_advance_pc);
1552 emit_sleb128 (w, code_size - prev_native_offset);
1553 emit_byte (w, DW_LNS_copy);
1554
1555 emit_byte (w, 0);
1556 emit_byte (w, 1);
1557 emit_byte (w, DW_LNE_end_sequence);
1558
1559 fflush (w->il_file);
1560 g_free (il_to_line);
1561 }
1562 mono_metadata_free_mh (header);
1563 }
1564
1565 static MonoMethodVar*
1566 find_vmv (MonoCompile *cfg, MonoInst *ins)
1567 {
1568 int j;
1569
1570 if (cfg->varinfo) {
1571 for (j = 0; j < cfg->num_varinfo; ++j) {
1572 if (cfg->varinfo [j] == ins)
1573 break;
1574 }
1575
1576 if (j < cfg->num_varinfo) {
1577 return MONO_VARINFO (cfg, j);
1578 }
1579 }
1580
1581 return NULL;
1582 }
1583
1584 void
1585 mono_dwarf_writer_emit_method (MonoDwarfWriter *w, MonoCompile *cfg, MonoMethod *method, char *start_symbol, char *end_symbol, guint8 *code, guint32 code_size, MonoInst **args, MonoInst **locals, GSList *unwind_info, MonoDebugMethodJitInfo *debug_info)
1586 {
1587 char *name;
1588 MonoMethodSignature *sig;
1589 MonoMethodHeader *header;
1590 char **names, **tdies, **local_tdies;
1591 char **local_names;
1592 int *local_indexes;
1593 int i, num_locals;
1594 guint8 buf [128];
1595 guint8 *p;
1596
1597 emit_section_change (w, ".debug_info", 0);
1598
1599 sig = mono_method_signature (method);
1600 header = mono_method_get_header (method);
1601
1602 /* Parameter types */
1603 tdies = g_new0 (char *, sig->param_count + sig->hasthis);
1604 for (i = 0; i < sig->param_count + sig->hasthis; ++i) {
1605 MonoType *t;
1606
1607 if (i == 0 && sig->hasthis) {
1608 if (method->klass->valuetype)
1609 t = &method->klass->this_arg;
1610 else
1611 t = &method->klass->byval_arg;
1612 } else {
1613 t = sig->params [i - sig->hasthis];
1614 }
1615
1616 emit_type (w, t);
1617 }
1618
1619 /* Local types */
1620 local_tdies = g_new0 (char *, header->num_locals);
1621 for (i = 0; i < header->num_locals; ++i) {
1622 emit_type (w, header->locals [i]);
1623 }
1624
1625 /* Subprogram */
1626 names = g_new0 (char *, sig->param_count);
1627 mono_method_get_param_names (method, (const char **) names);
1628
1629 emit_uleb128 (w, ABBREV_SUBPROGRAM);
1630 name = mono_method_full_name (method, FALSE);
1631 emit_string (w, name);
1632 g_free (name);
1633 if (start_symbol) {
1634 emit_pointer_unaligned (w, start_symbol);
1635 emit_pointer_unaligned (w, end_symbol);
1636 } else {
1637 emit_pointer_value (w, code);
1638 emit_pointer_value (w, code + code_size);
1639 }
1640 /* frame_base */
1641 emit_byte (w, 2);
1642 emit_byte (w, DW_OP_breg6);
1643 emit_byte (w, 16);
1644
1645 /* Parameters */
1646 for (i = 0; i < sig->param_count + sig->hasthis; ++i) {
1647 MonoInst *arg = args ? args [i] : NULL;
1648 MonoType *t;
1649 const char *pname;
1650 char pname_buf [128];
1651 MonoMethodVar *vmv = NULL;
1652 gboolean need_loclist = FALSE;
1653
1654 vmv = find_vmv (cfg, arg);
1655 if (code && vmv && (vmv->live_range_start || vmv->live_range_end))
1656 need_loclist = TRUE;
1657
1658 if (i == 0 && sig->hasthis) {
1659 if (method->klass->valuetype)
1660 t = &method->klass->this_arg;
1661 else
1662 t = &method->klass->byval_arg;
1663 pname = "this";
1664 } else {
1665 t = sig->params [i - sig->hasthis];
1666 pname = names [i - sig->hasthis];
1667 }
1668
1669 emit_uleb128 (w, need_loclist ? ABBREV_PARAM_LOCLIST : ABBREV_PARAM);
1670 /* name */
1671 if (pname[0] == '\0') {
1672 sprintf (pname_buf, "param%d", i - sig->hasthis);
1673 pname = pname_buf;
1674 }
1675 emit_string (w, pname);
1676 /* type */
1677 if (!arg || arg->flags & MONO_INST_IS_DEAD)
1678 emit_var_type (w, &mono_defaults.int32_class->byval_arg);
1679 else
1680 emit_var_type (w, t);
1681
1682 p = buf;
1683 encode_var_location (w, arg, p, &p);
1684 if (need_loclist) {
1685 vmv->live_range_start = 0;
1686 if (vmv->live_range_end == 0)
1687 /* FIXME: Uses made in calls are not recorded */
1688 vmv->live_range_end = code_size;
1689 emit_loclist (w, arg, code + vmv->live_range_start, code + vmv->live_range_end, buf, p - buf);
1690 } else {
1691 emit_byte (w, p - buf);
1692 emit_bytes (w, buf, p - buf);
1693 }
1694 }
1695 g_free (names);
1696
1697 /* Locals */
1698 num_locals = mono_debug_lookup_locals (method, &local_names, &local_indexes);
1699
1700 for (i = 0; i < header->num_locals; ++i) {
1701 MonoInst *ins = locals [i];
1702 char name_buf [128];
1703 int j;
1704 MonoMethodVar *vmv = NULL;
1705 gboolean need_loclist = FALSE;
1706
1707 /* ins->dreg no longer contains the original vreg */
1708 vmv = find_vmv (cfg, ins);
1709 if (code && vmv) {
1710 if (vmv->live_range_start) {
1711 /* This variable has a precise live range */
1712 need_loclist = TRUE;
1713 }
1714 }
1715
1716 emit_uleb128 (w, need_loclist ? ABBREV_VARIABLE_LOCLIST : ABBREV_VARIABLE);
1717 /* name */
1718 for (j = 0; j < num_locals; ++j)
1719 if (local_indexes [j] == i)
1720 break;
1721 if (j < num_locals) {
1722 emit_string (w, local_names [j]);
1723 } else {
1724 sprintf (name_buf, "V_%d", i);
1725 emit_string (w, name_buf);
1726 }
1727 /* type */
1728 if (!ins || ins->flags & MONO_INST_IS_DEAD)
1729 emit_var_type (w, &mono_defaults.int32_class->byval_arg);
1730 else
1731 emit_var_type (w, header->locals [i]);
1732
1733 p = buf;
1734 encode_var_location (w, ins, p, &p);
1735
1736 if (need_loclist) {
1737 if (vmv->live_range_end == 0)
1738 /* FIXME: Uses made in calls are not recorded */
1739 vmv->live_range_end = code_size;
1740 emit_loclist (w, ins, code + vmv->live_range_start, code + vmv->live_range_end, buf, p - buf);
1741 } else {
1742 emit_byte (w, p - buf);
1743 emit_bytes (w, buf, p - buf);
1744 }
1745 }
1746
1747 g_free (local_names);
1748 g_free (local_indexes);
1749
1750 /* Subprogram end */
1751 emit_uleb128 (w, 0x0);
1752
1753 emit_line (w);
1754
1755 emit_debug_info_end (w);
1756
1757 /* Emit unwind info */
1758 if (unwind_info) {
1759 emit_fde (w, w->fde_index, start_symbol, end_symbol, code, code_size, unwind_info, TRUE);
1760 w->fde_index ++;
1761 }
1762
1763 /* Emit line number info */
1764 /* != could happen when using --regression */
1765 if (debug_info && (debug_info->code_start == code))
1766 emit_line_number_info (w, method, start_symbol, end_symbol, code, code_size, debug_info);
1767
1768 emit_line (w);
1769 mono_metadata_free_mh (header);
1770 }
1771
1772 void
1773 mono_dwarf_writer_emit_trampoline (MonoDwarfWriter *w, const char *tramp_name, char *start_symbol, char *end_symbol, guint8 *code, guint32 code_size, GSList *unwind_info)
1774 {
1775 emit_section_change (w, ".debug_info", 0);
1776
1777 /* Subprogram */
1778 emit_uleb128 (w, ABBREV_SUBPROGRAM);
1779 emit_string (w, tramp_name);
1780 emit_pointer_value (w, code);
1781 emit_pointer_value (w, code + code_size);
1782 /* frame_base */
1783 emit_byte (w, 2);
1784 emit_byte (w, DW_OP_breg6);
1785 emit_byte (w, 16);
1786
1787 /* Subprogram end */
1788 emit_uleb128 (w, 0x0);
1789
1790 emit_debug_info_end (w);
1791
1792 /* Emit unwind info */
1793 emit_fde (w, w->fde_index, start_symbol, end_symbol, code, code_size, unwind_info, FALSE);
1794 w->fde_index ++;
1795 }
1796 #endif /* End of: !defined(DISABLE_AOT) && !defined(DISABLE_JIT) */
git-svn mirror of mono