share runtime code, r=zoltan

svn path=/trunk/mono/; revision=27431

diff --git a/config.h.in b/config.h.in
index c668c381e9c9b432f0c0835582de9bbf8f866189..ee8f509269f9f3f81663afbaa21ed190e73ae412 100644 (file)
--- a/config.h.in
+++ b/config.h.in
@@ -36,6 +36,7 @@
 #undef HAVE_SOCKLEN_T
 #undef HAVE_TRUNCL
 #undef HAVE_AINTL
+#undef HAVE_SCANDIR
 #undef HAVE_WORKING_SIGALTSTACK
 
 /* Define to 1 if you have the <aio.h> header file. */

diff --git a/mono/metadata/ChangeLog b/mono/metadata/ChangeLog
index 98522bf359d9b67880ef5ecca1e6ca35e2a46045..5c3db9edafe9c300ac335b8d3200b869ec2b11ef 100644 (file)
--- a/mono/metadata/ChangeLog
+++ b/mono/metadata/ChangeLog
@@ -1,3 +1,15 @@
+2004-05-14 Ben Maurer  <bmaurer@users.sourceforge.net>
+
+       * image.c: image->runtime_invoke_cache is keyed on signatures now.
+       * marshal.c (mono_mb_emit_calli): new helper to emit a CEE_CALLI with
+       a signature.
+       (mono_mb_emit_managed_call, mono_mb_emit_native_call): use the above.
+       (mono_marshal_get_runtime_invoke): The runtime invoke method now takes
+       an extra param that is the pointer of the method to invoke. The IL for
+       the invoke method is no longer specific to the method, but to the
+       signature of the method. Thus, we can share the same code for multiple
+       methods. This reduces the number of methods that have to be compiled.
+
 2004-05-14  Zoltan Varga  <vargaz@freemail.hu>
 
        * icall.c (ves_icall_System_Reflection_Assembly_load_with_partial_name): Fix warning.

diff --git a/mono/metadata/image.c b/mono/metadata/image.c
index 0c8ca5f9043e6a8c51652c3a35ae2442b0d2576a..2b5635082072c7919d945cfff4c6a427dde3c505 100644 (file)
--- a/mono/metadata/image.c
+++ b/mono/metadata/image.c
@@ -554,8 +554,10 @@ mono_image_init (MonoImage *image)
        image->delegate_invoke_cache = 
                g_hash_table_new ((GHashFunc)mono_signature_hash, 
                                  (GCompareFunc)mono_metadata_signature_equal);
-
-       image->runtime_invoke_cache = g_hash_table_new (NULL, NULL);
+       image->runtime_invoke_cache  = 
+               g_hash_table_new ((GHashFunc)mono_signature_hash, 
+                                 (GCompareFunc)mono_metadata_signature_equal);
+       
        image->managed_wrapper_cache = g_hash_table_new (NULL, NULL);
        image->native_wrapper_cache = g_hash_table_new (NULL, NULL);
        image->remoting_invoke_cache = g_hash_table_new (NULL, NULL);

diff --git a/mono/metadata/marshal.c b/mono/metadata/marshal.c
index 4284552dd811efac5bfbdbe88c502a08f6bc4dbe..f6b008c91921b060e00bda08ed47464fac16723d 100644 (file)
--- a/mono/metadata/marshal.c
+++ b/mono/metadata/marshal.c
@@ -559,16 +559,20 @@ mono_mb_emit_branch (MonoMethodBuilder *mb, guint8 op)
        return res;
 }
 
+static void
+mono_mb_emit_calli (MonoMethodBuilder *mb, MonoMethodSignature *sig)
+{
+       mono_mb_emit_byte (mb, CEE_CALLI);
+       mono_mb_emit_i4 (mb, mono_mb_add_data (mb, sig));
+}
+
 void
 mono_mb_emit_managed_call (MonoMethodBuilder *mb, MonoMethod *method, MonoMethodSignature *opt_sig)
 {
-       if (!opt_sig)
-               opt_sig = method->signature;
        mono_mb_emit_byte (mb, CEE_PREFIX1);
        mono_mb_emit_byte (mb, CEE_LDFTN);
        mono_mb_emit_i4 (mb, mono_mb_add_data (mb, method));
-       mono_mb_emit_byte (mb, CEE_CALLI);
-       mono_mb_emit_i4 (mb, mono_mb_add_data (mb, opt_sig));
+       mono_mb_emit_calli (mb, opt_sig ? opt_sig : method->signature);
 }
 
 void
@@ -577,8 +581,7 @@ mono_mb_emit_native_call (MonoMethodBuilder *mb, MonoMethodSignature *sig, gpoin
        mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
        mono_mb_emit_byte (mb, CEE_MONO_LDPTR);
        mono_mb_emit_i4 (mb, mono_mb_add_data (mb, func));
-       mono_mb_emit_byte (mb, CEE_CALLI);
-       mono_mb_emit_i4 (mb, mono_mb_add_data (mb, sig));
+       mono_mb_emit_calli (mb, sig);
 }
 
 void
@@ -1796,14 +1799,14 @@ mono_marshal_get_delegate_invoke (MonoMethod *method)
 
 /*
  * generates IL code for the runtime invoke function 
- * MonoObject *runtime_invoke (MonoObject *this, void **params, MonoObject **exc)
+ * MonoObject *runtime_invoke (MonoObject *this, void **params, MonoObject **exc, void* method)
  *
  * we also catch exceptions if exc != null
  */
 MonoMethod *
 mono_marshal_get_runtime_invoke (MonoMethod *method)
 {
-       MonoMethodSignature *sig, *csig;
+       MonoMethodSignature *sig, *csig, *callsig;
        MonoExceptionClause *clause;
        MonoMethodHeader *header;
        MonoMethodBuilder *mb;
@@ -1811,11 +1814,23 @@ mono_marshal_get_runtime_invoke (MonoMethod *method)
        GHashTable *cache;
        static MonoString *string_dummy = NULL;
        int i, pos;
+       char *name;
 
        g_assert (method);
+       
+       if (method->string_ctor) {
+               static MonoMethodSignature *strsig = NULL;
+               if (!strsig) {
+                       strsig = mono_metadata_signature_dup (method->signature);
+                       strsig->ret = &mono_defaults.string_class->byval_arg;
+               }
+               
+               callsig = strsig;
+       } else
+               callsig = method->signature;
 
        cache = method->klass->image->runtime_invoke_cache;
-       if ((res = mono_marshal_find_in_cache (cache, method)))
+       if ((res = mono_marshal_find_in_cache (cache, callsig)))
                return res;
 
        /* to make it work with our special string constructors */
@@ -1824,14 +1839,17 @@ mono_marshal_get_runtime_invoke (MonoMethod *method)
 
        sig = method->signature;
 
-       csig = mono_metadata_signature_alloc (method->klass->image, 3);
+       csig = mono_metadata_signature_alloc (method->klass->image, 4);
 
        csig->ret = &mono_defaults.object_class->byval_arg;
        csig->params [0] = &mono_defaults.object_class->byval_arg;
        csig->params [1] = &mono_defaults.int_class->byval_arg;
        csig->params [2] = &mono_defaults.int_class->byval_arg;
+       csig->params [3] = &mono_defaults.int_class->byval_arg;
 
-       mb = mono_mb_new (method->klass, method->name, MONO_WRAPPER_RUNTIME_INVOKE);
+       name = mono_signature_to_name (callsig, "runtime_invoke");
+       mb = mono_mb_new (method->klass, name,  MONO_WRAPPER_RUNTIME_INVOKE);
+       g_free (name);
 
        /* allocate local 0 (object) tmp */
        mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
@@ -1931,16 +1949,9 @@ handle_enum:
                        g_assert_not_reached ();
                }               
        }
-
-       if (method->string_ctor) {
-               MonoMethodSignature *strsig;
-
-               strsig = mono_metadata_signature_dup (sig);
-               strsig->ret = &mono_defaults.string_class->byval_arg;
-
-               mono_mb_emit_managed_call (mb, method, strsig);         
-       } else 
-               mono_mb_emit_managed_call (mb, method, NULL);
+       
+       mono_mb_emit_ldarg (mb, 3);
+       mono_mb_emit_calli (mb, callsig);
 
        if (sig->ret->byref) {
                /* fixme: */
@@ -2028,8 +2039,7 @@ handle_enum:
        mono_mb_emit_ldloc (mb, 0);
        mono_mb_emit_byte (mb, CEE_RET);
        
-       res = mono_mb_create_and_cache (cache, method,
-                                                                                mb, csig, sig->param_count + 16);
+       res = mono_mb_create_and_cache (cache, callsig, mb, csig, sig->param_count + 16);
        mono_mb_free (mb);
 
        header = ((MonoMethodNormal *)res)->header;

diff --git a/mono/mini/ChangeLog b/mono/mini/ChangeLog
index 548da40e84108a25ac441cd4953edaaa7162e215..f340b52ec1a440d5dbff4d7320ce945ba1a159a4 100644 (file)
--- a/mono/mini/ChangeLog
+++ b/mono/mini/ChangeLog
@@ -1,3 +1,8 @@
+2004-05-14 Ben Maurer  <bmaurer@users.sourceforge.net>
+
+       * mini.c (mono_jit_runtime_invoke): Follow new convention
+       of calling the invoke method with an function pointer.
+
 2004-05-14  Zoltan Varga  <vargaz@freemail.hu>
 
        * ChangeLog: Fix author of memory leak patch.

diff --git a/mono/mini/mini.c b/mono/mini/mini.c
index ea22e4c54c4297472baa4aa2de563133904b3e0f..bcb4dab7aa2900bbdc9bb7be0af15f4712e1f833 100644 (file)
--- a/mono/mini/mini.c
+++ b/mono/mini/mini.c
@@ -8163,7 +8163,8 @@ static MonoObject*
 mono_jit_runtime_invoke (MonoMethod *method, void *obj, void **params, MonoObject **exc)
 {
        MonoMethod *invoke;
-       MonoObject *(*runtime_invoke) (MonoObject *this, void **params, MonoObject **exc);
+       MonoObject *(*runtime_invoke) (MonoObject *this, void **params, MonoObject **exc, void* compiled_method);
+       void* compiled_method;
 
        if (obj == NULL && !(method->flags & METHOD_ATTRIBUTE_STATIC) && !method->string_ctor && (method->wrapper_type == 0)) {
                g_warning ("Ignoring invocation of an instance method on a NULL instance.\n");
@@ -8172,7 +8173,8 @@ mono_jit_runtime_invoke (MonoMethod *method, void *obj, void **params, MonoObjec
 
        invoke = mono_marshal_get_runtime_invoke (method);
        runtime_invoke = mono_jit_compile_method (invoke);
-       return runtime_invoke (obj, params, exc);
+       compiled_method = mono_jit_compile_method (method);
+       return runtime_invoke (obj, params, exc, compiled_method);
 }
 
 #ifdef PLATFORM_WIN32