3 * Mini-specific debugging stuff.
6 * Martin Baulig (martin@ximian.com)
8 * (C) 2003 Ximian, Inc.
14 #include <mono/metadata/verify.h>
15 #include <mono/metadata/mono-config.h>
16 #include <mono/metadata/mono-debug.h>
17 #include <mono/metadata/appdomain.h>
18 #include <mono/metadata/threads-types.h>
20 #include <mono/metadata/debug-internals.h>
22 #include <mono/utils/valgrind.h>
27 } MiniDebugBreakpointInfo;
31 MonoDebugMethodJitInfo *jit;
33 guint32 has_line_numbers;
34 guint32 breakpoint_id;
35 } MiniDebugMethodInfo;
38 record_line_number (MiniDebugMethodInfo *info, guint32 address, guint32 offset)
40 MonoDebugLineNumberEntry lne;
42 lne.native_offset = address;
43 lne.il_offset = offset;
45 g_array_append_val (info->line_numbers, lne);
50 mono_debug_init_method (MonoCompile *cfg, MonoBasicBlock *start_block, guint32 breakpoint_id)
52 MiniDebugMethodInfo *info;
54 if (!mono_debug_enabled ())
57 info = g_new0 (MiniDebugMethodInfo, 1);
58 info->breakpoint_id = breakpoint_id;
60 cfg->debug_info = info;
64 mono_debug_open_method (MonoCompile *cfg)
66 MiniDebugMethodInfo *info;
67 MonoDebugMethodJitInfo *jit;
68 MonoMethodHeader *header;
70 info = (MiniDebugMethodInfo *) cfg->debug_info;
74 mono_class_init (cfg->method->klass);
79 info->jit = jit = g_new0 (MonoDebugMethodJitInfo, 1);
80 info->line_numbers = g_array_new (FALSE, TRUE, sizeof (MonoDebugLineNumberEntry));
81 jit->num_locals = header->num_locals;
82 jit->locals = g_new0 (MonoDebugVarInfo, jit->num_locals);
86 write_variable (MonoInst *inst, MonoDebugVarInfo *var)
88 var->type = inst->inst_vtype;
90 if (inst->opcode == OP_REGVAR)
91 var->index = inst->dreg | MONO_DEBUG_VAR_ADDRESS_MODE_REGISTER;
92 else if (inst->flags & MONO_INST_IS_DEAD)
93 var->index = MONO_DEBUG_VAR_ADDRESS_MODE_DEAD;
94 else if (inst->opcode == OP_REGOFFSET) {
95 /* the debug interface needs fixing to allow 0(%base) address */
96 var->index = inst->inst_basereg | MONO_DEBUG_VAR_ADDRESS_MODE_REGOFFSET;
97 var->offset = inst->inst_offset;
98 } else if (inst->opcode == OP_GSHAREDVT_ARG_REGOFFSET) {
99 var->index = inst->inst_basereg | MONO_DEBUG_VAR_ADDRESS_MODE_REGOFFSET_INDIR;
100 var->offset = inst->inst_offset;
101 } else if (inst->opcode == OP_GSHAREDVT_LOCAL) {
102 var->index = inst->inst_imm | MONO_DEBUG_VAR_ADDRESS_MODE_GSHAREDVT_LOCAL;
103 } else if (inst->opcode == OP_VTARG_ADDR) {
106 vtaddr = inst->inst_left;
107 g_assert (vtaddr->opcode == OP_REGOFFSET);
108 var->offset = vtaddr->inst_offset;
109 var->index = vtaddr->inst_basereg | MONO_DEBUG_VAR_ADDRESS_MODE_VTADDR;
111 g_assert_not_reached ();
116 * mono_debug_add_vg_method:
118 * Register symbol information for the method with valgrind
121 mono_debug_add_vg_method (MonoMethod *method, MonoDebugMethodJitInfo *jit)
123 #ifdef VALGRIND_ADD_LINE_INFO
125 MonoMethodHeader *header;
126 MonoDebugMethodInfo *minfo;
128 char *filename = NULL;
129 guint32 address, line_number;
130 const char *full_name;
134 if (!RUNNING_ON_VALGRIND)
137 header = mono_method_get_header_checked (method, &error);
138 mono_error_assert_ok (&error); /* FIXME don't swallow the error */
140 full_name = mono_method_full_name (method, TRUE);
142 addresses = g_new0 (guint32, header->code_size + 1);
143 lines = g_new0 (guint32, header->code_size + 1);
146 * Very simple code to convert the addr->offset mappings that mono has
147 * into [addr-addr] ->line number mappings.
150 minfo = mono_debug_lookup_method (method);
152 /* Create offset->line number mapping */
153 for (i = 0; i < header->code_size; ++i) {
154 MonoDebugSourceLocation *location;
156 location = mono_debug_method_lookup_location (minfo, i);
160 lines [i] = location.row;
162 filename = location.source_file;
164 mono_debug_free_source_location (location);
168 /* Create address->offset mapping */
169 for (i = 0; i < jit->num_line_numbers; ++i) {
170 MonoDebugLineNumberEntry *lne = jit->line_numbers [i];
172 g_assert (lne->offset <= header->code_size);
174 if ((addresses [lne->offset] == 0) || (lne->address < addresses [lne->offset]))
175 addresses [lne->offset] = lne->address;
177 /* Fill out missing addresses */
179 for (i = 0; i < header->code_size; ++i) {
180 if (addresses [i] == 0)
181 addresses [i] = address;
183 address = addresses [i];
189 while (i < header->code_size) {
190 if (lines [i] == line_number)
193 if (line_number > 0) {
194 //g_assert (addresses [i] - 1 >= address);
196 if (addresses [i] - 1 >= address) {
197 VALGRIND_ADD_LINE_INFO (jit->code_start + address, jit->code_start + addresses [i] - 1, filename, line_number);
198 //printf ("[%d-%d] -> %d.\n", address, addresses [i] - 1, line_number);
201 address = addresses [i];
202 line_number = lines [i];
206 if (line_number > 0) {
207 VALGRIND_ADD_LINE_INFO (jit->code_start + address, jit->code_start + jit->code_size - 1, filename, line_number);
208 //printf ("[%d-%d] -> %d.\n", address, jit->code_size - 1, line_number);
211 VALGRIND_ADD_SYMBOL (jit->code_start, jit->code_size, full_name);
215 mono_metadata_free_mh (header);
216 #endif /* VALGRIND_ADD_LINE_INFO */
220 mono_debug_close_method (MonoCompile *cfg)
222 MiniDebugMethodInfo *info;
223 MonoDebugMethodJitInfo *jit;
224 MonoMethodHeader *header;
225 MonoMethodSignature *sig;
229 info = (MiniDebugMethodInfo *) cfg->debug_info;
230 if (!info || !info->jit) {
236 method = cfg->method;
237 header = cfg->header;
238 sig = mono_method_signature (method);
241 jit->code_start = cfg->native_code;
242 jit->epilogue_begin = cfg->epilog_begin;
243 jit->code_size = cfg->code_len;
244 jit->has_var_info = debug_options.mdb_optimizations || MONO_CFG_PROFILE_CALL_CONTEXT (cfg);
246 if (jit->epilogue_begin)
247 record_line_number (info, jit->epilogue_begin, header->code_size);
249 if (jit->has_var_info) {
250 jit->num_params = sig->param_count;
251 jit->params = g_new0 (MonoDebugVarInfo, jit->num_params);
253 for (i = 0; i < jit->num_locals; i++)
254 write_variable (cfg->locals [i], &jit->locals [i]);
257 jit->this_var = g_new0 (MonoDebugVarInfo, 1);
258 write_variable (cfg->args [0], jit->this_var);
261 for (i = 0; i < jit->num_params; i++)
262 write_variable (cfg->args [i + sig->hasthis], &jit->params [i]);
264 if (cfg->gsharedvt_info_var) {
265 jit->gsharedvt_info_var = g_new0 (MonoDebugVarInfo, 1);
266 jit->gsharedvt_locals_var = g_new0 (MonoDebugVarInfo, 1);
267 write_variable (cfg->gsharedvt_info_var, jit->gsharedvt_info_var);
268 write_variable (cfg->gsharedvt_locals_var, jit->gsharedvt_locals_var);
272 jit->num_line_numbers = info->line_numbers->len;
273 jit->line_numbers = g_new0 (MonoDebugLineNumberEntry, jit->num_line_numbers);
275 for (i = 0; i < jit->num_line_numbers; i++)
276 jit->line_numbers [i] = g_array_index (info->line_numbers, MonoDebugLineNumberEntry, i);
278 mono_debug_add_method (cfg->method_to_register, jit, cfg->domain);
280 mono_debug_add_vg_method (method, jit);
282 mono_debug_free_method_jit_info (jit);
283 mono_debug_free_method (cfg);
287 mono_debug_free_method (MonoCompile *cfg)
289 MiniDebugMethodInfo *info;
291 info = (MiniDebugMethodInfo *) cfg->debug_info;
293 if (info->line_numbers)
294 g_array_free (info->line_numbers, TRUE);
296 cfg->debug_info = NULL;
301 mono_debug_record_line_number (MonoCompile *cfg, MonoInst *ins, guint32 address)
303 MiniDebugMethodInfo *info;
304 MonoMethodHeader *header;
307 info = (MiniDebugMethodInfo *) cfg->debug_info;
308 if (!info || !info->jit || !ins->cil_code)
311 header = cfg->header;
314 if ((ins->cil_code < header->code) ||
315 (ins->cil_code > header->code + header->code_size))
318 offset = ins->cil_code - header->code;
319 if (!info->has_line_numbers) {
320 info->jit->prologue_end = address;
321 info->has_line_numbers = TRUE;
324 record_line_number (info, address, offset);
328 mono_debug_open_block (MonoCompile *cfg, MonoBasicBlock *bb, guint32 address)
330 MiniDebugMethodInfo *info;
331 MonoMethodHeader *header;
334 info = (MiniDebugMethodInfo *) cfg->debug_info;
335 if (!info || !info->jit || !bb->cil_code)
338 header = cfg->header;
341 if ((bb->cil_code < header->code) ||
342 (bb->cil_code > header->code + header->code_size))
345 offset = bb->cil_code - header->code;
346 if (!info->has_line_numbers) {
347 info->jit->prologue_end = address;
348 info->has_line_numbers = TRUE;
351 record_line_number (info, address, offset);
355 encode_value (gint32 value, guint8 *buf, guint8 **endbuf)
359 //printf ("ENCODE: %d 0x%x.\n", value, value);
362 * Same encoding as the one used in the metadata, extended to handle values
363 * greater than 0x1fffffff.
365 if ((value >= 0) && (value <= 127))
367 else if ((value >= 0) && (value <= 16383)) {
368 p [0] = 0x80 | (value >> 8);
369 p [1] = value & 0xff;
371 } else if ((value >= 0) && (value <= 0x1fffffff)) {
372 p [0] = (value >> 24) | 0xc0;
373 p [1] = (value >> 16) & 0xff;
374 p [2] = (value >> 8) & 0xff;
375 p [3] = value & 0xff;
380 p [1] = (value >> 24) & 0xff;
381 p [2] = (value >> 16) & 0xff;
382 p [3] = (value >> 8) & 0xff;
383 p [4] = value & 0xff;
391 decode_value (guint8 *ptr, guint8 **rptr)
396 if ((b & 0x80) == 0){
399 } else if ((b & 0x40) == 0){
400 len = ((b & 0x3f) << 8 | ptr [1]);
402 } else if (b != 0xff) {
403 len = ((b & 0x1f) << 24) |
410 len = (ptr [1] << 24) | (ptr [2] << 16) | (ptr [3] << 8) | ptr [4];
416 //printf ("DECODE: %d.\n", len);
421 serialize_variable (MonoDebugVarInfo *var, guint8 *p, guint8 **endbuf)
423 guint32 flags = var->index & MONO_DEBUG_VAR_ADDRESS_MODE_FLAGS;
425 encode_value (var->index, p, &p);
428 case MONO_DEBUG_VAR_ADDRESS_MODE_REGISTER:
430 case MONO_DEBUG_VAR_ADDRESS_MODE_REGOFFSET:
431 case MONO_DEBUG_VAR_ADDRESS_MODE_REGOFFSET_INDIR:
432 case MONO_DEBUG_VAR_ADDRESS_MODE_VTADDR:
433 encode_value (var->offset, p, &p);
435 case MONO_DEBUG_VAR_ADDRESS_MODE_GSHAREDVT_LOCAL:
436 case MONO_DEBUG_VAR_ADDRESS_MODE_DEAD:
439 g_assert_not_reached ();
445 mono_debug_serialize_debug_info (MonoCompile *cfg, guint8 **out_buf, guint32 *buf_len)
447 MonoDebugMethodJitInfo *jit;
448 guint32 size, prev_offset, prev_native_offset;
452 /* Can't use cfg->debug_info as it is freed by close_method () */
453 jit = mono_debug_find_method (cfg->method, mono_domain_get ());
459 size = ((jit->num_params + jit->num_locals + 1) * 10) + (jit->num_line_numbers * 10) + 64;
460 p = buf = (guint8 *)g_malloc (size);
461 encode_value (jit->epilogue_begin, p, &p);
462 encode_value (jit->prologue_end, p, &p);
463 encode_value (jit->code_size, p, &p);
464 encode_value (jit->has_var_info, p, &p);
466 if (jit->has_var_info) {
467 for (i = 0; i < jit->num_params; ++i)
468 serialize_variable (&jit->params [i], p, &p);
471 serialize_variable (jit->this_var, p, &p);
473 for (i = 0; i < jit->num_locals; i++)
474 serialize_variable (&jit->locals [i], p, &p);
476 if (jit->gsharedvt_info_var) {
477 encode_value (1, p, &p);
478 serialize_variable (jit->gsharedvt_info_var, p, &p);
479 serialize_variable (jit->gsharedvt_locals_var, p, &p);
481 encode_value (0, p, &p);
485 encode_value (jit->num_line_numbers, p, &p);
488 prev_native_offset = 0;
489 for (i = 0; i < jit->num_line_numbers; ++i) {
490 /* Sometimes, the offset values are not in increasing order */
491 MonoDebugLineNumberEntry *lne = &jit->line_numbers [i];
492 encode_value (lne->il_offset - prev_offset, p, &p);
493 encode_value (lne->native_offset - prev_native_offset, p, &p);
494 prev_offset = lne->il_offset;
495 prev_native_offset = lne->native_offset;
498 g_assert (p - buf < size);
505 deserialize_variable (MonoDebugVarInfo *var, guint8 *p, guint8 **endbuf)
509 var->index = decode_value (p, &p);
511 flags = var->index & MONO_DEBUG_VAR_ADDRESS_MODE_FLAGS;
514 case MONO_DEBUG_VAR_ADDRESS_MODE_REGISTER:
516 case MONO_DEBUG_VAR_ADDRESS_MODE_REGOFFSET:
517 case MONO_DEBUG_VAR_ADDRESS_MODE_REGOFFSET_INDIR:
518 case MONO_DEBUG_VAR_ADDRESS_MODE_VTADDR:
519 var->offset = decode_value (p, &p);
521 case MONO_DEBUG_VAR_ADDRESS_MODE_GSHAREDVT_LOCAL:
522 case MONO_DEBUG_VAR_ADDRESS_MODE_DEAD:
525 g_assert_not_reached ();
530 static MonoDebugMethodJitInfo *
531 deserialize_debug_info (MonoMethod *method, guint8 *code_start, guint8 *buf, guint32 buf_len)
534 MonoMethodHeader *header;
535 gint32 offset, native_offset, prev_offset, prev_native_offset;
536 MonoDebugMethodJitInfo *jit;
540 header = mono_method_get_header_checked (method, &error);
541 mono_error_assert_ok (&error); /* FIXME don't swallow the error */
543 jit = g_new0 (MonoDebugMethodJitInfo, 1);
544 jit->code_start = code_start;
547 jit->epilogue_begin = decode_value (p, &p);
548 jit->prologue_end = decode_value (p, &p);
549 jit->code_size = decode_value (p, &p);
550 jit->has_var_info = decode_value (p, &p);
552 if (jit->has_var_info) {
553 jit->num_locals = header->num_locals;
554 jit->num_params = mono_method_signature (method)->param_count;
555 jit->params = g_new0 (MonoDebugVarInfo, jit->num_params);
556 jit->locals = g_new0 (MonoDebugVarInfo, jit->num_locals);
558 for (i = 0; i < jit->num_params; ++i)
559 deserialize_variable (&jit->params [i], p, &p);
561 if (mono_method_signature (method)->hasthis) {
562 jit->this_var = g_new0 (MonoDebugVarInfo, 1);
563 deserialize_variable (jit->this_var, p, &p);
566 for (i = 0; i < jit->num_locals; i++)
567 deserialize_variable (&jit->locals [i], p, &p);
569 if (decode_value (p, &p)) {
570 jit->gsharedvt_info_var = g_new0 (MonoDebugVarInfo, 1);
571 jit->gsharedvt_locals_var = g_new0 (MonoDebugVarInfo, 1);
572 deserialize_variable (jit->gsharedvt_info_var, p, &p);
573 deserialize_variable (jit->gsharedvt_locals_var, p, &p);
577 jit->num_line_numbers = decode_value (p, &p);
578 jit->line_numbers = g_new0 (MonoDebugLineNumberEntry, jit->num_line_numbers);
581 prev_native_offset = 0;
582 for (i = 0; i < jit->num_line_numbers; ++i) {
583 MonoDebugLineNumberEntry *lne = &jit->line_numbers [i];
585 offset = prev_offset + decode_value (p, &p);
586 native_offset = prev_native_offset + decode_value (p, &p);
588 lne->native_offset = native_offset;
589 lne->il_offset = offset;
591 prev_offset = offset;
592 prev_native_offset = native_offset;
595 mono_metadata_free_mh (header);
600 mono_debug_add_aot_method (MonoDomain *domain, MonoMethod *method, guint8 *code_start,
601 guint8 *debug_info, guint32 debug_info_len)
603 MonoDebugMethodJitInfo *jit;
605 if (!mono_debug_enabled ())
608 if ((method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) ||
609 (method->iflags & METHOD_IMPL_ATTRIBUTE_RUNTIME) ||
610 (method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) ||
611 (method->flags & METHOD_ATTRIBUTE_ABSTRACT) ||
612 (method->wrapper_type != MONO_WRAPPER_NONE))
615 if (debug_info_len == 0)
618 jit = deserialize_debug_info (method, code_start, debug_info, debug_info_len);
620 mono_debug_add_method (method, jit, domain);
622 mono_debug_add_vg_method (method, jit);
624 mono_debug_free_method_jit_info (jit);
628 print_var_info (MonoDebugVarInfo *info, int idx, const char *name, const char *type)
630 switch (info->index & MONO_DEBUG_VAR_ADDRESS_MODE_FLAGS) {
631 case MONO_DEBUG_VAR_ADDRESS_MODE_REGISTER:
632 g_print ("%s %s (%d) in register %s\n", type, name, idx, mono_arch_regname (info->index & (~MONO_DEBUG_VAR_ADDRESS_MODE_FLAGS)));
634 case MONO_DEBUG_VAR_ADDRESS_MODE_REGOFFSET:
635 g_print ("%s %s (%d) in memory: base register %s + %d\n", type, name, idx, mono_arch_regname (info->index & (~MONO_DEBUG_VAR_ADDRESS_MODE_FLAGS)), info->offset);
637 case MONO_DEBUG_VAR_ADDRESS_MODE_REGOFFSET_INDIR:
638 g_print ("%s %s (%d) in indir memory: base register %s + %d\n", type, name, idx, mono_arch_regname (info->index & (~MONO_DEBUG_VAR_ADDRESS_MODE_FLAGS)), info->offset);
640 case MONO_DEBUG_VAR_ADDRESS_MODE_GSHAREDVT_LOCAL:
641 g_print ("%s %s (%d) gsharedvt local.\n", type, name, idx);
643 case MONO_DEBUG_VAR_ADDRESS_MODE_VTADDR:
644 g_print ("%s %s (%d) vt address: base register %s + %d\n", type, name, idx, mono_arch_regname (info->index & (~MONO_DEBUG_VAR_ADDRESS_MODE_FLAGS)), info->offset);
646 case MONO_DEBUG_VAR_ADDRESS_MODE_TWO_REGISTERS:
648 g_assert_not_reached ();
653 * mono_debug_print_locals:
655 * Prints to stdout the information about the local variables in
656 * a method (if \p only_arguments is false) or about the arguments.
657 * The information includes the storage info (where the variable
658 * lives, in a register or in memory).
659 * The method is found by looking up what method has been emitted at
660 * the instruction address \p ip.
661 * This is for use inside a debugger.
664 mono_debug_print_vars (gpointer ip, gboolean only_arguments)
666 MonoDomain *domain = mono_domain_get ();
667 MonoJitInfo *ji = mono_jit_info_table_find (domain, (char *)ip);
668 MonoDebugMethodJitInfo *jit;
674 jit = mono_debug_find_method (jinfo_get_method (ji), domain);
678 if (only_arguments) {
680 names = g_new (char *, jit->num_params);
681 mono_method_get_param_names (jinfo_get_method (ji), (const char **) names);
683 print_var_info (jit->this_var, 0, "this", "Arg");
684 for (i = 0; i < jit->num_params; ++i) {
685 print_var_info (&jit->params [i], i, names [i]? names [i]: "unknown name", "Arg");
689 for (i = 0; i < jit->num_locals; ++i) {
690 print_var_info (&jit->locals [i], i, "", "Local");
693 mono_debug_free_method_jit_info (jit);
697 * The old Debugger breakpoint interface.
699 * This interface is used to insert breakpoints on methods which are not yet JITed.
700 * The debugging code keeps a list of all such breakpoints and automatically inserts the
701 * breakpoint when the method is JITed.
704 static GPtrArray *breakpoints;
707 mono_debugger_insert_breakpoint_full (MonoMethodDesc *desc)
709 static int last_breakpoint_id = 0;
710 MiniDebugBreakpointInfo *info;
712 info = g_new0 (MiniDebugBreakpointInfo, 1);
714 info->index = ++last_breakpoint_id;
717 breakpoints = g_ptr_array_new ();
719 g_ptr_array_add (breakpoints, info);
724 /*FIXME This is part of the public API by accident, remove it from there when possible. */
726 mono_debugger_insert_breakpoint (const gchar *method_name, gboolean include_namespace)
728 MonoMethodDesc *desc;
730 desc = mono_method_desc_new (method_name, include_namespace);
734 return mono_debugger_insert_breakpoint_full (desc);
737 /*FIXME This is part of the public API by accident, remove it from there when possible. */
739 mono_debugger_method_has_breakpoint (MonoMethod *method)
746 for (i = 0; i < breakpoints->len; i++) {
747 MiniDebugBreakpointInfo *info = (MiniDebugBreakpointInfo *)g_ptr_array_index (breakpoints, i);
749 if (!mono_method_desc_full_match (info->desc, method))