2004-07-08 Zoltan Varga <vargaz@freemail.hu>

	* class-internals.h debug-helpers.c marshal.c: Add new wrapper types
	for isinst and castclass wrappers.

	* class-internals.h icall.c: Move registration and lookup of JIT icalls
	to libmetadata from the JIT, so they could be used by the marshalling
	code and the interpreter.

	* marshal.c: Register marshalling related JIT icalls here instead of
	in mini.c. Use CEE_MONO_ICALL instead of the family of
	CEE_MONO_PROC<x> opcodes to call marshalling functions.

	* metadata.h: Remove unneeded marshalling conversions.

	* opcodes.c: Update for new opcodes.

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

diff --git a/mono/metadata/ChangeLog b/mono/metadata/ChangeLog
index f424bd4b2e738171ae87be9c4c55b8c56d4031c7..3f9c922f1fdf410f15387585bba48bf28941f56c 100644 (file)
--- a/mono/metadata/ChangeLog
+++ b/mono/metadata/ChangeLog
@@ -1,3 +1,20 @@
+2004-07-08  Zoltan Varga  <vargaz@freemail.hu>
+
+       * class-internals.h debug-helpers.c marshal.c: Add new wrapper types 
+       for isinst and castclass wrappers.
+
+       * class-internals.h icall.c: Move registration and lookup of JIT icalls
+       to libmetadata from the JIT, so they could be used by the marshalling
+       code and the interpreter.
+
+       * marshal.c: Register marshalling related JIT icalls here instead of
+       in mini.c. Use CEE_MONO_ICALL instead of the family of 
+       CEE_MONO_PROC<x> opcodes to call marshalling functions.
+
+       * metadata.h: Remove unneeded marshalling conversions.
+
+       * opcodes.c: Update for new opcodes.
+       
 2004-07-08  Martin Baulig  <martin@ximian.com>
 
        * mono-debug.c: Check for `handle->symfile' being non-NULL everywhere.

diff --git a/mono/metadata/class-internals.h b/mono/metadata/class-internals.h
index 91dfce8d14466da616100c0eeee00a363b61b319..8f330a74cf8e4df3b6a6495c3f392c6519d8bcdc 100644 (file)
--- a/mono/metadata/class-internals.h
+++ b/mono/metadata/class-internals.h
@@ -31,6 +31,9 @@ typedef enum {
        MONO_WRAPPER_STFLD,
        MONO_WRAPPER_SYNCHRONIZED,
        MONO_WRAPPER_DYNAMIC_METHOD,
+       MONO_WRAPPER_ISINST,
+       MONO_WRAPPER_CASTCLASS,
+       MONO_WRAPPER_PROXY_ISINST,
        MONO_WRAPPER_UNKNOWN
 } MonoWrapperType;
 
@@ -49,7 +52,7 @@ struct _MonoMethod {
        /* this is used by the inlining algorithm */
        unsigned int inline_info:1;
        unsigned int uses_this:1;
-       unsigned int wrapper_type:4;
+       unsigned int wrapper_type:5;
        unsigned int string_ctor:1;
        unsigned int save_lmf:1;
        gint16 inline_count;
@@ -341,6 +344,13 @@ struct _MonoGenericParam {
        MonoClass** constraints; /* NULL means end of list */
 };
 
+typedef struct {
+       const char *name;
+       gconstpointer func;
+       gconstpointer wrapper;
+       MonoMethodSignature *sig;
+} MonoJitICallInfo;
+
 #define mono_class_has_parent(klass,parent) (((klass)->idepth >= (parent)->idepth) && ((klass)->supertypes [(parent)->idepth - 1] == (parent)))
 
 typedef struct {
@@ -475,5 +485,20 @@ mono_install_stack_walk (MonoStackWalkImpl func);
 
 MonoGenericParam *mono_metadata_load_generic_params (MonoImage *image, guint32 token, guint32 *num);
 
+MonoMethodSignature*
+mono_create_icall_signature (const char *sigstr);
+
+MonoJitICallInfo *
+mono_register_jit_icall (gconstpointer func, const char *name, MonoMethodSignature *sig, gboolean is_save);
+
+void
+mono_register_jit_icall_wrapper (MonoJitICallInfo *info, gconstpointer wrapper);
+
+MonoJitICallInfo *
+mono_find_jit_icall_by_name (const char *name);
+
+MonoJitICallInfo *
+mono_find_jit_icall_by_addr (gconstpointer addr);
+
 #endif /* __MONO_METADATA_CLASS_INTERBALS_H__ */
 

diff --git a/mono/metadata/debug-helpers.c b/mono/metadata/debug-helpers.c
index e0297cf0aa91195c5f2dddde05fd515752ce6e8f..f18163127fd7e5b0c7f2ab257b8b5c742af856c3 100644 (file)
--- a/mono/metadata/debug-helpers.c
+++ b/mono/metadata/debug-helpers.c
@@ -29,6 +29,9 @@ static const char *wrapper_type_names [] = {
        "stfld",
        "synchronized",
        "dynamic-method",
+       "isinst",
+       "cancast",
+       "proxy_isinst",
        "unknown"
 };
 

diff --git a/mono/metadata/icall.c b/mono/metadata/icall.c
index 2e79cd942ff2b06fdda3b24845acc0cc7f8ef15d..fc4846aaee0c67e680c8a5352d278a587fe70ff7 100644 (file)
--- a/mono/metadata/icall.c
+++ b/mono/metadata/icall.c
@@ -5909,6 +5909,8 @@ static const IcallMap icall_entries [] = {
 };
 
 static GHashTable *icall_hash = NULL;
+static GHashTable *jit_icall_hash_name = NULL;
+static GHashTable *jit_icall_hash_addr = NULL;
 
 void
 mono_init_icall (void)
@@ -6083,3 +6085,157 @@ mono_lookup_internal_call (MonoMethod *method)
        return NULL;
 }
 
+static MonoType*
+type_from_typename (char *typename)
+{
+       MonoClass *klass;
+
+       if (!strcmp (typename, "int"))
+               klass = mono_defaults.int_class;
+       else if (!strcmp (typename, "ptr"))
+               klass = mono_defaults.int_class;
+       else if (!strcmp (typename, "void"))
+               klass = mono_defaults.void_class;
+       else if (!strcmp (typename, "int32"))
+               klass = mono_defaults.int32_class;
+       else if (!strcmp (typename, "uint32"))
+               klass = mono_defaults.uint32_class;
+       else if (!strcmp (typename, "long"))
+               klass = mono_defaults.int64_class;
+       else if (!strcmp (typename, "ulong"))
+               klass = mono_defaults.uint64_class;
+       else if (!strcmp (typename, "float"))
+               klass = mono_defaults.single_class;
+       else if (!strcmp (typename, "double"))
+               klass = mono_defaults.double_class;
+       else if (!strcmp (typename, "object"))
+               klass = mono_defaults.object_class;
+       else if (!strcmp (typename, "obj"))
+               klass = mono_defaults.object_class;
+       else {
+               g_error (typename);
+               g_assert_not_reached ();
+       }
+       return &klass->byval_arg;
+}
+
+MonoMethodSignature*
+mono_create_icall_signature (const char *sigstr)
+{
+       gchar **parts;
+       int i, len;
+       gchar **tmp;
+       MonoMethodSignature *res;
+
+       mono_loader_lock ();
+       res = g_hash_table_lookup (mono_defaults.corlib->helper_signatures, sigstr);
+       if (res) {
+               mono_loader_unlock ();
+               return res;
+       }
+
+       parts = g_strsplit (sigstr, " ", 256);
+
+       tmp = parts;
+       len = 0;
+       while (*tmp) {
+               len ++;
+               tmp ++;
+       }
+
+       res = mono_metadata_signature_alloc (mono_defaults.corlib, len - 1);
+       res->pinvoke = 1;
+
+#ifdef PLATFORM_WIN32
+       /* 
+        * Under windows, the default pinvoke calling convention is STDCALL but
+        * we need CDECL.
+        */
+       res->call_convention = MONO_CALL_C;
+#endif
+
+       res->ret = type_from_typename (parts [0]);
+       for (i = 1; i < len; ++i) {
+               res->params [i - 1] = type_from_typename (parts [i]);
+       }
+
+       g_strfreev (parts);
+
+       g_hash_table_insert (mono_defaults.corlib->helper_signatures, sigstr, res);
+
+       mono_loader_unlock ();
+
+       return res;
+}
+
+MonoJitICallInfo *
+mono_find_jit_icall_by_name (const char *name)
+{
+       MonoJitICallInfo *info;
+       g_assert (jit_icall_hash_name);
+
+       mono_loader_lock ();
+       info = g_hash_table_lookup (jit_icall_hash_name, name);
+       mono_loader_unlock ();
+       return info;
+}
+
+MonoJitICallInfo *
+mono_find_jit_icall_by_addr (gconstpointer addr)
+{
+       MonoJitICallInfo *info;
+       g_assert (jit_icall_hash_addr);
+
+       mono_loader_lock ();
+       info = g_hash_table_lookup (jit_icall_hash_addr, (gpointer)addr);
+       mono_loader_unlock ();
+
+       return info;
+}
+
+void
+mono_register_jit_icall_wrapper (MonoJitICallInfo *info, gconstpointer wrapper)
+{
+       mono_loader_lock ();
+       g_hash_table_insert (jit_icall_hash_addr, (gpointer)info->wrapper, info);       
+       mono_loader_unlock ();
+}
+
+MonoJitICallInfo *
+mono_register_jit_icall (gconstpointer func, const char *name, MonoMethodSignature *sig, gboolean is_save)
+{
+       MonoJitICallInfo *info;
+       
+       g_assert (func);
+       g_assert (name);
+
+       mono_loader_lock ();
+
+       if (!jit_icall_hash_name) {
+               jit_icall_hash_name = g_hash_table_new (g_str_hash, g_str_equal);
+               jit_icall_hash_addr = g_hash_table_new (NULL, NULL);
+       }
+
+       if (g_hash_table_lookup (jit_icall_hash_name, name)) {
+               g_warning ("jit icall already defined \"%s\"\n", name);
+               g_assert_not_reached ();
+       }
+
+       info = g_new (MonoJitICallInfo, 1);
+       
+       info->name = name;
+       info->func = func;
+       info->sig = sig;
+
+       if (is_save) {
+               info->wrapper = func;
+       } else {
+               info->wrapper = NULL;
+       }
+
+       g_hash_table_insert (jit_icall_hash_name, (gpointer)info->name, info);
+       g_hash_table_insert (jit_icall_hash_addr, (gpointer)func, info);
+
+       mono_loader_unlock ();
+       return info;
+}

diff --git a/mono/metadata/marshal.c b/mono/metadata/marshal.c
index 580558b9c901ee22098189de32feec95759bcc38..7b15b67ccdf6e461ab548fb9073098c9a779e3cd 100644 (file)
--- a/mono/metadata/marshal.c
+++ b/mono/metadata/marshal.c
@@ -87,6 +87,14 @@ static MonoGHashTable *wrapper_hash;
 
 static guint32 last_error_tls_id;
 
+static void
+register_icall (gpointer func, const char *name, const char *sigstr, gboolean save)
+{
+       MonoMethodSignature *sig = mono_create_icall_signature (sigstr);
+
+       mono_register_jit_icall (func, name, sig, save);
+}
+
 void
 mono_marshal_init (void)
 {
@@ -97,6 +105,29 @@ mono_marshal_init (void)
                InitializeCriticalSection (&marshal_mutex);
                wrapper_hash = mono_g_hash_table_new (NULL, NULL);
                last_error_tls_id = TlsAlloc ();
+
+               register_icall (mono_string_to_utf16, "mono_string_to_utf16", "ptr obj", FALSE);
+               register_icall (mono_string_from_utf16, "mono_string_from_utf16", "obj ptr", FALSE);
+               register_icall (mono_string_new_wrapper, "mono_string_new_wrapper", "obj ptr", FALSE);
+               register_icall (mono_string_to_utf8, "mono_string_to_utf8", "ptr obj", FALSE);
+               register_icall (mono_string_to_bstr, "mono_string_to_bstr", "ptr obj", FALSE);
+               register_icall (mono_string_to_ansibstr, "mono_string_to_ansibstr", "ptr object", FALSE);
+               register_icall (mono_string_builder_to_utf8, "mono_string_builder_to_utf8", "ptr object", FALSE);
+               register_icall (mono_string_builder_to_utf16, "mono_string_builder_to_utf16", "ptr object", FALSE);
+               register_icall (mono_array_to_savearray, "mono_array_to_savearray", "ptr object", FALSE);
+               register_icall (mono_array_to_lparray, "mono_array_to_lparray", "ptr object", FALSE);
+               register_icall (mono_delegate_to_ftnptr, "mono_delegate_to_ftnptr", "ptr object", FALSE);
+               register_icall (mono_ftnptr_to_delegate, "mono_ftnptr_to_delegate", "object ptr ptr", FALSE);
+               register_icall (mono_marshal_string_array, "mono_marshal_string_array", "ptr object", FALSE);
+               register_icall (mono_marshal_string_array_to_unicode, "mono_marshal_string_array_to_unicode", "ptr object", FALSE);
+               register_icall (mono_marshal_asany, "mono_marshal_asany", "ptr object int", FALSE);
+               register_icall (mono_marshal_free_asany, "mono_marshal_free_asany", "void object ptr int", FALSE);
+               register_icall (mono_string_utf8_to_builder, "mono_string_utf8_to_builder", "void ptr ptr", FALSE);
+               register_icall (mono_string_utf16_to_builder, "mono_string_utf16_to_builder", "void ptr ptr", FALSE);
+               register_icall (mono_marshal_free_array, "mono_marshal_free_array", "void ptr ptr", FALSE);
+               register_icall (mono_string_to_byvalstr, "mono_string_to_byvalstr", "void ptr ptr ptr", FALSE);
+               register_icall (mono_string_to_byvalwstr, "mono_string_to_byvalwstr", "void ptr ptr ptr", FALSE);
+               register_icall (g_free, "g_free", "void ptr", FALSE);
        }
 }
 
@@ -611,6 +642,14 @@ mono_mb_emit_native_call (MonoMethodBuilder *mb, MonoMethodSignature *sig, gpoin
        mono_mb_emit_byte (mb, CEE_MONO_RESTORE_LMF);
 }
 
+static void
+mono_mb_emit_icall (MonoMethodBuilder *mb, gpointer func)
+{
+       mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
+       mono_mb_emit_byte (mb, CEE_MONO_ICALL);
+       mono_mb_emit_i4 (mb, mono_mb_add_data (mb, func));
+}
+
 void
 mono_mb_emit_exception (MonoMethodBuilder *mb, const char *exc_name, const char *msg)
 {
@@ -714,9 +753,7 @@ emit_ptr_to_str_conv (MonoMethodBuilder *mb, MonoType *type, MonoMarshalConv con
        case MONO_MARSHAL_CONV_STR_BYVALSTR: 
                mono_mb_emit_byte (mb, CEE_LDLOC_1);
                mono_mb_emit_byte (mb, CEE_LDLOC_0);
-               mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
-               mono_mb_emit_byte (mb, CEE_MONO_FUNC1);
-               mono_mb_emit_byte (mb, MONO_MARSHAL_CONV_LPSTR_STR);
+               mono_mb_emit_icall (mb, mono_string_new_wrapper);
                mono_mb_emit_byte (mb, CEE_STIND_I);            
                break;
        case MONO_MARSHAL_CONV_STR_LPTSTR:
@@ -724,9 +761,7 @@ emit_ptr_to_str_conv (MonoMethodBuilder *mb, MonoType *type, MonoMarshalConv con
                mono_mb_emit_byte (mb, CEE_LDLOC_1);
                mono_mb_emit_byte (mb, CEE_LDLOC_0);
                mono_mb_emit_byte (mb, CEE_LDIND_I);
-               mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
-               mono_mb_emit_byte (mb, CEE_MONO_FUNC1);
-               mono_mb_emit_byte (mb, MONO_MARSHAL_CONV_LPSTR_STR);
+               mono_mb_emit_icall (mb, mono_string_new_wrapper);
                mono_mb_emit_byte (mb, CEE_STIND_I);            
                break;
        case MONO_MARSHAL_CONV_OBJECT_STRUCT: {
@@ -788,6 +823,55 @@ emit_ptr_to_str_conv (MonoMethodBuilder *mb, MonoType *type, MonoMarshalConv con
        }
 }
 
+static gpointer
+conv_to_icall (MonoMarshalConv conv)
+{
+       switch (conv) {
+       case MONO_MARSHAL_CONV_STR_LPWSTR:
+               return mono_string_to_utf16;            
+       case MONO_MARSHAL_CONV_LPWSTR_STR:
+               return mono_string_from_utf16;
+       case MONO_MARSHAL_CONV_LPSTR_STR:
+               return mono_string_new_wrapper;
+       case MONO_MARSHAL_CONV_STR_LPTSTR:
+       case MONO_MARSHAL_CONV_STR_LPSTR:
+               return mono_string_to_utf8;
+       case MONO_MARSHAL_CONV_STR_BSTR:
+               return mono_string_to_bstr;
+       case MONO_MARSHAL_CONV_STR_TBSTR:
+       case MONO_MARSHAL_CONV_STR_ANSIBSTR:
+               return mono_string_to_ansibstr;
+       case MONO_MARSHAL_CONV_SB_LPSTR:
+       case MONO_MARSHAL_CONV_SB_LPTSTR:
+               return mono_string_builder_to_utf8;
+       case MONO_MARSHAL_CONV_SB_LPWSTR:
+               return mono_string_builder_to_utf16;
+       case MONO_MARSHAL_CONV_ARRAY_SAVEARRAY:
+               return mono_array_to_savearray;
+       case MONO_MARSHAL_CONV_ARRAY_LPARRAY:
+               return mono_array_to_lparray;
+       case MONO_MARSHAL_CONV_DEL_FTN:
+               return mono_delegate_to_ftnptr;
+       case MONO_MARSHAL_CONV_FTN_DEL:
+               return mono_ftnptr_to_delegate;
+       case MONO_MARSHAL_CONV_LPSTR_SB:
+       case MONO_MARSHAL_CONV_LPTSTR_SB:
+               return mono_string_utf8_to_builder;
+       case MONO_MARSHAL_CONV_LPWSTR_SB:
+               return mono_string_utf16_to_builder;
+       case MONO_MARSHAL_FREE_ARRAY:
+               return mono_marshal_free_array;
+       case MONO_MARSHAL_CONV_STR_BYVALSTR:
+               return mono_string_to_byvalstr;
+       case MONO_MARSHAL_CONV_STR_BYVALWSTR:
+               return mono_string_to_byvalwstr;
+       default:
+               g_assert_not_reached ();
+       }
+
+       return NULL;
+}
+
 static void
 emit_str_to_ptr_conv (MonoMethodBuilder *mb, MonoType *type, MonoMarshalConv conv, int usize, int msize,
                      MonoMarshalSpec *mspec)
@@ -813,33 +897,33 @@ emit_str_to_ptr_conv (MonoMethodBuilder *mb, MonoType *type, MonoMarshalConv con
        case MONO_MARSHAL_CONV_STR_LPTSTR:
        case MONO_MARSHAL_CONV_STR_BSTR:
        case MONO_MARSHAL_CONV_STR_ANSIBSTR:
-       case MONO_MARSHAL_CONV_STR_TBSTR:
+       case MONO_MARSHAL_CONV_STR_TBSTR: {
+               int pos;
+
                /* free space if free == true */
                mono_mb_emit_byte (mb, CEE_LDLOC_2);
                mono_mb_emit_byte (mb, CEE_BRFALSE_S);
-               mono_mb_emit_byte (mb, 4);
+               pos = mb->pos;
+               mono_mb_emit_byte (mb, 0);
                mono_mb_emit_byte (mb, CEE_LDLOC_1);
                mono_mb_emit_byte (mb, CEE_LDIND_I);
-               mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
-               mono_mb_emit_byte (mb, CEE_MONO_FREE);
+               mono_mb_emit_icall (mb, g_free);
+               mono_mb_patch_addr_s (mb, pos, mb->pos - pos - 1);
 
                mono_mb_emit_byte (mb, CEE_LDLOC_1);
                mono_mb_emit_byte (mb, CEE_LDLOC_0);
                mono_mb_emit_byte (mb, CEE_LDIND_I);
-               mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
-               mono_mb_emit_byte (mb, CEE_MONO_FUNC1);
-               mono_mb_emit_byte (mb, conv);
+               mono_mb_emit_icall (mb, conv_to_icall (conv));
                mono_mb_emit_byte (mb, CEE_STIND_I);    
                break;
+       }
        case MONO_MARSHAL_CONV_ARRAY_SAVEARRAY:
        case MONO_MARSHAL_CONV_ARRAY_LPARRAY:
        case MONO_MARSHAL_CONV_DEL_FTN:
                mono_mb_emit_byte (mb, CEE_LDLOC_1);
                mono_mb_emit_byte (mb, CEE_LDLOC_0);
                mono_mb_emit_byte (mb, CEE_LDIND_I);
-               mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
-               mono_mb_emit_byte (mb, CEE_MONO_FUNC1);
-               mono_mb_emit_byte (mb, conv);
+               mono_mb_emit_icall (mb, conv_to_icall (conv));
                mono_mb_emit_byte (mb, CEE_STIND_I);    
                break;
        case MONO_MARSHAL_CONV_STR_BYVALSTR: 
@@ -851,9 +935,7 @@ emit_str_to_ptr_conv (MonoMethodBuilder *mb, MonoType *type, MonoMarshalConv con
                mono_mb_emit_byte (mb, CEE_LDLOC_0);    
                mono_mb_emit_byte (mb, CEE_LDIND_I); /* src String */
                mono_mb_emit_icon (mb, usize);
-               mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
-               mono_mb_emit_byte (mb, CEE_MONO_PROC3);
-               mono_mb_emit_byte (mb, conv);
+               mono_mb_emit_icall (mb, conv_to_icall (conv));
                break;
        }
        case MONO_MARSHAL_CONV_ARRAY_BYVALARRAY: {
@@ -2354,9 +2436,7 @@ mono_marshal_get_managed_wrapper (MonoMethod *method, MonoObject *this, MonoMars
                                mono_mb_emit_byte (mb, CEE_MONO_LDPTR);
                                mono_mb_emit_i4 (mb, mono_mb_add_data (mb, klass));
                                mono_mb_emit_ldarg (mb, i);
-                               mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
-                               mono_mb_emit_byte (mb, CEE_MONO_FUNC2);
-                               mono_mb_emit_byte (mb, MONO_MARSHAL_CONV_FTN_DEL);
+                               mono_mb_emit_icall (mb, conv_to_icall (MONO_MARSHAL_CONV_FTN_DEL));
                                mono_mb_emit_stloc (mb, tmp_locals [i]);
                                break;
                        }
@@ -2457,15 +2537,13 @@ mono_marshal_get_managed_wrapper (MonoMethod *method, MonoObject *this, MonoMars
                        csig->params [i] = &mono_defaults.int_class->byval_arg;
 
                        mono_mb_emit_ldarg (mb, i);
-                       mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
-                       mono_mb_emit_byte (mb, CEE_MONO_FUNC1);
 
                        switch (encoding) {
                        case MONO_NATIVE_LPWSTR:
-                               mono_mb_emit_byte (mb, MONO_MARSHAL_CONV_LPWSTR_STR);
+                               mono_mb_emit_icall (mb, conv_to_icall (MONO_MARSHAL_CONV_LPWSTR_STR));
                                break;
                        case MONO_NATIVE_LPSTR:
-                               mono_mb_emit_byte (mb, MONO_MARSHAL_CONV_LPSTR_STR);
+                               mono_mb_emit_icall (mb, conv_to_icall (MONO_MARSHAL_CONV_LPSTR_STR));
                                break;
                        default: {
                                        char *msg = g_strdup_printf ("string marshalling conversion %d not implemented", encoding);
@@ -2587,9 +2665,7 @@ mono_marshal_get_managed_wrapper (MonoMethod *method, MonoObject *this, MonoMars
                case MONO_TYPE_STRING:          
                        csig->ret = &mono_defaults.int_class->byval_arg;
 
-                       mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
-                       mono_mb_emit_byte (mb, CEE_MONO_FUNC1);
-                       mono_mb_emit_byte (mb, MONO_MARSHAL_CONV_STR_LPSTR);
+                       mono_mb_emit_icall (mb, conv_to_icall (MONO_MARSHAL_CONV_STR_LPSTR));
                        mono_mb_emit_byte (mb, CEE_STLOC_3);
                        break;
                case MONO_TYPE_VALUETYPE:
@@ -2625,9 +2701,7 @@ mono_marshal_get_managed_wrapper (MonoMethod *method, MonoObject *this, MonoMars
                        klass = sig->ret->data.klass;
 
                        if (klass->delegate) {
-                               mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
-                               mono_mb_emit_byte (mb, CEE_MONO_FUNC1);
-                               mono_mb_emit_byte (mb, MONO_MARSHAL_CONV_DEL_FTN);
+                               mono_mb_emit_icall (mb, conv_to_icall (MONO_MARSHAL_CONV_DEL_FTN));
                                mono_mb_emit_byte (mb, CEE_STLOC_3);
                                break;
                        }
@@ -3335,9 +3409,7 @@ mono_marshal_get_native_wrapper (MonoMethod *method)
                        tmp_locals [i] = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
                        mono_mb_emit_ldarg (mb, argnum);
                        mono_mb_emit_icon (mb, encoding);
-                       mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
-                       mono_mb_emit_byte (mb, CEE_MONO_FUNC2);
-                       mono_mb_emit_byte (mb, MONO_MARSHAL_CONV_ASANY);
+                       mono_mb_emit_icall (mb, mono_marshal_asany);
                        mono_mb_emit_stloc (mb, tmp_locals [i]);
                        continue;
                }
@@ -3400,18 +3472,15 @@ mono_marshal_get_native_wrapper (MonoMethod *method)
                                mono_mb_emit_ldarg (mb, argnum);
                        }
 
-                       mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
-                       mono_mb_emit_byte (mb, CEE_MONO_FUNC1);
-                       
                        switch (encoding) {
                        case MONO_NATIVE_LPWSTR:
-                               mono_mb_emit_byte (mb, MONO_MARSHAL_CONV_STR_LPWSTR);
+                               mono_mb_emit_icall (mb, conv_to_icall (MONO_MARSHAL_CONV_STR_LPWSTR));
                                break;
                        case MONO_NATIVE_LPSTR:
-                               mono_mb_emit_byte (mb, MONO_MARSHAL_CONV_STR_LPSTR);
+                               mono_mb_emit_icall (mb, conv_to_icall (MONO_MARSHAL_CONV_STR_LPSTR));
                                break;
                        case MONO_NATIVE_LPTSTR:
-                               mono_mb_emit_byte (mb, MONO_MARSHAL_CONV_STR_LPTSTR);
+                               mono_mb_emit_icall (mb, conv_to_icall (MONO_MARSHAL_CONV_STR_LPTSTR));
                                break;
                        default: {
                                        char *msg = g_strdup_printf ("string marshalling conversion %d not implemented", encoding);
@@ -3435,20 +3504,16 @@ mono_marshal_get_native_wrapper (MonoMethod *method)
                        if (klass->delegate) {
                                g_assert (!t->byref);
                                mono_mb_emit_ldarg (mb, argnum);
-                               mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
-                               mono_mb_emit_byte (mb, CEE_MONO_FUNC1);
-                               mono_mb_emit_byte (mb, MONO_MARSHAL_CONV_DEL_FTN);
+                               mono_mb_emit_icall (mb, conv_to_icall (MONO_MARSHAL_CONV_DEL_FTN));
                                mono_mb_emit_stloc (mb, tmp_locals [i]);
                        } else if (klass == mono_defaults.stringbuilder_class) {
                                MonoMarshalNative encoding = mono_marshal_get_stringbuilder_to_ptr_encoding (piinfo, spec);
 
                                g_assert (!t->byref);
                                mono_mb_emit_ldarg (mb, argnum);
-                               mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
-                               mono_mb_emit_byte (mb, CEE_MONO_FUNC1);
 
                                if (encoding != -1)
-                                       mono_mb_emit_byte (mb, encoding);
+                                       mono_mb_emit_icall (mb, conv_to_icall (encoding));
                                else {
                                        char *msg = g_strdup_printf ("stringbuilder marshalling conversion %d not implemented", encoding);
                                        MonoException *exc = mono_get_exception_not_implemented (msg);
@@ -3520,15 +3585,13 @@ mono_marshal_get_native_wrapper (MonoMethod *method)
                                MonoMarshalNative encoding = mono_marshal_get_string_encoding (piinfo, spec);
 
                                mono_mb_emit_ldarg (mb, argnum);
-                               mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
-                               mono_mb_emit_byte (mb, CEE_MONO_FUNC1);
 
                                switch (encoding) {
-                               case MONO_NATIVE_LPWSTR:
-                                       mono_mb_emit_byte (mb, MONO_MARSHAL_CONV_STRARRAY_STRWLPARRAY);
-                                       break;
                                case MONO_NATIVE_LPSTR:
-                                       mono_mb_emit_byte (mb, MONO_MARSHAL_CONV_STRARRAY_STRLPARRAY);
+                                       mono_mb_emit_icall (mb, mono_marshal_string_array);
+                                       break;
+                               case MONO_NATIVE_LPWSTR:
+                                       mono_mb_emit_icall (mb, mono_marshal_string_array_to_unicode);
                                        break;
                                default: {
                                        char *msg = g_strdup_printf ("string array marshalling conversion %d not implemented", encoding);
@@ -3542,10 +3605,7 @@ mono_marshal_get_native_wrapper (MonoMethod *method)
                        }
                        else if (klass->element_class->blittable) {
                                mono_mb_emit_ldarg (mb, argnum);
-                               mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
-                               mono_mb_emit_byte (mb, CEE_MONO_FUNC1);
-
-                               mono_mb_emit_byte (mb, MONO_MARSHAL_CONV_ARRAY_LPARRAY);
+                               mono_mb_emit_icall (mb, conv_to_icall (MONO_MARSHAL_CONV_ARRAY_LPARRAY));
                                mono_mb_emit_stloc (mb, tmp_locals [i]);
                        }
                        else {
@@ -3612,9 +3672,7 @@ mono_marshal_get_native_wrapper (MonoMethod *method)
                                        mono_mb_emit_ldarg (mb, argnum);
                                        mono_mb_emit_ldloc (mb, index_var);
                                        mono_mb_emit_byte (mb, CEE_LDELEM_REF);
-                                       mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
-                                       mono_mb_emit_byte (mb, CEE_MONO_FUNC1);
-                                       mono_mb_emit_byte (mb, encoding);
+                                       mono_mb_emit_icall (mb, conv_to_icall (encoding));
                                        mono_mb_emit_byte (mb, CEE_STIND_I);
                                }
                                else {
@@ -3897,26 +3955,23 @@ mono_marshal_get_native_wrapper (MonoMethod *method)
                                mono_mb_emit_byte (mb, CEE_STLOC_0);
                                mono_mb_emit_byte (mb, CEE_LDLOC_0);
                                
-                               mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
-                               mono_mb_emit_byte (mb, CEE_MONO_FUNC1);
                                if (spec) {
                                        switch (spec->native) {
                                        case MONO_NATIVE_LPWSTR:
-                                               mono_mb_emit_byte (mb, MONO_MARSHAL_CONV_LPWSTR_STR);
+                                               mono_mb_emit_icall (mb, conv_to_icall (MONO_MARSHAL_CONV_LPWSTR_STR));
                                                break;
                                        default:
                                                g_warning ("marshalling conversion not implemented");
                                                g_assert_not_reached ();
                                        }
                                } else {
-                                       mono_mb_emit_byte (mb, MONO_MARSHAL_CONV_LPSTR_STR);
+                                       mono_mb_emit_icall (mb, conv_to_icall (MONO_MARSHAL_CONV_LPSTR_STR));
                                }
                                mono_mb_emit_byte (mb, CEE_STLOC_3);
 
                                /* free the string */
                                mono_mb_emit_byte (mb, CEE_LDLOC_0);
-                               mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
-                               mono_mb_emit_byte (mb, CEE_MONO_FREE);
+                               mono_mb_emit_icall (mb, g_free);
                                break;
                        case MONO_TYPE_CLASS:
                        case MONO_TYPE_OBJECT:
@@ -4037,9 +4092,7 @@ mono_marshal_get_native_wrapper (MonoMethod *method)
                        mono_mb_emit_ldarg (mb, argnum);
                        mono_mb_emit_ldloc (mb, tmp_locals [i]);
                        mono_mb_emit_icon (mb, encoding);
-                       mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
-                       mono_mb_emit_byte (mb, CEE_MONO_PROC3);
-                       mono_mb_emit_byte (mb, MONO_MARSHAL_FREE_ASANY);
+                       mono_mb_emit_icall (mb, mono_marshal_free_asany);
                        continue;
                }
                
@@ -4048,14 +4101,11 @@ mono_marshal_get_native_wrapper (MonoMethod *method)
                        if (t->byref && (t->attrs & PARAM_ATTRIBUTE_OUT)) {
                                mono_mb_emit_ldarg (mb, argnum);
                                mono_mb_emit_ldloc (mb, tmp_locals [i]);
-                               mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
-                               mono_mb_emit_byte (mb, CEE_MONO_FUNC1);
-                               mono_mb_emit_byte (mb, MONO_MARSHAL_CONV_LPSTR_STR);
+                               mono_mb_emit_icall (mb, conv_to_icall (MONO_MARSHAL_CONV_LPSTR_STR));
                                mono_mb_emit_byte (mb, CEE_STIND_I);            
                        } else {
                                mono_mb_emit_ldloc (mb, tmp_locals [i]);
-                               mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
-                               mono_mb_emit_byte (mb, CEE_MONO_FREE);
+                               mono_mb_emit_icall (mb, g_free);
                        }
                        break;
                case MONO_TYPE_CLASS:
@@ -4071,15 +4121,12 @@ mono_marshal_get_native_wrapper (MonoMethod *method)
 
                                mono_mb_emit_ldarg (mb, argnum);
                                mono_mb_emit_ldloc (mb, tmp_locals [i]);
-                               mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
-                               mono_mb_emit_byte (mb, CEE_MONO_PROC2);
 
-                               mono_mb_emit_byte (mb, encoding);
+                               mono_mb_emit_icall (mb, conv_to_icall (encoding));
 
                                if (need_free) {
                                        mono_mb_emit_ldloc (mb, tmp_locals [i]);
-                                       mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
-                                       mono_mb_emit_byte (mb, CEE_MONO_FREE);
+                                       mono_mb_emit_icall (mb, g_free);
                                }
                                break;
                        }
@@ -4173,15 +4220,12 @@ mono_marshal_get_native_wrapper (MonoMethod *method)
                                         * The array elements point to the managed string data so 
                                         * they don't need to be freed.
                                         */
-                                       mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
-                                       mono_mb_emit_byte (mb, CEE_MONO_FREE);
+                                       mono_mb_emit_icall (mb, g_free);
                                        break;
                                default:
                                        mono_mb_emit_ldarg (mb, argnum);
                                        mono_mb_emit_byte (mb, CEE_LDLEN);                              
-                                       mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
-                                       mono_mb_emit_byte (mb, CEE_MONO_PROC2);
-                                       mono_mb_emit_byte (mb, MONO_MARSHAL_FREE_ARRAY);
+                                       mono_mb_emit_icall (mb, conv_to_icall (MONO_MARSHAL_FREE_ARRAY));
                                        break;                                  
                                }
 
@@ -4240,18 +4284,14 @@ mono_marshal_get_native_wrapper (MonoMethod *method)
                                        mono_mb_emit_ldloc (mb, src_ptr);
                                        mono_mb_emit_byte (mb, CEE_LDIND_I);
 
-                                       mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
-                                       mono_mb_emit_byte (mb, CEE_MONO_PROC2);
-
-                                       mono_mb_emit_byte (mb, encoding);
+                                       mono_mb_emit_icall (mb, conv_to_icall (encoding));
 
                                        if (need_free) {
                                                /* src */
                                                mono_mb_emit_ldloc (mb, src_ptr);
                                                mono_mb_emit_byte (mb, CEE_LDIND_I);
 
-                                               mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
-                                               mono_mb_emit_byte (mb, CEE_MONO_FREE);
+                                               mono_mb_emit_icall (mb, g_free);
                                        }
                                }
                                else {
@@ -4362,7 +4402,7 @@ mono_marshal_get_isinst (MonoClass *klass)
        }
        
        name = g_strdup_printf ("__isinst_wrapper_%s", klass->name); 
-       mb = mono_mb_new (mono_defaults.object_class, name, MONO_WRAPPER_UNKNOWN);
+       mb = mono_mb_new (mono_defaults.object_class, name, MONO_WRAPPER_ISINST);
        g_free (name);
        
        mb->method->save_lmf = 1;
@@ -4450,7 +4490,7 @@ mono_marshal_get_castclass (MonoClass *klass)
        }
        
        name = g_strdup_printf ("__castclass_wrapper_%s", klass->name); 
-       mb = mono_mb_new (mono_defaults.object_class, name, MONO_WRAPPER_UNKNOWN);
+       mb = mono_mb_new (mono_defaults.object_class, name, MONO_WRAPPER_CASTCLASS);
        g_free (name);
        
        mb->method->save_lmf = 1;
@@ -4533,7 +4573,7 @@ mono_marshal_get_proxy_cancast (MonoClass *klass)
        }
        
        name = g_strdup_printf ("__proxy_isinst_wrapper_%s", klass->name); 
-       mb = mono_mb_new (mono_defaults.object_class, name, MONO_WRAPPER_UNKNOWN);
+       mb = mono_mb_new (mono_defaults.object_class, name, MONO_WRAPPER_PROXY_ISINST);
        g_free (name);
        
        mb->method->save_lmf = 1;
@@ -5809,4 +5849,3 @@ mono_marshal_free_asany (MonoObject *o, gpointer ptr, MonoMarshalNative string_e
                break;
        }
 }
-

diff --git a/mono/metadata/metadata.h b/mono/metadata/metadata.h
index ae18747dce4fce01cdd0052394951bf9a1c2bd5a..32b73f0cfcc9849f67565c509dc157fd734fa9e8 100644 (file)
--- a/mono/metadata/metadata.h
+++ b/mono/metadata/metadata.h
@@ -158,11 +158,7 @@ typedef enum {
        MONO_MARSHAL_CONV_OBJECT_STRUCT,
        MONO_MARSHAL_CONV_DEL_FTN,
        MONO_MARSHAL_CONV_FTN_DEL,
-       MONO_MARSHAL_CONV_STRARRAY_STRLPARRAY,
-       MONO_MARSHAL_CONV_STRARRAY_STRWLPARRAY,
-       MONO_MARSHAL_CONV_ASANY,
-       MONO_MARSHAL_FREE_ARRAY,
-       MONO_MARSHAL_FREE_ASANY
+       MONO_MARSHAL_FREE_ARRAY
 } MonoMarshalConv;
 
 typedef struct {

diff --git a/mono/metadata/opcodes.c b/mono/metadata/opcodes.c
index b9b3b540f829d1577325b257e17fee4ce31df831..1e22212f3b9fb7751c2a487cafdfb6a87e7959d9 100644 (file)
--- a/mono/metadata/opcodes.c
+++ b/mono/metadata/opcodes.c
@@ -10,7 +10,7 @@
 #include <stddef.h> /* for NULL */
 
 #define MONO_PREFIX1_OFFSET MONO_CEE_ARGLIST
-#define MONO_CUSTOM_PREFIX_OFFSET MONO_CEE_MONO_FUNC1
+#define MONO_CUSTOM_PREFIX_OFFSET MONO_CEE_MONO_ICALL
 
 #define OPDEF(a,b,c,d,e,f,g,h,i,j) \
        { Mono ## e, MONO_FLOW_ ## j, MONO_ ## a },