#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 */
+/*
+ * This mutex protects the various marshalling related caches in MonoImage
+ * and a few other data structures static to this file.
+ * Note that when this lock is held it is not possible to take other runtime
+ * locks like the loader lock.
+ */
#define mono_marshal_lock() EnterCriticalSection (&marshal_mutex)
#define mono_marshal_unlock() LeaveCriticalSection (&marshal_mutex)
static CRITICAL_SECTION marshal_mutex;
+/* This mutex protects the various cominterop related caches in MonoImage */
+#define mono_cominterop_lock() EnterCriticalSection (&cominterop_mutex)
+#define mono_cominterop_unlock() LeaveCriticalSection (&cominterop_mutex)
+static CRITICAL_SECTION cominterop_mutex;
+
/* Maps wrapper methods to the methods they wrap */
static GHashTable *wrapper_hash;
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);
return sig;
}
+/* Begin COM Interop related stuff until seperate file */
+
+
+/* STDCALL on windows, CDECL everywhere else to work with XPCOM and MainWin COM */
+#ifdef PLATFORM_WIN32
+#define STDCALL __stdcall
+#else
+#define STDCALL
+#endif
+
+/* Upon creation of a CCW, only allocate a weak handle and set the
+ * reference count to 0. If the unmanaged client code decides to addref and
+ * hold onto the CCW, I then allocate a strong handle. Once the reference count
+ * goes back to 0, convert back to a weak handle.
+ */
+typedef struct {
+ guint32 ref_count;
+ guint32 gc_handle;
+ GHashTable* vtable_hash;
+} MonoCCW;
+
+/* This type is the actual pointer passed to unmanaged code
+ * to represent a COM interface.
+ */
+typedef struct {
+ gpointer vtable;
+ MonoCCW* ccw;
+} MonoCCWInterface;
+
+/* IUnknown */
+static int STDCALL cominterop_ccw_addref (MonoCCWInterface* ccwe);
+
+static int STDCALL cominterop_ccw_release (MonoCCWInterface* ccwe);
+
+static int STDCALL cominterop_ccw_queryinterface (MonoCCWInterface* ccwe, guint8* riid, gpointer* ppv);
+
+/* IDispatch */
+static int STDCALL cominterop_ccw_get_type_info_count (MonoCCWInterface* ccwe, guint32 *pctinfo);
+
+static int STDCALL cominterop_ccw_get_type_info (MonoCCWInterface* ccwe, guint32 iTInfo, guint32 lcid, gpointer *ppTInfo);
+
+static int STDCALL cominterop_ccw_get_ids_of_names (MonoCCWInterface* ccwe, gpointer riid,
+ gunichar2** rgszNames, guint32 cNames,
+ guint32 lcid, gint32 *rgDispId);
+
+static int STDCALL cominterop_ccw_invoke (MonoCCWInterface* ccwe, guint32 dispIdMember,
+ gpointer riid, guint32 lcid,
+ guint16 wFlags, gpointer pDispParams,
+ gpointer pVarResult, gpointer pExcepInfo,
+ guint32 *puArgErr);
+
+static MonoMethod *
+cominterop_get_managed_wrapper_adjusted (MonoMethod *method);
+
+static gpointer
+cominterop_get_ccw (MonoObject* object, MonoClass* itf);
+
+static MonoObject*
+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 (klass && klass == mono_defaults.com_interop_proxy_class);
}
-/**
- * cominterop_get_com_slot_for_method:
- * @method: a method
- *
- * Returns: the method's slot in the COM interface vtable
- */
static int
-cominterop_get_com_slot_for_method (MonoMethod* method)
+cominterop_get_com_slot_begin (MonoClass* klass)
{
static MonoClass *interface_type_attribute = NULL;
- MonoInterfaceTypeAttribute* itf_attr = NULL;
MonoCustomAttrInfo *cinfo = NULL;
- guint32 offset = 7;
- guint32 slot = method->slot;
- GPtrArray *ifaces;
- MonoClass *ic = NULL;
- int i;
-
- 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 (!ic)
- ic = method->klass;
-
- g_assert (ic);
- g_assert (MONO_CLASS_IS_INTERFACE (ic));
+ MonoInterfaceTypeAttribute* itf_attr = NULL;
if (!interface_type_attribute)
interface_type_attribute = mono_class_from_name (mono_defaults.corlib, "System.Runtime.InteropServices", "InterfaceTypeAttribute");
- cinfo = mono_custom_attrs_from_class (ic);
+ cinfo = mono_custom_attrs_from_class (klass);
if (cinfo) {
itf_attr = (MonoInterfaceTypeAttribute*)mono_custom_attrs_get_attr (cinfo, interface_type_attribute);
if (!cinfo->cached)
}
if (itf_attr && itf_attr->intType == 1)
- offset = 3; /* 3 methods in IUnknown*/
+ return 3; /* 3 methods in IUnknown*/
else
- offset = 7; /* 7 methods in IDispatch*/
-
- return slot + offset;
+ return 7; /* 7 methods in IDispatch*/
}
/**
* cominterop_get_method_interface:
* @method: method being called
*
- * Returns: the Type on which the method is defined on
+ * Returns: the MonoClass* representing the interface on which
+ * the method is defined.
*/
-static MonoReflectionType*
+static MonoClass*
cominterop_get_method_interface (MonoMethod* method)
{
- GPtrArray *ifaces;
- MonoType* t = NULL;
- MonoClass *ic = NULL;
- int i;
- MonoReflectionType* rt = NULL;
+ 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)
- break;
- ic = NULL;
+ /* 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_ptr_array_free (ifaces, TRUE);
}
- if (!ic)
- ic = method->klass;
+ g_assert (ic);
+ g_assert (MONO_CLASS_IS_INTERFACE (ic));
+
+ return ic;
+}
+
+/**
+ * cominterop_get_com_slot_for_method:
+ * @method: a method
+ *
+ * Returns: the method's slot in the COM interface vtable
+ */
+static int
+cominterop_get_com_slot_for_method (MonoMethod* method)
+{
+ guint32 slot = method->slot;
+ MonoClass *ic = method->klass;
+
+ /* 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;
+ }
+
+ g_assert (ic);
+ g_assert (MONO_CLASS_IS_INTERFACE (ic));
+
+ return slot + cominterop_get_com_slot_begin (ic);
+}
+
+
+static void
+cominterop_mono_string_to_guid (const MonoString* string, guint8 *guid);
+
+static gboolean
+cominterop_class_guid (MonoClass* klass, guint8* guid)
+{
+ 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) {
+ 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;
+}
+
+/**
+ * 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 ();
+ }
+
+ }
+ if (throw_exception)
+ g_assert (itf);
+
+ return itf;
+}
- return rt;
+static int
+cominterop_get_hresult_for_exception (MonoException* exc)
+{
+ int hr = 0;
+ return hr;
}
void
if (!module_initialized) {
module_initialized = TRUE;
InitializeCriticalSection (&marshal_mutex);
+ InitializeCriticalSection (&cominterop_mutex);
wrapper_hash = g_hash_table_new (mono_aligned_addr_hash, NULL);
last_error_tls_id = TlsAlloc ();
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);
}
}
TlsFree (load_type_info_tls_id);
TlsFree (last_error_tls_id);
DeleteCriticalSection (&marshal_mutex);
+ DeleteCriticalSection (&cominterop_mutex);
}
MonoClass *byte_array_class;
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 delegate->delegate_trampoline;
}
+/*
+ * this hash table maps from a delegate trampoline object to a weak reference
+ * of the delegate. As an optimizations with a non-moving GC we store the
+ * object pointer itself, otherwise we use a GC handle.
+ */
static GHashTable *delegate_hash_table;
static GHashTable *
static void
delegate_hash_table_remove (MonoDelegate *d)
{
+#ifdef HAVE_MOVING_COLLECTOR
+ guint32 gchandle;
+#endif
mono_marshal_lock ();
if (delegate_hash_table == NULL)
delegate_hash_table = delegate_hash_table_new ();
+#ifdef HAVE_MOVING_COLLECTOR
+ gchandle = GPOINTER_TO_UINT (g_hash_table_lookup (delegate_hash_table, d->delegate_trampoline));
+#endif
g_hash_table_remove (delegate_hash_table, d->delegate_trampoline);
mono_marshal_unlock ();
+#ifdef HAVE_MOVING_COLLECTOR
+ mono_gchandle_free (gchandle);
+#endif
}
-void
+static void
delegate_hash_table_add (MonoDelegate *d)
{
+#ifdef HAVE_MOVING_COLLECTOR
+ guint32 gchandle = mono_gchandle_new_weakref ((MonoObject*)d, FALSE);
+#endif
mono_marshal_lock ();
if (delegate_hash_table == NULL)
delegate_hash_table = delegate_hash_table_new ();
+#ifdef HAVE_MOVING_COLLECTOR
+ g_hash_table_insert (delegate_hash_table, d->delegate_trampoline, GUINT_TO_POINTER (gchandle));
+#else
g_hash_table_insert (delegate_hash_table, d->delegate_trampoline, d);
+#endif
mono_marshal_unlock ();
}
MonoDelegate*
mono_ftnptr_to_delegate (MonoClass *klass, gpointer ftn)
{
+#ifdef HAVE_MOVING_COLLECTOR
+ guint32 gchandle;
+#endif
MonoDelegate *d;
mono_marshal_lock ();
if (delegate_hash_table == NULL)
delegate_hash_table = delegate_hash_table_new ();
+#ifdef HAVE_MOVING_COLLECTOR
+ gchandle = GPOINTER_TO_UINT (g_hash_table_lookup (delegate_hash_table, ftn));
+ mono_marshal_unlock ();
+ if (gchandle)
+ d = (MonoDelegate*)mono_gchandle_get_target (gchandle);
+ else
+ d = NULL;
+#else
d = g_hash_table_lookup (delegate_hash_table, ftn);
mono_marshal_unlock ();
+#endif
if (d == NULL) {
/* This is a native function, so construct a delegate for it */
static MonoClass *UnmanagedFunctionPointerAttribute;
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: Assumes the loader lock is held.
- */
-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;
-
- 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)
+static void
+mono_mb_emit_cominterop_call (MonoMethodBuilder *mb, MonoMethodSignature *sig, MonoMethod* method)
{
- if ((mb->pos + 4) >= mb->code_size) {
- mb->code_size += mb->code_size >> 1;
- mb->code = g_realloc (mb->code, mb->code_size);
- }
+ // get function pointer from 1st arg, the COM interface pointer
+ mono_mb_emit_ldarg (mb, 0);
+ mono_mb_emit_icon (mb, cominterop_get_com_slot_for_method (method));
+ mono_mb_emit_icall (mb, cominterop_get_function_pointer);
- 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)
-{
- // get function pointer from 1st arg, the COM interface pointer
- mono_mb_emit_ldarg (mb, 0);
- mono_mb_emit_icon (mb, cominterop_get_com_slot_for_method (method));
- mono_mb_emit_icall (mb, cominterop_get_function_pointer);
-
- mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
- mono_mb_emit_byte (mb, CEE_MONO_SAVE_LMF);
- 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_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);
+ mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
+ mono_mb_emit_byte (mb, CEE_MONO_SAVE_LMF);
+ 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_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);
static MonoMethod* com_interop_proxy_get_proxy = NULL;
static MonoMethod* get_transparent_proxy = NULL;
int real_proxy;
- guint32 pos_failed = 0;
- MonoClass *klass = mono_class_from_mono_type (type);
+ guint32 pos_null = 0, pos_ccw = 0, pos_end = 0;
+ MonoClass *klass = NULL;
+
+ /* COM types are initialized lazily */
+ mono_init_com_types ();
+
+ klass = mono_class_from_mono_type (type);
mono_mb_emit_ldloc (mb, 1);
mono_mb_emit_byte (mb, CEE_LDNULL);
mono_mb_emit_ldloc (mb, 0);
mono_mb_emit_byte (mb, CEE_LDIND_I);
- pos_failed = mono_mb_emit_short_branch (mb, CEE_BRFALSE_S);
+ pos_null = mono_mb_emit_short_branch (mb, CEE_BRFALSE_S);
+
+ /* load dst to store later */
+ mono_mb_emit_ldloc (mb, 1);
+
+ mono_mb_emit_ldloc (mb, 0);
+ mono_mb_emit_byte (mb, CEE_LDIND_I);
+ mono_mb_emit_icon (mb, TRUE);
+ mono_mb_emit_icall (mb, cominterop_get_ccw_object);
+ pos_ccw = mono_mb_emit_short_branch (mb, CEE_BRTRUE_S);
if (!com_interop_proxy_class)
com_interop_proxy_class = mono_class_from_name (mono_defaults.corlib, "Mono.Interop", "ComInteropProxy");
mono_mb_emit_ptr (mb, &mono_defaults.com_object_class->byval_arg);
mono_mb_emit_icall (mb, type_from_handle);
mono_mb_emit_managed_call (mb, com_interop_proxy_get_proxy, NULL);
- mono_mb_emit_stloc (mb, real_proxy);
-
-
- mono_mb_emit_ldloc (mb, 1);
- mono_mb_emit_ldloc (mb, real_proxy);
mono_mb_emit_managed_call (mb, get_transparent_proxy, NULL);
- if (klass && klass != mono_defaults.object_class)
+ if (conv == MONO_MARSHAL_CONV_OBJECT_INTERFACE) {
+ g_assert (klass);
+ 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_patch_short_branch (mb, pos_ccw);
+ mono_mb_emit_ldloc (mb, 0);
+ mono_mb_emit_byte (mb, CEE_LDIND_I);
+ mono_mb_emit_icon (mb, TRUE);
+ mono_mb_emit_icall (mb, cominterop_get_ccw_object);
+
+ if (conv == MONO_MARSHAL_CONV_OBJECT_INTERFACE) {
+ g_assert (klass);
mono_mb_emit_op (mb, CEE_CASTCLASS, klass);
+ }
mono_mb_emit_byte (mb, CEE_STIND_REF);
- // case if null
- mono_mb_patch_short_branch (mb, pos_failed);
+ mono_mb_patch_short_branch (mb, pos_end);
+ /* case if null */
+ mono_mb_patch_short_branch (mb, pos_null);
break;
}
break;
}
+ case MONO_MARSHAL_CONV_HANDLEREF: {
+ /*
+ * Passing HandleRefs in a struct that is ref()ed does not
+ * copy the values back to the HandleRef
+ */
+ break;
+ }
+
case MONO_MARSHAL_CONV_STR_BSTR:
case MONO_MARSHAL_CONV_STR_ANSIBSTR:
case MONO_MARSHAL_CONV_STR_TBSTR:
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);
case MONO_MARSHAL_CONV_OBJECT_INTERFACE:
case MONO_MARSHAL_CONV_OBJECT_IDISPATCH:
case MONO_MARSHAL_CONV_OBJECT_IUNKNOWN: {
- guint32 pos_failed = 0, pos_rcw = 0;
- char * msg;
+ guint32 pos_null = 0, pos_rcw = 0, pos_end = 0;
+
+ /* COM types are initialized lazily */
+ mono_init_com_types ();
+
mono_mb_emit_ldloc (mb, 1);
- //mono_mb_emit_ldloc (mb, 0);
- mono_mb_emit_ptr (mb, 0);
- //mono_mb_emit_byte (mb, CEE_LDIND_U1);
+ mono_mb_emit_icon (mb, 0);
+ mono_mb_emit_byte (mb, CEE_CONV_U);
mono_mb_emit_byte (mb, CEE_STIND_I);
mono_mb_emit_ldloc (mb, 0);
mono_mb_emit_byte (mb, CEE_LDIND_REF);
// if null just break, dst was already inited to 0
- pos_failed = mono_mb_emit_short_branch (mb, CEE_BRFALSE_S);
+ pos_null = mono_mb_emit_short_branch (mb, CEE_BRFALSE_S);
mono_mb_emit_ldloc (mb, 0);
mono_mb_emit_byte (mb, CEE_LDIND_REF);
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;
mono_mb_emit_managed_call (mb, idispatch->get, NULL);
}
else {
+ g_assert_not_reached ();
}
mono_mb_emit_byte (mb, CEE_STIND_I);
+ pos_end = mono_mb_emit_short_branch (mb, CEE_BR_S);
// if not rcw
mono_mb_patch_short_branch (mb, pos_rcw);
- msg = g_strdup ("Marshalling of COM Callable Wrappers is not yet implemented.");
- mono_mb_emit_exception_marshal_directive (mb, msg);
+ /* load dst to store later */
+ mono_mb_emit_ldloc (mb, 1);
+ /* load src */
+ mono_mb_emit_ldloc (mb, 0);
+ mono_mb_emit_byte (mb, CEE_LDIND_REF);
+
+ if (conv == MONO_MARSHAL_CONV_OBJECT_INTERFACE)
+ mono_mb_emit_ptr (mb, mono_type_get_class (type));
+ else if (conv == MONO_MARSHAL_CONV_OBJECT_IUNKNOWN)
+ mono_mb_emit_ptr (mb, mono_defaults.iunknown_class);
+ else if (conv == MONO_MARSHAL_CONV_OBJECT_IDISPATCH)
+ mono_mb_emit_ptr (mb, mono_defaults.idispatch_class);
+ else
+ g_assert_not_reached ();
+ mono_mb_emit_icall (mb, cominterop_get_ccw);
+ mono_mb_emit_byte (mb, CEE_STIND_I);
- // case if null
- mono_mb_patch_short_branch (mb, pos_failed);
+ mono_mb_patch_short_branch (mb, pos_end);
+ mono_mb_patch_short_branch (mb, pos_null);
break;
}
mono_mb_emit_byte (mb, CEE_STIND_I);
break;
}
+
+ case MONO_MARSHAL_CONV_HANDLEREF: {
+ mono_mb_emit_ldloc (mb, 1);
+ mono_mb_emit_ldloc (mb, 0);
+ 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;
+ }
+
default: {
char *msg = g_strdup_printf ("marshalling conversion %d not implemented", conv);
MonoException *exc = mono_get_exception_not_implemented (msg);
break;
}
case MONO_TYPE_OBJECT: {
+ mono_init_com_types ();
if (to_object) {
static MonoMethod *variant_clear = NULL;
static MonoMethod *get_object_for_native_variant = NULL;
+
if (!variant_clear)
variant_clear = mono_class_get_method_from_name (mono_defaults.variant_class, "Clear", 0);
if (!get_object_for_native_variant)
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);
{
MonoMethod *res;
- mono_loader_lock ();
mono_marshal_lock ();
res = g_hash_table_lookup (cache, key);
+ mono_marshal_unlock ();
if (!res) {
- /* This does not acquire any locks */
- res = mono_mb_create_method (mb, sig, max_stack);
- g_hash_table_insert (cache, key, res);
- g_hash_table_insert (wrapper_hash, res, key);
+ MonoMethod *newm;
+ newm = mono_mb_create_method (mb, sig, max_stack);
+ mono_marshal_lock ();
+ res = g_hash_table_lookup (cache, key);
+ if (!res) {
+ res = newm;
+ g_hash_table_insert (cache, key, res);
+ g_hash_table_insert (wrapper_hash, res, key);
+ mono_marshal_unlock ();
+ } else {
+ mono_marshal_unlock ();
+ mono_free_method (newm);
+ }
}
- mono_marshal_unlock ();
- mono_loader_unlock ();
return res;
}
case MONO_WRAPPER_XDOMAIN_DISPATCH: res = wrps->xdomain_dispatch; break;
}
}
-
+
+ /* it is important to do the unlock after the load from wrps, since in
+ * mono_remoting_mb_create_and_cache () we drop the marshal lock to be able
+ * to take the loader lock and some other thread may set the fields.
+ */
mono_marshal_unlock ();
return res;
}
MonoRemotingMethods *wrps;
GHashTable *cache = key->klass->image->remoting_invoke_cache;
- mono_loader_lock ();
mono_marshal_lock ();
wrps = g_hash_table_lookup (cache, key);
if (!wrps) {
case MONO_WRAPPER_XDOMAIN_DISPATCH: res = &wrps->xdomain_dispatch; break;
default: g_assert_not_reached (); break;
}
-
+ mono_marshal_unlock ();
+
if (*res == NULL) {
- /* This does not acquire any locks */
- *res = mono_mb_create_method (mb, sig, max_stack);
- g_hash_table_insert (wrapper_hash, *res, key);
+ MonoMethod *newm;
+ newm = mono_mb_create_method (mb, sig, max_stack);
+
+ mono_marshal_lock ();
+ if (!*res) {
+ *res = newm;
+ g_hash_table_insert (wrapper_hash, *res, key);
+ mono_marshal_unlock ();
+ } else {
+ mono_marshal_unlock ();
+ mono_free_method (newm);
+ }
}
- mono_marshal_unlock ();
- mono_loader_unlock ();
-
return *res;
}
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 ();
ares = mono_array_get (msg->args, gpointer, sig->param_count - 1);
g_assert (ares);
+ if (ares->async_delegate != (MonoObject*)delegate && mono_get_runtime_info ()->framework_version [0] >= '2') {
+ mono_raise_exception (mono_get_exception_invalid_operation (
+ "The IAsyncResult object provided does not match this delegate."));
+ return NULL;
+ }
+
if (delegate->target && mono_object_class (delegate->target) == mono_defaults.transparent_proxy_class) {
MonoTransparentProxy* tp = (MonoTransparentProxy *)delegate->target;
msg = (MonoMethodMessage *)mono_object_new (domain, mono_defaults.mono_method_message_class);
// 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);
- mono_loader_lock ();
- mono_marshal_lock ();
res = mono_mb_create_method (mb_native, sig_native, sig_native->param_count + 16);
- mono_marshal_unlock ();
- mono_loader_unlock ();
mono_mb_free (mb_native);
if ((res = mono_marshal_find_in_cache (cache, method)))
return res;
+ mono_init_com_types ();
+
sig = mono_method_signature (method);
mb = mono_mb_new (method->klass, method->name, MONO_WRAPPER_COMINTEROP);
}
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 (!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);
+ 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);
- // 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);
}
return res;
}
+/* Maps a managed object to its unmanaged representation
+ * i.e. it's COM Callable Wrapper (CCW).
+ * Key: MonoObject*
+ * Value: MonoCCW*
+ */
+static GHashTable* ccw_hash = NULL;
+
+/* Maps a CCW interface to it's containing CCW.
+ * Note that a CCW support many interfaces.
+ * Key: MonoCCW*
+ * Value: MonoCCWInterface*
+ */
+static GHashTable* ccw_interface_hash = NULL;
+
+/* Maps the IUnknown value of a RCW to
+ * it's MonoComInteropProxy*.
+ * Key: void*
+ * Value: gchandle
+ */
+static GHashTable* rcw_hash = NULL;
MonoMethod *
mono_marshal_get_remoting_invoke (MonoMethod *method)
/* 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);
}
if (method->wrapper_type == MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK)
return method;
- sig = signature_no_pinvoke (method);
-
/* we cant remote methods without this pointer */
- g_assert (sig->hasthis);
+ g_assert (mono_method_signature (method)->hasthis);
if ((res = mono_marshal_remoting_find_in_cache (method, MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK)))
return res;
+ sig = signature_no_pinvoke (method);
+
mb = mono_mb_new (method->klass, method->name, MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK);
for (i = 0; i <= sig->param_count; i++)
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;
}
-/*
- * the returned method invokes all methods in a multicast delegate
- */
+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.
+ */
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;
}
typedef struct {
- MonoMethod *ctor;
+ MonoMethodSignature *ctor_sig;
MonoMethodSignature *sig;
} CtorSigPair;
+/* protected by the marshal lock, contains CtorSigPair pointers */
+static GSList *strsig_list = NULL;
+
+static MonoMethodSignature *
+lookup_string_ctor_signature (MonoMethodSignature *sig)
+{
+ MonoMethodSignature *callsig;
+ CtorSigPair *cs;
+ GSList *item;
+
+ mono_marshal_lock ();
+ callsig = NULL;
+ for (item = strsig_list; item; item = item->next) {
+ cs = item->data;
+ /* mono_metadata_signature_equal () is safe to call with the marshal lock
+ * because it is lock-free.
+ */
+ if (mono_metadata_signature_equal (sig, cs->ctor_sig)) {
+ callsig = cs->sig;
+ break;
+ }
+ }
+ mono_marshal_unlock ();
+ return callsig;
+}
+
+static MonoMethodSignature *
+add_string_ctor_signature (MonoMethod *method)
+{
+ MonoMethodSignature *callsig;
+ CtorSigPair *cs;
+
+ callsig = signature_dup (method->klass->image, mono_method_signature (method));
+ callsig->ret = &mono_defaults.string_class->byval_arg;
+ cs = g_new (CtorSigPair, 1);
+ cs->sig = callsig;
+ cs->ctor_sig = mono_method_signature (method);
+ mono_marshal_lock ();
+ strsig_list = g_slist_prepend (strsig_list, cs);
+ mono_marshal_unlock ();
+ return callsig;
+}
/*
* generates IL code for the runtime invoke function
GHashTable *cache = NULL;
MonoClass *target_klass;
MonoMethod *res = NULL;
- GSList *item;
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);
- target_klass = method->klass;
-
- mono_marshal_lock ();
+ 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) {
- static GSList *strsig_list = NULL;
- CtorSigPair *cs;
-
- callsig = NULL;
- for (item = strsig_list; item; item = item->next) {
- cs = item->data;
- if (mono_metadata_signature_equal (mono_method_signature (method), mono_method_signature (cs->ctor))) {
- callsig = cs->sig;
- break;
- }
- }
- if (!callsig) {
- callsig = signature_dup (method->klass->image, mono_method_signature (method));
- callsig->ret = &mono_defaults.string_class->byval_arg;
- cs = g_new (CtorSigPair, 1);
- cs->sig = callsig;
- cs->ctor = method;
- strsig_list = g_slist_prepend (strsig_list, cs);
- }
+ callsig = lookup_string_ctor_signature (mono_method_signature (method));
+ if (!callsig)
+ callsig = add_string_ctor_signature (method);
} else {
if (method->klass->valuetype && mono_method_signature (method)->hasthis) {
/*
*/
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);
}
}
- cache = method->klass->image->runtime_invoke_cache;
+ /* 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
+ * in the method image
+ */
+ 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;
+ }
+ }
+ }
+#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 */
- 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;
}
- target_klass = mono_defaults.object_class;
-
/* to make it work with our special string constructors */
if (!string_dummy) {
MONO_GC_REGISTER_ROOT (string_dummy);
sig = mono_method_signature (method);
- csig = mono_metadata_signature_alloc (method->klass->image, 4);
+ csig = mono_metadata_signature_alloc (target_klass->image, 4);
csig->ret = &mono_defaults.object_class->byval_arg;
if (method->klass->valuetype && mono_method_signature (method)->hasthis)
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;
}
/* fall through */
case MONO_TYPE_VALUETYPE:
- if (t->data.klass->enumtype) {
+ if (type == MONO_TYPE_VALUETYPE && t->data.klass->enumtype) {
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_loader_lock ();
- mono_marshal_lock ();
+ 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) {
+ 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 ();
+ }
- res = g_hash_table_lookup (cache, callsig);
- /* Somebody may have created it before us */
- if (!res) {
- res = mono_mb_create_method (mb, csig, sig->param_count + 16);
- g_hash_table_insert (cache, callsig, res);
- g_hash_table_insert (wrapper_hash, res, callsig);
+ /* end mono_mb_create_and_cache */
}
- mono_marshal_unlock ();
- mono_loader_unlock ();
- /* end mono_mb_create_and_cache */
-
mono_mb_free (mb);
header = ((MonoMethodNormal *)res)->header;
* 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_MANAGED_CONV_IN:
- if (t->byref) {
- conv_arg = 0;
- break;
- }
-
conv_arg = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
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)
+ mono_mb_emit_byte (mb, CEE_LDIND_I);
pos2 = mono_mb_emit_branch (mb, CEE_BRFALSE);
mono_mb_emit_ldstr (mb, g_strdup (spec->data.custom_data.cookie));
mono_mb_emit_op (mb, CEE_CALL, get_instance);
mono_mb_emit_ldarg (mb, argnum);
+ if (t->byref)
+ mono_mb_emit_byte (mb, CEE_LDIND_I);
mono_mb_emit_op (mb, CEE_CALLVIRT, marshal_native_to_managed);
mono_mb_emit_stloc (mb, conv_arg);
break;
case MARSHAL_ACTION_MANAGED_CONV_OUT:
- g_assert (!t->byref);
/* Check for null */
mono_mb_emit_ldloc (mb, conv_arg);
pos2 = mono_mb_emit_branch (mb, CEE_BRFALSE);
+ if (t->byref) {
+ mono_mb_emit_ldarg (mb, argnum);
+
+ mono_mb_emit_ldstr (mb, g_strdup (spec->data.custom_data.cookie));
+
+ mono_mb_emit_op (mb, CEE_CALL, get_instance);
+
+ mono_mb_emit_ldloc (mb, conv_arg);
+ mono_mb_emit_op (mb, CEE_CALLVIRT, marshal_managed_to_native);
+ mono_mb_emit_byte (mb, CEE_STIND_I);
+ }
+
/* Call CleanUpManagedData */
mono_mb_emit_ldstr (mb, g_strdup (spec->data.custom_data.cookie));
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;
}
return conv_arg;
}
+static int
+emit_marshal_handleref (EmitMarshalContext *m, int argnum, MonoType *t,
+ MonoMarshalSpec *spec, int conv_arg,
+ MonoType **conv_arg_type, MarshalAction action)
+{
+ MonoMethodBuilder *mb = m->mb;
+
+ switch (action){
+ case MARSHAL_ACTION_CONV_IN: {
+ MonoType *intptr_type;
+
+ intptr_type = &mono_defaults.int_class->byval_arg;
+ conv_arg = mono_mb_add_local (mb, intptr_type);
+ *conv_arg_type = intptr_type;
+
+ if (t->byref){
+ mono_mb_emit_exception_marshal_directive (mb,
+ "HandleRefs can not be returned from unmanaged code (or passed by ref)");
+ break;
+ }
+ 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;
+ }
+
+ case MARSHAL_ACTION_PUSH:
+ mono_mb_emit_ldloc (mb, conv_arg);
+ break;
+
+ case MARSHAL_ACTION_CONV_OUT: {
+ /* no resource release required */
+ break;
+ }
+
+ case MARSHAL_ACTION_CONV_RESULT: {
+ mono_mb_emit_exception_marshal_directive (mb,
+ "HandleRefs can not be returned from unmanaged code (or passed by ref)");
+ break;
+ }
+
+ case MARSHAL_ACTION_MANAGED_CONV_IN:
+ fprintf (stderr, "mono/marshal: SafeHandles missing MANAGED_CONV_IN\n");
+ break;
+
+ case MARSHAL_ACTION_MANAGED_CONV_OUT:
+ fprintf (stderr, "mono/marshal: SafeHandles missing MANAGED_CONV_OUT\n");
+ break;
+
+ case MARSHAL_ACTION_MANAGED_CONV_RESULT:
+ fprintf (stderr, "mono/marshal: SafeHandles missing MANAGED_CONV_RESULT\n");
+ break;
+ default:
+ fprintf (stderr, "Unhandled case for MarshalAction: %d\n", action);
+ }
+
+ return conv_arg;
+}
+
static int
emit_marshal_object (EmitMarshalContext *m, int argnum, MonoType *t,
MonoMarshalSpec *spec,
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 */
{
MonoMethodBuilder *mb = m->mb;
MonoClass *klass = t->data.klass;
+ static MonoMethod* get_object_for_iunknown = NULL;
+ 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_iunknown_for_object_internal = mono_class_get_method_from_name (mono_defaults.marshal_class, "GetIUnknownForObjectInternal", 1);
+ if (!get_idispatch_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 ();
switch (action) {
case MARSHAL_ACTION_CONV_IN: {
+ guint32 pos_null = 0;
+
*conv_arg_type = &mono_defaults.int_class->byval_arg;
conv_arg = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
- m->orig_conv_args [argnum] = 0;
+ mono_mb_emit_ptr (mb, NULL);
+ mono_mb_emit_stloc (mb, conv_arg);
- mono_mb_emit_ptr (mb, 0);
- mono_mb_emit_stloc (mb, conv_arg);
+ /* we dont need any conversions for out parameters */
+ if (t->byref && t->attrs & PARAM_ATTRIBUTE_OUT)
+ break;
- if (t->byref) {
- /* we dont need any conversions for out parameters */
- if (t->attrs & PARAM_ATTRIBUTE_OUT)
- break;
- else {
- char *msg = g_strdup_printf ("non out object references are no implemented");
- MonoException *exc = mono_get_exception_not_implemented (msg);
- g_warning (msg);
- g_free (msg);
- mono_raise_exception (exc);
+ mono_mb_emit_ldarg (mb, argnum);
+ if (t->byref)
+ mono_mb_emit_byte (mb, CEE_LDIND_REF);
+ /* if null just break, conv arg was already inited to 0 */
+ pos_null = mono_mb_emit_short_branch (mb, CEE_BRFALSE_S);
- }
- } else {
- char *msg = NULL;
- guint32 pos_failed = 0, pos_rcw = 0;
- mono_mb_emit_ldarg (mb, argnum);
- // if null just break, conv arg was already inited to 0
- pos_failed = mono_mb_emit_short_branch (mb, CEE_BRFALSE_S);
+ mono_mb_emit_ldarg (mb, argnum);
+ if (t->byref)
+ mono_mb_emit_byte (mb, CEE_LDIND_REF);
- mono_mb_emit_ldarg (mb, argnum);
- mono_mb_emit_icall (mb, cominterop_object_is_rcw);
- pos_rcw = mono_mb_emit_short_branch (mb, CEE_BRFALSE_S);
+ 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, conv_arg);
+ mono_mb_patch_short_branch (mb, pos_null);
+ break;
+ }
+
+ case MARSHAL_ACTION_CONV_OUT: {
+ if (t->byref && (t->attrs & PARAM_ATTRIBUTE_OUT)) {
+ int ccw_obj;
+ guint32 pos_null = 0, pos_ccw = 0, pos_end = 0;
+ ccw_obj = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
mono_mb_emit_ldarg (mb, argnum);
- mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoTransparentProxy, rp));
- mono_mb_emit_byte (mb, CEE_LDIND_REF);
+ mono_mb_emit_byte (mb, CEE_LDNULL);
+ mono_mb_emit_byte (mb, CEE_STIND_REF);
- /* load the RCW from the ComInteropProxy*/
- mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoComInteropProxy, com_object));
- mono_mb_emit_byte (mb, CEE_LDIND_REF);
+ mono_mb_emit_ldloc (mb, conv_arg);
+ pos_null = mono_mb_emit_short_branch (mb, CEE_BRFALSE_S);
- if (klass && klass != mono_defaults.object_class) {
- 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, t);
- mono_mb_emit_icall (mb, type_from_handle);
- mono_mb_emit_managed_call (mb, GetInterface, NULL);
- }
- else if (spec->native == MONO_NATIVE_IUNKNOWN) {
- static MonoProperty* iunknown = NULL;
-
- if (!iunknown)
- iunknown = mono_class_get_property_from_name (mono_defaults.com_object_class, "IUnknown");
- mono_mb_emit_managed_call (mb, iunknown->get, NULL);
- }
- else if (spec->native == MONO_NATIVE_IDISPATCH) {
- static MonoProperty* idispatch = NULL;
-
- if (!idispatch)
- idispatch = mono_class_get_property_from_name (mono_defaults.com_object_class, "IDispatch");
- mono_mb_emit_managed_call (mb, idispatch->get, NULL);
- }
- else {
- }
- mono_mb_emit_stloc (mb, conv_arg);
-
- // if not rcw
- mono_mb_patch_short_branch (mb, pos_rcw);
- msg = g_strdup ("Marshalling of COM Callable Wrappers is not yet implemented.");
- mono_mb_emit_exception_marshal_directive (mb, msg);
-
- // case if null
- mono_mb_patch_short_branch (mb, pos_failed);
- }
- break;
- }
-
- case MARSHAL_ACTION_CONV_OUT: {
- if (t->byref && (t->attrs & PARAM_ATTRIBUTE_OUT)) {
- static MonoClass* com_interop_proxy_class = NULL;
- static MonoMethod* com_interop_proxy_get_proxy = NULL;
- static MonoMethod* get_transparent_proxy = NULL;
- int real_proxy;
- guint32 pos_failed = 0;
+ mono_mb_emit_ldloc (mb, conv_arg);
+ 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_ldarg (mb, argnum);
- mono_mb_emit_byte (mb, CEE_LDNULL);
- mono_mb_emit_byte (mb, CEE_STIND_REF);
-
mono_mb_emit_ldloc (mb, conv_arg);
- pos_failed = mono_mb_emit_short_branch (mb, CEE_BRFALSE_S);
-
- if (!com_interop_proxy_class)
- com_interop_proxy_class = mono_class_from_name (mono_defaults.corlib, "Mono.Interop", "ComInteropProxy");
- if (!com_interop_proxy_get_proxy)
- com_interop_proxy_get_proxy = mono_class_get_method_from_name_flags (com_interop_proxy_class, "GetProxy", 2, METHOD_ATTRIBUTE_PRIVATE);
- if (!get_transparent_proxy)
- get_transparent_proxy = mono_class_get_method_from_name (mono_defaults.real_proxy_class, "GetTransparentProxy", 0);
+ mono_mb_emit_managed_call (mb, get_object_for_iunknown, NULL);
- real_proxy = mono_mb_add_local (mb, &com_interop_proxy_class->byval_arg);
+ if (klass && klass != mono_defaults.object_class)
+ mono_mb_emit_op (mb, CEE_CASTCLASS, klass);
+ mono_mb_emit_byte (mb, CEE_STIND_REF);
- mono_mb_emit_ldloc (mb, conv_arg);
- mono_mb_emit_ptr (mb, &mono_defaults.com_object_class->byval_arg);
- mono_mb_emit_icall (mb, type_from_handle);
- mono_mb_emit_managed_call (mb, com_interop_proxy_get_proxy, NULL);
- mono_mb_emit_stloc (mb, real_proxy);
+ 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_ldarg (mb, argnum);
- mono_mb_emit_ldloc (mb, real_proxy);
- mono_mb_emit_managed_call (mb, get_transparent_proxy, NULL);
+ 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_byte (mb, CEE_STIND_REF);
- // case if null
- mono_mb_patch_short_branch (mb, pos_failed);
+ 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_PUSH:
if (t->byref)
mono_mb_emit_ldloc_addr (mb, conv_arg);
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_IN: {
- char *msg = g_strdup ("Marshalling of COM Objects is not yet implemented.");
- mono_mb_emit_exception_marshal_directive (mb, msg);
+ int ccw_obj;
+ guint32 pos_null = 0, pos_ccw = 0, pos_end = 0;
+ ccw_obj = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
+
+ klass = mono_class_from_mono_type (t);
+ conv_arg = mono_mb_add_local (mb, &klass->byval_arg);
+ *conv_arg_type = &mono_defaults.int_class->byval_arg;
+
+ mono_mb_emit_byte (mb, CEE_LDNULL);
+ mono_mb_emit_stloc (mb, conv_arg);
+ if (t->attrs & PARAM_ATTRIBUTE_OUT)
+ break;
+
+ mono_mb_emit_ldarg (mb, argnum);
+ if (t->byref)
+ mono_mb_emit_byte (mb, CEE_LDIND_REF);
+ pos_null = mono_mb_emit_short_branch (mb, CEE_BRFALSE_S);
+
+ mono_mb_emit_ldarg (mb, argnum);
+ if (t->byref)
+ mono_mb_emit_byte (mb, CEE_LDIND_REF);
+ 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_ldarg (mb, argnum);
+ if (t->byref)
+ mono_mb_emit_byte (mb, CEE_LDIND_REF);
+ 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, conv_arg);
+ 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, conv_arg);
+
+ mono_mb_patch_short_branch (mb, pos_end);
+ /* case if null */
+ mono_mb_patch_short_branch (mb, pos_null);
break;
}
case MARSHAL_ACTION_MANAGED_CONV_OUT: {
- char *msg = g_strdup ("Marshalling of COM Objects is not yet implemented.");
- mono_mb_emit_exception_marshal_directive (mb, msg);
+ if (t->byref && t->attrs & PARAM_ATTRIBUTE_OUT) {
+ guint32 pos_null = 0;
+
+ if (!AddRef)
+ AddRef = mono_class_get_method_from_name (mono_defaults.marshal_class, "AddRef", 1);
+
+ mono_mb_emit_ldloc (mb, conv_arg);
+ /* 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_ldarg (mb, argnum);
+ mono_mb_emit_ldloc (mb, conv_arg);
+ 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_byte (mb, CEE_STIND_I);
+
+ mono_mb_emit_ldarg (mb, argnum);
+ mono_mb_emit_byte (mb, CEE_LDIND_I);
+ mono_mb_emit_managed_call (mb, AddRef, NULL);
+ mono_mb_emit_byte (mb, CEE_POP);
+
+ mono_mb_patch_short_branch (mb, pos_null);
+ }
break;
}
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;
}
MarshalAction action)
{
MonoMethodBuilder *mb = m->mb;
+ static MonoMethod *get_object_for_native_variant = NULL;
+ static MonoMethod *get_native_variant_for_object = NULL;
- switch (action) {
- case MARSHAL_ACTION_CONV_IN: {
- static MonoMethod *get_native_variant_for_object = NULL;
+ mono_init_com_types ();
+
+ if (!get_object_for_native_variant)
+ get_object_for_native_variant = mono_class_get_method_from_name (mono_defaults.marshal_class, "GetObjectForNativeVariant", 1);
+ g_assert (get_object_for_native_variant);
- if (!get_native_variant_for_object)
- get_native_variant_for_object = mono_class_get_method_from_name (mono_defaults.marshal_class, "GetNativeVariantForObject", 2);
- g_assert (get_native_variant_for_object);
+ if (!get_native_variant_for_object)
+ get_native_variant_for_object = mono_class_get_method_from_name (mono_defaults.marshal_class, "GetNativeVariantForObject", 2);
+ g_assert (get_native_variant_for_object);
- *conv_arg_type = &mono_defaults.variant_class->byval_arg;
+ switch (action) {
+ case MARSHAL_ACTION_CONV_IN: {
conv_arg = mono_mb_add_local (mb, &mono_defaults.variant_class->byval_arg);
+
+ if (t->byref)
+ *conv_arg_type = &mono_defaults.variant_class->this_arg;
+ else
+ *conv_arg_type = &mono_defaults.variant_class->byval_arg;
+
+ if (t->byref && t->attrs & PARAM_ATTRIBUTE_OUT)
+ break;
mono_mb_emit_ldarg (mb, argnum);
if (t->byref)
case MARSHAL_ACTION_CONV_OUT: {
static MonoMethod *variant_clear = NULL;
- static MonoMethod *get_object_for_native_variant = NULL;
if (!variant_clear)
variant_clear = mono_class_get_method_from_name (mono_defaults.variant_class, "Clear", 0);
g_assert (variant_clear);
- if (!get_object_for_native_variant)
- get_object_for_native_variant = mono_class_get_method_from_name (mono_defaults.marshal_class, "GetObjectForNativeVariant", 1);
- g_assert (get_object_for_native_variant);
if (t->byref) {
mono_mb_emit_ldarg (mb, argnum);
break;
case MARSHAL_ACTION_CONV_RESULT: {
- char *msg = g_strdup ("Marshalling of VARIANT not supported.");
+ char *msg = g_strdup ("Marshalling of VARIANT not supported as a return type.");
mono_mb_emit_exception_marshal_directive (mb, msg);
break;
}
case MARSHAL_ACTION_MANAGED_CONV_IN: {
- char *msg = g_strdup ("Marshalling of VARIANT not supported.");
- mono_mb_emit_exception_marshal_directive (mb, msg);
+ conv_arg = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
+
+ if (t->byref)
+ *conv_arg_type = &mono_defaults.variant_class->this_arg;
+ else
+ *conv_arg_type = &mono_defaults.variant_class->byval_arg;
+
+ if (t->byref && t->attrs & PARAM_ATTRIBUTE_OUT)
+ break;
+
+ if (t->byref)
+ mono_mb_emit_ldarg (mb, argnum);
+ else
+ mono_mb_emit_ldarg_addr (mb, argnum);
+ mono_mb_emit_managed_call (mb, get_object_for_native_variant, NULL);
+ mono_mb_emit_stloc (mb, conv_arg);
break;
}
case MARSHAL_ACTION_MANAGED_CONV_OUT: {
- char *msg = g_strdup ("Marshalling of VARIANT not supported.");
- mono_mb_emit_exception_marshal_directive (mb, msg);
+ if (t->byref) {
+ mono_mb_emit_ldloc (mb, conv_arg);
+ mono_mb_emit_ldarg (mb, argnum);
+ mono_mb_emit_managed_call (mb, get_native_variant_for_object, NULL);
+ }
break;
}
case MARSHAL_ACTION_MANAGED_CONV_RESULT: {
- char *msg = g_strdup ("Marshalling of VARIANT not supported.");
+ char *msg = g_strdup ("Marshalling of VARIANT not supported as a return type.");
mono_mb_emit_exception_marshal_directive (mb, msg);
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);
static int
emit_marshal_boolean (EmitMarshalContext *m, int argnum, MonoType *t,
- MonoMarshalSpec *spec,
- int conv_arg, MonoType **conv_arg_type,
- MarshalAction action)
+ MonoMarshalSpec *spec,
+ int conv_arg, MonoType **conv_arg_type,
+ MarshalAction action)
{
MonoMethodBuilder *mb = m->mb;
} 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:
static int
emit_marshal_ptr (EmitMarshalContext *m, int argnum, MonoType *t,
- MonoMarshalSpec *spec, int conv_arg,
- MonoType **conv_arg_type, MarshalAction action)
+ MonoMarshalSpec *spec, int conv_arg,
+ MonoType **conv_arg_type, MarshalAction action)
{
MonoMethodBuilder *mb = m->mb;
static int
emit_marshal_char (EmitMarshalContext *m, int argnum, MonoType *t,
- MonoMarshalSpec *spec, int conv_arg,
- MonoType **conv_arg_type, MarshalAction action)
+ MonoMarshalSpec *spec, int conv_arg,
+ MonoType **conv_arg_type, MarshalAction action)
{
MonoMethodBuilder *mb = m->mb;
static int
emit_marshal_scalar (EmitMarshalContext *m, int argnum, MonoType *t,
- MonoMarshalSpec *spec, int conv_arg,
- MonoType **conv_arg_type, MarshalAction action)
+ MonoMarshalSpec *spec, int conv_arg,
+ MonoType **conv_arg_type, MarshalAction action)
{
MonoMethodBuilder *mb = m->mb;
static int
emit_marshal (EmitMarshalContext *m, int argnum, MonoType *t,
- MonoMarshalSpec *spec, int conv_arg,
- MonoType **conv_arg_type, MarshalAction action)
+ MonoMarshalSpec *spec, int conv_arg,
+ MonoType **conv_arg_type, MarshalAction action)
{
/* Ensure that we have marshalling info for this param */
mono_marshal_load_type_info (mono_class_from_mono_type (t));
switch (t->type) {
case MONO_TYPE_VALUETYPE:
+ if (t->data.klass == mono_defaults.handleref_class)
+ return emit_marshal_handleref (m, argnum, t, spec, conv_arg, conv_arg_type, action);
+
return emit_marshal_vtype (m, argnum, t, spec, conv_arg, conv_arg_type, action);
case MONO_TYPE_STRING:
return emit_marshal_string (m, argnum, t, spec, conv_arg, conv_arg_type, action);
/**
* 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);
switch (t->type) {
case MONO_TYPE_CLASS:
case MONO_TYPE_VALUETYPE:
+ case MONO_TYPE_OBJECT:
emit_marshal (m, i, t, mspecs [i + 1], tmp_locals [i], NULL, MARSHAL_ACTION_MANAGED_CONV_OUT);
break;
}
/* 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);
mono_mb_emit_exception (mb, "IndexOutOfRangeException", NULL);
g_free (branch_positions);
- mono_loader_lock ();
ret = mono_mb_create_method (mb, sig, 4);
- mono_loader_unlock ();
mono_mb_free (mb);
/* cache the result */
}
void *
-mono_marshal_realloc (gpointer ptr, gpointer size)
+mono_marshal_string_to_utf16 (MonoString *s)
{
- MONO_ARCH_SAVE_REGS;
-
- return g_try_realloc (ptr, (gulong)size);
+ return s ? mono_string_chars (s) : NULL;
}
-void *
-mono_marshal_string_to_utf16 (MonoString *s)
+static void *
+mono_marshal_string_to_utf16_copy (MonoString *s)
{
- return s ? mono_string_chars (s) : NULL;
+ 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;
+ }
}
/**
return mono_string_to_bstr(ptr);
}
-// STDCALL on windows, CDECL everywhere else to work with XPCOM and MainWin COM
-#ifdef PLATFORM_WIN32
-#ifdef _MSC_VER
-#define STDCALL __stdcall
-#else
-#define STDCALL __attribute__((stdcall))
-#endif
-#else
-#define STDCALL
-#endif
-
typedef struct
{
int (STDCALL *QueryInterface)(gpointer pUnk, gpointer riid, gpointer* ppv);
}
int
-ves_icall_System_Runtime_InteropServices_Marshal_AddRef (gpointer pUnk)
+ves_icall_System_Runtime_InteropServices_Marshal_AddRefInternal (gpointer pUnk)
{
- MONO_ARCH_SAVE_REGS;
-
+ g_assert (pUnk);
return (*(MonoIUnknown**)pUnk)->AddRef(pUnk);
}
int
-ves_icall_System_Runtime_InteropServices_Marshal_QueryInterface (gpointer pUnk, gpointer riid, gpointer* ppv)
+ves_icall_System_Runtime_InteropServices_Marshal_QueryInterfaceInternal (gpointer pUnk, gpointer riid, gpointer* ppv)
{
- MONO_ARCH_SAVE_REGS;
-
+ g_assert (pUnk);
return (*(MonoIUnknown**)pUnk)->QueryInterface(pUnk, riid, ppv);
}
int
-ves_icall_System_Runtime_InteropServices_Marshal_Release (gpointer pUnk)
+ves_icall_System_Runtime_InteropServices_Marshal_ReleaseInternal (gpointer pUnk)
{
- MONO_ARCH_SAVE_REGS;
-
+ g_assert (pUnk);
return (*(MonoIUnknown**)pUnk)->Release(pUnk);
}
+static void*
+cominterop_get_idispatch_for_object (MonoObject* object)
+{
+ if (!object)
+ return NULL;
+
+ if (cominterop_object_is_rcw (object)) {
+ 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);
+ }
+}
+
+void*
+ves_icall_System_Runtime_InteropServices_Marshal_GetIUnknownForObjectInternal (MonoObject* object)
+{
+ if (!object)
+ return NULL;
+
+ if (cominterop_object_is_rcw (object)) {
+ MonoClass *klass = NULL;
+ MonoRealProxy* real_proxy = NULL;
+ if (!object)
+ return NULL;
+ klass = mono_object_class (object);
+ if (klass != mono_defaults.transparent_proxy_class) {
+ g_assert_not_reached ();
+ return NULL;
+ }
+
+ real_proxy = ((MonoTransparentProxy*)object)->rp;
+ if (!real_proxy) {
+ g_assert_not_reached ();
+ return NULL;
+ }
+
+ klass = mono_object_class (real_proxy);
+ if (klass != mono_defaults.com_interop_proxy_class) {
+ g_assert_not_reached ();
+ return NULL;
+ }
+
+ if (!((MonoComInteropProxy*)real_proxy)->com_object) {
+ g_assert_not_reached ();
+ return NULL;
+ }
+
+ return ((MonoComInteropProxy*)real_proxy)->com_object->iunknown;
+ }
+ else {
+ return cominterop_get_ccw (object, mono_defaults.iunknown_class);
+ }
+}
+
+MonoObject*
+ves_icall_System_Runtime_InteropServices_Marshal_GetObjectForCCW (void* pUnk)
+{
+ MonoObject* object = NULL;
+
+ if (!pUnk)
+ return NULL;
+
+ /* see if it is a CCW */
+ object = cominterop_get_ccw_object ((MonoCCWInterface*)pUnk, TRUE);
+
+ return object;
+}
+
+void*
+ves_icall_System_Runtime_InteropServices_Marshal_GetIDispatchForObjectInternal (MonoObject* object)
+{
+ return cominterop_get_idispatch_for_object (object);
+}
+
+void*
+ves_icall_System_Runtime_InteropServices_Marshal_GetCCW (MonoObject* object, MonoReflectionType* type)
+{
+ MonoClass* klass = NULL;
+ void* itf = NULL;
+ g_assert (type);
+ g_assert (type->type);
+ klass = mono_type_get_class (type->type);
+ g_assert (klass);
+ itf = cominterop_get_ccw (object, klass);
+ g_assert (itf);
+ return itf;
+}
+
+
+MonoBoolean
+ves_icall_System_Runtime_InteropServices_Marshal_IsComObject (MonoObject* object)
+{
+ return (MonoBoolean)cominterop_object_is_rcw (object);
+}
+
+gint32
+ves_icall_System_Runtime_InteropServices_Marshal_ReleaseComObjectInternal (MonoObject* object)
+{
+ MonoComInteropProxy* proxy = NULL;
+ gint32 ref_count = 0;
+
+ g_assert (object);
+ g_assert (cominterop_object_is_rcw (object));
+
+ proxy = (MonoComInteropProxy*)((MonoTransparentProxy*)object)->rp;
+ g_assert (proxy);
+
+ ref_count = InterlockedDecrement (&proxy->ref_count);
+ g_assert (ref_count >= 0);
+
+ if (ref_count == 0)
+ ves_icall_System_ComObject_ReleaseInterfaces (proxy->com_object);
+
+ return ref_count;
+}
+
guint32
ves_icall_System_Runtime_InteropServices_Marshal_GetComSlotForMethodInfoInternal (MonoReflectionMethod *m)
{
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:
return res;
}
-void
-ves_icall_System_Runtime_InteropServices_Marshal_FreeHGlobal (void *ptr)
+gpointer
+ves_icall_System_Runtime_InteropServices_Marshal_ReAllocHGlobal (gpointer ptr, int size)
{
- MONO_ARCH_SAVE_REGS;
+ gpointer res;
+
+ if (ptr == NULL) {
+ mono_gc_out_of_memory ((gulong)size);
+ return NULL;
+ }
#ifdef PLATFORM_WIN32
- GlobalFree (ptr);
+ res = GlobalReAlloc (ptr, (gulong)size, GMEM_MOVEABLE);
+#else
+ res = g_try_realloc (ptr, (gulong)size);
+#endif
+ if (!res)
+ mono_gc_out_of_memory ((gulong)size);
+
+ return res;
+}
+
+void
+ves_icall_System_Runtime_InteropServices_Marshal_FreeHGlobal (void *ptr)
+{
+ MONO_ARCH_SAVE_REGS;
+
+#ifdef PLATFORM_WIN32
+ GlobalFree (ptr);
#else
g_free (ptr);
#endif
#endif
}
+gpointer
+ves_icall_System_Runtime_InteropServices_Marshal_ReAllocCoTaskMem (gpointer ptr, int size)
+{
+ MONO_ARCH_SAVE_REGS;
+
+#ifdef PLATFORM_WIN32
+ return CoTaskMemRealloc (ptr, size);
+#else
+ return g_try_realloc (ptr, (gulong)size);
+#endif
+}
+
void*
ves_icall_System_Runtime_InteropServices_Marshal_UnsafeAddrOfPinnedArrayElement (MonoArray *arrayobj, int index)
{
static gboolean
cominterop_finalizer (gpointer key, gpointer value, gpointer user_data)
{
- ves_icall_System_Runtime_InteropServices_Marshal_Release (value);
+ ves_icall_System_Runtime_InteropServices_Marshal_ReleaseInternal (value);
return TRUE;
}
void
-ves_icall_System_ComObject_Finalizer(MonoComObject* obj)
+ves_icall_System_ComObject_ReleaseInterfaces (MonoComObject* obj)
{
g_assert(obj);
- if (obj->itf_hash)
+ if (obj->itf_hash) {
+ guint32 gchandle = 0;
+ mono_cominterop_lock ();
+ gchandle = GPOINTER_TO_UINT (g_hash_table_lookup (rcw_hash, obj->iunknown));
+ if (gchandle) {
+ mono_gchandle_free (gchandle);
+ g_hash_table_remove (rcw_hash, obj->iunknown);
+ }
+
g_hash_table_foreach_remove (obj->itf_hash, cominterop_finalizer, NULL);
- obj->itf_hash = NULL;
+ ves_icall_System_Runtime_InteropServices_Marshal_ReleaseInternal (obj->iunknown);
+ obj->itf_hash = obj->iunknown = NULL;
+ mono_cominterop_unlock ();
+ }
}
-#define MONO_IUNKNOWN_INTERFACE_SLOT 0
-
gpointer
-ves_icall_System_ComObject_FindInterface (MonoComObject* obj, MonoReflectionType* type)
+ves_icall_System_ComObject_GetInterfaceInternal (MonoComObject* obj, MonoReflectionType* type, MonoBoolean throw_exception)
{
- MonoClass* klass;
- g_assert(obj);
- g_assert(obj->itf_hash);
-
- klass = mono_class_from_mono_type (type->type);
-
- return g_hash_table_lookup (obj->itf_hash, GUINT_TO_POINTER ((guint)klass->interface_id));
+ return cominterop_get_interface (obj, mono_type_get_class (type->type), (gboolean)throw_exception);
}
void
-ves_icall_System_ComObject_CacheInterface (MonoComObject* obj, MonoReflectionType* type, gpointer pItf)
+ves_icall_Mono_Interop_ComInteropProxy_AddProxy (gpointer pUnk, MonoComInteropProxy* proxy)
{
- MonoClass* klass;
- g_assert(obj);
- g_assert(obj->itf_hash);
+ guint32 gchandle = 0;
+ if (!rcw_hash) {
+ mono_cominterop_lock ();
+ rcw_hash = g_hash_table_new (mono_aligned_addr_hash, NULL);
+ mono_cominterop_unlock ();
+ }
- klass = mono_class_from_mono_type (type->type);
+ gchandle = mono_gchandle_new_weakref ((MonoObject*)proxy, FALSE);
- g_hash_table_insert (obj->itf_hash, GUINT_TO_POINTER ((guint)klass->interface_id), pItf);
+ mono_cominterop_lock ();
+ g_hash_table_insert (rcw_hash, pUnk, GUINT_TO_POINTER (gchandle));
+ mono_cominterop_unlock ();
}
-gpointer
-ves_icall_System_ComObject_GetIUnknown (MonoComObject* obj)
+MonoComInteropProxy*
+ves_icall_Mono_Interop_ComInteropProxy_FindProxy (gpointer pUnk)
{
- g_assert(obj);
- if (!obj->itf_hash)
- return NULL;
- return g_hash_table_lookup (obj->itf_hash, MONO_IUNKNOWN_INTERFACE_SLOT);
-}
+ MonoComInteropProxy* proxy = NULL;
+ guint32 gchandle = 0;
-void
-ves_icall_System_ComObject_SetIUnknown (MonoComObject* obj, gpointer pUnk)
-{
- g_assert(obj);
- g_assert(!obj->itf_hash);
- obj->itf_hash = g_hash_table_new (mono_aligned_addr_hash, NULL);
- g_hash_table_insert (obj->itf_hash, MONO_IUNKNOWN_INTERFACE_SLOT, pUnk);
+ mono_cominterop_lock ();
+ if (rcw_hash)
+ gchandle = GPOINTER_TO_UINT (g_hash_table_lookup (rcw_hash, pUnk));
+ mono_cominterop_unlock ();
+ if (gchandle) {
+ proxy = (MonoComInteropProxy*)mono_gchandle_get_target (gchandle);
+ /* proxy is null means we need to free up old RCW */
+ if (!proxy) {
+ mono_gchandle_free (gchandle);
+ g_hash_table_remove (rcw_hash, pUnk);
+ }
+ }
+ return proxy;
}
/**
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 */
+
+/**
+ * cominterop_get_ccw_object:
+ * @ccw_entry: a pointer to the CCWEntry
+ * @verify: verify ccw_entry is in fact a ccw
+ *
+ * Returns: the corresponding object for the CCW
+ */
+static MonoObject*
+cominterop_get_ccw_object (MonoCCWInterface* ccw_entry, gboolean verify)
+{
+ MonoCCW *ccw = NULL;
+
+ /* no CCW's exist yet */
+ if (!ccw_interface_hash)
+ return NULL;
+
+ if (verify) {
+ ccw = g_hash_table_lookup (ccw_interface_hash, ccw_entry);
+ }
+ else {
+ ccw = ccw_entry->ccw;
+ g_assert (ccw);
+ }
+ if (ccw)
+ return mono_gchandle_get_target (ccw->gc_handle);
+ else
+ return NULL;
+}
+
+static void
+cominterop_setup_marshal_context (EmitMarshalContext *m, MonoMethod *method)
+{
+ MonoMethodSignature *sig, *csig;
+ sig = mono_method_signature (method);
+ /* we copy the signature, so that we can modify it */
+ /* 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;
+
+ m->image = method->klass->image;
+ m->piinfo = NULL;
+ m->retobj_var = 0;
+ m->sig = sig;
+ m->csig = csig;
+}
+
+/**
+ * cominterop_get_ccw:
+ * @object: a pointer to the object
+ * @itf: interface type needed
+ *
+ * Returns: a value indicating if the object is a
+ * Runtime Callable Wrapper (RCW) for a COM object
+ */
+static gpointer
+cominterop_get_ccw (MonoObject* object, MonoClass* itf)
+{
+ int i;
+ MonoCCW *ccw = NULL;
+ MonoCCWInterface* ccw_entry = NULL;
+ gpointer *vtable = NULL;
+ static gpointer iunknown[3] = {NULL, NULL, NULL};
+ static gpointer idispatch[4] = {NULL, NULL, NULL, NULL};
+ MonoClass* iface = NULL;
+ MonoClass* klass = NULL;
+ EmitMarshalContext m;
+ int start_slot = 3;
+ int method_count = 0;
+ GList *ccw_list, *ccw_list_item;
+ MonoCustomAttrInfo *cinfo = NULL;
+
+ if (!object)
+ return NULL;
+
+ klass = mono_object_get_class (object);
+
+ if (!ccw_hash)
+ ccw_hash = g_hash_table_new (mono_aligned_addr_hash, NULL);
+ if (!ccw_interface_hash)
+ ccw_interface_hash = g_hash_table_new (mono_aligned_addr_hash, NULL);
+
+ ccw_list = g_hash_table_lookup (ccw_hash, GINT_TO_POINTER (mono_object_hash (object)));
+
+ ccw_list_item = ccw_list;
+ while (ccw_list_item) {
+ MonoCCW* ccw_iter = ccw_list_item->data;
+ if (mono_gchandle_get_target (ccw_iter->gc_handle) == object) {
+ ccw = ccw_iter;
+ break;
+ }
+ ccw_list_item = g_list_next(ccw_list_item);
+ }
+
+ if (!iunknown [0]) {
+ iunknown [0] = cominterop_ccw_queryinterface;
+ iunknown [1] = cominterop_ccw_addref;
+ iunknown [2] = cominterop_ccw_release;
+ }
+
+ if (!idispatch [0]) {
+ idispatch [0] = cominterop_ccw_get_type_info_count;
+ idispatch [1] = cominterop_ccw_get_type_info;
+ idispatch [2] = cominterop_ccw_get_ids_of_names;
+ idispatch [3] = cominterop_ccw_invoke;
+ }
+
+ if (!ccw) {
+ ccw = g_new0 (MonoCCW, 1);
+ ccw->vtable_hash = g_hash_table_new (mono_aligned_addr_hash, NULL);
+ ccw->ref_count = 0;
+ /* just alloc a weak handle until we are addref'd*/
+ ccw->gc_handle = mono_gchandle_new_weakref (object, FALSE);
+
+ if (!ccw_list) {
+ ccw_list = g_list_alloc ();
+ ccw_list->data = ccw;
+ }
+ else
+ 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;
+ }
+ else if (iface == mono_defaults.idispatch_class) {
+ start_slot = 7;
+ }
+ else {
+ 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);
+
+ if (!ccw_entry) {
+ int vtable_index = method_count-1+start_slot;
+ mono_loader_lock ();
+ vtable = mono_mempool_alloc0 (klass->image->mempool, sizeof (gpointer)*(method_count+start_slot));
+ mono_loader_unlock ();
+ memcpy (vtable, iunknown, sizeof (iunknown));
+ if (start_slot == 7)
+ memcpy (vtable+3, idispatch, sizeof (idispatch));
+
+ iface = itf;
+ 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);
+
+
+ /* move managed args up one */
+ for (param_index = sig->param_count; param_index >= 1; param_index--)
+ mspecs [param_index+1] = mspecs [param_index];
+
+ /* 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 ();
+
+ /* skip visiblity since we call internal methods */
+ wrapper_method->skip_visibility = TRUE;
+
+ 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);
+ }
+
+ ccw_entry = g_new0 (MonoCCWInterface, 1);
+ ccw_entry->ccw = ccw;
+ ccw_entry->vtable = vtable;
+ g_hash_table_insert (ccw->vtable_hash, itf, ccw_entry);
+ g_hash_table_insert (ccw_interface_hash, ccw_entry, ccw);
+ }
+
+ return ccw_entry;
+}
+
+static gboolean
+mono_marshal_free_ccw_entry (gpointer key, gpointer value, gpointer user_data)
+{
+ g_assert (value);
+ g_free (value);
+ return TRUE;
+}
+
+/**
+ * mono_marshal_free_ccw:
+ * @object: the mono object
+ *
+ * Returns: whether the object had a CCW
+ */
+gboolean
+mono_marshal_free_ccw (MonoObject* object)
+{
+ GList *ccw_list, *ccw_list_orig, *ccw_list_item;
+ /* no ccw's were created */
+ if (!ccw_hash || g_hash_table_size (ccw_hash) == 0)
+ return FALSE;
+
+ /* need to cache orig list address to remove from hash_table if empty */
+ mono_cominterop_lock ();
+ ccw_list = ccw_list_orig = g_hash_table_lookup (ccw_hash, GINT_TO_POINTER (mono_object_hash (object)));
+ mono_cominterop_unlock ();
+
+ if (!ccw_list)
+ return FALSE;
+
+ ccw_list_item = ccw_list;
+ while (ccw_list_item) {
+ MonoCCW* ccw_iter = ccw_list_item->data;
+ MonoObject* handle_target = mono_gchandle_get_target (ccw_iter->gc_handle);
+
+ /* Looks like the GC NULLs the weakref handle target before running the
+ * finalizer. So if we get a NULL target, destroy the CCW as well. */
+ if (!handle_target || handle_target == object) {
+ /* remove all interfaces */
+ g_hash_table_foreach_remove (ccw_iter->vtable_hash, mono_marshal_free_ccw_entry, NULL);
+ g_hash_table_destroy (ccw_iter->vtable_hash);
+
+ /* get next before we delete */
+ ccw_list_item = g_list_next(ccw_list_item);
+
+ /* remove ccw from list */
+ ccw_list = g_list_remove (ccw_list, ccw_iter);
+ g_free (ccw_iter);
+ }
+ else
+ ccw_list_item = g_list_next(ccw_list_item);
+ }
+
+ /* if list is empty remove original address from hash */
+ if (g_list_length (ccw_list) == 0)
+ g_hash_table_remove (ccw_hash, GINT_TO_POINTER (mono_object_hash (object)));
+
+
+ return TRUE;
+}
+
+/**
+ * cominterop_get_native_wrapper_adjusted:
+ * @method: managed COM Interop method
+ *
+ * Returns: the generated method to call with signature matching
+ * the unmanaged COM Method signature
+ */
+static MonoMethod *
+cominterop_get_managed_wrapper_adjusted (MonoMethod *method)
+{
+ static MonoMethod *get_hr_for_exception = NULL;
+ MonoMethod *res = NULL;
+ MonoMethodBuilder *mb;
+ MonoMarshalSpec **mspecs;
+ MonoMethodSignature *sig, *sig_native;
+ MonoExceptionClause *main_clause = NULL;
+ MonoMethodHeader *header;
+ int pos_leave;
+ 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);
+
+ sig = mono_method_signature (method);
+
+ /* create unmanaged wrapper */
+ mb = mono_mb_new (method->klass, method->name, MONO_WRAPPER_COMINTEROP);
+
+ sig_native = cominterop_method_signature (method);
+
+ mspecs = g_new0 (MonoMarshalSpec*, sig_native->param_count+1);
+
+ mono_method_get_marshal_info (method, mspecs);
+
+ /* move managed args up one */
+ for (i = sig->param_count; i >= 1; i--)
+ mspecs [i+1] = mspecs [i];
+
+ /* 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_native->param_count] = mspecs [0];
+
+ mspecs [0] = NULL;
+
+ if (!preserve_sig) {
+ hr = mono_mb_add_local (mb, &mono_defaults.int32_class->byval_arg);
+
+ /* try */
+ main_clause = g_new0 (MonoExceptionClause, 1);
+ main_clause->try_offset = mono_mb_get_label (mb);
+ }
+
+ /* 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_ldarg (mb, 0);
+ mono_mb_emit_icon (mb, FALSE);
+ mono_mb_emit_icall (mb, cominterop_get_ccw_object);
+
+ for (i = 0; i < sig->param_count; i++)
+ mono_mb_emit_ldarg (mb, i+1);
+
+ mono_mb_emit_managed_call (mb, method, NULL);
+
+ 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);
+
+ /* 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_branch (mb, pos_leave);
+
+ mono_mb_emit_ldloc (mb, hr);
+ }
+
+ mono_mb_emit_byte (mb, CEE_RET);
+
+ mono_loader_lock ();
+ mono_marshal_lock ();
+ res = mono_mb_create_method (mb, sig_native, sig_native->param_count + 16);
+ mono_marshal_unlock ();
+ mono_loader_unlock ();
+
mono_mb_free (mb);
+ for (i = sig_native->param_count; i >= 0; i--)
+ if (mspecs [i])
+ mono_metadata_free_marshal_spec (mspecs [i]);
+ g_free (mspecs);
+
+ if (!preserve_sig) {
+ header = ((MonoMethodNormal *)res)->header;
+ header->num_clauses = 1;
+ header->clauses = main_clause;
+ }
+
return res;
}
+
+/**
+ * cominterop_mono_string_to_guid:
+ *
+ * Converts the standard string representation of a GUID
+ * to a 16 byte Microsoft GUID.
+ */
+static void
+cominterop_mono_string_to_guid (const MonoString* string, guint8 *guid) {
+ gunichar2 * chars = mono_string_chars (string);
+ int i = 0;
+ static guint8 indexes[16] = {7, 5, 3, 1, 12, 10, 17, 15, 20, 22, 25, 27, 29, 31, 33, 35};
+
+ 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);
+}
+
+static gboolean
+cominterop_class_guid_equal (guint8* guid, MonoClass* klass)
+{
+ guint8 klass_guid [16];
+ if (cominterop_class_guid (klass, klass_guid))
+ return !memcmp (guid, klass_guid, sizeof (klass_guid));
+ return FALSE;
+}
+
+static int STDCALL
+cominterop_ccw_addref (MonoCCWInterface* ccwe)
+{
+ gint32 ref_count = 0;
+ MonoCCW* ccw = ccwe->ccw;
+ g_assert (ccw);
+ g_assert (ccw->gc_handle);
+ g_assert (ccw->ref_count >= 0);
+ ref_count = InterlockedIncrement ((gint32*)&ccw->ref_count);
+ if (ref_count == 1) {
+ guint32 oldhandle = ccw->gc_handle;
+ g_assert (oldhandle);
+ /* since we now have a ref count, alloc a strong handle*/
+ ccw->gc_handle = mono_gchandle_new (mono_gchandle_get_target (oldhandle), FALSE);
+ mono_gchandle_free (oldhandle);
+ }
+ return ref_count;
+}
+
+static int STDCALL
+cominterop_ccw_release (MonoCCWInterface* ccwe)
+{
+ gint32 ref_count = 0;
+ MonoCCW* ccw = ccwe->ccw;
+ g_assert (ccw);
+ g_assert (ccw->ref_count > 0);
+ ref_count = InterlockedDecrement ((gint32*)&ccw->ref_count);
+ if (ref_count == 0) {
+ /* allow gc of object */
+ guint32 oldhandle = ccw->gc_handle;
+ g_assert (oldhandle);
+ ccw->gc_handle = mono_gchandle_new_weakref (mono_gchandle_get_target (oldhandle), FALSE);
+ mono_gchandle_free (oldhandle);
+ }
+ return ref_count;
+}
+
+#define MONO_S_OK 0x00000000L
+#define MONO_E_NOINTERFACE 0x80004002L
+#define MONO_E_NOTIMPL 0x80004001L
+
+static int STDCALL
+cominterop_ccw_queryinterface (MonoCCWInterface* ccwe, guint8* riid, gpointer* ppv)
+{
+ GPtrArray *ifaces;
+ MonoClass *itf = NULL;
+ int i;
+ MonoCCW* ccw = ccwe->ccw;
+ MonoClass* klass = NULL;
+ MonoObject* object = mono_gchandle_get_target (ccw->gc_handle);
+
+ g_assert (object);
+ klass = mono_object_class (object);
+
+ if (ppv)
+ *ppv = NULL;
+
+ /* handle IUnknown special */
+ if (cominterop_class_guid_equal (riid, mono_defaults.iunknown_class)) {
+ *ppv = cominterop_get_ccw (object, mono_defaults.iunknown_class);
+ /* remember to addref on QI */
+ cominterop_ccw_addref (*ppv);
+ return MONO_S_OK;
+ }
+
+ /* handle IDispatch special */
+ if (cominterop_class_guid_equal (riid, mono_defaults.idispatch_class)) {
+ *ppv = cominterop_get_ccw (object, mono_defaults.idispatch_class);
+ /* remember to addref on QI */
+ cominterop_ccw_addref (*ppv);
+ return MONO_S_OK;
+ }
+
+ ifaces = mono_class_get_implemented_interfaces (klass);
+ if (ifaces) {
+ for (i = 0; i < ifaces->len; ++i) {
+ MonoClass *ic = NULL;
+ ic = g_ptr_array_index (ifaces, i);
+ if (cominterop_class_guid_equal (riid, ic)) {
+ itf = ic;
+ break;
+ }
+ }
+ g_ptr_array_free (ifaces, TRUE);
+ }
+ if (itf) {
+ *ppv = cominterop_get_ccw (object, itf);
+ /* remember to addref on QI */
+ cominterop_ccw_addref (*ppv);
+ return MONO_S_OK;
+ }
+
+ return MONO_E_NOINTERFACE;
+}
+
+static int STDCALL
+cominterop_ccw_get_type_info_count (MonoCCWInterface* ccwe, guint32 *pctinfo)
+{
+ return MONO_E_NOTIMPL;
+}
+
+static int STDCALL
+cominterop_ccw_get_type_info (MonoCCWInterface* ccwe, guint32 iTInfo, guint32 lcid, gpointer *ppTInfo)
+{
+ return MONO_E_NOTIMPL;
+}
+
+static int STDCALL
+cominterop_ccw_get_ids_of_names (MonoCCWInterface* ccwe, gpointer riid,
+ gunichar2** rgszNames, guint32 cNames,
+ guint32 lcid, gint32 *rgDispId)
+{
+ return MONO_E_NOTIMPL;
+}
+
+static int STDCALL
+cominterop_ccw_invoke (MonoCCWInterface* ccwe, guint32 dispIdMember,
+ gpointer riid, guint32 lcid,
+ guint16 wFlags, gpointer pDispParams,
+ gpointer pVarResult, gpointer pExcepInfo,
+ guint32 *puArgErr)
+{
+ return MONO_E_NOTIMPL;
+}
projects / mono.git / blobdiff