X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmini%2Ftrace.c;h=d9a5b50e41fd2b1c4e44bfdf0daa605c99588e93;hb=ec3740aa803f594718e5080f733bd2b5988f7d4d;hp=1a687005fafa46a7d62913da106c20cb75a8776e;hpb=51f5800c2dfaea59325338e13d51c82fe644c23f;p=mono.git diff --git a/mono/mini/trace.c b/mono/mini/trace.c index 1a687005faf..d9a5b50e41f 100644 --- a/mono/mini/trace.c +++ b/mono/mini/trace.c @@ -6,19 +6,67 @@ * Dietmar Maurer (dietmar@ximian.com) * * (C) 2002 Ximian, Inc. + * Copyright 2011 Xamarin, Inc (http://www.xamarin.com) */ #include #include +#ifdef HAVE_ALLOCA_H +#include +#endif +#ifdef HAVE_UNISTD_H #include +#endif #include #include "mini.h" #include #include +#include #include "trace.h" +#if defined (PLATFORM_ANDROID) || (defined (TARGET_IOS) && defined (TARGET_IOS)) +# undef printf +# define printf(...) g_log("mono", G_LOG_LEVEL_MESSAGE, __VA_ARGS__) +# undef fprintf +# define fprintf(__ignore, ...) g_log ("mono-gc", G_LOG_LEVEL_MESSAGE, __VA_ARGS__) +#endif + static MonoTraceSpec trace_spec; +gboolean +mono_trace_eval_exception (MonoClass *klass) +{ + int include = 0; + int i; + + if (!klass) + return FALSE; + + for (i = 0; i < trace_spec.len; i++) { + MonoTraceOperation *op = &trace_spec.ops [i]; + int inc = 0; + + switch (op->op){ + case MONO_TRACEOP_EXCEPTION: + if (strcmp ("", op->data) == 0 && strcmp ("all", op->data2) == 0) + inc = 1; + else if (strcmp ("", op->data) == 0 || strcmp (klass->name_space, op->data) == 0) + if (strcmp (klass->name, op->data2) == 0) + inc = 1; + break; + default: + break; + } + if (op->exclude){ + if (inc) + include = 0; + } else if (inc) + include = 1; + } + + return include; +} + gboolean mono_trace_eval (MonoMethod *method) { @@ -33,7 +81,11 @@ mono_trace_eval (MonoMethod *method) case MONO_TRACEOP_ALL: inc = 1; break; case MONO_TRACEOP_PROGRAM: - if (method->klass->image == mono_assembly_get_image (trace_spec.assembly)) + if (trace_spec.assembly && (method->klass->image == mono_assembly_get_image (trace_spec.assembly))) + inc = 1; break; + case MONO_TRACEOP_WRAPPER: + if ((method->wrapper_type == MONO_WRAPPER_NATIVE_TO_MANAGED) || + (method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE)) inc = 1; break; case MONO_TRACEOP_METHOD: if (mono_method_desc_full_match ((MonoMethodDesc *) op->data, method)) @@ -49,6 +101,8 @@ mono_trace_eval (MonoMethod *method) case MONO_TRACEOP_NAMESPACE: if (strcmp (method->klass->name_space, op->data) == 0) inc = 1; + case MONO_TRACEOP_EXCEPTION: + break; } if (op->exclude){ if (inc) @@ -65,7 +119,9 @@ static int is_filenamechar (char p) return TRUE; if (p >= 'a' && p <= 'z') return TRUE; - if (p == '.' || p == ':') + if (p >= '0' && p <= '9') + return TRUE; + if (p == '.' || p == ':' || p == '_' || p == '-') return TRUE; return FALSE; } @@ -91,9 +147,12 @@ enum Token { TOKEN_CLASS, TOKEN_ALL, TOKEN_PROGRAM, + TOKEN_EXCEPTION, TOKEN_NAMESPACE, + TOKEN_WRAPPER, TOKEN_STRING, TOKEN_EXCLUDE, + TOKEN_DISABLED, TOKEN_SEPARATOR, TOKEN_END, TOKEN_ERROR @@ -102,42 +161,55 @@ enum Token { static int get_token (void) { - while (*input != 0){ - if (input [0] == 'M' && input [1] == ':'){ - input += 2; - get_string (); - return TOKEN_METHOD; - } - if (input [0] == 'N' && input [1] == ':'){ - input += 2; - get_string (); - return TOKEN_NAMESPACE; - } - if (input [0] == 'T' && input [1] == ':'){ - input += 2; - get_string (); - return TOKEN_CLASS; - } - if (is_filenamechar (*input)){ - get_string (); - if (strcmp (value, "all") == 0) - return TOKEN_ALL; - if (strcmp (value, "program") == 0) - return TOKEN_PROGRAM; - return TOKEN_STRING; - } - if (*input == '-'){ - input++; - return TOKEN_EXCLUDE; - } - if (*input == ','){ - input++; - return TOKEN_SEPARATOR; - } + while (input [0] == '+') input++; - + + if (input [0] == '\0') { + return TOKEN_END; + } + if (input [0] == 'M' && input [1] == ':'){ + input += 2; + get_string (); + return TOKEN_METHOD; + } + if (input [0] == 'N' && input [1] == ':'){ + input += 2; + get_string (); + return TOKEN_NAMESPACE; + } + if (input [0] == 'T' && input [1] == ':'){ + input += 2; + get_string (); + return TOKEN_CLASS; + } + if (input [0] == 'E' && input [1] == ':'){ + input += 2; + get_string (); + return TOKEN_EXCEPTION; + } + if (*input == '-'){ + input++; + return TOKEN_EXCLUDE; + } + if (is_filenamechar (*input)){ + get_string (); + if (strcmp (value, "all") == 0) + return TOKEN_ALL; + if (strcmp (value, "program") == 0) + return TOKEN_PROGRAM; + if (strcmp (value, "wrapper") == 0) + return TOKEN_WRAPPER; + if (strcmp (value, "disabled") == 0) + return TOKEN_DISABLED; + return TOKEN_STRING; } - return TOKEN_END; + if (*input == ','){ + input++; + return TOKEN_SEPARATOR; + } + + fprintf (stderr, "Syntax error at or around '%s'\n", input); + return TOKEN_ERROR; } static void @@ -177,20 +249,29 @@ get_spec (int *last) trace_spec.ops [*last].op = MONO_TRACEOP_ALL; else if (token == TOKEN_PROGRAM) trace_spec.ops [*last].op = MONO_TRACEOP_PROGRAM; + else if (token == TOKEN_WRAPPER) + trace_spec.ops [*last].op = MONO_TRACEOP_WRAPPER; else if (token == TOKEN_NAMESPACE){ trace_spec.ops [*last].op = MONO_TRACEOP_NAMESPACE; trace_spec.ops [*last].data = g_strdup (value); - } else if (token == TOKEN_CLASS){ + } else if (token == TOKEN_CLASS || token == TOKEN_EXCEPTION){ char *p = strrchr (value, '.'); - *p++ = 0; - trace_spec.ops [*last].op = MONO_TRACEOP_CLASS; - trace_spec.ops [*last].data = g_strdup (value); - trace_spec.ops [*last].data2 = g_strdup (p); + if (p) { + *p++ = 0; + trace_spec.ops [*last].data = g_strdup (value); + trace_spec.ops [*last].data2 = g_strdup (p); + } + else { + trace_spec.ops [*last].data = g_strdup (""); + trace_spec.ops [*last].data2 = g_strdup (value); + } + trace_spec.ops [*last].op = token == TOKEN_CLASS ? MONO_TRACEOP_CLASS : MONO_TRACEOP_EXCEPTION; } else if (token == TOKEN_STRING){ trace_spec.ops [*last].op = MONO_TRACEOP_ASSEMBLY; trace_spec.ops [*last].data = g_strdup (value); - } - else { + } else if (token == TOKEN_DISABLED) { + trace_spec.enabled = FALSE; + } else { fprintf (stderr, "Syntax error in trace option specification\n"); return TOKEN_ERROR; } @@ -199,15 +280,14 @@ get_spec (int *last) } MonoTraceSpec * -mono_trace_parse_options (MonoAssembly *assembly, char *options) +mono_trace_parse_options (const char *options) { - char *p = options; + char *p = (char*)options; int size = 1; int last_used; int token; - - trace_spec.assembly = assembly; - + + trace_spec.enabled = TRUE; if (*p == 0){ trace_spec.len = 1; trace_spec.ops = g_new0 (MonoTraceOperation, 1); @@ -215,13 +295,13 @@ mono_trace_parse_options (MonoAssembly *assembly, char *options) return &trace_spec; } - for (p = options; *p != 0; p++) + for (p = (char*)options; *p != 0; p++) if (*p == ',') size++; trace_spec.ops = g_new0 (MonoTraceOperation, size); - input = options; + input = (char*)options; last_used = 0; while ((token = (get_spec (&last_used))) != TOKEN_END){ @@ -235,21 +315,71 @@ mono_trace_parse_options (MonoAssembly *assembly, char *options) return &trace_spec; } -static int indent_level = 0; +void +mono_trace_set_assembly (MonoAssembly *assembly) +{ + trace_spec.assembly = assembly; +} + +static +#ifdef HAVE_KW_THREAD +__thread +#endif +int indent_level = 0; +static guint64 start_time = 0; + +static double seconds_since_start (void) +{ + guint64 diff = mono_100ns_ticks () - start_time; + return diff/10000000.0; +} static void indent (int diff) { - int v; if (diff < 0) indent_level += diff; - v = indent_level; - while (v-- > 0) { - printf (". "); - } + if (start_time == 0) + start_time = mono_100ns_ticks (); + printf ("[%p: %.5f %d] ", (void*)GetCurrentThreadId (), seconds_since_start (), indent_level); if (diff > 0) indent_level += diff; } -static gboolean enable_trace = TRUE; +static char * +string_to_utf8 (MonoString *s) +{ + char *as; + GError *error = NULL; + + g_assert (s); + + if (!s->length) + return g_strdup (""); + + as = g_utf16_to_utf8 (mono_string_chars (s), s->length, NULL, NULL, &error); + if (error) { + /* Happens with StringBuilders */ + g_error_free (error); + return g_strdup (""); + } + else + return as; +} + +/* + * cpos (ebp + arg_info[n].offset) points to the beginning of the + * stack slot for this argument. On little-endian systems, we can + * simply dereference it. On big-endian systems, we need to adjust + * cpos upward first if the datatype we're referencing is smaller than + * a stack slot. Also - one can't assume that gpointer is also the + * size of a stack slot - use SIZEOF_REGISTER instead. The following + * helper macro tries to keep down the mess of all the pointer + * calculations. + */ +#if (G_BYTE_ORDER == G_LITTLE_ENDIAN) +#define arg_in_stack_slot(cpos, type) ((type *)(cpos)) +#else +#define arg_in_stack_slot(cpos, type) ((type *)((sizeof(type) < SIZEOF_REGISTER) ? (((gssize)(cpos)) + SIZEOF_REGISTER - sizeof(type)) : (gssize)(cpos))) +#endif void mono_trace_enter_method (MonoMethod *method, char *ebp) @@ -261,7 +391,7 @@ mono_trace_enter_method (MonoMethod *method, char *ebp) MonoMethodSignature *sig; char *fname; - if (!enable_trace) + if (!trace_spec.enabled) return; fname = mono_method_full_name (method, TRUE); @@ -273,34 +403,35 @@ mono_trace_enter_method (MonoMethod *method, char *ebp) printf (") ip: %p\n", __builtin_return_address (1)); return; } - if (((int)ebp & (MONO_ARCH_FRAME_ALIGNMENT - 1)) != 0) { - g_error ("unaligned stack detected (%p)", ebp); - } - sig = method->signature; + sig = mono_method_signature (method); arg_info = alloca (sizeof (MonoJitArgumentInfo) * (sig->param_count + 1)); - mono_arch_get_argument_info (sig, sig->param_count, arg_info); + mono_arch_get_argument_info (NULL, sig, sig->param_count, arg_info); - if (MONO_TYPE_ISSTRUCT (method->signature->ret)) { - g_assert (!method->signature->ret->byref); + if (MONO_TYPE_ISSTRUCT (mono_method_signature (method)->ret)) { + g_assert (!mono_method_signature (method)->ret->byref); printf ("VALUERET:%p, ", *((gpointer *)(ebp + 8))); } - if (method->signature->hasthis) { + if (mono_method_signature (method)->hasthis) { gpointer *this = (gpointer *)(ebp + arg_info [0].offset); if (method->klass->valuetype) { - printf ("value:%p, ", *this); + printf ("value:%p, ", *arg_in_stack_slot(this, gpointer *)); } else { - o = *((MonoObject **)this); + o = *arg_in_stack_slot(this, MonoObject *); if (o) { class = o->vtable->klass; if (class == mono_defaults.string_class) { - printf ("this:[STRING:%p:%s], ", o, mono_string_to_utf8 ((MonoString *)o)); + MonoString *s = (MonoString*)o; + char *as = string_to_utf8 (s); + + printf ("this:[STRING:%p:%s], ", o, as); + g_free (as); } else { printf ("this:%p[%s.%s %s], ", o, class->name_space, class->name, o->vtable->domain->friendly_name); } @@ -309,57 +440,67 @@ mono_trace_enter_method (MonoMethod *method, char *ebp) } } - for (i = 0; i < method->signature->param_count; ++i) { + for (i = 0; i < mono_method_signature (method)->param_count; ++i) { gpointer *cpos = (gpointer *)(ebp + arg_info [i + 1].offset); int size = arg_info [i + 1].size; - MonoType *type = method->signature->params [i]; + MonoType *type = mono_method_signature (method)->params [i]; if (type->byref) { - printf ("[BYREF:%p], ", *cpos); - } else switch (type->type) { + printf ("[BYREF:%p], ", *arg_in_stack_slot(cpos, gpointer *)); + } else switch (mono_type_get_underlying_type (type)->type) { case MONO_TYPE_I: case MONO_TYPE_U: - printf ("%p, ", (gpointer)*((int *)(cpos))); + printf ("%p, ", *arg_in_stack_slot(cpos, gpointer *)); break; case MONO_TYPE_BOOLEAN: case MONO_TYPE_CHAR: case MONO_TYPE_I1: case MONO_TYPE_U1: - printf ("%d, ", *((gint8 *)(cpos))); + printf ("%d, ", *arg_in_stack_slot(cpos, gint8)); break; case MONO_TYPE_I2: case MONO_TYPE_U2: - printf ("%d, ", *((gint16 *)(cpos))); + printf ("%d, ", *arg_in_stack_slot(cpos, gint16)); break; case MONO_TYPE_I4: case MONO_TYPE_U4: - printf ("%d, ", *((int *)(cpos))); + printf ("%d, ", *arg_in_stack_slot(cpos, int)); break; case MONO_TYPE_STRING: { - MonoString *s = *((MonoString **)cpos); + MonoString *s = *arg_in_stack_slot(cpos, MonoString *); if (s) { + char *as; + g_assert (((MonoObject *)s)->vtable->klass == mono_defaults.string_class); - printf ("[STRING:%p:%s], ", s, mono_string_to_utf8 (s)); + as = string_to_utf8 (s); + + printf ("[STRING:%p:%s], ", s, as); + g_free (as); } else printf ("[STRING:null], "); break; } case MONO_TYPE_CLASS: case MONO_TYPE_OBJECT: { - o = *((MonoObject **)cpos); + o = *arg_in_stack_slot(cpos, MonoObject *); if (o) { class = o->vtable->klass; if (class == mono_defaults.string_class) { - printf ("[STRING:%p:%s], ", o, mono_string_to_utf8 ((MonoString *)o)); + char *as = string_to_utf8 ((MonoString*)o); + + printf ("[STRING:%p:%s], ", o, as); + g_free (as); } else if (class == mono_defaults.int32_class) { printf ("[INT32:%p:%d], ", o, *(gint32 *)((char *)o + sizeof (MonoObject))); + } else if (class == mono_defaults.monotype_class) { + printf ("[TYPE:%s], ", mono_type_full_name (((MonoReflectionType*)o)->type)); } else printf ("[%s.%s:%p], ", class->name_space, class->name, o); } else { - printf ("%p, ", *((gpointer *)(cpos))); + printf ("%p, ", *arg_in_stack_slot(cpos, gpointer)); } break; } @@ -367,17 +508,17 @@ mono_trace_enter_method (MonoMethod *method, char *ebp) case MONO_TYPE_FNPTR: case MONO_TYPE_ARRAY: case MONO_TYPE_SZARRAY: - printf ("%p, ", *((gpointer *)(cpos))); + printf ("%p, ", *arg_in_stack_slot(cpos, gpointer)); break; case MONO_TYPE_I8: case MONO_TYPE_U8: - printf ("0x%016llx, ", *((gint64 *)(cpos))); + printf ("0x%016llx, ", (long long)*arg_in_stack_slot(cpos, gint64)); break; case MONO_TYPE_R4: - printf ("%f, ", *((float *)(cpos))); + printf ("%f, ", *arg_in_stack_slot(cpos, float)); break; case MONO_TYPE_R8: - printf ("%f, ", *((double *)(cpos))); + printf ("%f, ", *arg_in_stack_slot(cpos, double)); break; case MONO_TYPE_VALUETYPE: printf ("["); @@ -391,6 +532,7 @@ mono_trace_enter_method (MonoMethod *method, char *ebp) } printf (")\n"); + fflush (stdout); } void @@ -400,7 +542,7 @@ mono_trace_leave_method (MonoMethod *method, ...) char *fname; va_list ap; - if (!enable_trace) + if (!trace_spec.enabled) return; va_start(ap, method); @@ -410,7 +552,7 @@ mono_trace_leave_method (MonoMethod *method, ...) printf ("LEAVE: %s", fname); g_free (fname); - type = method->signature->ret; + type = mono_method_signature (method)->ret; handle_enum: switch (type->type) { @@ -442,8 +584,12 @@ handle_enum: MonoString *s = va_arg (ap, MonoString *); ; if (s) { + char *as; + g_assert (((MonoObject *)s)->vtable->klass == mono_defaults.string_class); - printf ("[STRING:%p:%s]", s, mono_string_to_utf8 (s)); + as = string_to_utf8 (s); + printf ("[STRING:%p:%s]", s, as); + g_free (as); } else printf ("[STRING:null], "); break; @@ -458,7 +604,7 @@ handle_enum: } else if (o->vtable->klass == mono_defaults.int32_class) { printf ("[INT32:%p:%d]", o, *((gint32 *)((char *)o + sizeof (MonoObject)))); } else if (o->vtable->klass == mono_defaults.int64_class) { - printf ("[INT64:%p:%lld]", o, *((gint64 *)((char *)o + sizeof (MonoObject)))); + printf ("[INT64:%p:%lld]", o, (long long)*((gint64 *)((char *)o + sizeof (MonoObject)))); } else printf ("[%s.%s:%p]", o->vtable->klass->name_space, o->vtable->klass->name, o); } else @@ -476,12 +622,12 @@ handle_enum: } case MONO_TYPE_I8: { gint64 l = va_arg (ap, gint64); - printf ("lresult=0x%16llx", l); + printf ("lresult=0x%16llx", (long long)l); break; } case MONO_TYPE_U8: { gint64 l = va_arg (ap, gint64); - printf ("lresult=0x%16llx", l); + printf ("lresult=0x%16llx", (long long)l); break; } case MONO_TYPE_R4: @@ -492,7 +638,7 @@ handle_enum: } case MONO_TYPE_VALUETYPE: if (type->data.klass->enumtype) { - type = type->data.klass->enum_basetype; + type = mono_class_enum_basetype (type->data.klass); goto handle_enum; } else { guint8 *p = va_arg (ap, gpointer); @@ -505,9 +651,22 @@ handle_enum: } break; default: - printf ("(unknown return type %x)", method->signature->ret->type); + printf ("(unknown return type %x)", mono_method_signature (method)->ret->type); } //printf (" ip: %p\n", __builtin_return_address (1)); printf ("\n"); + fflush (stdout); +} + +void +mono_trace_enable (gboolean enable) +{ + trace_spec.enabled = enable; +} + +gboolean +mono_trace_is_enabled () +{ + return trace_spec.enabled; }