projects / mono.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
[sgen] Fix warning
[mono.git] / mono / metadata / loader.c
diff --git a/mono/metadata/loader.c b/mono/metadata/loader.c
index dc9259d560934e6b72e44df111fdad0985e950e0..0db6ff561fb9bc5f6298081dc9510d2bb94a9ecf 100644 (file)
--- a/mono/metadata/loader.c
+++ b/mono/metadata/loader.c
@@ -103,6 +103,7 @@ mono_loader_init ()
                mono_native_tls_alloc (&loader_error_thread_id, NULL);
                mono_native_tls_alloc (&loader_lock_nest_id, NULL);
 
+               mono_counters_init ();
                mono_counters_register ("Inflated signatures size",
                                                                MONO_COUNTER_GENERICS | MONO_COUNTER_INT, &inflated_signatures_size);
                mono_counters_register ("Memberref signature cache size",
@@ -286,6 +287,17 @@ mono_loader_get_last_error (void)
        return (MonoLoaderError*)mono_native_tls_get_value (loader_error_thread_id);
 }
 
+void
+mono_loader_assert_no_error (void)
+{
+       MonoLoaderError *error = mono_loader_get_last_error ();
+
+       if (error) {
+               g_print ("Unhandled loader error: %x, %s %s %s\n", error->exception_type, error->msg, error->assembly_name, error->class_name);
+               g_assert_not_reached ();
+       }
+}
+
 /**
  * mono_loader_clear_error:
  *
@@ -447,7 +459,7 @@ field_from_memberref (MonoImage *image, guint32 token, MonoClass **retklass,
        MonoTableInfo *tables = image->tables;
        MonoType *sig_type;
        guint32 cols[6];
-       guint32 nindex, class, class_table;
+       guint32 nindex, class;
        const char *fname;
        const char *ptr;
        guint32 idx = mono_metadata_token_index (token);
@@ -467,15 +479,12 @@ field_from_memberref (MonoImage *image, guint32 token, MonoClass **retklass,
 
        switch (class) {
        case MONO_MEMBERREF_PARENT_TYPEDEF:
-               class_table = MONO_TOKEN_TYPE_DEF;
                klass = mono_class_get_checked (image, MONO_TOKEN_TYPE_DEF | nindex, error);
                break;
        case MONO_MEMBERREF_PARENT_TYPEREF:
-               class_table = MONO_TOKEN_TYPE_REF;
                klass = mono_class_from_typeref_checked (image, MONO_TOKEN_TYPE_REF | nindex, error);
                break;
        case MONO_MEMBERREF_PARENT_TYPESPEC:
-               class_table = MONO_TOKEN_TYPE_SPEC;
                klass = mono_class_get_and_inflate_typespec_checked (image, MONO_TOKEN_TYPE_SPEC | nindex, context, error);
                break;
        default:
@@ -513,7 +522,7 @@ field_from_memberref (MonoImage *image, guint32 token, MonoClass **retklass,
        field = mono_class_get_field_from_name_full (klass, fname, sig_type);
 
        if (!field) {
-               g_assert (!mono_loader_get_last_error ());
+               mono_loader_assert_no_error ();
                mono_error_set_field_load (error, klass, fname, "Could not find field '%s'", fname);
        }
 
@@ -529,7 +538,7 @@ mono_field_from_token (MonoImage *image, guint32 token, MonoClass **retklass, Mo
 {
        MonoError error;
        MonoClassField *res = mono_field_from_token_checked (image, token, retklass, context, &error);
-       g_assert (!mono_loader_get_last_error ());
+       mono_loader_assert_no_error ();
        if (!mono_error_ok (&error)) {
                mono_loader_set_error_from_mono_error (&error);
                mono_error_cleanup (&error);
@@ -568,7 +577,7 @@ mono_field_from_token_checked (MonoImage *image, guint32 token, MonoClass **retk
 
        if (mono_metadata_token_table (token) == MONO_TABLE_MEMBERREF) {
                field = field_from_memberref (image, token, retklass, context, error);
-               g_assert (!mono_loader_get_last_error ());
+               mono_loader_assert_no_error ();
        } else {
                type = mono_metadata_typedef_from_field (image, mono_metadata_token_index (token));
                if (!type) {
@@ -591,10 +600,13 @@ mono_field_from_token_checked (MonoImage *image, guint32 token, MonoClass **retk
                }
        }
 
-       if (field && field->parent && !field->parent->generic_class && !field->parent->generic_container)
+       if (field && field->parent && !field->parent->generic_class && !field->parent->generic_container) {
+               mono_image_lock (image);
                mono_conc_hashtable_insert (image->field_cache, GUINT_TO_POINTER (token), field);
+               mono_image_unlock (image);
+       }
 
-       g_assert (!mono_loader_get_last_error ());
+       mono_loader_assert_no_error ();
        return field;
 }
 
@@ -892,7 +904,7 @@ mono_method_get_signature_full (MonoMethod *method, MonoImage *image, guint32 to
        MonoError error;
        MonoMethodSignature *res = mono_method_get_signature_checked (method, image, token, context, &error);
 
-       g_assert (!mono_loader_get_last_error ());
+       mono_loader_assert_no_error ();
 
        if (!res) {
                g_assert (!mono_error_ok (&error));
@@ -993,7 +1005,7 @@ mono_method_get_signature (MonoMethod *method, MonoImage *image, guint32 token)
        MonoError error;
        MonoMethodSignature *res = mono_method_get_signature_checked (method, image, token, NULL, &error);
 
-       g_assert (!mono_loader_get_last_error ());
+       mono_loader_assert_no_error ();
 
        if (!res) {
                g_assert (!mono_error_ok (&error));
@@ -1145,11 +1157,11 @@ method_from_memberref (MonoImage *image, guint32 idx, MonoGenericContext *typesp
                g_free (msig);
        }
 
-       g_assert (!mono_loader_get_last_error ());
+       mono_loader_assert_no_error ();
        return method;
 
 fail:
-       g_assert (!mono_loader_get_last_error ());
+       mono_loader_assert_no_error ();
        g_assert (!mono_error_ok (error));
        return NULL;
 }
@@ -1185,7 +1197,7 @@ method_from_methodspec (MonoImage *image, MonoGenericContext *context, guint32 i
 
        inst = mono_metadata_parse_generic_inst (image, NULL, param_count, ptr, &ptr);
        if (!inst) {
-               g_assert (!mono_loader_get_last_error ());
+               mono_loader_assert_no_error ();
                mono_error_set_bad_image (error, image, "Cannot parse generic instance for methodspec 0x%08x", idx);
                return NULL;
        }
@@ -1197,13 +1209,9 @@ method_from_methodspec (MonoImage *image, MonoGenericContext *context, guint32 i
        }
 
        if ((token & MONO_METHODDEFORREF_MASK) == MONO_METHODDEFORREF_METHODDEF) {
-               method = mono_get_method_full (image, MONO_TOKEN_METHOD_DEF | nindex, NULL, context);
-               if (!method) {
-                       if (mono_loader_get_last_error ())
-                               mono_error_set_from_loader_error (error);
-                       else
-                               mono_error_set_bad_image (error, image, "Could not resolve methodspec 0x%08x methoddef token 0x%08x", idx, MONO_TOKEN_METHOD_DEF | nindex);
-               }
+               method = mono_get_method_checked (image, MONO_TOKEN_METHOD_DEF | nindex, NULL, context, error);
+               if (!method)
+                       return NULL;
        } else {
                method = method_from_memberref (image, nindex, context, NULL, error);
        }
@@ -1222,7 +1230,7 @@ method_from_methodspec (MonoImage *image, MonoGenericContext *context, guint32 i
        new_context.method_inst = inst;
 
        method = mono_class_inflate_generic_method_full_checked (method, klass, &new_context, error);
-       g_assert (!mono_loader_get_last_error ());
+       mono_loader_assert_no_error ();
        return method;
 }
 
@@ -1494,7 +1502,7 @@ mono_lookup_pinvoke_call (MonoMethod *method, const char **exc_class, const char
        /*
         * Try loading the module using a variety of names
         */
-       for (i = 0; i < 4; ++i) {
+       for (i = 0; i < 5; ++i) {
                char *base_name = NULL, *dir_name = NULL;
                gboolean is_absolute = is_absolute_path (new_scope);
                
@@ -1528,6 +1536,14 @@ mono_lookup_pinvoke_call (MonoMethod *method, const char **exc_class, const char
                                break;
                        }
                        continue;
+               case 3:
+                       if (!is_absolute && mono_dl_get_system_dir ()) {
+                               dir_name = (char*)mono_dl_get_system_dir ();
+                               file_name = g_path_get_basename (new_scope);
+                               base_name = NULL;
+                       } else
+                               continue;
+                       break;
                default:
 #ifndef TARGET_WIN32
                        if (!g_ascii_strcasecmp ("user32.dll", new_scope) ||
@@ -1738,12 +1754,16 @@ mono_lookup_pinvoke_call (MonoMethod *method, const char **exc_class, const char
                                                                "Probing '%s'.", mangled_name2);
 
                                        error_msg = mono_dl_symbol (module, mangled_name2, &piinfo->addr);
-                                       g_free (error_msg);
-                                       error_msg = NULL;
 
                                        if (piinfo->addr)
                                                mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_DLLIMPORT,
                                                                        "Found as '%s'.", mangled_name2);
+                                       else
+                                               mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_DLLIMPORT,
+                                                                       "Could not find '%s' due to '%s'.", mangled_name2, error_msg);
+
+                                       g_free (error_msg);
+                                       error_msg = NULL;
 
                                        if (mangled_name != mangled_name2)
                                                g_free (mangled_name2);
@@ -1778,7 +1798,6 @@ mono_get_method_from_token (MonoImage *image, guint32 token, MonoClass *klass,
        MonoTableInfo *tables = image->tables;
        MonoGenericContainer *generic_container = NULL, *container = NULL;
        const char *sig = NULL;
-       int size;
        guint32 cols [MONO_TYPEDEF_SIZE];
 
        mono_error_init (error);
@@ -1787,7 +1806,7 @@ mono_get_method_from_token (MonoImage *image, guint32 token, MonoClass *klass,
                MonoClass *handle_class;
 
                result = mono_lookup_dynamic_token_class (image, token, TRUE, &handle_class, context);
-               g_assert (!mono_loader_get_last_error ());
+               mono_loader_assert_no_error ();
 
                // This checks the memberref type as well
                if (result && handle_class != mono_defaults.methodhandle_class) {
@@ -1848,7 +1867,7 @@ mono_get_method_from_token (MonoImage *image, guint32 token, MonoClass *klass,
 
        if (!sig) /* already taken from the methodref */
                sig = mono_metadata_blob_heap (image, cols [4]);
-       size = mono_metadata_decode_blob_size (sig, &sig);
+       /* size = */ mono_metadata_decode_blob_size (sig, &sig);
 
        container = klass->generic_container;
 
@@ -1858,7 +1877,7 @@ mono_get_method_from_token (MonoImage *image, guint32 token, MonoClass *klass,
         */
        if (*sig & 0x10) {
                generic_container = mono_metadata_load_generic_params (image, token, container);
-               g_assert (!mono_loader_get_last_error ()); /* FIXME don't swallow this error. */
+               mono_loader_assert_no_error (); /* FIXME don't swallow this error. */
        }
        if (generic_container) {
                result->is_generic = TRUE;
@@ -1892,7 +1911,7 @@ mono_get_method_from_token (MonoImage *image, guint32 token, MonoClass *klass,
        if (generic_container)
                mono_method_set_generic_container (result, generic_container);
 
-       g_assert (!mono_loader_get_last_error ());
+       mono_loader_assert_no_error ();
        return result;
 }
 
@@ -1908,7 +1927,7 @@ mono_get_method_full (MonoImage *image, guint32 token, MonoClass *klass,
 {
        MonoError error;
        MonoMethod *result = mono_get_method_checked (image, token, klass, context, &error);
-       g_assert (!mono_loader_get_last_error ());
+       mono_loader_assert_no_error ();
        if (!mono_error_ok (&error)) {
                mono_loader_set_error_from_mono_error (&error);
                mono_error_cleanup (&error);
@@ -2056,7 +2075,7 @@ mono_get_method_constrained (MonoImage *image, guint32 token, MonoClass *constra
        MonoError error;
        MonoMethod *result = mono_get_method_constrained_checked (image, token, constrained_class, context, cil_method, &error);
 
-       g_assert (!mono_loader_get_last_error ());
+       mono_loader_assert_no_error ();
        if (!mono_error_ok (&error)) {
                mono_loader_set_error_from_mono_error (&error);
                mono_error_cleanup (&error);
@@ -2360,10 +2379,11 @@ stack_walk_adapter (MonoStackFrameInfo *frame, MonoContext *ctx, gpointer data)
        switch (frame->type) {
        case FRAME_TYPE_DEBUGGER_INVOKE:
        case FRAME_TYPE_MANAGED_TO_NATIVE:
+       case FRAME_TYPE_TRAMPOLINE:
                return FALSE;
        case FRAME_TYPE_MANAGED:
                g_assert (frame->ji);
-               return d->func (mono_jit_info_get_method (frame->ji), frame->native_offset, frame->il_offset, frame->managed, d->user_data);
+               return d->func (frame->actual_method, frame->native_offset, frame->il_offset, frame->managed, d->user_data);
                break;
        default:
                g_assert_not_reached ();
@@ -2399,14 +2419,16 @@ async_stack_walk_adapter (MonoStackFrameInfo *frame, MonoContext *ctx, gpointer
        switch (frame->type) {
        case FRAME_TYPE_DEBUGGER_INVOKE:
        case FRAME_TYPE_MANAGED_TO_NATIVE:
+       case FRAME_TYPE_TRAMPOLINE:
                return FALSE;
        case FRAME_TYPE_MANAGED:
                if (!frame->ji)
                        return FALSE;
-               if (frame->ji->async)
+               if (frame->ji->async) {
                        return d->func (NULL, frame->domain, frame->ji->code_start, frame->native_offset, d->user_data);
-               else
-                       return d->func (mono_jit_info_get_method (frame->ji), frame->domain, frame->ji->code_start, frame->native_offset, d->user_data);
+               } else {
+                       return d->func (frame->actual_method, frame->domain, frame->ji->code_start, frame->native_offset, d->user_data);
+               }
                break;
        default:
                g_assert_not_reached ();
@@ -2458,7 +2480,10 @@ static gboolean loader_lock_track_ownership = FALSE;
 void
 mono_loader_lock (void)
 {
+       MONO_TRY_BLOCKING;
        mono_locks_acquire (&loader_mutex, LoaderLock);
+       MONO_FINISH_TRY_BLOCKING;
+               
        if (G_UNLIKELY (loader_lock_track_ownership)) {
                mono_native_tls_set_value (loader_lock_nest_id, GUINT_TO_POINTER (GPOINTER_TO_UINT (mono_native_tls_get_value (loader_lock_nest_id)) + 1));
        }
@@ -2529,7 +2554,6 @@ MonoMethodSignature*
 mono_method_signature_checked (MonoMethod *m, MonoError *error)
 {
        int idx;
-       int size;
        MonoImage* img;
        const char *sig;
        gboolean can_cache_signature;
@@ -2597,7 +2621,7 @@ mono_method_signature_checked (MonoMethod *m, MonoError *error)
                if (!mono_verifier_verify_method_signature (img, sig_offset, error))
                        return NULL;
 
-               size = mono_metadata_decode_blob_size (sig, &sig_body);
+               /* size = */ mono_metadata_decode_blob_size (sig, &sig_body);
 
                signature = mono_metadata_parse_method_signature_full (img, container, idx, sig_body, NULL, error);
                if (!signature)
my mono mirror. check out Moved to http://github.com/mono/mono