#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>
};
#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.
void *
mono_marshal_string_to_utf16 (MonoString *s);
+static void *
+mono_marshal_string_to_utf16_copy (MonoString *s);
+
static gpointer
mono_string_to_lpstr (MonoString *string_obj);
cominterop_get_ccw_object (MonoCCWInterface* ccw_entry, gboolean verify);
/**
- * signature_cominterop:
- * @image: a image
- * @sig: managed method signature
+ * cominterop_method_signature:
+ * @method: a method
*
* Returns: the corresponding unmanaged method signature for a managed COM
* method.
*/
static MonoMethodSignature*
-signature_cominterop (MonoImage *image, MonoMethodSignature *sig)
+cominterop_method_signature (MonoMethod* method)
{
MonoMethodSignature *res;
+ MonoImage *image = method->klass->image;
+ MonoMethodSignature *sig = mono_method_signature (method);
+ gboolean preserve_sig = method->iflags & METHOD_IMPL_ATTRIBUTE_PRESERVE_SIG;
int sigsize;
int i;
int param_count = sig->param_count + 1; // convert this arg into IntPtr arg
- if (!MONO_TYPE_IS_VOID (sig->ret))
+ if (!preserve_sig &&!MONO_TYPE_IS_VOID (sig->ret))
param_count++;
sigsize = sizeof (MonoMethodSignature) + ((param_count - MONO_ZERO_LEN_ARRAY) * sizeof (MonoType *));
// first arg is interface pointer
res->params[0] = &mono_defaults.int_class->byval_arg;
- // last arg is return type
- if (!MONO_TYPE_IS_VOID (sig->ret)) {
- res->params[param_count-1] = mono_metadata_type_dup_mp (image, sig->ret);
- res->params[param_count-1]->byref = 1;
- res->params[param_count-1]->attrs = PARAM_ATTRIBUTE_OUT;
+ if (preserve_sig) {
+ res->ret = sig->ret;
+ }
+ else {
+ // last arg is return type
+ if (!MONO_TYPE_IS_VOID (sig->ret)) {
+ res->params[param_count-1] = mono_metadata_type_dup (image->mempool, sig->ret);
+ res->params[param_count-1]->byref = 1;
+ res->params[param_count-1]->attrs = PARAM_ATTRIBUTE_OUT;
+ }
+
+ // return type is always int32 (HRESULT)
+ res->ret = &mono_defaults.int32_class->byval_arg;
}
// no pinvoke
// set param_count
res->param_count = param_count;
- // return type is always int32 (HRESULT)
- res->ret = &mono_defaults.int32_class->byval_arg;
-
// STDCALL on windows, CDECL everywhere else to work with XPCOM and MainWin COM
#ifdef PLATFORM_WIN32
res->call_convention = MONO_CALL_STDCALL;
return 7; /* 7 methods in IDispatch*/
}
+/**
+ * cominterop_get_method_interface:
+ * @method: method being called
+ *
+ * Returns: the MonoClass* representing the interface on which
+ * the method is defined.
+ */
+static MonoClass*
+cominterop_get_method_interface (MonoMethod* method)
+{
+ MonoClass *ic = method->klass;
+
+ /* if method is on a class, we need to look up interface method exists on */
+ if (!MONO_CLASS_IS_INTERFACE(method->klass)) {
+ GPtrArray *ifaces = mono_class_get_implemented_interfaces (method->klass);
+ if (ifaces) {
+ int i;
+ for (i = 0; i < ifaces->len; ++i) {
+ int offset;
+ ic = g_ptr_array_index (ifaces, i);
+ offset = mono_class_interface_offset (method->klass, ic);
+ if (method->slot >= offset && method->slot < offset + ic->method.count)
+ break;
+ ic = NULL;
+ }
+ g_ptr_array_free (ifaces, TRUE);
+ }
+ }
+
+ g_assert (ic);
+ g_assert (MONO_CLASS_IS_INTERFACE (ic));
+
+ return ic;
+}
+
/**
* cominterop_get_com_slot_for_method:
* @method: a method
cominterop_get_com_slot_for_method (MonoMethod* method)
{
guint32 slot = method->slot;
- GPtrArray *ifaces;
- MonoClass *ic = NULL;
- int i;
+ MonoClass *ic = method->klass;
- ifaces = mono_class_get_implemented_interfaces (method->klass);
- if (ifaces) {
- int offset;
- for (i = 0; i < ifaces->len; ++i) {
- ic = g_ptr_array_index (ifaces, i);
- offset = method->klass->interface_offsets[ic->interface_id];
- if (method->slot >= offset && method->slot < offset + ic->method.count) {
- slot -= offset;
- break;
- }
- }
- g_ptr_array_free (ifaces, TRUE);
+ /* if method is on a class, we need to look up interface method exists on */
+ if (!MONO_CLASS_IS_INTERFACE(ic)) {
+ int offset = 0;
+ ic = cominterop_get_method_interface (method);
+ offset = mono_class_interface_offset (method->klass, ic);
+ g_assert(offset >= 0);
+ slot -= offset;
}
- if (!ic)
- ic = method->klass;
-
g_assert (ic);
g_assert (MONO_CLASS_IS_INTERFACE (ic));
return slot + cominterop_get_com_slot_begin (ic);
}
-/**
- * cominterop_get_method_interface:
- * @method: method being called
- *
- * Returns: the Type on which the method is defined on
- */
-static MonoReflectionType*
-cominterop_get_method_interface (MonoMethod* method)
+
+static void
+cominterop_mono_string_to_guid (const MonoString* string, guint8 *guid);
+
+static gboolean
+cominterop_class_guid (MonoClass* klass, guint8* guid)
{
- GPtrArray *ifaces;
- MonoType* t = NULL;
- MonoClass *ic = NULL;
- int i;
- MonoReflectionType* rt = NULL;
+ static MonoClass *GuidAttribute = NULL;
+ MonoCustomAttrInfo *cinfo;
- ifaces = mono_class_get_implemented_interfaces (method->klass);
- if (ifaces) {
- int offset;
- for (i = 0; i < ifaces->len; ++i) {
- ic = g_ptr_array_index (ifaces, i);
- offset = method->klass->interface_offsets[ic->interface_id];
- if (method->slot >= offset && method->slot < offset + ic->method.count)
- break;
- ic = NULL;
- }
- g_ptr_array_free (ifaces, TRUE);
+ /* Handle the GuidAttribute */
+ if (!GuidAttribute)
+ GuidAttribute = mono_class_from_name (mono_defaults.corlib, "System.Runtime.InteropServices", "GuidAttribute");
+
+ cinfo = mono_custom_attrs_from_class (klass);
+ if (cinfo) {
+ MonoReflectionGuidAttribute *attr = (MonoReflectionGuidAttribute*)mono_custom_attrs_get_attr (cinfo, GuidAttribute);
+
+ if (!attr)
+ return FALSE;
+ if (!cinfo->cached)
+ mono_custom_attrs_free (cinfo);
+
+ cominterop_mono_string_to_guid (attr->guid, guid);
+ return TRUE;
}
+ return FALSE;
+}
- if (!ic)
- ic = method->klass;
+/**
+ * cominterop_get_interface:
+ * @obj: managed wrapper object containing COM object
+ * @ic: interface type to retrieve for COM object
+ *
+ * Returns: the COM interface requested
+ */
+static gpointer
+cominterop_get_interface (MonoComObject* obj, MonoClass* ic, gboolean throw_exception)
+{
+ gpointer itf = NULL;
g_assert (ic);
g_assert (MONO_CLASS_IS_INTERFACE (ic));
- t = mono_class_get_type (ic);
- rt = mono_type_get_object (mono_domain_get(), t);
+ mono_cominterop_lock ();
+ if (obj->itf_hash)
+ itf = g_hash_table_lookup (obj->itf_hash, GUINT_TO_POINTER ((guint)ic->interface_id));
+ mono_cominterop_unlock ();
+
+ if (!itf) {
+ guint8 iid [16];
+ int found = cominterop_class_guid (ic, iid);
+ int hr;
+ g_assert(found);
+ hr = ves_icall_System_Runtime_InteropServices_Marshal_QueryInterfaceInternal (obj->iunknown, iid, &itf);
+ if (hr < 0 && throw_exception) {
+ static MonoMethod* throw_exception_for_hr = NULL;
+ MonoException* ex;
+ void* params[1] = {&hr};
+ if (!throw_exception_for_hr)
+ throw_exception_for_hr = mono_class_get_method_from_name (mono_defaults.marshal_class, "GetExceptionForHR", 1);
+ ex = (MonoException*)mono_runtime_invoke (throw_exception_for_hr, NULL, params, NULL);
+ mono_raise_exception (ex);
+ }
+
+ if (hr >= 0 && itf) {
+ mono_cominterop_lock ();
+ if (!obj->itf_hash)
+ obj->itf_hash = g_hash_table_new (mono_aligned_addr_hash, NULL);
+ g_hash_table_insert (obj->itf_hash, GUINT_TO_POINTER ((guint)ic->interface_id), itf);
+ mono_cominterop_unlock ();
+ }
- return rt;
+ }
+ if (throw_exception)
+ g_assert (itf);
+
+ return itf;
}
static int
load_type_info_tls_id = TlsAlloc ();
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);
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_upgrade_remote_class_wrapper, "mono_upgrade_remote_class_wrapper", "void object object", FALSE);
register_icall (type_from_handle, "type_from_handle", "object ptr", FALSE);
register_icall (mono_gc_wbarrier_generic_store, "wb_generic", "void ptr object", FALSE);
- register_icall (cominterop_get_method_interface, "cominterop_get_method_interface", "object ptr", FALSE);
+ register_icall (cominterop_get_method_interface, "cominterop_get_method_interface", "ptr ptr", FALSE);
register_icall (cominterop_get_function_pointer, "cominterop_get_function_pointer", "ptr ptr int32", FALSE);
register_icall (cominterop_object_is_rcw, "cominterop_object_is_rcw", "int32 object", FALSE);
register_icall (cominterop_get_ccw, "cominterop_get_ccw", "ptr object ptr", FALSE);
register_icall (cominterop_get_ccw_object, "cominterop_get_ccw_object", "object ptr int32", FALSE);
register_icall (cominterop_get_hresult_for_exception, "cominterop_get_hresult_for_exception", "int32 object", FALSE);
+ register_icall (cominterop_get_interface, "cominterop_get_interface", "ptr object ptr int32", 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;
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));
+ return mono_string_new_utf16 (mono_domain_get (), bstr, *(guint32 *)((char *)bstr - 4) / 2);
#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;
- } 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);
- }
-
- if (max_stack < 8)
- max_stack = 8;
-
- header->max_stack = max_stack;
-
- for (i = 0, l = mb->locals_list; l; l = l->next, i++) {
- header->locals [i] = (MonoType *)l->data;
- }
-
- 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);
- }
-}
-
-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));
-}
-
-static 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);
-}
-
-static 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_byte (mb, CEE_STIND_REF);
break;
case MONO_MARSHAL_CONV_STR_LPTSTR:
+ mono_mb_emit_ldloc (mb, 1);
+ mono_mb_emit_ldloc (mb, 0);
+ mono_mb_emit_byte (mb, CEE_LDIND_I);
+#ifdef PLATFORM_WIN32
+ mono_mb_emit_icall (mb, mono_string_from_utf16);
+#else
+ mono_mb_emit_icall (mb, mono_string_new_wrapper);
+#endif
+ mono_mb_emit_byte (mb, CEE_STIND_REF);
+ break;
case MONO_MARSHAL_CONV_STR_LPSTR:
mono_mb_emit_ldloc (mb, 1);
mono_mb_emit_ldloc (mb, 0);
case MONO_MARSHAL_CONV_LPSTR_STR:
return mono_string_new_wrapper;
case MONO_MARSHAL_CONV_STR_LPTSTR:
+#ifdef PLATFORM_WIN32
+ return mono_marshal_string_to_utf16;
+#else
+ return mono_string_to_lpstr;
+#endif
case MONO_MARSHAL_CONV_STR_LPSTR:
return mono_string_to_lpstr;
case MONO_MARSHAL_CONV_STR_BSTR:
case MONO_MARSHAL_CONV_STR_ANSIBSTR:
return mono_string_to_ansibstr;
case MONO_MARSHAL_CONV_SB_LPSTR:
+ return mono_string_builder_to_utf8;
case MONO_MARSHAL_CONV_SB_LPTSTR:
+#ifdef PLATFORM_WIN32
+ return mono_string_builder_to_utf16;
+#else
return mono_string_builder_to_utf8;
+#endif
case MONO_MARSHAL_CONV_SB_LPWSTR:
return mono_string_builder_to_utf16;
case MONO_MARSHAL_CONV_ARRAY_SAVEARRAY:
case MONO_MARSHAL_CONV_FTN_DEL:
return mono_ftnptr_to_delegate;
case MONO_MARSHAL_CONV_LPSTR_SB:
+ return mono_string_utf8_to_builder;
case MONO_MARSHAL_CONV_LPTSTR_SB:
+#ifdef PLATFORM_WIN32
+ return mono_string_utf16_to_builder;
+#else
return mono_string_utf8_to_builder;
+#endif
case MONO_MARSHAL_CONV_LPWSTR_SB:
return mono_string_utf16_to_builder;
case MONO_MARSHAL_FREE_ARRAY:
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_byte (mb, CEE_LDIND_REF);
if (conv == MONO_MARSHAL_CONV_OBJECT_INTERFACE) {
- static MonoMethod* GetInterface = NULL;
-
- if (!GetInterface)
- GetInterface = mono_class_get_method_from_name (mono_defaults.com_object_class, "GetInterface", 1);
- mono_mb_emit_ptr (mb, type);
- mono_mb_emit_icall (mb, type_from_handle);
- mono_mb_emit_managed_call (mb, GetInterface, NULL);
+ mono_mb_emit_ptr (mb, mono_type_get_class (type));
+ mono_mb_emit_icon (mb, TRUE);
+ mono_mb_emit_icall (mb, cominterop_get_interface);
+
}
else if (conv == MONO_MARSHAL_CONV_OBJECT_IUNKNOWN) {
static MonoProperty* iunknown = NULL;
case MONO_MARSHAL_CONV_HANDLEREF: {
mono_mb_emit_ldloc (mb, 1);
mono_mb_emit_ldloc (mb, 0);
- mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoHandleRef, handle));
+ mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoHandleRef, handle));
+ mono_mb_emit_byte (mb, CEE_ADD);
mono_mb_emit_byte (mb, CEE_LDIND_I);
mono_mb_emit_byte (mb, CEE_STIND_I);
break;
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);
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 ();
// create unmanaged wrapper
mb_native = mono_mb_new (method->klass, method->name, MONO_WRAPPER_MANAGED_TO_NATIVE);
- sig_native = signature_cominterop (method->klass->image, sig);
+ sig_native = cominterop_method_signature (method);
mspecs = g_new (MonoMarshalSpec*, sig_native->param_count+1);
memset (mspecs, 0, sizeof(MonoMarshalSpec*)*(sig_native->param_count+1));
// first arg is IntPtr for interface
mspecs[1] = NULL;
- // move return spec to last param
- if (!MONO_TYPE_IS_VOID (sig->ret))
- mspecs[sig_native->param_count] = mspecs[0];
+ if (!(method->iflags & METHOD_IMPL_ATTRIBUTE_PRESERVE_SIG)) {
+ // move return spec to last param
+ if (!MONO_TYPE_IS_VOID (sig->ret))
+ mspecs[sig_native->param_count] = mspecs[0];
- mspecs[0] = NULL;
+ mspecs[0] = NULL;
+ }
- mono_marshal_emit_native_wrapper(mono_defaults.corlib, mb_native, sig_native, piinfo, mspecs, piinfo->addr);
+ mono_marshal_emit_native_wrapper(method->klass->image, mb_native, sig_native, piinfo, mspecs, piinfo->addr);
res = mono_mb_create_method (mb_native, sig_native, sig_native->param_count + 16);
}
else {
static MonoMethod * ThrowExceptionForHR = NULL;
- static MonoMethod * GetInterface = NULL;
MonoMethod *adjusted_method;
- int hr;
int retval = 0;
int ptr_this;
int i;
- if (!GetInterface)
- GetInterface = mono_class_get_method_from_name (mono_defaults.com_object_class, "GetInterface", 1);
+ gboolean preserve_sig = method->iflags & METHOD_IMPL_ATTRIBUTE_PRESERVE_SIG;
// add local variables
- hr = mono_mb_add_local (mb, &mono_defaults.int32_class->byval_arg);
ptr_this = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
if (!MONO_TYPE_IS_VOID (sig->ret))
retval = mono_mb_add_local (mb, sig->ret);
mono_mb_emit_ldarg (mb, 0);
mono_mb_emit_ptr (mb, method);
mono_mb_emit_icall (mb, cominterop_get_method_interface);
- mono_mb_emit_managed_call (mb, GetInterface, NULL);
+ mono_mb_emit_icon (mb, TRUE);
+ mono_mb_emit_icall (mb, cominterop_get_interface);
mono_mb_emit_stloc (mb, ptr_this);
// arg 1 is unmanaged this pointer
mono_mb_emit_ldarg (mb, i);
// push managed return value as byref last argument
- if (!MONO_TYPE_IS_VOID (sig->ret))
+ if (!MONO_TYPE_IS_VOID (sig->ret) && !preserve_sig)
mono_mb_emit_ldloc_addr (mb, retval);
adjusted_method = cominterop_get_native_wrapper_adjusted (method);
mono_mb_emit_managed_call (mb, adjusted_method, NULL);
- // store HRESULT to check
- mono_mb_emit_stloc (mb, hr);
+ if (!preserve_sig) {
+ if (!ThrowExceptionForHR)
+ ThrowExceptionForHR = mono_class_get_method_from_name (mono_defaults.marshal_class, "ThrowExceptionForHR", 1);
+ mono_mb_emit_managed_call (mb, ThrowExceptionForHR, NULL);
- if (!ThrowExceptionForHR)
- ThrowExceptionForHR = mono_class_get_method_from_name (mono_defaults.marshal_class, "ThrowExceptionForHR", 1);
- mono_mb_emit_ldloc (mb, hr);
- mono_mb_emit_managed_call (mb, ThrowExceptionForHR, NULL);
-
- // load return value managed is expecting
- if (!MONO_TYPE_IS_VOID (sig->ret))
- mono_mb_emit_ldloc (mb, retval);
+ // load return value managed is expecting
+ if (!MONO_TYPE_IS_VOID (sig->ret))
+ mono_mb_emit_ldloc (mb, retval);
+ }
mono_mb_emit_byte (mb, CEE_RET);
}
/* try */
- main_clause = g_new0 (MonoExceptionClause, 1);
- main_clause->try_offset = mb->pos;
+ mono_loader_lock ();
+ main_clause = mono_mempool_alloc0 (method->klass->image->mempool, sizeof (MonoExceptionClause));
+ mono_loader_unlock ();
+ 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;
- int pos0, pos1;
+ 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);
- pos1 = mono_mb_emit_branch (mb, CEE_BR);
+ 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);
+ }
- /* return */
- mono_mb_patch_branch (mb, pos1);
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;
int i, pos, posna;
char *name;
+ gboolean need_direct_wrapper = FALSE;
g_assert (method);
+ 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 */
+ /*
+ * FIXME: Sharing runtime invoke wrappers between different methods means that
+ * calling a method of klass A might invoke the type initializer of class B.
+ * Normally, the type initializer of type B was already executed when B's method
+ * was called but in some complex cases this might not be true.
+ * See #349621 for an example. We avoid that for mscorlib methods by putting every
+ * wrapper into the object class, but the non-mscorlib case needs fixing.
+ */
+ if (method->klass->image == mono_defaults.corlib)
+ target_klass = mono_defaults.object_class;
+ else {
+ target_klass = method->klass;
+ }
+#if 0
target_klass = mono_defaults.object_class;
/*
* if types in the signature belong to non-mscorlib, we cache only
}
}
}
- cache = target_klass->image->runtime_invoke_cache;
+#endif
+ 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 ();
+ /* 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);
mono_mb_emit_byte (mb, CEE_LDNULL);
mono_mb_emit_stloc (mb, conv_arg);
+ if (t->byref && t->attrs & PARAM_ATTRIBUTE_OUT)
+ break;
+
/* Check for null */
mono_mb_emit_ldarg (mb, argnum);
if (t->byref)
break;
case MARSHAL_ACTION_MANAGED_CONV_RESULT:
- mono_mb_emit_icall (mb, conv_to_icall (MONO_MARSHAL_CONV_STR_LPSTR));
+ if (conv_to_icall (conv) == mono_marshal_string_to_utf16)
+ /* We need to make a copy so the caller is able to free it */
+ mono_mb_emit_icall (mb, mono_marshal_string_to_utf16_copy);
+ else
+ mono_mb_emit_icall (mb, conv_to_icall (conv));
mono_mb_emit_stloc (mb, 3);
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;
}
"HandleRefs can not be returned from unmanaged code (or passed by ref)");
break;
}
- mono_mb_emit_ldarg (mb, argnum);
- mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoHandleRef, handle));
+ mono_mb_emit_ldarg_addr (mb, argnum);
+ mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoHandleRef, handle));
+ mono_mb_emit_byte (mb, CEE_ADD);
mono_mb_emit_byte (mb, CEE_LDIND_I);
mono_mb_emit_stloc (mb, conv_arg);
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 */
static MonoMethod* get_iunknown_for_object_internal = NULL;
static MonoMethod* get_com_interface_for_object_internal = NULL;
static MonoMethod* get_idispatch_for_object_internal = NULL;
+ static MonoMethod* marshal_release = NULL;
+ static MonoMethod* AddRef = NULL;
if (!get_object_for_iunknown)
get_object_for_iunknown = mono_class_get_method_from_name (mono_defaults.marshal_class, "GetObjectForIUnknown", 1);
if (!get_iunknown_for_object_internal)
get_idispatch_for_object_internal = mono_class_get_method_from_name (mono_defaults.marshal_class, "GetIDispatchForObjectInternal", 1);
if (!get_com_interface_for_object_internal)
get_com_interface_for_object_internal = mono_class_get_method_from_name (mono_defaults.marshal_class, "GetComInterfaceForObjectInternal", 2);
+ if (!marshal_release)
+ marshal_release = mono_class_get_method_from_name (mono_defaults.marshal_class, "Release", 1);
/* COM types are initialized lazily */
mono_init_com_types ();
if (klass && klass != mono_defaults.object_class)
mono_mb_emit_op (mb, CEE_CASTCLASS, klass);
mono_mb_emit_byte (mb, CEE_STIND_REF);
+
pos_end = mono_mb_emit_short_branch (mb, CEE_BR_S);
/* is already managed object */
mono_mb_emit_op (mb, CEE_CASTCLASS, klass);
mono_mb_emit_byte (mb, CEE_STIND_REF);
-
mono_mb_patch_short_branch (mb, pos_end);
+
+ /* need to call Release to follow COM rules of ownership */
+ mono_mb_emit_ldloc (mb, conv_arg);
+ mono_mb_emit_managed_call (mb, marshal_release, NULL);
+ mono_mb_emit_byte (mb, CEE_POP);
+
/* case if null */
mono_mb_patch_short_branch (mb, pos_null);
}
break;
case MARSHAL_ACTION_CONV_RESULT: {
- char *msg = g_strdup ("Marshalling of COM Objects is not yet implemented.");
- mono_mb_emit_exception_marshal_directive (mb, msg);
+ int ccw_obj, ret_ptr;
+ guint32 pos_null = 0, pos_ccw = 0, pos_end = 0;
+ ccw_obj = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
+ ret_ptr = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
+
+ /* store return value */
+ mono_mb_emit_stloc (mb, ret_ptr);
+
+ mono_mb_emit_ldloc (mb, ret_ptr);
+ pos_null = mono_mb_emit_short_branch (mb, CEE_BRFALSE_S);
+
+ mono_mb_emit_ldloc (mb, ret_ptr);
+ mono_mb_emit_icon (mb, TRUE);
+ mono_mb_emit_icall (mb, cominterop_get_ccw_object);
+ mono_mb_emit_stloc (mb, ccw_obj);
+ mono_mb_emit_ldloc (mb, ccw_obj);
+ pos_ccw = mono_mb_emit_short_branch (mb, CEE_BRTRUE_S);
+
+ mono_mb_emit_ldloc (mb, ret_ptr);
+ mono_mb_emit_managed_call (mb, get_object_for_iunknown, NULL);
+
+ if (klass && klass != mono_defaults.object_class)
+ mono_mb_emit_op (mb, CEE_CASTCLASS, klass);
+ mono_mb_emit_stloc (mb, 3);
+
+ pos_end = mono_mb_emit_short_branch (mb, CEE_BR_S);
+
+ /* is already managed object */
+ mono_mb_patch_short_branch (mb, pos_ccw);
+ mono_mb_emit_ldloc (mb, ccw_obj);
+
+ if (klass && klass != mono_defaults.object_class)
+ mono_mb_emit_op (mb, CEE_CASTCLASS, klass);
+ mono_mb_emit_stloc (mb, 3);
+
+ mono_mb_patch_short_branch (mb, pos_end);
+
+ /* need to call Release to follow COM rules of ownership */
+ mono_mb_emit_ldloc (mb, ret_ptr);
+ mono_mb_emit_managed_call (mb, marshal_release, NULL);
+ mono_mb_emit_byte (mb, CEE_POP);
+
+ /* case if null */
+ mono_mb_patch_short_branch (mb, pos_null);
break;
}
case MARSHAL_ACTION_MANAGED_CONV_OUT: {
if (t->byref && t->attrs & PARAM_ATTRIBUTE_OUT) {
- static MonoMethod* AddRef = NULL;
guint32 pos_null = 0;
if (!AddRef)
}
case MARSHAL_ACTION_MANAGED_CONV_RESULT: {
- char *msg = g_strdup ("Marshalling of COM Objects is not yet implemented.");
- mono_mb_emit_exception_marshal_directive (mb, msg);
+ guint32 pos_null = 0;
+ int ccw_obj;
+ ccw_obj = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
+
+ if (!AddRef)
+ AddRef = mono_class_get_method_from_name (mono_defaults.marshal_class, "AddRef", 1);
+
+ /* store return value */
+ mono_mb_emit_stloc (mb, ccw_obj);
+
+ mono_mb_emit_ldloc (mb, ccw_obj);
+
+ /* if null just break, conv arg was already inited to 0 */
+ pos_null = mono_mb_emit_short_branch (mb, CEE_BRFALSE_S);
+
+ /* to store later */
+ mono_mb_emit_ldloc (mb, ccw_obj);
+ if (klass && klass != mono_defaults.object_class) {
+ mono_mb_emit_ptr (mb, t);
+ mono_mb_emit_icall (mb, type_from_handle);
+ mono_mb_emit_managed_call (mb, get_com_interface_for_object_internal, NULL);
+ }
+ else if (spec->native == MONO_NATIVE_IUNKNOWN)
+ mono_mb_emit_managed_call (mb, get_iunknown_for_object_internal, NULL);
+ else if (spec->native == MONO_NATIVE_IDISPATCH)
+ mono_mb_emit_managed_call (mb, get_idispatch_for_object_internal, NULL);
+ else if (!klass && spec->native == MONO_NATIVE_INTERFACE)
+ mono_mb_emit_managed_call (mb, get_iunknown_for_object_internal, NULL);
+ else
+ g_assert_not_reached ();
+ mono_mb_emit_stloc (mb, 3);
+ mono_mb_emit_ldloc (mb, 3);
+
+ mono_mb_emit_managed_call (mb, AddRef, NULL);
+ mono_mb_emit_byte (mb, CEE_POP);
+
+ mono_mb_patch_short_branch (mb, pos_null);
break;
}
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)
/* set dst_ptr */
mono_mb_emit_ldarg (mb, argnum);
if (t->byref)
- mono_mb_emit_byte (mb, CEE_LDIND_I);
+ mono_mb_emit_byte (mb, CEE_LDIND_REF);
mono_mb_emit_ldloc (mb, index_var);
mono_mb_emit_op (mb, CEE_LDELEMA, eklass);
mono_mb_emit_stloc (mb, 1);
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:
/**
* 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);
/* we copy the signature, so that we can modify it */
- csig = signature_dup (method->klass->image, sig);
+ if (this)
+ /* Need to free this later */
+ csig = mono_metadata_signature_dup (sig);
+ else
+ csig = signature_dup (method->klass->image, sig);
csig->hasthis = 0;
csig->pinvoke = 1;
/* 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_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);
return s ? mono_string_chars (s) : NULL;
}
+static void *
+mono_marshal_string_to_utf16_copy (MonoString *s)
+{
+ if (s == NULL) {
+ return NULL;
+ } else {
+ gunichar2 *res = mono_marshal_alloc ((mono_string_length (s) * 2) + 2);
+ memcpy (res, mono_string_chars (s), mono_string_length (s) * 2);
+ res [mono_string_length (s)] = 0;
+ return res;
+ }
+}
+
/**
* mono_marshal_set_last_error:
*
return (*(MonoIUnknown**)pUnk)->Release(pUnk);
}
-void*
+static void*
cominterop_get_idispatch_for_object (MonoObject* object)
{
if (!object)
return NULL;
if (cominterop_object_is_rcw (object)) {
- /* FIXME: Implement this case */
- g_assert_not_reached ();
- return NULL;
+ return cominterop_get_interface (((MonoComInteropProxy*)((MonoTransparentProxy*)object)->rp)->com_object,
+ mono_defaults.idispatch_class, TRUE);
}
else {
return cominterop_get_ccw (object, mono_defaults.idispatch_class);
case MONO_MARSHAL_CONV_STR_LPWSTR:
/* We assume this field points inside a MonoString */
break;
- case MONO_MARSHAL_CONV_STR_LPSTR:
case MONO_MARSHAL_CONV_STR_LPTSTR:
+#ifdef PLATFORM_WIN32
+ /* We assume this field points inside a MonoString
+ * on Win32 */
+ break;
+#endif
+ case MONO_MARSHAL_CONV_STR_LPSTR:
case MONO_MARSHAL_CONV_STR_BSTR:
case MONO_MARSHAL_CONV_STR_ANSIBSTR:
case MONO_MARSHAL_CONV_STR_TBSTR:
}
#ifdef PLATFORM_WIN32
- res = GlobalReAlloc (ptr, (gulong)size, 0);
+ res = GlobalReAlloc (ptr, (gulong)size, GMEM_MOVEABLE);
#else
res = g_try_realloc (ptr, (gulong)size);
#endif
}
gpointer
-ves_icall_System_ComObject_FindInterface (MonoComObject* obj, MonoReflectionType* type)
-{
- MonoClass* klass;
- gpointer itf = NULL;
- g_assert(obj);
- g_assert(type);
- if (!obj->itf_hash)
- return NULL;
-
- klass = mono_object_class (obj);
- klass = mono_class_from_mono_type (type->type);
-
- mono_cominterop_lock ();
- itf = g_hash_table_lookup (obj->itf_hash, GUINT_TO_POINTER ((guint)klass->interface_id));
- mono_cominterop_unlock ();
-
- return itf;
-}
-
-void
-ves_icall_System_ComObject_AddInterface (MonoComObject* obj, MonoReflectionType* type, gpointer pItf)
+ves_icall_System_ComObject_GetInterfaceInternal (MonoComObject* obj, MonoReflectionType* type, MonoBoolean throw_exception)
{
- MonoClass* klass;
- g_assert(obj);
- g_assert(type);
- if (!obj->itf_hash) {
- mono_cominterop_lock ();
- obj->itf_hash = g_hash_table_new (mono_aligned_addr_hash, NULL);
- mono_cominterop_unlock ();
- }
-
- klass = mono_object_class (obj);
- klass = mono_class_from_mono_type (type->type);
-
- mono_cominterop_lock ();
- g_hash_table_insert (obj->itf_hash, GUINT_TO_POINTER ((guint)klass->interface_id), pItf);
- mono_cominterop_unlock ();
+ return cominterop_get_interface (obj, mono_type_get_class (type->type), (gboolean)throw_exception);
}
void
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)
return mspec->data.array_data.num_elem * esize;
}
case MONO_NATIVE_CUSTOM:
- g_assert_not_reached ();
+ *align = sizeof (gpointer);
+ return sizeof (gpointer);
break;
case MONO_NATIVE_CURRENCY:
case MONO_NATIVE_VBBYREFSTR:
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;
}
+/*
+ * The mono_win32_compat_* functions are implementations of inline
+ * Windows kernel32 APIs, which are DllImport-able under MS.NET,
+ * although not exported by kernel32.
+ *
+ * We map the appropiate kernel32 entries to these functions using
+ * dllmaps declared in the global etc/mono/config.
+ */
+
+void
+mono_win32_compat_CopyMemory (gpointer dest, gconstpointer source, gsize length)
+{
+ if (!dest || !source)
+ return;
+
+ memcpy (dest, source, length);
+}
+
+void
+mono_win32_compat_FillMemory (gpointer dest, gsize length, guchar fill)
+{
+ memset (dest, fill, length);
+}
+
+void
+mono_win32_compat_MoveMemory (gpointer dest, gconstpointer source, gsize length)
+{
+ if (!dest || !source)
+ return;
+
+ memmove (dest, source, length);
+}
+
+void
+mono_win32_compat_ZeroMemory (gpointer dest, gsize length)
+{
+ memset (dest, 0, length);
+}
+
/* Put COM Interop related stuff here */
/**
/* FIXME: which to use? */
csig = signature_dup (method->klass->image, sig);
/* csig = mono_metadata_signature_dup (sig); */
+
+ /* STDCALL on windows, CDECL everywhere else to work with XPCOM and MainWin COM */
+#ifdef PLATFORM_WIN32
csig->call_convention = MONO_CALL_STDCALL;
+#else
+ csig->call_convention = MONO_CALL_C;
+#endif
csig->hasthis = 0;
csig->pinvoke = 1;
int start_slot = 3;
int method_count = 0;
GList *ccw_list, *ccw_list_item;
+ MonoCustomAttrInfo *cinfo = NULL;
if (!object)
return NULL;
ccw_list->data = ccw;
}
else
- g_list_append (ccw_list, ccw);
+ ccw_list = g_list_append (ccw_list, ccw);
g_hash_table_insert (ccw_hash, GINT_TO_POINTER (mono_object_hash (object)), ccw_list);
/* register for finalization to clean up ccw */
mono_object_register_finalizer (object);
}
+ cinfo = mono_custom_attrs_from_class (itf);
+ if (cinfo) {
+ static MonoClass* coclass_attribute = NULL;
+ if (!coclass_attribute)
+ coclass_attribute = mono_class_from_name (mono_defaults.corlib, "System.Runtime.InteropServices", "CoClassAttribute");
+ if (mono_custom_attrs_has_attr (cinfo, coclass_attribute)) {
+ g_assert(itf->interface_count && itf->interfaces[0]);
+ itf = itf->interfaces[0];
+ }
+ if (!cinfo->cached)
+ mono_custom_attrs_free (cinfo);
+ }
+
iface = itf;
if (iface == mono_defaults.iunknown_class) {
start_slot = 3;
start_slot = 7;
}
else {
- while (iface) {
- method_count += iface->method.count;
- if (iface->interface_count) {
- iface = iface->interfaces [0];
- }
- else {
- start_slot = cominterop_get_com_slot_begin (iface);
- iface = NULL;
- }
- }
+ method_count += iface->method.count;
+ start_slot = cominterop_get_com_slot_begin (iface);
+ iface = NULL;
}
ccw_entry = g_hash_table_lookup (ccw->vtable_hash, itf);
memcpy (vtable+3, idispatch, sizeof (idispatch));
iface = itf;
- while (iface) {
- for (i = iface->method.count-1; i >= 0;i--) {
- int param_index = 0;
- MonoMethodBuilder *mb;
- MonoMarshalSpec ** mspecs;
- MonoMethod *wrapper_method, *adjust_method;
- MonoMethod *method = iface->methods [i];
- MonoMethodSignature* sig_adjusted;
- MonoMethodSignature* sig = mono_method_signature (method);
-
-
- mb = mono_mb_new (iface, method->name, MONO_WRAPPER_NATIVE_TO_MANAGED);
- adjust_method = cominterop_get_managed_wrapper_adjusted (method);
- sig_adjusted = mono_method_signature (adjust_method);
-
- mspecs = g_new (MonoMarshalSpec*, sig_adjusted->param_count + 1);
- mono_method_get_marshal_info (method, mspecs);
-
-
- /* move managed args up one */
- for (param_index = sig->param_count; param_index >= 1; param_index--)
- mspecs [param_index+1] = mspecs [param_index];
+ for (i = iface->method.count-1; i >= 0;i--) {
+ int param_index = 0;
+ MonoMethodBuilder *mb;
+ MonoMarshalSpec ** mspecs;
+ MonoMethod *wrapper_method, *adjust_method;
+ MonoMethod *method = iface->methods [i];
+ MonoMethodSignature* sig_adjusted;
+ MonoMethodSignature* sig = mono_method_signature (method);
+ gboolean preserve_sig = method->iflags & METHOD_IMPL_ATTRIBUTE_PRESERVE_SIG;
+
+
+ mb = mono_mb_new (iface, method->name, MONO_WRAPPER_NATIVE_TO_MANAGED);
+ adjust_method = cominterop_get_managed_wrapper_adjusted (method);
+ sig_adjusted = mono_method_signature (adjust_method);
+
+ mspecs = g_new (MonoMarshalSpec*, sig_adjusted->param_count + 1);
+ mono_method_get_marshal_info (method, mspecs);
- /* first arg is IntPtr for interface */
- mspecs [1] = NULL;
+
+ /* move managed args up one */
+ for (param_index = sig->param_count; param_index >= 1; param_index--)
+ mspecs [param_index+1] = mspecs [param_index];
- /* move return spec to last param */
- if (!MONO_TYPE_IS_VOID (sig->ret))
- mspecs [sig_adjusted->param_count] = mspecs [0];
+ /* first arg is IntPtr for interface */
+ mspecs [1] = NULL;
+ /* move return spec to last param */
+ if (!preserve_sig && !MONO_TYPE_IS_VOID (sig->ret)) {
+ mspecs [sig_adjusted->param_count] = mspecs [0];
mspecs [0] = NULL;
+ }
- cominterop_setup_marshal_context (&m, adjust_method);
- m.mb = mb;
- mono_marshal_emit_managed_wrapper (mb, sig_adjusted, mspecs, &m, adjust_method, NULL);
- mono_loader_lock ();
- mono_marshal_lock ();
- wrapper_method = mono_mb_create_method (mb, sig_adjusted, sig_adjusted->param_count + 16);
- mono_marshal_unlock ();
- mono_loader_unlock ();
+ cominterop_setup_marshal_context (&m, adjust_method);
+ m.mb = mb;
+ mono_marshal_emit_managed_wrapper (mb, sig_adjusted, mspecs, &m, adjust_method, NULL);
+ mono_loader_lock ();
+ mono_marshal_lock ();
+ wrapper_method = mono_mb_create_method (mb, sig_adjusted, sig_adjusted->param_count + 16);
+ mono_marshal_unlock ();
+ mono_loader_unlock ();
- /* skip visiblity since we call internal methods */
- wrapper_method->skip_visibility = TRUE;
+ /* skip visiblity since we call internal methods */
+ wrapper_method->skip_visibility = TRUE;
- vtable [vtable_index--] = mono_compile_method (wrapper_method);
+ vtable [vtable_index--] = mono_compile_method (wrapper_method);
-
- for (param_index = sig_adjusted->param_count; param_index >= 0; param_index--)
- if (mspecs [param_index])
- mono_metadata_free_marshal_spec (mspecs [param_index]);
- g_free (mspecs);
- }
- if (iface->interface_count)
- iface = iface->interfaces [0];
- else
- iface = NULL;
+
+ for (param_index = sig_adjusted->param_count; param_index >= 0; param_index--)
+ if (mspecs [param_index])
+ mono_metadata_free_marshal_spec (mspecs [param_index]);
+ g_free (mspecs);
}
ccw_entry = g_new0 (MonoCCWInterface, 1);
/* 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;
MonoMethodBuilder *mb;
MonoMarshalSpec **mspecs;
MonoMethodSignature *sig, *sig_native;
- MonoExceptionClause *main_clause;
+ MonoExceptionClause *main_clause = NULL;
MonoMethodHeader *header;
int pos_leave;
- int hr;
+ int hr = 0;
int i;
+ gboolean preserve_sig = method->iflags & METHOD_IMPL_ATTRIBUTE_PRESERVE_SIG;
if (!get_hr_for_exception)
get_hr_for_exception = mono_class_get_method_from_name (mono_defaults.marshal_class, "GetHRForException", -1);
/* create unmanaged wrapper */
mb = mono_mb_new (method->klass, method->name, MONO_WRAPPER_COMINTEROP);
- sig_native = signature_cominterop (method->klass->image, sig);
+ sig_native = cominterop_method_signature (method);
mspecs = g_new0 (MonoMarshalSpec*, sig_native->param_count+1);
mspecs [1] = NULL;
/* move return spec to last param */
- if (!MONO_TYPE_IS_VOID (sig->ret))
+ if (!preserve_sig && !MONO_TYPE_IS_VOID (sig->ret))
mspecs [sig_native->param_count] = mspecs [0];
mspecs [0] = NULL;
- hr = mono_mb_add_local (mb, &mono_defaults.int32_class->byval_arg);
-
- /* try */
+ if (!preserve_sig) {
+ hr = mono_mb_add_local (mb, &mono_defaults.int32_class->byval_arg);
- main_clause = g_new0 (MonoExceptionClause, 1);
- main_clause->try_offset = mb->pos;
+ /* try */
+ main_clause = g_new0 (MonoExceptionClause, 1);
+ main_clause->try_offset = mono_mb_get_label (mb);
+ }
- if (!MONO_TYPE_IS_VOID (sig->ret))
+ /* load last param to store result if not preserve_sig and not void */
+ if (!preserve_sig && !MONO_TYPE_IS_VOID (sig->ret))
mono_mb_emit_ldarg (mb, sig_native->param_count-1);
/* the CCW -> object conversion */
mono_mb_emit_managed_call (mb, method, NULL);
- /* store result if we have one */
- if (!MONO_TYPE_IS_VOID (sig->ret))
- mono_mb_emit_byte (mb, CEE_STIND_REF);
+ if (!preserve_sig) {
+ /* store result if not preserve_sig and we have one */
+ if (!MONO_TYPE_IS_VOID (sig->ret))
+ mono_mb_emit_byte (mb, mono_type_to_stind (sig->ret));
- pos_leave = mono_mb_emit_branch (mb, CEE_LEAVE);
+ pos_leave = mono_mb_emit_branch (mb, CEE_LEAVE);
- /* Main exception catch */
- main_clause->flags = MONO_EXCEPTION_CLAUSE_NONE;
- main_clause->try_len = mb->pos - main_clause->try_offset;
- main_clause->data.catch_class = mono_defaults.object_class;
-
- /* handler code */
- main_clause->handler_offset = mb->pos;
- 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;
- /* end catch */
+ /* Main exception catch */
+ main_clause->flags = MONO_EXCEPTION_CLAUSE_NONE;
+ 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 = 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 = 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);
+ }
- /* FIXME: need to emit try/catch block and return failure code if exception */
- mono_mb_emit_ldloc (mb, hr);
mono_mb_emit_byte (mb, CEE_RET);
mono_loader_lock ();
mono_metadata_free_marshal_spec (mspecs [i]);
g_free (mspecs);
- header = ((MonoMethodNormal *)res)->header;
- header->num_clauses = 1;
- header->clauses = main_clause;
+ if (!preserve_sig) {
+ header = ((MonoMethodNormal *)res)->header;
+ header->num_clauses = 1;
+ header->clauses = main_clause;
+ }
return res;
}
* Converts the standard string representation of a GUID
* to a 16 byte Microsoft GUID.
*/
-void
+static void
cominterop_mono_string_to_guid (const MonoString* string, guint8 *guid) {
gunichar2 * chars = mono_string_chars (string);
int i = 0;
for (i = 0; i < sizeof(indexes); i++)
guid [i] = g_unichar_xdigit_value (chars [indexes [i]]) + (g_unichar_xdigit_value (chars [indexes [i] - 1]) << 4);
-
- //guid [0] = g_unichar_xdigit_value (chars [7]) + (g_unichar_xdigit_value (chars [6]) << 4);
- //guid [1] = g_unichar_xdigit_value (chars [5]) + (g_unichar_xdigit_value (chars [4]) << 4);
- //guid [2] = g_unichar_xdigit_value (chars [3]) + (g_unichar_xdigit_value (chars [2]) << 4);
- //guid [3] = g_unichar_xdigit_value (chars [1]) + (g_unichar_xdigit_value (chars [0]) << 4);
- //guid [4] = g_unichar_xdigit_value (chars [12]) + (g_unichar_xdigit_value (chars [11]) << 4);
- //guid [5] = g_unichar_xdigit_value (chars [10]) + (g_unichar_xdigit_value (chars [9]) << 4);
- //guid [6] = g_unichar_xdigit_value (chars [17]) + (g_unichar_xdigit_value (chars [16]) << 4);
- //guid [7] = g_unichar_xdigit_value (chars [15]) + (g_unichar_xdigit_value (chars [14]) << 4);
- //guid [8] = g_unichar_xdigit_value (chars [20]) + (g_unichar_xdigit_value (chars [19]) << 4);
- //guid [9] = g_unichar_xdigit_value (chars [22]) + (g_unichar_xdigit_value (chars [21]) << 4);
- //guid [10] = g_unichar_xdigit_value (chars [25]) + (g_unichar_xdigit_value (chars [24]) << 4);
- //guid [11] = g_unichar_xdigit_value (chars [27]) + (g_unichar_xdigit_value (chars [26]) << 4);
- //guid [12] = g_unichar_xdigit_value (chars [29]) + (g_unichar_xdigit_value (chars [28]) << 4);
- //guid [13] = g_unichar_xdigit_value (chars [31]) + (g_unichar_xdigit_value (chars [30]) << 4);
- //guid [14] = g_unichar_xdigit_value (chars [33]) + (g_unichar_xdigit_value (chars [32]) << 4);
- //guid [15] = g_unichar_xdigit_value (chars [35]) + (g_unichar_xdigit_value (chars [34]) << 4);
}
static gboolean
cominterop_class_guid_equal (guint8* guid, MonoClass* klass)
{
- static MonoClass *GuidAttribute = NULL;
- MonoCustomAttrInfo *cinfo;
-
- /* Handle the GuidAttribute */
- if (!GuidAttribute)
- GuidAttribute = mono_class_from_name (mono_defaults.corlib, "System.Runtime.InteropServices", "GuidAttribute");
-
- cinfo = mono_custom_attrs_from_class (klass);
- if (cinfo) {
- guint8 klass_guid [16];
- MonoReflectionGuidAttribute *attr = (MonoReflectionGuidAttribute*)mono_custom_attrs_get_attr (cinfo, GuidAttribute);
-
- if (!attr)
- return FALSE;
- if (!cinfo->cached)
- mono_custom_attrs_free (cinfo);
-
- cominterop_mono_string_to_guid (attr->guid, klass_guid);
+ guint8 klass_guid [16];
+ if (cominterop_class_guid (klass, klass_guid))
return !memcmp (guid, klass_guid, sizeof (klass_guid));
- }
return FALSE;
}
g_assert (ccw);
g_assert (ccw->gc_handle);
g_assert (ccw->ref_count >= 0);
- ref_count = InterlockedIncrement (&ccw->ref_count);
+ ref_count = InterlockedIncrement ((gint32*)&ccw->ref_count);
if (ref_count == 1) {
guint32 oldhandle = ccw->gc_handle;
g_assert (oldhandle);
MonoCCW* ccw = ccwe->ccw;
g_assert (ccw);
g_assert (ccw->ref_count > 0);
- ref_count = InterlockedDecrement (&ccw->ref_count);
+ ref_count = InterlockedDecrement ((gint32*)&ccw->ref_count);
if (ref_count == 0) {
/* allow gc of object */
guint32 oldhandle = ccw->gc_handle;
projects / mono.git / blobdiff