#include "object.h"
#include "loader.h"
#include "metadata/marshal.h"
+#include "metadata/method-builder.h"
#include "metadata/tabledefs.h"
#include "metadata/exception.h"
#include "metadata/appdomain.h"
#include "mono/metadata/gc-internal.h"
#include "mono/metadata/threads-types.h"
#include "mono/metadata/string-icalls.h"
-#include <mono/os/gc_wrapper.h>
+#include <mono/metadata/gc-internal.h>
#include <string.h>
#include <errno.h>
MONO_MARSHAL_SERIALIZE /* Value needs to be serialized into the new domain */
} MonoXDomainMarshalType;
+typedef enum {
+ MONO_COM_DEFAULT,
+ MONO_COM_MS
+} MonoCOMProvider;
+
+static MonoCOMProvider com_provider = MONO_COM_DEFAULT;
+
enum {
#include "mono/cil/opcode.def"
LAST = 0xff
};
#undef OPDEF
-struct _MonoMethodBuilder {
- MonoMethod *method;
- char *name;
- GList *locals_list;
- int locals;
- gboolean dynamic;
- guint32 code_size, pos;
- unsigned char *code;
-};
-
struct _MonoRemotingMethods {
MonoMethod *invoke;
MonoMethod *invoke_with_check;
typedef struct _MonoRemotingMethods MonoRemotingMethods;
-#ifdef DEBUG_RUNTIME_CODE
-static char*
-indenter (MonoDisHelper *dh, MonoMethod *method, guint32 ip_offset)
-{
- return g_strdup (" ");
-}
-
-static MonoDisHelper marshal_dh = {
- "\n",
- "IL_%04x: ",
- "IL_%04x",
- indenter,
- NULL,
- NULL
-};
-#endif
-
/*
* This mutex protects the various marshalling related caches in MonoImage
* and a few other data structures static to this file.
mono_marshal_set_last_error_windows (int error);
static void
-mono_marshal_emit_native_wrapper (MonoImage *image, MonoMethodBuilder *mb, MonoMethodSignature *sig, MonoMethodPInvoke *piinfo, MonoMarshalSpec **mspecs, gpointer func);
+mono_marshal_emit_native_wrapper (MonoImage *image, MonoMethodBuilder *mb, MonoMethodSignature *sig, MonoMethodPInvoke *piinfo, MonoMarshalSpec **mspecs, gpointer func, gboolean check_exceptions);
static void init_safe_handle (void);
static gboolean module_initialized = FALSE;
if (!module_initialized) {
+ char* com_provider_env = NULL;
module_initialized = TRUE;
InitializeCriticalSection (&marshal_mutex);
InitializeCriticalSection (&cominterop_mutex);
last_error_tls_id = TlsAlloc ();
load_type_info_tls_id = TlsAlloc ();
+ com_provider_env = getenv ("MONO_COM");
+ if (com_provider_env && !strcmp(com_provider_env, "MS"))
+ com_provider = MONO_COM_MS;
+
register_icall (mono_marshal_string_to_utf16, "mono_marshal_string_to_utf16", "ptr obj", FALSE);
register_icall (mono_marshal_string_to_utf16_copy, "mono_marshal_string_to_utf16_copy", "ptr obj", FALSE);
register_icall (mono_string_to_utf16, "mono_string_to_utf16", "ptr obj", FALSE);
klass = ((MonoObject *)delegate)->vtable->klass;
g_assert (klass->delegate);
- method = delegate->method_info->method;
+ method = delegate->method;
wrapper = mono_marshal_get_managed_wrapper (method, klass, delegate->target);
return NULL;
}
+typedef gpointer (*SysAllocStringLenFunc)(gunichar* str, guint32 len);
+typedef guint32 (*SysStringLenFunc)(gpointer bstr);
+typedef void (*SysFreeStringFunc)(gunichar* str);
+
+static SysAllocStringLenFunc sys_alloc_string_len_ms = NULL;
+static SysStringLenFunc sys_string_len_ms = NULL;
+static SysFreeStringFunc sys_free_string_ms = NULL;
+
+static gboolean
+init_com_provider_ms (void)
+{
+ static gboolean initialized = FALSE;
+ char *error_msg;
+ MonoDl *module = NULL;
+ const char* scope = "liboleaut32.so";
+
+ if (initialized)
+ return TRUE;
+
+ module = mono_dl_open(scope, MONO_DL_LAZY, &error_msg);
+ if (error_msg) {
+ g_warning ("Error loading COM support library '%s': %s", scope, error_msg);
+ g_assert_not_reached ();
+ return FALSE;
+ }
+ error_msg = mono_dl_symbol (module, "SysAllocStringLen", (gpointer*)&sys_alloc_string_len_ms);
+ if (error_msg) {
+ g_warning ("Error loading entry point '%s' in COM support library '%s': %s", "SysAllocStringLen", scope, error_msg);
+ g_assert_not_reached ();
+ return FALSE;
+ }
+
+ error_msg = mono_dl_symbol (module, "SysStringLen", (gpointer*)&sys_string_len_ms);
+ if (error_msg) {
+ g_warning ("Error loading entry point '%s' in COM support library '%s': %s", "SysStringLen", scope, error_msg);
+ g_assert_not_reached ();
+ return FALSE;
+ }
+
+ error_msg = mono_dl_symbol (module, "SysFreeString", (gpointer*)&sys_free_string_ms);
+ if (error_msg) {
+ g_warning ("Error loading entry point '%s' in COM support library '%s': %s", "SysFreeString", scope, error_msg);
+ g_assert_not_reached ();
+ return FALSE;
+ }
+
+ initialized = TRUE;
+ return TRUE;
+}
+
gpointer
mono_string_to_bstr (MonoString *string_obj)
{
return NULL;
return SysAllocStringLen (mono_string_chars (string_obj), mono_string_length (string_obj));
#else
- int slen = mono_string_length (string_obj);
- char *ret = g_malloc (slen * 2 + 4 + 2);
- if (ret == NULL)
- return NULL;
- memcpy (ret + 4, mono_string_chars (string_obj), slen * 2);
- * ((guint32 *) ret) = slen * 2;
- ret [4 + slen * 2] = 0;
- ret [5 + slen * 2] = 0;
-
- return ret + 4;
+ if (com_provider == MONO_COM_DEFAULT) {
+ int slen = mono_string_length (string_obj);
+ char *ret = g_malloc (slen * 2 + 4 + 2);
+ if (ret == NULL)
+ return NULL;
+ memcpy (ret + 4, mono_string_chars (string_obj), slen * 2);
+ * ((guint32 *) ret) = slen;
+ ret [4 + slen * 2] = 0;
+ ret [5 + slen * 2] = 0;
+
+ return ret + 4;
+ } else if (com_provider == MONO_COM_MS && init_com_provider_ms ()) {
+ gpointer ret = NULL;
+ gunichar* str = NULL;
+ guint32 len;
+ len = mono_string_length (string_obj);
+ str = g_utf16_to_ucs4 (mono_string_chars (string_obj), len,
+ NULL, NULL, NULL);
+ ret = sys_alloc_string_len_ms (str, len);
+ g_free(str);
+ return ret;
+ } else {
+ g_assert_not_reached ();
+ }
#endif
}
return NULL;
return mono_string_new_utf16 (mono_domain_get (), bstr, SysStringLen (bstr));
#else
- return mono_string_new_utf16 (mono_domain_get (), bstr, *(guint32 *)((char *)bstr - 4));
+ if (com_provider == MONO_COM_DEFAULT) {
+ return mono_string_new_utf16 (mono_domain_get (), bstr, *(guint32 *)((char *)bstr - 4));
+ } else if (com_provider == MONO_COM_MS && init_com_provider_ms ()) {
+ MonoString* str = NULL;
+ glong written = 0;
+ gunichar2* utf16 = NULL;
+
+ utf16 = g_ucs4_to_utf16 (bstr, sys_string_len_ms (bstr), NULL, &written, NULL);
+ str = mono_string_new_utf16 (mono_domain_get (), utf16, written);
+ g_free (utf16);
+ return str;
+ } else {
+ g_assert_not_reached ();
+ }
+
#endif
}
#ifdef PLATFORM_WIN32
SysFreeString ((BSTR)bstr);
#else
- g_free (((char *)bstr) - 4);
+ if (com_provider == MONO_COM_DEFAULT) {
+ g_free (((char *)bstr) - 4);
+ } else if (com_provider == MONO_COM_MS && init_com_provider_ms ()) {
+ sys_free_string_ms (bstr);
+ } else {
+ g_assert_not_reached ();
+ }
+
#endif
}
*((gunichar2 *) dst + len) = 0;
}
-void
-mono_mb_free (MonoMethodBuilder *mb)
-{
- g_list_free (mb->locals_list);
- if (!mb->dynamic) {
- g_free (mb->method);
- g_free (mb->name);
- g_free (mb->code);
- }
- g_free (mb);
-}
-
-MonoMethodBuilder *
-mono_mb_new (MonoClass *klass, const char *name, MonoWrapperType type)
-{
- MonoMethodBuilder *mb;
- MonoMethod *m;
-
- g_assert (klass != NULL);
- g_assert (name != NULL);
-
- mb = g_new0 (MonoMethodBuilder, 1);
-
- mb->method = m = (MonoMethod *)g_new0 (MonoMethodWrapper, 1);
-
- m->klass = klass;
- m->inline_info = 1;
- m->wrapper_type = type;
-
- mb->name = g_strdup (name);
- mb->code_size = 40;
- mb->code = g_malloc (mb->code_size);
-
- return mb;
-}
-
-int
-mono_mb_add_local (MonoMethodBuilder *mb, MonoType *type)
-{
- int res;
-
- g_assert (mb != NULL);
- g_assert (type != NULL);
-
- res = mb->locals;
- mb->locals_list = g_list_append (mb->locals_list, type);
- mb->locals++;
-
- return res;
-}
-
-/**
- * mono_mb_create_method:
- *
- * Create a MonoMethod from this method builder.
- * Returns: the newly created method.
- *
- * LOCKING: Takes the loader lock.
- */
-MonoMethod *
-mono_mb_create_method (MonoMethodBuilder *mb, MonoMethodSignature *signature, int max_stack)
-{
- MonoMethodHeader *header;
- MonoMethodWrapper *mw;
- MonoMemPool *mp;
- MonoMethod *method;
- GList *l;
- int i;
-
- g_assert (mb != NULL);
-
- mp = mb->method->klass->image->mempool;
-
- mono_loader_lock ();
- if (mb->dynamic) {
- method = mb->method;
-
- method->name = mb->name;
- method->dynamic = TRUE;
-
- ((MonoMethodNormal *)method)->header = header = (MonoMethodHeader *)
- g_malloc0 (sizeof (MonoMethodHeader) + mb->locals * sizeof (MonoType *));
-
- header->code = mb->code;
-
- for (i = 0, l = mb->locals_list; l; l = l->next, i++) {
- header->locals [i] = mono_metadata_type_dup (NULL, (MonoType*)l->data);
- }
- } else {
- /* Realloc the method info into a mempool */
-
- method = mono_mempool_alloc (mp, sizeof (MonoMethodWrapper));
- memcpy (method, mb->method, sizeof (MonoMethodWrapper));
-
- method->name = mono_mempool_strdup (mp, mb->name);
-
- ((MonoMethodNormal *)method)->header = header = (MonoMethodHeader *)
- mono_mempool_alloc0 (mp, sizeof (MonoMethodHeader) + mb->locals * sizeof (MonoType *));
-
- header->code = mono_mempool_alloc (mp, mb->pos);
- memcpy ((char*)header->code, mb->code, mb->pos);
-
- for (i = 0, l = mb->locals_list; l; l = l->next, i++) {
- header->locals [i] = (MonoType *)l->data;
- }
- }
-
- if (max_stack < 8)
- max_stack = 8;
-
- header->max_stack = max_stack;
-
- method->signature = signature;
-
- header->code_size = mb->pos;
- header->num_locals = mb->locals;
- header->init_locals = TRUE;
-
- mw = (MonoMethodWrapper*) mb->method;
- i = g_list_length (mw->method_data);
- if (i) {
- GList *tmp;
- void **data;
- l = g_list_reverse (mw->method_data);
- if (method->dynamic)
- data = g_malloc (sizeof (gpointer) * (i + 1));
- else
- data = mono_mempool_alloc (mp, sizeof (gpointer) * (i + 1));
- /* store the size in the first element */
- data [0] = GUINT_TO_POINTER (i);
- i = 1;
- for (tmp = l; tmp; tmp = tmp->next) {
- data [i++] = tmp->data;
- }
- g_list_free (l);
-
- ((MonoMethodWrapper*)method)->method_data = data;
- }
- /*{
- static int total_code = 0;
- static int total_alloc = 0;
- total_code += mb->pos;
- total_alloc += mb->code_size;
- g_print ("code size: %d of %d (allocated: %d)\n", mb->pos, total_code, total_alloc);
- }*/
-
-#ifdef DEBUG_RUNTIME_CODE
- printf ("RUNTIME CODE FOR %s\n", mono_method_full_name (method, TRUE));
- printf ("%s\n", mono_disasm_code (&marshal_dh, method, mb->code, mb->code + mb->pos));
-#endif
-
- mono_loader_unlock ();
- return method;
-}
-
-guint32
-mono_mb_add_data (MonoMethodBuilder *mb, gpointer data)
-{
- MonoMethodWrapper *mw;
-
- g_assert (mb != NULL);
-
- mw = (MonoMethodWrapper *)mb->method;
-
- /* one O(n) is enough */
- mw->method_data = g_list_prepend (mw->method_data, data);
-
- return g_list_length (mw->method_data);
-}
-
-void
-mono_mb_patch_addr (MonoMethodBuilder *mb, int pos, int value)
-{
- mb->code [pos] = value & 0xff;
- mb->code [pos + 1] = (value >> 8) & 0xff;
- mb->code [pos + 2] = (value >> 16) & 0xff;
- mb->code [pos + 3] = (value >> 24) & 0xff;
-}
-
-void
-mono_mb_patch_addr_s (MonoMethodBuilder *mb, int pos, gint8 value)
-{
- *((gint8 *)(&mb->code [pos])) = value;
-}
-
-void
-mono_mb_emit_byte (MonoMethodBuilder *mb, guint8 op)
-{
- if (mb->pos >= mb->code_size) {
- mb->code_size += mb->code_size >> 1;
- mb->code = g_realloc (mb->code, mb->code_size);
- }
-
- mb->code [mb->pos++] = op;
-}
-
-void
-mono_mb_emit_ldflda (MonoMethodBuilder *mb, gint32 offset)
-{
- mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
- mono_mb_emit_byte (mb, CEE_MONO_OBJADDR);
-
- if (offset) {
- mono_mb_emit_icon (mb, offset);
- mono_mb_emit_byte (mb, CEE_ADD);
- }
-}
-
static int
mono_mb_emit_proxy_check (MonoMethodBuilder *mb, int branch_code)
{
mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
mono_mb_emit_byte (mb, CEE_MONO_CLASSCONST);
mono_mb_emit_i4 (mb, mono_mb_add_data (mb, mono_defaults.transparent_proxy_class));
- mono_mb_emit_byte (mb, branch_code);
- pos = mb->pos;
- mono_mb_emit_i4 (mb, 0);
+ pos = mono_mb_emit_branch (mb, branch_code);
return pos;
}
mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoRealProxy, target_domain_id));
mono_mb_emit_byte (mb, CEE_LDIND_I4);
mono_mb_emit_icon (mb, -1);
- mono_mb_emit_byte (mb, branch_code);
- pos = mb->pos;
- mono_mb_emit_i4 (mb, 0);
+ pos = mono_mb_emit_branch (mb, branch_code);
return pos;
}
-void
-mono_mb_emit_i4 (MonoMethodBuilder *mb, gint32 data)
-{
- if ((mb->pos + 4) >= mb->code_size) {
- mb->code_size += mb->code_size >> 1;
- mb->code = g_realloc (mb->code, mb->code_size);
- }
-
- mono_mb_patch_addr (mb, mb->pos, data);
- mb->pos += 4;
-}
-
-void
-mono_mb_emit_i2 (MonoMethodBuilder *mb, gint16 data)
-{
- if ((mb->pos + 2) >= mb->code_size) {
- mb->code_size += mb->code_size >> 1;
- mb->code = g_realloc (mb->code, mb->code_size);
- }
-
- mb->code [mb->pos] = data & 0xff;
- mb->code [mb->pos + 1] = (data >> 8) & 0xff;
- mb->pos += 2;
-}
-
-static inline void
-mono_mb_emit_op (MonoMethodBuilder *mb, guint8 op, gpointer data)
-{
- mono_mb_emit_byte (mb, op);
- mono_mb_emit_i4 (mb, mono_mb_add_data (mb, data));
-}
-
-void
-mono_mb_emit_ldstr (MonoMethodBuilder *mb, char *str)
-{
- mono_mb_emit_op (mb, CEE_LDSTR, str);
-}
-
-void
-mono_mb_emit_ldarg (MonoMethodBuilder *mb, guint argnum)
-{
- if (argnum < 4) {
- mono_mb_emit_byte (mb, CEE_LDARG_0 + argnum);
- } else if (argnum < 256) {
- mono_mb_emit_byte (mb, CEE_LDARG_S);
- mono_mb_emit_byte (mb, argnum);
- } else {
- mono_mb_emit_byte (mb, CEE_PREFIX1);
- mono_mb_emit_byte (mb, CEE_LDARG);
- mono_mb_emit_i2 (mb, argnum);
- }
-}
-
-void
-mono_mb_emit_ldarg_addr (MonoMethodBuilder *mb, guint argnum)
-{
- if (argnum < 256) {
- mono_mb_emit_byte (mb, CEE_LDARGA_S);
- mono_mb_emit_byte (mb, argnum);
- } else {
- mono_mb_emit_byte (mb, CEE_PREFIX1);
- mono_mb_emit_byte (mb, CEE_LDARGA);
- mono_mb_emit_i2 (mb, argnum);
- }
-}
-
-void
-mono_mb_emit_ldloc_addr (MonoMethodBuilder *mb, guint locnum)
-{
- if (locnum < 256) {
- mono_mb_emit_byte (mb, CEE_LDLOCA_S);
- mono_mb_emit_byte (mb, locnum);
- } else {
- mono_mb_emit_byte (mb, CEE_PREFIX1);
- mono_mb_emit_byte (mb, CEE_LDLOCA);
- mono_mb_emit_i2 (mb, locnum);
- }
-}
-
-void
-mono_mb_emit_ldloc (MonoMethodBuilder *mb, guint num)
-{
- if (num < 4) {
- mono_mb_emit_byte (mb, CEE_LDLOC_0 + num);
- } else if (num < 256) {
- mono_mb_emit_byte (mb, CEE_LDLOC_S);
- mono_mb_emit_byte (mb, num);
- } else {
- mono_mb_emit_byte (mb, CEE_PREFIX1);
- mono_mb_emit_byte (mb, CEE_LDLOC);
- mono_mb_emit_i2 (mb, num);
- }
-}
-
-void
-mono_mb_emit_stloc (MonoMethodBuilder *mb, guint num)
-{
- if (num < 4) {
- mono_mb_emit_byte (mb, CEE_STLOC_0 + num);
- } else if (num < 256) {
- mono_mb_emit_byte (mb, CEE_STLOC_S);
- mono_mb_emit_byte (mb, num);
- } else {
- mono_mb_emit_byte (mb, CEE_PREFIX1);
- mono_mb_emit_byte (mb, CEE_STLOC);
- mono_mb_emit_i2 (mb, num);
- }
-}
-
-void
-mono_mb_emit_icon (MonoMethodBuilder *mb, gint32 value)
-{
- if (value >= -1 && value < 8) {
- mono_mb_emit_byte (mb, CEE_LDC_I4_0 + value);
- } else if (value >= -128 && value <= 127) {
- mono_mb_emit_byte (mb, CEE_LDC_I4_S);
- mono_mb_emit_byte (mb, value);
- } else {
- mono_mb_emit_byte (mb, CEE_LDC_I4);
- mono_mb_emit_i4 (mb, value);
- }
-}
-
-int
-mono_mb_get_label (MonoMethodBuilder *mb)
-{
- return mb->pos;
-}
-
-guint32
-mono_mb_emit_branch (MonoMethodBuilder *mb, guint8 op)
-{
- guint32 res;
- mono_mb_emit_byte (mb, op);
- res = mb->pos;
- mono_mb_emit_i4 (mb, 0);
- return res;
-}
-
-guint32
-mono_mb_emit_short_branch (MonoMethodBuilder *mb, guint8 op)
-{
- guint32 res;
- mono_mb_emit_byte (mb, op);
- res = mb->pos;
- mono_mb_emit_byte (mb, 0);
-
- return res;
-}
-
-static void
-mono_mb_patch_branch (MonoMethodBuilder *mb, guint32 pos)
-{
- mono_mb_patch_addr (mb, pos, mb->pos - (pos + 4));
-}
-
-void
-mono_mb_patch_short_branch (MonoMethodBuilder *mb, guint32 pos)
-{
- mono_mb_patch_addr_s (mb, pos, mb->pos - (pos + 1));
-}
-
-static void
-mono_mb_emit_ptr (MonoMethodBuilder *mb, gpointer ptr)
-{
- mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
- mono_mb_emit_op (mb, CEE_MONO_LDPTR, ptr);
-}
-
-static void
-mono_mb_emit_calli (MonoMethodBuilder *mb, MonoMethodSignature *sig)
-{
- mono_mb_emit_op (mb, CEE_CALLI, sig);
-}
-
-void
-mono_mb_emit_managed_call (MonoMethodBuilder *mb, MonoMethod *method, MonoMethodSignature *opt_sig)
-{
- mono_mb_emit_op (mb, CEE_CALL, method);
-}
-
-void
-mono_mb_emit_native_call (MonoMethodBuilder *mb, MonoMethodSignature *sig, gpointer func)
-{
- mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
- mono_mb_emit_byte (mb, CEE_MONO_SAVE_LMF);
- mono_mb_emit_ptr (mb, func);
- mono_mb_emit_calli (mb, sig);
- mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
- mono_mb_emit_byte (mb, CEE_MONO_RESTORE_LMF);
-}
-
-void
-mono_mb_emit_icall (MonoMethodBuilder *mb, gpointer func)
-{
- mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
- mono_mb_emit_op (mb, CEE_MONO_ICALL, func);
-}
-
static void
mono_mb_emit_cominterop_call (MonoMethodBuilder *mb, MonoMethodSignature *sig, MonoMethod* method)
{
mono_mb_emit_byte (mb, CEE_MONO_RESTORE_LMF);
}
-static void
-mono_mb_emit_exception_full (MonoMethodBuilder *mb, const char *exc_nspace, const char *exc_name, const char *msg)
-{
- MonoMethod *ctor = NULL;
-
- MonoClass *mme = mono_class_from_name (mono_defaults.corlib, exc_nspace, exc_name);
- mono_class_init (mme);
- ctor = mono_class_get_method_from_name (mme, ".ctor", 0);
- g_assert (ctor);
- mono_mb_emit_op (mb, CEE_NEWOBJ, ctor);
- if (msg != NULL) {
- mono_mb_emit_byte (mb, CEE_DUP);
- mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoException, message));
- mono_mb_emit_ldstr (mb, (char*)msg);
- mono_mb_emit_byte (mb, CEE_STIND_REF);
- }
- mono_mb_emit_byte (mb, CEE_THROW);
-}
-
-void
-mono_mb_emit_exception (MonoMethodBuilder *mb, const char *exc_name, const char *msg)
-{
- mono_mb_emit_exception_full (mb, "System", exc_name, msg);
-}
-
static void
mono_mb_emit_exception_marshal_directive (MonoMethodBuilder *mb, const char *msg)
{
mono_mb_emit_exception_full (mb, "System.Runtime.InteropServices", "MarshalDirectiveException", msg);
}
-void
-mono_mb_emit_add_to_local (MonoMethodBuilder *mb, guint16 local, gint32 incr)
-{
- mono_mb_emit_ldloc (mb, local);
- mono_mb_emit_icon (mb, incr);
- mono_mb_emit_byte (mb, CEE_ADD);
- mono_mb_emit_stloc (mb, local);
-}
-
guint
mono_type_to_ldind (MonoType *type)
{
mono_mb_emit_stloc (mb, index_var);
/* Loop header */
- label2 = mb->pos;
+ label2 = mono_mb_get_label (mb);
mono_mb_emit_ldloc (mb, index_var);
mono_mb_emit_ldloc (mb, array_var);
mono_mb_emit_byte (mb, CEE_LDLEN);
/* Loop footer */
mono_mb_emit_add_to_local (mb, index_var, 1);
- mono_mb_emit_byte (mb, CEE_BR);
- mono_mb_emit_i4 (mb, label2 - (mb->pos + 4));
+ mono_mb_emit_branch_label (mb, CEE_BR, label2);
mono_mb_patch_branch (mb, label3);
mono_mb_emit_stloc (mb, index_var);
/* Loop header */
- label2 = mb->pos;
+ label2 = mono_mb_get_label (mb);
mono_mb_emit_ldloc (mb, index_var);
mono_mb_emit_ldloc (mb, array_var);
mono_mb_emit_byte (mb, CEE_LDLEN);
/* Loop footer */
mono_mb_emit_add_to_local (mb, index_var, 1);
- mono_mb_emit_byte (mb, CEE_BR);
- mono_mb_emit_i4 (mb, label2 - (mb->pos + 4));
+ mono_mb_emit_branch_label (mb, CEE_BR, label2);
mono_mb_patch_branch (mb, label3);
mono_mb_emit_icall (mb, checkpoint_func);
- mono_mb_patch_addr (mb, pos_noabort, mb->pos - (pos_noabort + 4));
+ mono_mb_patch_branch (mb, pos_noabort);
}
static void
MonoObject *exc;
MonoArray *out_args;
HANDLE handle;
- method = delegate->method_info->method;
+ method = delegate->method;
msg = mono_method_call_message_new (mono_marshal_method_from_wrapper (method), params, NULL, &async_callback, &state);
handle = CreateEvent (NULL, TRUE, FALSE, NULL);
switch (encoding) {
case MONO_NATIVE_LPWSTR:
+ *need_free = FALSE;
return MONO_MARSHAL_CONV_LPWSTR_STR;
case MONO_NATIVE_LPSTR:
return MONO_MARSHAL_CONV_LPSTR_STR;
g_assert (delegate);
+ if (!delegate->method_info) {
+ g_assert (delegate->method);
+ MONO_OBJECT_SETREF (delegate, method_info, mono_method_get_object (domain, delegate->method, NULL));
+ }
+
if (!delegate->method_info || !delegate->method_info->method)
g_assert_not_reached ();
mspecs[0] = NULL;
}
- mono_marshal_emit_native_wrapper(method->klass->image, mb_native, sig_native, piinfo, mspecs, piinfo->addr);
+ mono_marshal_emit_native_wrapper (method->klass->image, mb_native, sig_native, piinfo, mspecs, piinfo->addr, TRUE);
res = mono_mb_create_method (mb_native, sig_native, sig_native->param_count + 16);
mono_loader_lock ();
main_clause = mono_mempool_alloc0 (method->klass->image->mempool, sizeof (MonoExceptionClause));
mono_loader_unlock ();
- main_clause->try_offset = mb->pos;
+ main_clause->try_offset = mono_mb_get_label (mb);
/* Clean the call context */
else
mono_mb_emit_byte (mb, CEE_POP);
- mono_mb_patch_addr_s (mb, pos, mb->pos - (pos + 1));
+ mono_mb_patch_short_branch (mb, pos);
/* Get the target object */
/* Main exception catch */
main_clause->flags = MONO_EXCEPTION_CLAUSE_NONE;
- main_clause->try_len = mb->pos - main_clause->try_offset;
+ main_clause->try_len = mono_mb_get_pos (mb) - main_clause->try_offset;
main_clause->data.catch_class = mono_defaults.object_class;
/* handler code */
- main_clause->handler_offset = mb->pos;
+ main_clause->handler_offset = mono_mb_get_label (mb);
mono_mb_emit_managed_call (mb, method_rs_serialize_exc, NULL);
mono_mb_emit_stloc (mb, loc_serialized_exc);
mono_mb_emit_ldarg (mb, 2);
mono_mb_emit_ldloc (mb, loc_serialized_exc);
mono_mb_emit_byte (mb, CEE_STIND_REF);
mono_mb_emit_branch (mb, CEE_LEAVE);
- main_clause->handler_len = mb->pos - main_clause->handler_offset;
+ main_clause->handler_len = mono_mb_get_pos (mb) - main_clause->handler_offset;
/* end catch */
- mono_mb_patch_addr (mb, pos_leave, mb->pos - (pos_leave + 4));
+ mono_mb_patch_branch (mb, pos_leave);
if (copy_return)
mono_mb_emit_ldloc (mb, loc_return);
mono_mb_emit_op (mb, CEE_CASTCLASS, mono_defaults.exception_class);
mono_mb_emit_managed_call (mb, method_exc_fixexc, NULL);
mono_mb_emit_byte (mb, CEE_THROW);
- mono_mb_patch_addr_s (mb, pos_noex, mb->pos - pos_noex - 1);
+ mono_mb_patch_short_branch (mb, pos_noex);
/* copy back non-serialized output parameters */
pos = mono_mb_emit_short_branch (mb, CEE_BRFALSE_S);
mono_marshal_emit_xdomain_copy_value (mb, byte_array_class);
- mono_mb_patch_addr_s (mb, pos, mb->pos - (pos + 1));
+ mono_mb_patch_short_branch (mb, pos);
mono_mb_emit_managed_call (mb, method_rs_deserialize, NULL);
mono_mb_emit_byte (mb, CEE_POP);
}
mono_mb_emit_managed_call (mb, native, mono_method_signature (native));
mono_mb_emit_byte (mb, CEE_RET);
- mono_mb_patch_addr (mb, pos_rem, mb->pos - (pos_rem + 4));
+ mono_mb_patch_branch (mb, pos_rem);
}
/* wrapper for normal remote calls */
native = mono_marshal_get_remoting_invoke (method);
return res;
}
+typedef struct
+{
+ MonoMethodSignature *sig;
+ MonoMethod *method;
+} SignatureMethodPair;
+
+static guint
+signature_method_pair_hash (gconstpointer data)
+{
+ SignatureMethodPair *pair = (SignatureMethodPair*)data;
+
+ return mono_signature_hash (pair->sig) ^ mono_aligned_addr_hash (pair->method);
+}
+
+static gboolean
+signature_method_pair_equal (SignatureMethodPair *pair1, SignatureMethodPair *pair2)
+{
+ return mono_metadata_signature_equal (pair1->sig, pair2->sig) && (pair1->method == pair2->method);
+}
+
+static void
+free_signature_method_pair (SignatureMethodPair *pair)
+{
+ g_free (pair);
+}
+
/*
- * the returned method invokes all methods in a multicast delegate
+ * the returned method invokes all methods in a multicast delegate.
*/
MonoMethod *
-mono_marshal_get_delegate_invoke (MonoMethod *method)
+mono_marshal_get_delegate_invoke (MonoMethod *method, MonoDelegate *del)
{
MonoMethodSignature *sig, *static_sig;
int i;
MonoMethodBuilder *mb;
- MonoMethod *res;
+ MonoMethod *res, *newm;
GHashTable *cache;
+ SignatureMethodPair key;
+ SignatureMethodPair *new_key;
+ int local_prev, local_target;
int pos0;
char *name;
+ MonoMethod *target_method = NULL;
+ gboolean callvirt = FALSE;
+
+ /*
+ * If the delegate target is null, and the target method is not static, a virtual
+ * call is made to that method with the first delegate argument as this. This is
+ * a non-documented .NET feature.
+ */
+ if (del && !del->target && del->method && mono_method_signature (del->method)->hasthis) {
+ callvirt = TRUE;
+ target_method = del->method;
+ }
g_assert (method && method->klass->parent == mono_defaults.multicastdelegate_class &&
!strcmp (method->name, "Invoke"));
sig = signature_no_pinvoke (method);
- cache = method->klass->image->delegate_invoke_cache;
- if ((res = mono_marshal_find_in_cache (cache, sig)))
- return res;
+ if (callvirt) {
+ /* We need to cache the signature+method pair */
+ mono_marshal_lock ();
+ if (!method->klass->image->delegate_abstract_invoke_cache)
+ method->klass->image->delegate_abstract_invoke_cache = g_hash_table_new_full (signature_method_pair_hash, (GEqualFunc)signature_method_pair_equal, (GDestroyNotify)free_signature_method_pair, NULL);
+ cache = method->klass->image->delegate_abstract_invoke_cache;
+ key.sig = sig;
+ key.method = target_method;
+ res = g_hash_table_lookup (cache, &key);
+ mono_marshal_unlock ();
+ if (res)
+ return res;
+ } else {
+ cache = method->klass->image->delegate_invoke_cache;
+ if ((res = mono_marshal_find_in_cache (cache, sig)))
+ return res;
+ }
static_sig = signature_dup (method->klass->image, sig);
static_sig->hasthis = 0;
g_free (name);
/* allocate local 0 (object) */
- mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
+ local_target = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
+ local_prev = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
g_assert (sig->hasthis);
mono_mb_emit_ldarg (mb, 0);
mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoMulticastDelegate, prev));
mono_mb_emit_byte (mb, CEE_LDIND_REF);
+ mono_mb_emit_stloc (mb, local_prev);
+ mono_mb_emit_ldloc (mb, local_prev);
/* if prev != null */
pos0 = mono_mb_emit_branch (mb, CEE_BRFALSE);
mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
mono_mb_emit_byte (mb, CEE_MONO_NOT_TAKEN);
- mono_mb_emit_ldarg (mb, 0);
- mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoMulticastDelegate, prev));
- mono_mb_emit_byte (mb, CEE_LDIND_REF);
+ mono_mb_emit_ldloc (mb, local_prev);
for (i = 0; i < sig->param_count; i++)
mono_mb_emit_ldarg (mb, i + 1);
- mono_mb_emit_managed_call (mb, method, mono_method_signature (method));
+ mono_mb_emit_op (mb, CEE_CALLVIRT, method);
if (sig->ret->type != MONO_TYPE_VOID)
mono_mb_emit_byte (mb, CEE_POP);
mono_mb_emit_ldarg (mb, 0);
mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoDelegate, target));
mono_mb_emit_byte (mb, CEE_LDIND_REF);
- mono_mb_emit_stloc (mb, 0);
+ mono_mb_emit_stloc (mb, local_target);
/* if target != null */
- mono_mb_emit_ldloc (mb, 0);
+ mono_mb_emit_ldloc (mb, local_target);
pos0 = mono_mb_emit_branch (mb, CEE_BRFALSE);
/* then call this->method_ptr nonstatic */
- mono_mb_emit_ldloc (mb, 0);
- for (i = 0; i < sig->param_count; ++i)
- mono_mb_emit_ldarg (mb, i + 1);
- mono_mb_emit_ldarg (mb, 0);
- mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoDelegate, method_ptr));
- mono_mb_emit_byte (mb, CEE_LDIND_I );
- mono_mb_emit_op (mb, CEE_CALLI, sig);
+ if (callvirt) {
+ // FIXME:
+ mono_mb_emit_exception_full (mb, "System", "NotImplementedException", "");
+ } else {
+ mono_mb_emit_ldloc (mb, local_target);
+ for (i = 0; i < sig->param_count; ++i)
+ mono_mb_emit_ldarg (mb, i + 1);
+ mono_mb_emit_ldarg (mb, 0);
+ mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoDelegate, method_ptr));
+ mono_mb_emit_byte (mb, CEE_LDIND_I );
+ mono_mb_emit_op (mb, CEE_CALLI, sig);
- mono_mb_emit_byte (mb, CEE_RET);
+ mono_mb_emit_byte (mb, CEE_RET);
+ }
/* else [target == null] call this->method_ptr static */
mono_mb_patch_branch (mb, pos0);
- for (i = 0; i < sig->param_count; ++i)
- mono_mb_emit_ldarg (mb, i + 1);
- mono_mb_emit_ldarg (mb, 0);
- mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoDelegate, method_ptr));
- mono_mb_emit_byte (mb, CEE_LDIND_I );
- mono_mb_emit_op (mb, CEE_CALLI, static_sig);
+ if (callvirt) {
+ mono_mb_emit_ldarg (mb, 1);
+ mono_mb_emit_op (mb, CEE_CASTCLASS, target_method->klass);
+ for (i = 1; i < sig->param_count; ++i)
+ mono_mb_emit_ldarg (mb, i + 1);
+ mono_mb_emit_op (mb, CEE_CALLVIRT, target_method);
+ } else {
+ for (i = 0; i < sig->param_count; ++i)
+ mono_mb_emit_ldarg (mb, i + 1);
+ mono_mb_emit_ldarg (mb, 0);
+ mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoDelegate, method_ptr));
+ mono_mb_emit_byte (mb, CEE_LDIND_I );
+ mono_mb_emit_op (mb, CEE_CALLI, static_sig);
+ }
mono_mb_emit_byte (mb, CEE_RET);
- res = mono_mb_create_and_cache (cache, sig,
- mb, sig, sig->param_count + 16);
+ if (callvirt) {
+ // From mono_mb_create_and_cache
+ newm = mono_mb_create_method (mb, sig, sig->param_count + 16);
+ mono_marshal_lock ();
+ res = g_hash_table_lookup (cache, &key);
+ if (!res) {
+ res = newm;
+ new_key = g_new0 (SignatureMethodPair, 1);
+ new_key->sig = sig;
+ new_key->method = target_method;
+ g_hash_table_insert (cache, new_key, res);
+ g_hash_table_insert (wrapper_hash, res, new_key);
+ mono_marshal_unlock ();
+ } else {
+ mono_marshal_unlock ();
+ mono_free_method (newm);
+ }
+ } else {
+ res = mono_mb_create_and_cache (cache, sig, mb, sig, sig->param_count + 16);
+ }
mono_mb_free (mb);
return res;
MonoClass *target_klass;
MonoMethod *res = NULL;
static MonoString *string_dummy = NULL;
- static MonoMethodSignature *dealy_abort_sig = NULL;
+ static MonoMethodSignature *delay_abort_sig = NULL;
+ static MonoMethodSignature *cctor_signature = NULL;
+ static MonoMethodSignature *finalize_signature = NULL;
int i, pos, posna;
char *name;
+ gboolean need_direct_wrapper = FALSE;
g_assert (method);
+ if (!cctor_signature) {
+ cctor_signature = mono_metadata_signature_alloc (mono_defaults.corlib, 0);
+ cctor_signature->ret = &mono_defaults.void_class->byval_arg;
+ }
+ if (!finalize_signature) {
+ finalize_signature = mono_metadata_signature_alloc (mono_defaults.corlib, 0);
+ finalize_signature->ret = &mono_defaults.void_class->byval_arg;
+ finalize_signature->hasthis = 1;
+ }
+
+ if (method->klass->rank && (method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) &&
+ (method->iflags & METHOD_IMPL_ATTRIBUTE_NATIVE)) {
+ /*
+ * Array Get/Set/Address methods. The JIT implements them using inline code
+ * so we need to create an invoke wrapper which calls the method directly.
+ */
+ need_direct_wrapper = TRUE;
+ }
+
if (method->string_ctor) {
callsig = lookup_string_ctor_signature (mono_method_signature (method));
if (!callsig)
*/
callsig = signature_dup_add_this (mono_method_signature (method), method->klass);
} else {
- callsig = mono_method_signature (method);
+ if (method->dynamic)
+ callsig = signature_dup (method->klass->image, mono_method_signature (method));
+ else
+ callsig = mono_method_signature (method);
}
}
- /* See bug #80743 */
- target_klass = method->klass;
-#if 0
- target_klass = mono_defaults.object_class;
- /*
- * if types in the signature belong to non-mscorlib, we cache only
- * in the method image
+ /*
+ * We try to share runtime invoke wrappers between different methods but have to
+ * be careful about methods whose klass has a type cctor, since putting the wrapper
+ * into that klass would mean that calling a method of klass A might invoke the
+ * type initializer of class B, or throw an exception if the type initializer
+ * was called before and failed. See #349621 for an example.
+ * We avoid that for mscorlib methods by putting every wrapper into the object class.
*/
- if (mono_class_from_mono_type (callsig->ret)->image != mono_defaults.corlib) {
- target_klass = method->klass;
- } else {
- for (i = 0; i < callsig->param_count; i++) {
- if (mono_class_from_mono_type (callsig->params [i])->image != mono_defaults.corlib) {
- target_klass = method->klass;
- break;
- }
+ if (method->klass->image == mono_defaults.corlib)
+ target_klass = mono_defaults.object_class;
+ else {
+ /* Try to share wrappers for non-corlib methods with simple signatures */
+ if (mono_metadata_signature_equal (callsig, cctor_signature)) {
+ callsig = cctor_signature;
+ target_klass = mono_defaults.object_class;
+ } else if (mono_metadata_signature_equal (callsig, finalize_signature)) {
+ callsig = finalize_signature;
+ target_klass = mono_defaults.object_class;
+ } else {
+ if (mono_class_get_cctor (method->klass))
+ need_direct_wrapper = TRUE;
+ /*
+ * Can't put these wrappers into object, since they reference non-corlib
+ * metadata (callsig).
+ */
+ target_klass = method->klass;
}
}
-#endif
- cache = target_klass->image->runtime_invoke_cache;
- /* from mono_marshal_find_in_cache */
- mono_marshal_lock ();
- res = g_hash_table_lookup (cache, callsig);
- mono_marshal_unlock ();
+ if (need_direct_wrapper) {
+ cache = target_klass->image->runtime_invoke_direct_cache;
+ res = mono_marshal_find_in_cache (cache, method);
+ } else {
+ cache = target_klass->image->runtime_invoke_cache;
+
+ /* from mono_marshal_find_in_cache */
+ mono_marshal_lock ();
+ res = g_hash_table_lookup (cache, callsig);
+ mono_marshal_unlock ();
+ }
if (res) {
return res;
}
- if (!dealy_abort_sig) {
- dealy_abort_sig = mono_metadata_signature_alloc (mono_defaults.corlib, 0);
- dealy_abort_sig->ret = &mono_defaults.void_class->byval_arg;
- dealy_abort_sig->pinvoke = 0;
+ if (!delay_abort_sig) {
+ delay_abort_sig = mono_metadata_signature_alloc (mono_defaults.corlib, 0);
+ delay_abort_sig->ret = &mono_defaults.void_class->byval_arg;
+ delay_abort_sig->pinvoke = 0;
}
/* to make it work with our special string constructors */
mono_mb_emit_icon (mb, sizeof (gpointer) * i);
mono_mb_emit_byte (mb, CEE_ADD);
}
- mono_mb_emit_byte (mb, CEE_LDIND_I);
- if (t->byref)
+ if (t->byref) {
+ mono_mb_emit_byte (mb, CEE_LDIND_I);
continue;
+ }
type = sig->params [i]->type;
handle_enum:
case MONO_TYPE_R8:
case MONO_TYPE_I8:
case MONO_TYPE_U8:
+ mono_mb_emit_byte (mb, CEE_LDIND_I);
mono_mb_emit_byte (mb, mono_type_to_ldind (sig->params [i]));
break;
case MONO_TYPE_STRING:
case MONO_TYPE_PTR:
case MONO_TYPE_SZARRAY:
case MONO_TYPE_OBJECT:
- /* do nothing */
+ mono_mb_emit_byte (mb, mono_type_to_ldind (sig->params [i]));
break;
case MONO_TYPE_GENERICINST:
if (!mono_type_generic_inst_is_valuetype (sig->params [i])) {
- /* do nothing */
+ mono_mb_emit_byte (mb, CEE_LDIND_I);
break;
}
type = t->data.klass->enum_basetype->type;
goto handle_enum;
}
+ mono_mb_emit_byte (mb, CEE_LDIND_I);
if (mono_class_is_nullable (mono_class_from_mono_type (sig->params [i]))) {
/* Need to convert a boxed vtype to an mp to a Nullable struct */
mono_mb_emit_op (mb, CEE_UNBOX, mono_class_from_mono_type (sig->params [i]));
}
}
- mono_mb_emit_ldarg (mb, 3);
- mono_mb_emit_calli (mb, callsig);
+ if (need_direct_wrapper) {
+ mono_mb_emit_op (mb, CEE_CALL, method);
+ } else {
+ mono_mb_emit_ldarg (mb, 3);
+ mono_mb_emit_calli (mb, callsig);
+ }
if (sig->ret->byref) {
/* fixme: */
clause = mono_mempool_alloc0 (target_klass->image->mempool, sizeof (MonoExceptionClause));
mono_loader_unlock ();
clause->flags = MONO_EXCEPTION_CLAUSE_FILTER;
- clause->try_len = mb->pos;
+ clause->try_len = mono_mb_get_label (mb);
/* filter code */
- clause->data.filter_offset = mb->pos;
+ clause->data.filter_offset = mono_mb_get_label (mb);
mono_mb_emit_byte (mb, CEE_POP);
mono_mb_emit_byte (mb, CEE_LDARG_2);
mono_mb_emit_byte (mb, CEE_PREFIX1);
mono_mb_emit_byte (mb, CEE_ENDFILTER);
- clause->handler_offset = mb->pos;
+ clause->handler_offset = mono_mb_get_label (mb);
/* handler code */
/* store exception */
posna = mono_mb_emit_short_branch (mb, CEE_BRFALSE_S);
/* Delay the abort exception */
- mono_mb_emit_native_call (mb, dealy_abort_sig, ves_icall_System_Threading_Thread_ResetAbort);
+ mono_mb_emit_native_call (mb, delay_abort_sig, ves_icall_System_Threading_Thread_ResetAbort);
mono_mb_patch_short_branch (mb, posna);
mono_mb_emit_branch (mb, CEE_LEAVE);
- clause->handler_len = mb->pos - clause->handler_offset;
+ clause->handler_len = mono_mb_get_pos (mb) - clause->handler_offset;
/* return result */
mono_mb_patch_branch (mb, pos);
mono_mb_emit_ldloc (mb, 0);
mono_mb_emit_byte (mb, CEE_RET);
- /* taken from mono_mb_create_and_cache */
- mono_marshal_lock ();
- res = g_hash_table_lookup (cache, callsig);
- mono_marshal_unlock ();
-
- /* Somebody may have created it before us */
- if (!res) {
- MonoMethod *newm;
- newm = mono_mb_create_method (mb, csig, sig->param_count + 16);
-
+ if (need_direct_wrapper) {
+ res = mono_mb_create_and_cache (cache, method, mb, csig, sig->param_count + 16);
+ } else {
+ /* taken from mono_mb_create_and_cache */
mono_marshal_lock ();
res = g_hash_table_lookup (cache, callsig);
+ mono_marshal_unlock ();
+
+ /* Somebody may have created it before us */
if (!res) {
- res = newm;
- g_hash_table_insert (cache, callsig, res);
- g_hash_table_insert (wrapper_hash, res, callsig);
- } else {
- mono_free_method (newm);
+ MonoMethod *newm;
+ newm = mono_mb_create_method (mb, csig, sig->param_count + 16);
+
+ mono_marshal_lock ();
+ res = g_hash_table_lookup (cache, callsig);
+ if (!res) {
+ res = newm;
+ g_hash_table_insert (cache, callsig, res);
+ g_hash_table_insert (wrapper_hash, res, callsig);
+ } else {
+ mono_free_method (newm);
+ }
+ mono_marshal_unlock ();
}
- mono_marshal_unlock ();
- }
- /* end mono_mb_create_and_cache */
+ /* end mono_mb_create_and_cache */
+ }
mono_mb_free (mb);
* calls the unmanaged code in func)
*/
MonoMethod *
-mono_marshal_get_icall_wrapper (MonoMethodSignature *sig, const char *name, gconstpointer func)
+mono_marshal_get_icall_wrapper (MonoMethodSignature *sig, const char *name, gconstpointer func, gboolean check_exceptions)
{
MonoMethodSignature *csig;
MonoMethodBuilder *mb;
mono_mb_emit_ldarg (mb, i + sig->hasthis);
mono_mb_emit_native_call (mb, sig, (gpointer) func);
- emit_thread_interrupt_checkpoint (mb);
+ if (check_exceptions)
+ emit_thread_interrupt_checkpoint (mb);
mono_mb_emit_byte (mb, CEE_RET);
csig = signature_dup (mono_defaults.corlib, sig);
break;
case MARSHAL_ACTION_CONV_OUT:
+ conv = mono_marshal_get_ptr_to_string_conv (m->piinfo, spec, &need_free);
+ if (conv == -1) {
+ char *msg = g_strdup_printf ("string marshalling conversion %d not implemented", encoding);
+ mono_mb_emit_exception_marshal_directive (mb, msg);
+ break;
+ }
+
if (t->byref && (t->attrs & PARAM_ATTRIBUTE_OUT)) {
mono_mb_emit_ldarg (mb, argnum);
mono_mb_emit_ldloc (mb, conv_arg);
- if (conv == MONO_MARSHAL_CONV_STR_BSTR) {
- mono_mb_emit_icall (mb, conv_to_icall (MONO_MARSHAL_CONV_BSTR_STR));
- // BSTRs always need freed
- mono_mb_emit_ldloc (mb, conv_arg);
+ mono_mb_emit_icall (mb, conv_to_icall (conv));
+ mono_mb_emit_byte (mb, CEE_STIND_REF);
+
+ }
+
+ if (need_free || (t->byref && (t->attrs & PARAM_ATTRIBUTE_OUT))) {
+ mono_mb_emit_ldloc (mb, conv_arg);
+ if (conv == MONO_MARSHAL_CONV_BSTR_STR)
mono_mb_emit_icall (mb, mono_free_bstr);
- }
else
- mono_mb_emit_icall (mb, conv_to_icall (MONO_MARSHAL_CONV_LPSTR_STR));
- mono_mb_emit_byte (mb, CEE_STIND_REF);
- } else {
- if (mono_marshal_need_free (t, m->piinfo, spec)) {
- mono_mb_emit_ldloc (mb, conv_arg);
- if (conv == MONO_MARSHAL_CONV_STR_BSTR)
- mono_mb_emit_icall (mb, mono_free_bstr);
- else
- mono_mb_emit_icall (mb, mono_marshal_free);
- }
+ mono_mb_emit_icall (mb, mono_marshal_free);
}
break;
label_next = mono_mb_emit_branch (mb, CEE_BRFALSE);
mono_mb_emit_ldarg (mb, argnum);
mono_mb_emit_managed_call (mb, sh_dangerous_release, NULL);
- mono_mb_patch_addr (mb, label_next, mb->pos - (label_next + 4));
+ mono_mb_patch_branch (mb, label_next);
}
break;
}
m->orig_conv_args [argnum] = 0;
if (klass->delegate) {
- g_assert (!t->byref);
- mono_mb_emit_ldarg (mb, argnum);
- mono_mb_emit_icall (mb, conv_to_icall (MONO_MARSHAL_CONV_DEL_FTN));
- mono_mb_emit_stloc (mb, conv_arg);
+ if (t->byref && !(t->attrs & PARAM_ATTRIBUTE_OUT)) {
+ char *msg = g_strdup_printf ("Byref marshalling of delegates is not implemented.");
+ mono_mb_emit_exception_marshal_directive (mb, msg);
+ } else {
+ mono_mb_emit_ldarg (mb, argnum);
+ mono_mb_emit_icall (mb, conv_to_icall (MONO_MARSHAL_CONV_DEL_FTN));
+ mono_mb_emit_stloc (mb, conv_arg);
+ }
} else if (klass == mono_defaults.stringbuilder_class) {
MonoMarshalNative encoding = mono_marshal_get_string_encoding (m->piinfo, spec);
MonoMarshalConv conv = mono_marshal_get_stringbuilder_to_ptr_conv (m->piinfo, spec);
break;
}
- if (klass->delegate)
+ if (klass->delegate) {
+ if (t->byref) {
+ mono_mb_emit_ldarg (mb, argnum);
+ mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
+ mono_mb_emit_op (mb, CEE_MONO_CLASSCONST, klass);
+ mono_mb_emit_ldloc (mb, conv_arg);
+ mono_mb_emit_icall (mb, conv_to_icall (MONO_MARSHAL_CONV_FTN_DEL));
+ mono_mb_emit_byte (mb, CEE_STIND_REF);
+ }
break;
+ }
if (t->byref && (t->attrs & PARAM_ATTRIBUTE_OUT)) {
/* allocate a new object */
index_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
mono_mb_emit_byte (mb, CEE_LDC_I4_0);
mono_mb_emit_stloc (mb, index_var);
- label2 = mb->pos;
+ label2 = mono_mb_get_label (mb);
mono_mb_emit_ldloc (mb, index_var);
mono_mb_emit_ldloc (mb, src_var);
mono_mb_emit_byte (mb, CEE_LDLEN);
mono_mb_emit_add_to_local (mb, index_var, 1);
mono_mb_emit_add_to_local (mb, dest_ptr, esize);
- mono_mb_emit_byte (mb, CEE_BR);
- mono_mb_emit_i4 (mb, label2 - (mb->pos + 4));
+ mono_mb_emit_branch_label (mb, CEE_BR, label2);
mono_mb_patch_branch (mb, label3);
index_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
mono_mb_emit_byte (mb, CEE_LDC_I4_0);
mono_mb_emit_stloc (mb, index_var);
- label2 = mb->pos;
+ label2 = mono_mb_get_label (mb);
mono_mb_emit_ldloc (mb, index_var);
mono_mb_emit_ldarg (mb, argnum);
if (t->byref)
mono_mb_emit_add_to_local (mb, index_var, 1);
mono_mb_emit_add_to_local (mb, src_ptr, esize);
- mono_mb_emit_byte (mb, CEE_BR);
- mono_mb_emit_i4 (mb, label2 - (mb->pos + 4));
+ mono_mb_emit_branch_label (mb, CEE_BR, label2);
mono_mb_patch_branch (mb, label1);
mono_mb_patch_branch (mb, label3);
index_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
mono_mb_emit_byte (mb, CEE_LDC_I4_0);
mono_mb_emit_stloc (mb, index_var);
- label2 = mb->pos;
+ label2 = mono_mb_get_label (mb);
mono_mb_emit_ldloc (mb, index_var);
mono_mb_emit_ldloc (mb, conv_arg);
mono_mb_emit_byte (mb, CEE_LDLEN);
mono_mb_emit_add_to_local (mb, index_var, 1);
mono_mb_emit_add_to_local (mb, src_ptr, esize);
- mono_mb_emit_byte (mb, CEE_BR);
- mono_mb_emit_i4 (mb, label2 - (mb->pos + 4));
+ mono_mb_emit_branch_label (mb, CEE_BR, label2);
mono_mb_patch_branch (mb, label1);
mono_mb_patch_branch (mb, label3);
index_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
mono_mb_emit_byte (mb, CEE_LDC_I4_0);
mono_mb_emit_stloc (mb, index_var);
- label2 = mb->pos;
+ label2 = mono_mb_get_label (mb);
mono_mb_emit_ldloc (mb, index_var);
mono_mb_emit_ldloc (mb, conv_arg);
mono_mb_emit_byte (mb, CEE_LDLEN);
mono_mb_emit_add_to_local (mb, index_var, 1);
mono_mb_emit_add_to_local (mb, dest_ptr, esize);
- mono_mb_emit_byte (mb, CEE_BR);
- mono_mb_emit_i4 (mb, label2 - (mb->pos + 4));
+ mono_mb_emit_branch_label (mb, CEE_BR, label2);
mono_mb_patch_branch (mb, label1);
mono_mb_patch_branch (mb, label3);
index_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
mono_mb_emit_byte (mb, CEE_LDC_I4_0);
mono_mb_emit_stloc (mb, index_var);
- label2 = mb->pos;
+ label2 = mono_mb_get_label (mb);
mono_mb_emit_ldloc (mb, index_var);
mono_mb_emit_ldloc (mb, src);
mono_mb_emit_byte (mb, CEE_LDLEN);
mono_mb_emit_add_to_local (mb, index_var, 1);
mono_mb_emit_add_to_local (mb, dest, esize);
- mono_mb_emit_byte (mb, CEE_BR);
- mono_mb_emit_i4 (mb, label2 - (mb->pos + 4));
+ mono_mb_emit_branch_label (mb, CEE_BR, label2);
mono_mb_patch_branch (mb, label3);
mono_mb_patch_branch (mb, label1);
} else {
switch (spec->native) {
case MONO_NATIVE_I1:
+ case MONO_NATIVE_U1:
local_type = &mono_defaults.byte_class->byval_arg;
break;
case MONO_NATIVE_VARIANTBOOL:
* @piinfo: Marshalling information
* @mspecs: Marshalling information
* @func: the native function to call
+ * @check_exceptions: Whenever to check for pending exceptions after the native call
*
* generates IL code for the pinvoke wrapper, the generated code calls @func.
*/
static void
-mono_marshal_emit_native_wrapper (MonoImage *image, MonoMethodBuilder *mb, MonoMethodSignature *sig, MonoMethodPInvoke *piinfo, MonoMarshalSpec **mspecs, gpointer func)
+mono_marshal_emit_native_wrapper (MonoImage *image, MonoMethodBuilder *mb, MonoMethodSignature *sig, MonoMethodPInvoke *piinfo, MonoMarshalSpec **mspecs, gpointer func, gboolean check_exceptions)
{
EmitMarshalContext m;
MonoMethodSignature *csig;
* Need to call this after converting the result since MONO_VTADDR needs
* to be adjacent to the call instruction.
*/
- emit_thread_interrupt_checkpoint (mb);
+ if (check_exceptions)
+ emit_thread_interrupt_checkpoint (mb);
/* we need to convert byref arguments back and free string arrays */
for (i = 0; i < sig->param_count; i++) {
/**
* mono_marshal_get_native_wrapper:
* @method: The MonoMethod to wrap.
+ * @check_exceptions: Whenever to check for pending exceptions
*
* generates IL code for the pinvoke wrapper (the generated method
* calls the unmanaged code in piinfo->addr)
*/
MonoMethod *
-mono_marshal_get_native_wrapper (MonoMethod *method)
+mono_marshal_get_native_wrapper (MonoMethod *method, gboolean check_exceptions)
{
MonoMethodSignature *sig, *csig;
MonoMethodPInvoke *piinfo = (MonoMethodPInvoke *) method;
g_assert (piinfo->addr);
mono_mb_emit_native_call (mb, csig, piinfo->addr);
- emit_thread_interrupt_checkpoint (mb);
+ if (check_exceptions)
+ emit_thread_interrupt_checkpoint (mb);
mono_mb_emit_byte (mb, CEE_RET);
csig = signature_dup (method->klass->image, csig);
mspecs = g_new (MonoMarshalSpec*, sig->param_count + 1);
mono_method_get_marshal_info (method, mspecs);
- mono_marshal_emit_native_wrapper (mb->method->klass->image, mb, sig, piinfo, mspecs, piinfo->addr);
+ mono_marshal_emit_native_wrapper (mb->method->klass->image, mb, sig, piinfo, mspecs, piinfo->addr, check_exceptions);
csig = signature_dup (method->klass->image, sig);
csig->pinvoke = 0;
mb = mono_mb_new (mono_defaults.object_class, name, MONO_WRAPPER_MANAGED_TO_NATIVE);
mb->method->save_lmf = 1;
- mono_marshal_emit_native_wrapper (image, mb, sig, piinfo, mspecs, func);
+ mono_marshal_emit_native_wrapper (image, mb, sig, piinfo, mspecs, func, TRUE);
csig = signature_dup (image, sig);
csig->pinvoke = 0;
/* fail */
- mono_mb_patch_addr (mb, pos_failed, mb->pos - (pos_failed + 4));
+ mono_mb_patch_branch (mb, pos_failed);
mono_mb_emit_byte (mb, CEE_LDNULL);
pos_end2 = mono_mb_emit_branch (mb, CEE_BR);
/* success */
- mono_mb_patch_addr (mb, pos_was_ok, mb->pos - (pos_was_ok + 4));
+ mono_mb_patch_branch (mb, pos_was_ok);
mono_mb_emit_byte (mb, CEE_POP);
mono_mb_emit_ldarg (mb, 0);
/* the end */
- mono_mb_patch_addr (mb, pos_end, mb->pos - (pos_end + 4));
- mono_mb_patch_addr (mb, pos_end2, mb->pos - (pos_end2 + 4));
+ mono_mb_patch_branch (mb, pos_end);
+ mono_mb_patch_branch (mb, pos_end2);
mono_mb_emit_byte (mb, CEE_RET);
res = mono_mb_create_and_cache (cache, klass, mb, isint_sig, isint_sig->param_count + 16);
mono_mb_emit_exception (mb, "InvalidCastException", NULL);
/* success */
- mono_mb_patch_addr (mb, pos_was_ok, mb->pos - (pos_was_ok + 4));
- mono_mb_patch_addr (mb, pos_was_ok2, mb->pos - (pos_was_ok2 + 4));
+ mono_mb_patch_branch (mb, pos_was_ok);
+ mono_mb_patch_branch (mb, pos_was_ok2);
mono_mb_emit_ldarg (mb, 0);
/* the end */
/* fail */
- mono_mb_patch_addr (mb, pos_failed, mb->pos - (pos_failed + 4));
+ mono_mb_patch_branch (mb, pos_failed);
mono_mb_emit_byte (mb, CEE_LDNULL);
/* the end */
- mono_mb_patch_addr (mb, pos_end, mb->pos - (pos_end + 4));
+ mono_mb_patch_branch (mb, pos_end);
mono_mb_emit_byte (mb, CEE_RET);
res = mono_mb_create_and_cache (cache, klass, mb, isint_sig, isint_sig->param_count + 16);
mono_mb_emit_byte (mb, CEE_RET);
- res = mono_mb_create_method (mb, mono_method_signature (stoptr), 0);
+ res = mono_mb_create_method (mb, signature_no_pinvoke (stoptr), 0);
mono_mb_free (mb);
klass->marshal_info->str_to_ptr = res;
if (klass->marshal_info->ptr_to_str)
return klass->marshal_info->ptr_to_str;
- if (!ptostr)
+ if (!ptostr) {
+ MonoMethodSignature *sig;
+
/* Create the signature corresponding to
static void PtrToStructure (IntPtr ptr, object structure);
defined in class/corlib/System.Runtime.InteropServices/Marshal.cs */
- ptostr = mono_create_icall_signature ("void ptr object");
+ sig = mono_create_icall_signature ("void ptr object");
+ sig = signature_dup (mono_defaults.corlib, sig);
+ sig->pinvoke = 0;
+ mono_memory_barrier ();
+ ptostr = sig;
+ }
mb = mono_mb_new (klass, "PtrToStructure", MONO_WRAPPER_UNKNOWN);
mono_mb_emit_ldloc (mb, this_local);
mono_mb_emit_managed_call (mb, enter_method, NULL);
- clause->try_offset = mb->pos;
+ clause->try_offset = mono_mb_get_label (mb);
/* Call the method */
if (sig->hasthis)
pos = mono_mb_emit_branch (mb, CEE_LEAVE);
- clause->try_len = mb->pos - clause->try_offset;
- clause->handler_offset = mb->pos;
+ clause->try_len = mono_mb_get_pos (mb) - clause->try_offset;
+ clause->handler_offset = mono_mb_get_label (mb);
/* Call Monitor::Exit() */
mono_mb_emit_ldloc (mb, this_local);
mono_mb_emit_managed_call (mb, exit_method, NULL);
mono_mb_emit_byte (mb, CEE_ENDFINALLY);
- clause->handler_len = mb->pos - clause->handler_offset;
+ clause->handler_len = mono_mb_get_pos (mb) - clause->handler_offset;
mono_mb_patch_branch (mb, pos);
if (!MONO_TYPE_IS_VOID (sig->ret))
b3 = mono_mb_emit_branch (mb, CEE_BNE_UN);
- copy_pos = mb->pos;
+ copy_pos = mono_mb_get_label (mb);
/* do_store */
mono_mb_patch_branch (mb, b1);
mono_mb_emit_ldloc (mb, array_slot_addr);
native_size += parent_size;
info->native_size = parent_size;
}
-
+
iter = NULL;
j = 0;
while ((field = mono_class_get_fields (klass, &iter))) {
mono_class_native_size (MonoClass *klass, guint32 *align)
{
if (!klass->marshal_info) {
- if (mono_marshal_is_loading_type_info (klass))
+ if (mono_marshal_is_loading_type_info (klass)) {
+ if (align)
+ *align = 0;
return 0;
- else
+ } else {
mono_marshal_load_type_info (klass);
+ }
}
if (align)
MonoMethod *res;
int i;
- mb = mono_mb_new (class, name, MONO_WRAPPER_MANAGED_TO_MANAGED);
+ mb = mono_mb_new_no_dup_name (class, name, MONO_WRAPPER_MANAGED_TO_MANAGED);
mb->method->slot = -1;
mb->method->flags = METHOD_ATTRIBUTE_PRIVATE | METHOD_ATTRIBUTE_VIRTUAL |
res = mono_mb_create_method (mb, csig, csig->param_count + 16);
+ /* We can corlib internal methods */
+ res->skip_visibility = TRUE;
+
mono_mb_free (mb);
return res;
/* if list is empty remove original address from hash */
if (g_list_length (ccw_list) == 0)
- g_hash_table_remove (ccw_hash, ccw_list_orig);
+ g_hash_table_remove (ccw_hash, GINT_TO_POINTER (mono_object_hash (object)));
return TRUE;
/* try */
main_clause = g_new0 (MonoExceptionClause, 1);
- main_clause->try_offset = mb->pos;
+ main_clause->try_offset = mono_mb_get_label (mb);
}
/* load last param to store result if not preserve_sig and not void */
/* Main exception catch */
main_clause->flags = MONO_EXCEPTION_CLAUSE_NONE;
- main_clause->try_len = mb->pos - main_clause->try_offset;
+ main_clause->try_len = mono_mb_get_pos (mb) - main_clause->try_offset;
main_clause->data.catch_class = mono_defaults.object_class;
/* handler code */
- main_clause->handler_offset = mb->pos;
+ main_clause->handler_offset = mono_mb_get_label (mb);
mono_mb_emit_managed_call (mb, get_hr_for_exception, NULL);
mono_mb_emit_stloc (mb, hr);
mono_mb_emit_branch (mb, CEE_LEAVE);
- main_clause->handler_len = mb->pos - main_clause->handler_offset;
+ main_clause->handler_len = mono_mb_get_pos (mb) - main_clause->handler_offset;
/* end catch */
- mono_mb_patch_addr (mb, pos_leave, mb->pos - (pos_leave + 4));
+ mono_mb_patch_branch (mb, pos_leave);
mono_mb_emit_ldloc (mb, hr);
}
{
return MONO_E_NOTIMPL;
}
+
+void
+mono_marshal_find_nonzero_bit_offset (guint8 *buf, int len, int *byte_offset, guint8 *bitmask)
+{
+ int i;
+ guint8 byte;
+
+ for (i = 0; i < len; ++i)
+ if (buf [i])
+ break;
+
+ g_assert (i < len);
+
+ byte = buf [i];
+ while (byte && !(byte & 1))
+ byte >>= 1;
+ g_assert (byte == 1);
+
+ *byte_offset = i;
+ *bitmask = buf [i];
+}
projects / mono.git / blobdiff