X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmini%2Fdebug-mini.c;h=cc06068cf6d69785ffbd48179d14fab79f80a4a4;hb=338396b5effae6b7d7a4139c45d822c9633f84c1;hp=9cba86003109f70a33347c08f734ad796a884fec;hpb=5d9434fcb3acc1ed7d3d30603faae797d672fe65;p=mono.git diff --git a/mono/mini/debug-mini.c b/mono/mini/debug-mini.c index 9cba8600310..cc06068cf6d 100644 --- a/mono/mini/debug-mini.c +++ b/mono/mini/debug-mini.c @@ -14,12 +14,25 @@ #include #include #include +#include + +#define _IN_THE_MONO_DEBUGGER #include +#include "debug-mini.h" #ifdef HAVE_VALGRIND_H #include #endif +#ifdef MONO_DEBUGGER_SUPPORTED +#include +#endif + +typedef struct { + guint32 index; + MonoMethodDesc *desc; +} MiniDebugBreakpointInfo; + typedef struct { MonoDebugMethodJitInfo *jit; @@ -28,6 +41,33 @@ typedef struct guint32 breakpoint_id; } MiniDebugMethodInfo; +struct _MonoDebuggerThreadInfo { + guint64 tid; + guint64 lmf_addr; + guint64 end_stack; + + guint64 extended_notifications; + + /* Next pointer. */ + MonoDebuggerThreadInfo *next; + + /* + * The stack bounds are only used when reading a core file. + */ + guint64 stack_start; + guint64 signal_stack_start; + guint32 stack_size; + guint32 signal_stack_size; + + /* + * The debugger doesn't access anything beyond this point. + */ + MonoJitTlsData *jit_tls; + MonoThread *thread; +}; + +MonoDebuggerThreadInfo *mono_debugger_thread_table = NULL; + static inline void record_line_number (MiniDebugMethodInfo *info, guint32 address, guint32 offset) { @@ -39,6 +79,7 @@ record_line_number (MiniDebugMethodInfo *info, guint32 address, guint32 offset) g_array_append_val (info->line_numbers, lne); } + void mono_debug_init_method (MonoCompile *cfg, MonoBasicBlock *start_block, guint32 breakpoint_id) { @@ -78,9 +119,14 @@ mono_debug_open_method (MonoCompile *cfg) static void write_variable (MonoInst *inst, MonoDebugVarInfo *var) { + var->type = inst->inst_vtype; + if (inst->opcode == OP_REGVAR) var->index = inst->dreg | MONO_DEBUG_VAR_ADDRESS_MODE_REGISTER; - else { + else if (inst->flags & MONO_INST_IS_DEAD) { + // FIXME: + var->index = 0 | MONO_DEBUG_VAR_ADDRESS_MODE_REGISTER; + } else { /* the debug interface needs fixing to allow 0(%base) address */ var->index = inst->inst_basereg | MONO_DEBUG_VAR_ADDRESS_MODE_REGOFFSET; var->offset = inst->inst_offset; @@ -195,6 +241,7 @@ mono_debug_close_method (MonoCompile *cfg) MonoDebugMethodJitInfo *jit; MonoMethodHeader *header; MonoMethodSignature *sig; + MonoDebugMethodAddress *debug_info; MonoMethod *method; int i; @@ -214,21 +261,22 @@ mono_debug_close_method (MonoCompile *cfg) jit->epilogue_begin = cfg->epilog_begin; jit->code_size = cfg->code_len; - record_line_number (info, jit->epilogue_begin, header->code_size); + if (jit->epilogue_begin) + record_line_number (info, jit->epilogue_begin, header->code_size); jit->num_params = sig->param_count; jit->params = g_new0 (MonoDebugVarInfo, jit->num_params); for (i = 0; i < jit->num_locals; i++) - write_variable (cfg->varinfo [cfg->locals_start + i], &jit->locals [i]); + write_variable (cfg->locals [i], &jit->locals [i]); if (sig->hasthis) { jit->this_var = g_new0 (MonoDebugVarInfo, 1); - write_variable (cfg->varinfo [0], jit->this_var); + write_variable (cfg->args [0], jit->this_var); } for (i = 0; i < jit->num_params; i++) - write_variable (cfg->varinfo [i + sig->hasthis], &jit->params [i]); + write_variable (cfg->args [i + sig->hasthis], &jit->params [i]); jit->num_line_numbers = info->line_numbers->len; jit->line_numbers = g_new0 (MonoDebugLineNumberEntry, jit->num_line_numbers); @@ -236,13 +284,15 @@ mono_debug_close_method (MonoCompile *cfg) for (i = 0; i < jit->num_line_numbers; i++) jit->line_numbers [i] = g_array_index (info->line_numbers, MonoDebugLineNumberEntry, i); - mono_debug_add_method (method, jit, cfg->domain); + debug_info = mono_debug_add_method (method, jit, cfg->domain); mono_debug_add_vg_method (method, jit); if (info->breakpoint_id) mono_debugger_breakpoint_callback (method, info->breakpoint_id); + mono_debugger_check_breakpoints (method, debug_info); + mono_debug_free_method_jit_info (jit); g_array_free (info->line_numbers, TRUE); g_free (info); @@ -390,18 +440,17 @@ serialize_variable (MonoDebugVarInfo *var, guint8 *p, guint8 **endbuf) void mono_debug_serialize_debug_info (MonoCompile *cfg, guint8 **out_buf, guint32 *buf_len) { - MiniDebugMethodInfo *info; MonoDebugMethodJitInfo *jit; guint32 size, prev_offset, prev_native_offset; guint8 *buf, *p; int i; - info = (MiniDebugMethodInfo *) cfg->debug_info; - if (!info || !info->jit) { + /* Can't use cfg->debug_info as it is freed by close_method () */ + jit = mono_debug_find_method (cfg->method, mono_domain_get ()); + if (!jit) { *buf_len = 0; return; } - jit = info->jit; size = ((jit->num_params + jit->num_locals + 1) * 10) + (jit->num_line_numbers * 10) + 64; p = buf = g_malloc (size); @@ -535,12 +584,6 @@ mono_debug_add_aot_method (MonoDomain *domain, MonoMethod *method, guint8 *code_ jit = deserialize_debug_info (method, code_start, debug_info, debug_info_len); -#if 0 - jit = mono_debug_read_method ((MonoDebugMethodAddress *) debug_info); - jit->code_start = code_start; - jit->wrapper_addr = NULL; -#endif - mono_debug_add_method (method, jit, domain); mono_debug_add_vg_method (method, jit); @@ -589,20 +632,16 @@ mono_debug_print_vars (gpointer ip, gboolean only_arguments) { MonoDomain *domain = mono_domain_get (); MonoJitInfo *ji = mono_jit_info_table_find (domain, ip); - MonoDebugMethodInfo *minfo; MonoDebugMethodJitInfo *jit; int i; if (!ji) return; - minfo = mono_debug_lookup_method (mono_jit_info_get_method (ji)); - if (!minfo) - return; - - jit = mono_debug_find_method (minfo, domain); + jit = mono_debug_find_method (mono_jit_info_get_method (ji), domain); if (!jit) return; + if (only_arguments) { char **names; names = g_new (char *, jit->num_params); @@ -618,5 +657,194 @@ mono_debug_print_vars (gpointer ip, gboolean only_arguments) print_var_info (&jit->locals [i], i, "", "Local"); } } + mono_debug_free_method_jit_info (jit); +} + +/* + * The old Debugger breakpoint interface. + * + * This interface is used to insert breakpoints on methods which are not yet JITed. + * The debugging code keeps a list of all such breakpoints and automatically inserts the + * breakpoint when the method is JITed. + */ + +static GPtrArray *breakpoints = NULL; + +int +mono_debugger_insert_breakpoint_full (MonoMethodDesc *desc) +{ + static int last_breakpoint_id = 0; + MiniDebugBreakpointInfo *info; + + info = g_new0 (MiniDebugBreakpointInfo, 1); + info->desc = desc; + info->index = ++last_breakpoint_id; + + if (!breakpoints) + breakpoints = g_ptr_array_new (); + + g_ptr_array_add (breakpoints, info); + + return info->index; +} + +int +mono_debugger_remove_breakpoint (int breakpoint_id) +{ + int i; + + if (!breakpoints) + return 0; + + for (i = 0; i < breakpoints->len; i++) { + MiniDebugBreakpointInfo *info = g_ptr_array_index (breakpoints, i); + + if (info->index != breakpoint_id) + continue; + + mono_method_desc_free (info->desc); + g_ptr_array_remove (breakpoints, info); + g_free (info); + return 1; + } + + return 0; +} + +int +mono_debugger_insert_breakpoint (const gchar *method_name, gboolean include_namespace) +{ + MonoMethodDesc *desc; + + desc = mono_method_desc_new (method_name, include_namespace); + if (!desc) + return 0; + + return mono_debugger_insert_breakpoint_full (desc); +} + +int +mono_debugger_method_has_breakpoint (MonoMethod *method) +{ + int i; + + if (!breakpoints || (method->wrapper_type != MONO_WRAPPER_NONE)) + return 0; + + for (i = 0; i < breakpoints->len; i++) { + MiniDebugBreakpointInfo *info = g_ptr_array_index (breakpoints, i); + + if (!mono_method_desc_full_match (info->desc, method)) + continue; + + return info->index; + } + + return 0; +} + +void +mono_debugger_breakpoint_callback (MonoMethod *method, guint32 index) +{ + mono_debugger_event (MONO_DEBUGGER_EVENT_JIT_BREAKPOINT, (guint64) (gsize) method, index); +} + +void +mono_debugger_thread_created (gsize tid, MonoThread *thread, MonoJitTlsData *jit_tls) +{ +#ifdef MONO_DEBUGGER_SUPPORTED + size_t stsize = 0; + guint8 *staddr = NULL; + MonoDebuggerThreadInfo *info; + + if (mono_debug_format == MONO_DEBUG_FORMAT_NONE) + return; + + mono_debugger_lock (); + + mono_thread_get_stack_bounds (&staddr, &stsize); + + info = g_new0 (MonoDebuggerThreadInfo, 1); + info->tid = tid; + info->thread = thread; + info->stack_start = (guint64) (gsize) staddr; + info->signal_stack_start = (guint64) (gsize) jit_tls->signal_stack; + info->stack_size = stsize; + info->signal_stack_size = jit_tls->signal_stack_size; + info->end_stack = (guint64) (gsize) GC_mono_debugger_get_stack_ptr (); + info->lmf_addr = (guint64) (gsize) mono_get_lmf_addr (); + info->jit_tls = jit_tls; + + info->next = mono_debugger_thread_table; + mono_debugger_thread_table = info; + + mono_debugger_event (MONO_DEBUGGER_EVENT_THREAD_CREATED, + tid, (guint64) (gsize) info); + + mono_debugger_unlock (); +#endif /* MONO_DEBUGGER_SUPPORTED */ +} + +void +mono_debugger_thread_cleanup (MonoJitTlsData *jit_tls) +{ +#ifdef MONO_DEBUGGER_SUPPORTED + MonoDebuggerThreadInfo **ptr; + + if (mono_debug_format == MONO_DEBUG_FORMAT_NONE) + return; + + mono_debugger_lock (); + + for (ptr = &mono_debugger_thread_table; *ptr; ptr = &(*ptr)->next) { + MonoDebuggerThreadInfo *info = *ptr; + + if (info->jit_tls != jit_tls) + continue; + + mono_debugger_event (MONO_DEBUGGER_EVENT_THREAD_CLEANUP, + info->tid, (guint64) (gsize) info); + + *ptr = info->next; + g_free (info); + break; + } + + mono_debugger_unlock (); +#endif } +void +mono_debugger_extended_notification (MonoDebuggerEvent event, guint64 data, guint64 arg) +{ +#ifdef MONO_DEBUGGER_SUPPORTED + MonoDebuggerThreadInfo **ptr; + MonoThread *thread = mono_thread_current (); + + if (!mono_debug_using_mono_debugger ()) + return; + + mono_debugger_lock (); + + for (ptr = &mono_debugger_thread_table; *ptr; ptr = &(*ptr)->next) { + MonoDebuggerThreadInfo *info = *ptr; + + if (info->thread != thread) + continue; + + if ((info->extended_notifications & (int) event) == 0) + continue; + + mono_debugger_event (event, data, arg); + } + + mono_debugger_unlock (); +#endif +} + +void +mono_debugger_trampoline_compiled (MonoMethod *method, const guint8 *code) +{ + mono_debugger_extended_notification (MONO_DEBUGGER_EVENT_TRAMPOLINE, + (guint64) (gsize) method, (guint64) (gsize) code); +}