X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmini%2Ftrace.c;h=d9a5b50e41fd2b1c4e44bfdf0daa605c99588e93;hb=ec3740aa803f594718e5080f733bd2b5988f7d4d;hp=11fdb054c1de17d3e79b3b5e81701aa25024866f;hpb=b585d00928892398dfbfc315ed78b8032fa14708;p=mono.git diff --git a/mono/mini/trace.c b/mono/mini/trace.c index 11fdb054c1d..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) { @@ -35,6 +83,10 @@ mono_trace_eval (MonoMethod *method) case MONO_TRACEOP_PROGRAM: 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)) inc = 1; break; @@ -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) @@ -67,7 +121,7 @@ static int is_filenamechar (char p) return TRUE; if (p >= '0' && p <= '9') return TRUE; - if (p == '.' || p == ':' || p == '_') + if (p == '.' || p == ':' || p == '_' || p == '-') return TRUE; return FALSE; } @@ -93,7 +147,9 @@ enum Token { TOKEN_CLASS, TOKEN_ALL, TOKEN_PROGRAM, + TOKEN_EXCEPTION, TOKEN_NAMESPACE, + TOKEN_WRAPPER, TOKEN_STRING, TOKEN_EXCLUDE, TOKEN_DISABLED, @@ -105,6 +161,9 @@ enum Token { static int get_token (void) { + while (input [0] == '+') + input++; + if (input [0] == '\0') { return TOKEN_END; } @@ -123,20 +182,27 @@ get_token (void) 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; } - if (*input == '-'){ - input++; - return TOKEN_EXCLUDE; - } if (*input == ','){ input++; return TOKEN_SEPARATOR; @@ -183,10 +249,12 @@ 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, '.'); if (p) { *p++ = 0; @@ -197,7 +265,7 @@ get_spec (int *last) trace_spec.ops [*last].data = g_strdup (""); trace_spec.ops [*last].data2 = g_strdup (value); } - trace_spec.ops [*last].op = MONO_TRACEOP_CLASS; + 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); @@ -212,9 +280,9 @@ get_spec (int *last) } MonoTraceSpec * -mono_trace_parse_options (char *options) +mono_trace_parse_options (const char *options) { - char *p = options; + char *p = (char*)options; int size = 1; int last_used; int token; @@ -227,13 +295,13 @@ mono_trace_parse_options (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){ @@ -253,20 +321,66 @@ mono_trace_set_assembly (MonoAssembly *assembly) trace_spec.assembly = assembly; } -static int indent_level = 0; +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 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) { @@ -289,15 +403,12 @@ mono_trace_enter_method (MonoMethod *method, char *ebp) printf (") ip: %p\n", __builtin_return_address (1)); return; } - if ((GPOINTER_TO_INT (ebp) & (MONO_ARCH_FRAME_ALIGNMENT - 1)) != 0) { - g_error ("unaligned stack detected (%p)", ebp); - } 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 (mono_method_signature (method)->ret)) { g_assert (!mono_method_signature (method)->ret->byref); @@ -308,15 +419,19 @@ mono_trace_enter_method (MonoMethod *method, char *ebp) 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); } @@ -332,50 +447,60 @@ mono_trace_enter_method (MonoMethod *method, char *ebp) MonoType *type = mono_method_signature (method)->params [i]; if (type->byref) { - printf ("[BYREF:%p], ", *cpos); + 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 **)(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; } @@ -383,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, ", (long long)*((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 ("["); @@ -407,6 +532,7 @@ mono_trace_enter_method (MonoMethod *method, char *ebp) } printf (")\n"); + fflush (stdout); } void @@ -458,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; @@ -508,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); @@ -526,6 +656,7 @@ handle_enum: //printf (" ip: %p\n", __builtin_return_address (1)); printf ("\n"); + fflush (stdout); } void @@ -539,4 +670,3 @@ mono_trace_is_enabled () { return trace_spec.enabled; } -