?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2008-11-27 Mark Probst <mark.probst@gmail.com>
[mono-project.git] / mono / metadata / marshal.c
blob147c9a22eaae20573c7f351efc8ae5fef0a483b1
1 /*
2 * marshal.c: Routines for marshaling complex types in P/Invoke methods.
3 *
4 * Author:
5 * Paolo Molaro (lupus@ximian.com)
6 *
7 * (C) 2002 Ximian, Inc. http://www.ximian.com
8 *
9 */
10
11 #include "config.h"
12 #include "object.h"
13 #include "loader.h"
14 #include "cil-coff.h"
15 #include "metadata/marshal.h"
16 #include "metadata/method-builder.h"
17 #include "metadata/tabledefs.h"
18 #include "metadata/exception.h"
19 #include "metadata/appdomain.h"
20 #include "mono/metadata/debug-helpers.h"
21 #include "mono/metadata/threadpool.h"
22 #include "mono/metadata/threads.h"
23 #include "mono/metadata/monitor.h"
24 #include "mono/metadata/metadata-internals.h"
25 #include "mono/metadata/domain-internals.h"
26 #include "mono/metadata/gc-internal.h"
27 #include "mono/metadata/threads-types.h"
28 #include "mono/metadata/string-icalls.h"
29 #include "mono/metadata/attrdefs.h"
30 #include "mono/metadata/gc-internal.h"
31 #include "mono/utils/mono-counters.h"
32 #include <string.h>
33 #include <errno.h>
34
35 /* #define DEBUG_RUNTIME_CODE */
36
37 #define OPDEF(a,b,c,d,e,f,g,h,i,j) \
38 a = i,
39
40 typedef enum {
41 MONO_MARSHAL_NONE, /* No marshalling needed */
42 MONO_MARSHAL_COPY, /* Can be copied by value to the new domain */
43 MONO_MARSHAL_COPY_OUT, /* out parameter that needs to be copied back to the original instance */
44 MONO_MARSHAL_SERIALIZE /* Value needs to be serialized into the new domain */
45 } MonoXDomainMarshalType;
46
47 typedef enum {
48 MONO_COM_DEFAULT,
49 MONO_COM_MS
50 } MonoCOMProvider;
51
52 static MonoCOMProvider com_provider = MONO_COM_DEFAULT;
53
54 enum {
55 #include "mono/cil/opcode.def"
56 LAST = 0xff
57 };
58 #undef OPDEF
59
60 struct _MonoRemotingMethods {
61 MonoMethod *invoke;
62 MonoMethod *invoke_with_check;
63 MonoMethod *xdomain_invoke;
64 MonoMethod *xdomain_dispatch;
65 };
66
67 typedef struct _MonoRemotingMethods MonoRemotingMethods;
68
69 /*
70 * This mutex protects the various marshalling related caches in MonoImage
71 * and a few other data structures static to this file.
72 * Note that when this lock is held it is not possible to take other runtime
73 * locks like the loader lock.
74 */
75 #define mono_marshal_lock() EnterCriticalSection (&marshal_mutex)
76 #define mono_marshal_unlock() LeaveCriticalSection (&marshal_mutex)
77 static CRITICAL_SECTION marshal_mutex;
78
79 /* This mutex protects the various cominterop related caches in MonoImage */
80 #define mono_cominterop_lock() EnterCriticalSection (&cominterop_mutex)
81 #define mono_cominterop_unlock() LeaveCriticalSection (&cominterop_mutex)
82 static CRITICAL_SECTION cominterop_mutex;
83
84 static guint32 last_error_tls_id;
85
86 static guint32 load_type_info_tls_id;
87
88 static void
89 delegate_hash_table_add (MonoDelegate *d);
90
91 static void
92 emit_struct_conv (MonoMethodBuilder *mb, MonoClass *klass, gboolean to_object);
93
94 static void
95 mono_struct_delete_old (MonoClass *klass, char *ptr);
96
97 void *
98 mono_marshal_string_to_utf16 (MonoString *s);
99
100 static void *
101 mono_marshal_string_to_utf16_copy (MonoString *s);
102
103 static gpointer
104 mono_string_to_lpstr (MonoString *string_obj);
105
106 static MonoString *
107 mono_string_from_bstr (gpointer bstr);
108
109 static void
110 mono_free_bstr (gpointer bstr);
111
112 static MonoStringBuilder *
113 mono_string_utf8_to_builder2 (char *text);
114
115 static void
116 mono_byvalarray_to_array (MonoArray *arr, gpointer native_arr, MonoClass *eltype, guint32 elnum);
117
118 static void
119 mono_array_to_byvalarray (gpointer native_arr, MonoArray *arr, MonoClass *eltype, guint32 elnum);
120
121 static MonoObject *
122 mono_remoting_wrapper (MonoMethod *method, gpointer *params);
123
124 static MonoAsyncResult *
125 mono_delegate_begin_invoke (MonoDelegate *delegate, gpointer *params);
126
127 static MonoObject *
128 mono_delegate_end_invoke (MonoDelegate *delegate, gpointer *params);
129
130 static MonoObject *
131 mono_marshal_xdomain_copy_value (MonoObject *val);
132
133 static void
134 mono_marshal_xdomain_copy_out_value (MonoObject *src, MonoObject *dst);
135
136 static gint32
137 mono_marshal_set_domain_by_id (gint32 id, MonoBoolean push);
138
139 static gboolean
140 mono_marshal_check_domain_image (gint32 domain_id, MonoImage *image);
141
142 void
143 mono_upgrade_remote_class_wrapper (MonoReflectionType *rtype, MonoTransparentProxy *tproxy);
144
145 static MonoReflectionType *
146 type_from_handle (MonoType *handle);
147
148 static void
149 mono_marshal_set_last_error_windows (int error);
150
151 static void
152 mono_marshal_emit_native_wrapper (MonoImage *image, MonoMethodBuilder *mb, MonoMethodSignature *sig, MonoMethodPInvoke *piinfo, MonoMarshalSpec **mspecs, gpointer func, gboolean aot, gboolean check_exceptions);
153
154 static void init_safe_handle (void);
155
156 /* MonoMethod pointers to SafeHandle::DangerousAddRef and ::DangerousRelease */
157 static MonoMethod *sh_dangerous_add_ref;
158 static MonoMethod *sh_dangerous_release;
159
160
161 static void
162 init_safe_handle ()
163 {
164 sh_dangerous_add_ref = mono_class_get_method_from_name (
165 mono_defaults.safehandle_class, "DangerousAddRef", 1);
166 sh_dangerous_release = mono_class_get_method_from_name (
167 mono_defaults.safehandle_class, "DangerousRelease", 0);
168 }
169
170 static void
171 register_icall (gpointer func, const char *name, const char *sigstr, gboolean save)
172 {
173 MonoMethodSignature *sig = mono_create_icall_signature (sigstr);
174
175 mono_register_jit_icall (func, name, sig, save);
176 }
177
178 static MonoMethodSignature*
179 signature_dup (MonoImage *image, MonoMethodSignature *sig)
180 {
181 MonoMethodSignature *res;
182 int sigsize;
183
184 res = mono_metadata_signature_alloc (image, sig->param_count);
185 sigsize = sizeof (MonoMethodSignature) + ((sig->param_count - MONO_ZERO_LEN_ARRAY) * sizeof (MonoType *));
186 memcpy (res, sig, sigsize);
187
188 return res;
189 }
190
191 MonoMethodSignature*
192 mono_signature_no_pinvoke (MonoMethod *method)
193 {
194 MonoMethodSignature *sig = mono_method_signature (method);
195 if (sig->pinvoke) {
196 sig = signature_dup (method->klass->image, sig);
197 sig->pinvoke = FALSE;
198 }
199
200 return sig;
201 }
202
203 /* Begin COM Interop related stuff until seperate file */
204
205
206 /* STDCALL on windows, CDECL everywhere else to work with XPCOM and MainWin COM */
207 #ifdef PLATFORM_WIN32
208 #define STDCALL __stdcall
209 #else
210 #define STDCALL
211 #endif
212
213 /* Upon creation of a CCW, only allocate a weak handle and set the
214 * reference count to 0. If the unmanaged client code decides to addref and
215 * hold onto the CCW, I then allocate a strong handle. Once the reference count
216 * goes back to 0, convert back to a weak handle.
217 */
218 typedef struct {
219 guint32 ref_count;
220 guint32 gc_handle;
221 GHashTable* vtable_hash;
222 #ifdef PLATFORM_WIN32
223 gpointer free_marshaler;
224 #endif
225 } MonoCCW;
226
227 /* This type is the actual pointer passed to unmanaged code
228 * to represent a COM interface.
229 */
230 typedef struct {
231 gpointer vtable;
232 MonoCCW* ccw;
233 } MonoCCWInterface;
234
235 #ifndef DISABLE_COM
236
237 /* IUnknown */
238 static int STDCALL cominterop_ccw_addref (MonoCCWInterface* ccwe);
239
240 static int STDCALL cominterop_ccw_release (MonoCCWInterface* ccwe);
241
242 static int STDCALL cominterop_ccw_queryinterface (MonoCCWInterface* ccwe, guint8* riid, gpointer* ppv);
243
244 /* IDispatch */
245 static int STDCALL cominterop_ccw_get_type_info_count (MonoCCWInterface* ccwe, guint32 *pctinfo);
246
247 static int STDCALL cominterop_ccw_get_type_info (MonoCCWInterface* ccwe, guint32 iTInfo, guint32 lcid, gpointer *ppTInfo);
248
249 static int STDCALL cominterop_ccw_get_ids_of_names (MonoCCWInterface* ccwe, gpointer riid,
250 gunichar2** rgszNames, guint32 cNames,
251 guint32 lcid, gint32 *rgDispId);
252
253 static int STDCALL cominterop_ccw_invoke (MonoCCWInterface* ccwe, guint32 dispIdMember,
254 gpointer riid, guint32 lcid,
255 guint16 wFlags, gpointer pDispParams,
256 gpointer pVarResult, gpointer pExcepInfo,
257 guint32 *puArgErr);
258
259 static MonoMethod *
260 cominterop_get_managed_wrapper_adjusted (MonoMethod *method);
261
262 static gpointer
263 cominterop_get_ccw (MonoObject* object, MonoClass* itf);
264
265 static MonoObject*
266 cominterop_get_ccw_object (MonoCCWInterface* ccw_entry, gboolean verify);
267
268 /**
269 * cominterop_method_signature:
270 * @method: a method
271 *
272 * Returns: the corresponding unmanaged method signature for a managed COM
273 * method.
274 */
275 static MonoMethodSignature*
276 cominterop_method_signature (MonoMethod* method)
277 {
278 MonoMethodSignature *res;
279 MonoImage *image = method->klass->image;
280 MonoMethodSignature *sig = mono_method_signature (method);
281 gboolean preserve_sig = method->iflags & METHOD_IMPL_ATTRIBUTE_PRESERVE_SIG;
282 int sigsize;
283 int i;
284 int param_count = sig->param_count + 1; // convert this arg into IntPtr arg
285
286 if (!preserve_sig &&!MONO_TYPE_IS_VOID (sig->ret))
287 param_count++;
288
289 res = mono_metadata_signature_alloc (image, param_count);
290 sigsize = sizeof (MonoMethodSignature) + ((sig->param_count - MONO_ZERO_LEN_ARRAY) * sizeof (MonoType *));
291 memcpy (res, sig, sigsize);
292
293 // now move args forward one
294 for (i = sig->param_count-1; i >= 0; i--)
295 res->params[i+1] = sig->params[i];
296
297 // first arg is interface pointer
298 res->params[0] = &mono_defaults.int_class->byval_arg;
299
300 if (preserve_sig) {
301 res->ret = sig->ret;
302 }
303 else {
304 // last arg is return type
305 if (!MONO_TYPE_IS_VOID (sig->ret)) {
306 res->params[param_count-1] = mono_metadata_type_dup (image->mempool, sig->ret);
307 res->params[param_count-1]->byref = 1;
308 res->params[param_count-1]->attrs = PARAM_ATTRIBUTE_OUT;
309 }
310
311 // return type is always int32 (HRESULT)
312 res->ret = &mono_defaults.int32_class->byval_arg;
313 }
314
315 // no pinvoke
316 res->pinvoke = FALSE;
317
318 // no hasthis
319 res->hasthis = 0;
320
321 // set param_count
322 res->param_count = param_count;
323
324 // STDCALL on windows, CDECL everywhere else to work with XPCOM and MainWin COM
325 #ifdef PLATFORM_WIN32
326 res->call_convention = MONO_CALL_STDCALL;
327 #else
328 res->call_convention = MONO_CALL_C;
329 #endif
330
331 return res;
332 }
333
334 /**
335 * cominterop_get_function_pointer:
336 * @itf: a pointer to the COM interface
337 * @slot: the vtable slot of the method pointer to return
338 *
339 * Returns: the unmanaged vtable function pointer from the interface
340 */
341 static gpointer
342 cominterop_get_function_pointer (gpointer itf, int slot)
343 {
344 gpointer func;
345 func = *((*(gpointer**)itf)+slot);
346 return func;
347 }
348
349 /**
350 * cominterop_object_is_com_object:
351 * @obj: a pointer to the object
352 *
353 * Returns: a value indicating if the object is a
354 * Runtime Callable Wrapper (RCW) for a COM object
355 */
356 static gboolean
357 cominterop_object_is_rcw (MonoObject *obj)
358 {
359 MonoClass *klass = NULL;
360 MonoRealProxy* real_proxy = NULL;
361 if (!obj)
362 return FALSE;
363 klass = mono_object_class (obj);
364 if (klass != mono_defaults.transparent_proxy_class)
365 return FALSE;
366
367 real_proxy = ((MonoTransparentProxy*)obj)->rp;
368 if (!real_proxy)
369 return FALSE;
370
371 klass = mono_object_class (real_proxy);
372 return (klass && klass == mono_defaults.com_interop_proxy_class);
373 }
374
375 static int
376 cominterop_get_com_slot_begin (MonoClass* klass)
377 {
378 static MonoClass *interface_type_attribute = NULL;
379 MonoCustomAttrInfo *cinfo = NULL;
380 MonoInterfaceTypeAttribute* itf_attr = NULL;
381
382 if (!interface_type_attribute)
383 interface_type_attribute = mono_class_from_name (mono_defaults.corlib, "System.Runtime.InteropServices", "InterfaceTypeAttribute");
384 cinfo = mono_custom_attrs_from_class (klass);
385 if (cinfo) {
386 itf_attr = (MonoInterfaceTypeAttribute*)mono_custom_attrs_get_attr (cinfo, interface_type_attribute);
387 if (!cinfo->cached)
388 mono_custom_attrs_free (cinfo);
389 }
390
391 if (itf_attr && itf_attr->intType == 1)
392 return 3; /* 3 methods in IUnknown*/
393 else
394 return 7; /* 7 methods in IDispatch*/
395 }
396
397 /**
398 * cominterop_get_method_interface:
399 * @method: method being called
400 *
401 * Returns: the MonoClass* representing the interface on which
402 * the method is defined.
403 */
404 static MonoClass*
405 cominterop_get_method_interface (MonoMethod* method)
406 {
407 MonoClass *ic = method->klass;
408
409 /* if method is on a class, we need to look up interface method exists on */
410 if (!MONO_CLASS_IS_INTERFACE(method->klass)) {
411 GPtrArray *ifaces = mono_class_get_implemented_interfaces (method->klass);
412 if (ifaces) {
413 int i;
414 for (i = 0; i < ifaces->len; ++i) {
415 int offset;
416 ic = g_ptr_array_index (ifaces, i);
417 offset = mono_class_interface_offset (method->klass, ic);
418 if (method->slot >= offset && method->slot < offset + ic->method.count)
419 break;
420 ic = NULL;
421 }
422 g_ptr_array_free (ifaces, TRUE);
423 }
424 }
425
426 g_assert (ic);
427 g_assert (MONO_CLASS_IS_INTERFACE (ic));
428
429 return ic;
430 }
431
432 /**
433 * cominterop_get_com_slot_for_method:
434 * @method: a method
435 *
436 * Returns: the method's slot in the COM interface vtable
437 */
438 static int
439 cominterop_get_com_slot_for_method (MonoMethod* method)
440 {
441 guint32 slot = method->slot;
442 MonoClass *ic = method->klass;
443
444 /* if method is on a class, we need to look up interface method exists on */
445 if (!MONO_CLASS_IS_INTERFACE(ic)) {
446 int offset = 0;
447 ic = cominterop_get_method_interface (method);
448 offset = mono_class_interface_offset (method->klass, ic);
449 g_assert(offset >= 0);
450 slot -= offset;
451 }
452
453 g_assert (ic);
454 g_assert (MONO_CLASS_IS_INTERFACE (ic));
455
456 return slot + cominterop_get_com_slot_begin (ic);
457 }
458
459
460 static void
461 cominterop_mono_string_to_guid (const MonoString* string, guint8 *guid);
462
463 static gboolean
464 cominterop_class_guid (MonoClass* klass, guint8* guid)
465 {
466 static MonoClass *GuidAttribute = NULL;
467 MonoCustomAttrInfo *cinfo;
468
469 /* Handle the GuidAttribute */
470 if (!GuidAttribute)
471 GuidAttribute = mono_class_from_name (mono_defaults.corlib, "System.Runtime.InteropServices", "GuidAttribute");
472
473 cinfo = mono_custom_attrs_from_class (klass);
474 if (cinfo) {
475 MonoReflectionGuidAttribute *attr = (MonoReflectionGuidAttribute*)mono_custom_attrs_get_attr (cinfo, GuidAttribute);
476
477 if (!attr)
478 return FALSE;
479 if (!cinfo->cached)
480 mono_custom_attrs_free (cinfo);
481
482 cominterop_mono_string_to_guid (attr->guid, guid);
483 return TRUE;
484 }
485 return FALSE;
486 }
487
488 /**
489 * cominterop_get_interface:
490 * @obj: managed wrapper object containing COM object
491 * @ic: interface type to retrieve for COM object
492 *
493 * Returns: the COM interface requested
494 */
495 static gpointer
496 cominterop_get_interface (MonoComObject* obj, MonoClass* ic, gboolean throw_exception)
497 {
498 gpointer itf = NULL;
499
500 g_assert (ic);
501 g_assert (MONO_CLASS_IS_INTERFACE (ic));
502
503 mono_cominterop_lock ();
504 if (obj->itf_hash)
505 itf = g_hash_table_lookup (obj->itf_hash, GUINT_TO_POINTER ((guint)ic->interface_id));
506 mono_cominterop_unlock ();
507
508 if (!itf) {
509 guint8 iid [16];
510 int found = cominterop_class_guid (ic, iid);
511 int hr;
512 g_assert(found);
513 hr = ves_icall_System_Runtime_InteropServices_Marshal_QueryInterfaceInternal (obj->iunknown, iid, &itf);
514 if (hr < 0 && throw_exception) {
515 static MonoMethod* throw_exception_for_hr = NULL;
516 MonoException* ex;
517 void* params[1] = {&hr};
518 if (!throw_exception_for_hr)
519 throw_exception_for_hr = mono_class_get_method_from_name (mono_defaults.marshal_class, "GetExceptionForHR", 1);
520 ex = (MonoException*)mono_runtime_invoke (throw_exception_for_hr, NULL, params, NULL);
521 mono_raise_exception (ex);
522 }
523
524 if (hr >= 0 && itf) {
525 mono_cominterop_lock ();
526 if (!obj->itf_hash)
527 obj->itf_hash = g_hash_table_new (mono_aligned_addr_hash, NULL);
528 g_hash_table_insert (obj->itf_hash, GUINT_TO_POINTER ((guint)ic->interface_id), itf);
529 mono_cominterop_unlock ();
530 }
531
532 }
533 if (throw_exception)
534 g_assert (itf);
535
536 return itf;
537 }
538
539 static int
540 cominterop_get_hresult_for_exception (MonoException* exc)
541 {
542 int hr = 0;
543 return hr;
544 }
545
546 #endif /* DISABLE_COM */
547
548 void
549 mono_marshal_init (void)
550 {
551 static gboolean module_initialized = FALSE;
552
553 if (!module_initialized) {
554 char* com_provider_env = NULL;
555 module_initialized = TRUE;
556 InitializeCriticalSection (&marshal_mutex);
557 InitializeCriticalSection (&cominterop_mutex);
558 last_error_tls_id = TlsAlloc ();
559 load_type_info_tls_id = TlsAlloc ();
560
561 com_provider_env = getenv ("MONO_COM");
562 if (com_provider_env && !strcmp(com_provider_env, "MS"))
563 com_provider = MONO_COM_MS;
564
565 register_icall (ves_icall_System_Threading_Thread_ResetAbort, "ves_icall_System_Threading_Thread_ResetAbort", "void", TRUE);
566 register_icall (mono_marshal_string_to_utf16, "mono_marshal_string_to_utf16", "ptr obj", FALSE);
567 register_icall (mono_marshal_string_to_utf16_copy, "mono_marshal_string_to_utf16_copy", "ptr obj", FALSE);
568 register_icall (mono_string_to_utf16, "mono_string_to_utf16", "ptr obj", FALSE);
569 register_icall (mono_string_from_utf16, "mono_string_from_utf16", "obj ptr", FALSE);
570 register_icall (mono_string_new_wrapper, "mono_string_new_wrapper", "obj ptr", FALSE);
571 register_icall (mono_string_to_utf8, "mono_string_to_utf8", "ptr obj", FALSE);
572 register_icall (mono_string_to_lpstr, "mono_string_to_lpstr", "ptr obj", FALSE);
573 register_icall (mono_string_to_bstr, "mono_string_to_bstr", "ptr obj", FALSE);
574 register_icall (mono_string_from_bstr, "mono_string_from_bstr", "obj ptr", FALSE);
575 register_icall (mono_free_bstr, "mono_free_bstr", "void ptr", FALSE);
576 register_icall (mono_string_to_ansibstr, "mono_string_to_ansibstr", "ptr object", FALSE);
577 register_icall (mono_string_builder_to_utf8, "mono_string_builder_to_utf8", "ptr object", FALSE);
578 register_icall (mono_string_builder_to_utf16, "mono_string_builder_to_utf16", "ptr object", FALSE);
579 register_icall (mono_array_to_savearray, "mono_array_to_savearray", "ptr object", FALSE);
580 register_icall (mono_array_to_lparray, "mono_array_to_lparray", "ptr object", FALSE);
581 register_icall (mono_byvalarray_to_array, "mono_byvalarray_to_array", "void object ptr ptr int32", FALSE);
582 register_icall (mono_array_to_byvalarray, "mono_array_to_byvalarray", "void ptr object ptr int32", FALSE);
583 register_icall (mono_delegate_to_ftnptr, "mono_delegate_to_ftnptr", "ptr object", FALSE);
584 register_icall (mono_ftnptr_to_delegate, "mono_ftnptr_to_delegate", "object ptr ptr", FALSE);
585 register_icall (mono_marshal_asany, "mono_marshal_asany", "ptr object int32 int32", FALSE);
586 register_icall (mono_marshal_free_asany, "mono_marshal_free_asany", "void object ptr int32 int32", FALSE);
587 register_icall (mono_marshal_alloc, "mono_marshal_alloc", "ptr int32", FALSE);
588 register_icall (mono_marshal_free, "mono_marshal_free", "void ptr", FALSE);
589 register_icall (mono_marshal_set_last_error, "mono_marshal_set_last_error", "void", FALSE);
590 register_icall (mono_marshal_set_last_error_windows, "mono_marshal_set_last_error_windows", "void int32", FALSE);
591 register_icall (mono_string_utf8_to_builder, "mono_string_utf8_to_builder", "void ptr ptr", FALSE);
592 register_icall (mono_string_utf8_to_builder2, "mono_string_utf8_to_builder2", "object ptr", FALSE);
593 register_icall (mono_string_utf16_to_builder, "mono_string_utf16_to_builder", "void ptr ptr", FALSE);
594 register_icall (mono_marshal_free_array, "mono_marshal_free_array", "void ptr int32", FALSE);
595 register_icall (mono_string_to_byvalstr, "mono_string_to_byvalstr", "void ptr ptr int32", FALSE);
596 register_icall (mono_string_to_byvalwstr, "mono_string_to_byvalwstr", "void ptr ptr int32", FALSE);
597 register_icall (g_free, "g_free", "void ptr", FALSE);
598 register_icall (mono_object_isinst, "mono_object_isinst", "object object ptr", FALSE);
599 register_icall (mono_struct_delete_old, "mono_struct_delete_old", "void ptr ptr", FALSE);
600 register_icall (mono_remoting_wrapper, "mono_remoting_wrapper", "object ptr ptr", FALSE);
601 register_icall (mono_delegate_begin_invoke, "mono_delegate_begin_invoke", "object object ptr", FALSE);
602 register_icall (mono_delegate_end_invoke, "mono_delegate_end_invoke", "object object ptr", FALSE);
603 register_icall (mono_marshal_xdomain_copy_value, "mono_marshal_xdomain_copy_value", "object object", FALSE);
604 register_icall (mono_marshal_xdomain_copy_out_value, "mono_marshal_xdomain_copy_out_value", "void object object", FALSE);
605 register_icall (mono_marshal_set_domain_by_id, "mono_marshal_set_domain_by_id", "int32 int32 int32", FALSE);
606 register_icall (mono_marshal_check_domain_image, "mono_marshal_check_domain_image", "int32 int32 ptr", FALSE);
607 register_icall (mono_compile_method, "mono_compile_method", "ptr ptr", FALSE);
608 register_icall (mono_context_get, "mono_context_get", "object", FALSE);
609 register_icall (mono_context_set, "mono_context_set", "void object", FALSE);
610 register_icall (mono_upgrade_remote_class_wrapper, "mono_upgrade_remote_class_wrapper", "void object object", FALSE);
611 register_icall (type_from_handle, "type_from_handle", "object ptr", FALSE);
612 register_icall (mono_gc_wbarrier_generic_store, "wb_generic", "void ptr object", FALSE);
613 #ifndef DISABLE_COM
614 register_icall (cominterop_get_method_interface, "cominterop_get_method_interface", "ptr ptr", FALSE);
615 register_icall (cominterop_get_function_pointer, "cominterop_get_function_pointer", "ptr ptr int32", FALSE);
616 register_icall (cominterop_object_is_rcw, "cominterop_object_is_rcw", "int32 object", FALSE);
617 register_icall (cominterop_get_ccw, "cominterop_get_ccw", "ptr object ptr", FALSE);
618 register_icall (cominterop_get_ccw_object, "cominterop_get_ccw_object", "object ptr int32", FALSE);
619 register_icall (cominterop_get_hresult_for_exception, "cominterop_get_hresult_for_exception", "int32 object", FALSE);
620 register_icall (cominterop_get_interface, "cominterop_get_interface", "ptr object ptr int32", FALSE);
621 #endif /* DISABLE_COM */
622 }
623 }
624
625 void
626 mono_marshal_cleanup (void)
627 {
628 TlsFree (load_type_info_tls_id);
629 TlsFree (last_error_tls_id);
630 DeleteCriticalSection (&marshal_mutex);
631 DeleteCriticalSection (&cominterop_mutex);
632 }
633
634 MonoClass *byte_array_class;
635 static MonoMethod *method_rs_serialize, *method_rs_deserialize, *method_exc_fixexc, *method_rs_appdomain_target;
636 static MonoMethod *method_set_context, *method_get_context;
637 static MonoMethod *method_set_call_context, *method_needs_context_sink, *method_rs_serialize_exc;
638
639 static void
640 mono_remoting_marshal_init (void)
641 {
642 MonoClass *klass;
643
644 static gboolean module_initialized = FALSE;
645
646 if (!module_initialized) {
647 klass = mono_class_from_name (mono_defaults.corlib, "System.Runtime.Remoting", "RemotingServices");
648 method_rs_serialize = mono_class_get_method_from_name (klass, "SerializeCallData", -1);
649 method_rs_deserialize = mono_class_get_method_from_name (klass, "DeserializeCallData", -1);
650 method_rs_serialize_exc = mono_class_get_method_from_name (klass, "SerializeExceptionData", -1);
651
652 klass = mono_defaults.real_proxy_class;
653 method_rs_appdomain_target = mono_class_get_method_from_name (klass, "GetAppDomainTarget", -1);
654
655 klass = mono_defaults.exception_class;
656 method_exc_fixexc = mono_class_get_method_from_name (klass, "FixRemotingException", -1);
657
658 klass = mono_defaults.thread_class;
659 method_get_context = mono_class_get_method_from_name (klass, "get_CurrentContext", -1);
660
661 klass = mono_defaults.appdomain_class;
662 method_set_context = mono_class_get_method_from_name (klass, "InternalSetContext", -1);
663 byte_array_class = mono_array_class_get (mono_defaults.byte_class, 1);
664
665 klass = mono_class_from_name (mono_defaults.corlib, "System.Runtime.Remoting.Messaging", "CallContext");
666 method_set_call_context = mono_class_get_method_from_name (klass, "SetCurrentCallContext", -1);
667
668 klass = mono_class_from_name (mono_defaults.corlib, "System.Runtime.Remoting.Contexts", "Context");
669 method_needs_context_sink = mono_class_get_method_from_name (klass, "get_NeedsContextSink", -1);
670
671 module_initialized = TRUE;
672 }
673 }
674
675 gpointer
676 mono_delegate_to_ftnptr (MonoDelegate *delegate)
677 {
678 MonoMethod *method, *wrapper;
679 MonoClass *klass;
680
681 if (!delegate)
682 return NULL;
683
684 if (delegate->delegate_trampoline)
685 return delegate->delegate_trampoline;
686
687 klass = ((MonoObject *)delegate)->vtable->klass;
688 g_assert (klass->delegate);
689
690 method = delegate->method;
691
692 wrapper = mono_marshal_get_managed_wrapper (method, klass, delegate->target);
693
694 delegate->delegate_trampoline = mono_compile_method (wrapper);
695
696 // Add the delegate to the delegate hash table
697 delegate_hash_table_add (delegate);
698
699 /* when the object is collected, collect the dynamic method, too */
700 mono_object_register_finalizer ((MonoObject*)delegate);
701
702 return delegate->delegate_trampoline;
703 }
704
705 /*
706 * this hash table maps from a delegate trampoline object to a weak reference
707 * of the delegate. As an optimizations with a non-moving GC we store the
708 * object pointer itself, otherwise we use a GC handle.
709 */
710 static GHashTable *delegate_hash_table;
711
712 static GHashTable *
713 delegate_hash_table_new (void) {
714 return g_hash_table_new (NULL, NULL);
715 }
716
717 static void
718 delegate_hash_table_remove (MonoDelegate *d)
719 {
720 #ifdef HAVE_MOVING_COLLECTOR
721 guint32 gchandle;
722 #endif
723 mono_marshal_lock ();
724 if (delegate_hash_table == NULL)
725 delegate_hash_table = delegate_hash_table_new ();
726 #ifdef HAVE_MOVING_COLLECTOR
727 gchandle = GPOINTER_TO_UINT (g_hash_table_lookup (delegate_hash_table, d->delegate_trampoline));
728 #endif
729 g_hash_table_remove (delegate_hash_table, d->delegate_trampoline);
730 mono_marshal_unlock ();
731 #ifdef HAVE_MOVING_COLLECTOR
732 mono_gchandle_free (gchandle);
733 #endif
734 }
735
736 static void
737 delegate_hash_table_add (MonoDelegate *d)
738 {
739 #ifdef HAVE_MOVING_COLLECTOR
740 guint32 gchandle = mono_gchandle_new_weakref ((MonoObject*)d, FALSE);
741 #endif
742 mono_marshal_lock ();
743 if (delegate_hash_table == NULL)
744 delegate_hash_table = delegate_hash_table_new ();
745 #ifdef HAVE_MOVING_COLLECTOR
746 g_hash_table_insert (delegate_hash_table, d->delegate_trampoline, GUINT_TO_POINTER (gchandle));
747 #else
748 g_hash_table_insert (delegate_hash_table, d->delegate_trampoline, d);
749 #endif
750 mono_marshal_unlock ();
751 }
752
753 MonoDelegate*
754 mono_ftnptr_to_delegate (MonoClass *klass, gpointer ftn)
755 {
756 #ifdef HAVE_MOVING_COLLECTOR
757 guint32 gchandle;
758 #endif
759 MonoDelegate *d;
760
761 mono_marshal_lock ();
762 if (delegate_hash_table == NULL)
763 delegate_hash_table = delegate_hash_table_new ();
764
765 #ifdef HAVE_MOVING_COLLECTOR
766 gchandle = GPOINTER_TO_UINT (g_hash_table_lookup (delegate_hash_table, ftn));
767 mono_marshal_unlock ();
768 if (gchandle)
769 d = (MonoDelegate*)mono_gchandle_get_target (gchandle);
770 else
771 d = NULL;
772 #else
773 d = g_hash_table_lookup (delegate_hash_table, ftn);
774 mono_marshal_unlock ();
775 #endif
776 if (d == NULL) {
777 /* This is a native function, so construct a delegate for it */
778 static MonoClass *UnmanagedFunctionPointerAttribute;
779 MonoMethodSignature *sig;
780 MonoMethod *wrapper;
781 MonoMarshalSpec **mspecs;
782 MonoCustomAttrInfo *cinfo;
783 MonoReflectionUnmanagedFunctionPointerAttribute *attr;
784 MonoMethod *invoke = mono_get_delegate_invoke (klass);
785 MonoMethodPInvoke piinfo;
786 int i;
787
788 memset (&piinfo, 0, sizeof (piinfo));
789 if (!UnmanagedFunctionPointerAttribute)
790 UnmanagedFunctionPointerAttribute = mono_class_from_name (mono_defaults.corlib, "System.Runtime.InteropServices", "UnmanagedFunctionPointerAttribute");
791
792 /* The attribute is only available in Net 2.0 */
793 if (UnmanagedFunctionPointerAttribute) {
794 /*
795 * The pinvoke attributes are stored in a real custom attribute so we have to
796 * construct it.
797 */
798 cinfo = mono_custom_attrs_from_class (klass);
799 if (cinfo) {
800 attr = (MonoReflectionUnmanagedFunctionPointerAttribute*)mono_custom_attrs_get_attr (cinfo, UnmanagedFunctionPointerAttribute);
801 if (attr) {
802 piinfo.piflags = (attr->call_conv << 8) | (attr->charset ? (attr->charset - 1) * 2 : 1) | attr->set_last_error;
803 }
804 if (!cinfo->cached)
805 mono_custom_attrs_free (cinfo);
806 }
807 }
808
809 mspecs = g_new0 (MonoMarshalSpec*, mono_method_signature (invoke)->param_count + 1);
810 mono_method_get_marshal_info (invoke, mspecs);
811 /* Freed below so don't alloc from mempool */
812 sig = mono_metadata_signature_dup (mono_method_signature (invoke));
813 sig->hasthis = 0;
814
815 wrapper = mono_marshal_get_native_func_wrapper (klass->image, sig, &piinfo, mspecs, ftn);
816
817 for (i = mono_method_signature (invoke)->param_count; i >= 0; i--)
818 if (mspecs [i])
819 mono_metadata_free_marshal_spec (mspecs [i]);
820 g_free (mspecs);
821 g_free (sig);
822
823 d = (MonoDelegate*)mono_object_new (mono_domain_get (), klass);
824 mono_delegate_ctor_with_method ((MonoObject*)d, NULL, mono_compile_method (wrapper), wrapper);
825 }
826
827 if (d->object.vtable->domain != mono_domain_get ())
828 mono_raise_exception (mono_get_exception_not_supported ("Delegates cannot be marshalled from native code into a domain other than their home domain"));
829
830 return d;
831 }
832
833 void
834 mono_delegate_free_ftnptr (MonoDelegate *delegate)
835 {
836 MonoJitInfo *ji;
837 void *ptr;
838
839 delegate_hash_table_remove (delegate);
840
841 ptr = (gpointer)InterlockedExchangePointer (&delegate->delegate_trampoline, NULL);
842
843 if (!delegate->target) {
844 /* The wrapper method is shared between delegates -> no need to free it */
845 return;
846 }
847
848 if (ptr) {
849 ji = mono_jit_info_table_find (mono_domain_get (), mono_get_addr_from_ftnptr (ptr));
850 g_assert (ji);
851
852 mono_runtime_free_method (mono_object_domain (delegate), ji->method);
853 }
854 }
855
856 gpointer
857 mono_array_to_savearray (MonoArray *array)
858 {
859 if (!array)
860 return NULL;
861
862 g_assert_not_reached ();
863 return NULL;
864 }
865
866 gpointer
867 mono_array_to_lparray (MonoArray *array)
868 {
869 if (!array)
870 return NULL;
871
872 /* fixme: maybe we need to make a copy */
873 return array->vector;
874 }
875
876 static void
877 mono_byvalarray_to_array (MonoArray *arr, gpointer native_arr, MonoClass *elclass, guint32 elnum)
878 {
879 g_assert (arr->obj.vtable->klass->element_class == mono_defaults.char_class);
880
881 if (elclass == mono_defaults.byte_class) {
882 GError *error = NULL;
883 guint16 *ut;
884 glong items_written;
885
886 ut = g_utf8_to_utf16 (native_arr, elnum, NULL, &items_written, &error);
887
888 if (!error) {
889 memcpy (mono_array_addr (arr, guint16, 0), ut, items_written * sizeof (guint16));
890 g_free (ut);
891 }
892 else
893 g_error_free (error);
894 }
895 else
896 g_assert_not_reached ();
897 }
898
899 static void
900 mono_array_to_byvalarray (gpointer native_arr, MonoArray *arr, MonoClass *elclass, guint32 elnum)
901 {
902 g_assert (arr->obj.vtable->klass->element_class == mono_defaults.char_class);
903
904 if (elclass == mono_defaults.byte_class) {
905 char *as;
906 GError *error = NULL;
907
908 as = g_utf16_to_utf8 (mono_array_addr (arr, gunichar2, 0), mono_array_length (arr), NULL, NULL, &error);
909 if (error) {
910 MonoException *exc = mono_get_exception_argument ("string", error->message);
911 g_error_free (error);
912 mono_raise_exception (exc);
913 }
914
915 memcpy (native_arr, as, MIN (strlen (as), elnum));
916 g_free (as);
917 } else {
918 g_assert_not_reached ();
919 }
920 }
921
922 void
923 mono_string_utf8_to_builder (MonoStringBuilder *sb, char *text)
924 {
925 GError *error = NULL;
926 guint16 *ut;
927 glong items_written;
928 int l;
929
930 if (!sb || !text)
931 return;
932
933 l = strlen (text);
934
935 ut = g_utf8_to_utf16 (text, l, NULL, &items_written, &error);
936
937 if (items_written > mono_stringbuilder_capacity (sb))
938 items_written = mono_stringbuilder_capacity (sb);
939
940 if (!error) {
941 if (! sb->str || sb->str == sb->cached_str) {
942 MONO_OBJECT_SETREF (sb, str, mono_string_new_size (mono_domain_get (), items_written));
943 sb->cached_str = NULL;
944 }
945
946 memcpy (mono_string_chars (sb->str), ut, items_written * 2);
947 sb->length = items_written;
948 } else
949 g_error_free (error);
950
951 g_free (ut);
952 }
953
954 MonoStringBuilder *
955 mono_string_utf8_to_builder2 (char *text)
956 {
957 int l;
958 MonoStringBuilder *sb;
959 static MonoClass *string_builder_class;
960 static MonoMethod *sb_ctor;
961 void *args [1];
962 MonoObject *exc;
963
964 if (!text)
965 return NULL;
966
967 if (!string_builder_class) {
968 MonoMethodDesc *desc;
969
970 string_builder_class = mono_class_from_name (mono_defaults.corlib, "System.Text", "StringBuilder");
971 g_assert (string_builder_class);
972 desc = mono_method_desc_new (":.ctor(int)", FALSE);
973 sb_ctor = mono_method_desc_search_in_class (desc, string_builder_class);
974 g_assert (sb_ctor);
975 mono_method_desc_free (desc);
976 }
977
978 l = strlen (text);
979
980 sb = (MonoStringBuilder*)mono_object_new (mono_domain_get (), string_builder_class);
981 g_assert (sb);
982 args [0] = &l;
983 mono_runtime_invoke (sb_ctor, sb, args, &exc);
984 g_assert (!exc);
985
986 mono_string_utf8_to_builder (sb, text);
987
988 return sb;
989 }
990
991 /*
992 * FIXME: This routine does not seem to do what it seems to do
993 * the @text is never copied into the string builder
994 */
995 void
996 mono_string_utf16_to_builder (MonoStringBuilder *sb, gunichar2 *text)
997 {
998 guint32 len;
999
1000 if (!sb || !text)
1001 return;
1002
1003 g_assert (mono_string_chars (sb->str) == text);
1004
1005 for (len = 0; text [len] != 0; ++len)
1006 ;
1007
1008 sb->length = len;
1009 }
1010
1011 /**
1012 * mono_string_builder_to_utf8:
1013 * @sb: the string builder
1014 *
1015 * Converts to utf8 the contents of the MonoStringBuilder.
1016 *
1017 * Returns: a utf8 string with the contents of the StringBuilder.
1018 *
1019 * The return value must be released with g_free.
1020 */
1021 gpointer
1022 mono_string_builder_to_utf8 (MonoStringBuilder *sb)
1023 {
1024 GError *error = NULL;
1025 gchar *tmp, *res = NULL;
1026
1027 if (!sb)
1028 return NULL;
1029
1030 if ((sb->str == sb->cached_str) && (sb->str->length == 0)) {
1031 /*
1032 * The sb could have been allocated with the default capacity and be empty.
1033 * we need to alloc a buffer of the default capacity in this case.
1034 */
1035 MONO_OBJECT_SETREF (sb, str, mono_string_new_size (mono_domain_get (), 16));
1036 sb->cached_str = NULL;
1037 }
1038
1039 tmp = g_utf16_to_utf8 (mono_string_chars (sb->str), sb->length, NULL, NULL, &error);
1040 if (error) {
1041 g_error_free (error);
1042 mono_raise_exception (mono_get_exception_execution_engine ("Failed to convert StringBuilder from utf16 to utf8"));
1043 } else {
1044 res = mono_marshal_alloc (mono_stringbuilder_capacity (sb) + 1);
1045 memcpy (res, tmp, sb->length + 1);
1046 g_free (tmp);
1047 }
1048
1049 return res;
1050 }
1051
1052 /**
1053 * mono_string_builder_to_utf16:
1054 * @sb: the string builder
1055 *
1056 * Converts to utf16 the contents of the MonoStringBuilder.
1057 *
1058 * Returns: a utf16 string with the contents of the StringBuilder.
1059 *
1060 * The return value must not be freed.
1061 */
1062 gpointer
1063 mono_string_builder_to_utf16 (MonoStringBuilder *sb)
1064 {
1065 if (!sb)
1066 return NULL;
1067
1068 g_assert (sb->str);
1069
1070 /*
1071 * The stringbuilder might not have ownership of this string. If this is
1072 * the case, we must duplicate the string, so that we don't munge immutable
1073 * strings
1074 */
1075 if (sb->str == sb->cached_str) {
1076 /*
1077 * The sb could have been allocated with the default capacity and be empty.
1078 * we need to alloc a buffer of the default capacity in this case.
1079 */
1080 if (sb->str->length == 0)
1081 MONO_OBJECT_SETREF (sb, str, mono_string_new_size (mono_domain_get (), 16));
1082 else
1083 MONO_OBJECT_SETREF (sb, str, mono_string_new_utf16 (mono_domain_get (), mono_string_chars (sb->str), mono_stringbuilder_capacity (sb)));
1084 sb->cached_str = NULL;
1085 }
1086
1087 return mono_string_chars (sb->str);
1088 }
1089
1090 static gpointer
1091 mono_string_to_lpstr (MonoString *s)
1092 {
1093 #ifdef PLATFORM_WIN32
1094 char *as, *tmp;
1095 glong len;
1096 GError *error = NULL;
1097
1098 if (s == NULL)
1099 return NULL;
1100
1101 if (!s->length) {
1102 as = CoTaskMemAlloc (1);
1103 as [0] = '\0';
1104 return as;
1105 }
1106
1107 tmp = g_utf16_to_utf8 (mono_string_chars (s), s->length, NULL, &len, &error);
1108 if (error) {
1109 MonoException *exc = mono_get_exception_argument ("string", error->message);
1110 g_error_free (error);
1111 mono_raise_exception(exc);
1112 return NULL;
1113 } else {
1114 as = CoTaskMemAlloc (len + 1);
1115 memcpy (as, tmp, len + 1);
1116 g_free (tmp);
1117 return as;
1118 }
1119 #else
1120 return mono_string_to_utf8 (s);
1121 #endif
1122 }
1123
1124 gpointer
1125 mono_string_to_ansibstr (MonoString *string_obj)
1126 {
1127 g_error ("UnmanagedMarshal.BStr is not implemented.");
1128 return NULL;
1129 }
1130
1131 typedef gpointer (*SysAllocStringLenFunc)(gunichar* str, guint32 len);
1132 typedef guint32 (*SysStringLenFunc)(gpointer bstr);
1133 typedef void (*SysFreeStringFunc)(gunichar* str);
1134
1135 static SysAllocStringLenFunc sys_alloc_string_len_ms = NULL;
1136 static SysStringLenFunc sys_string_len_ms = NULL;
1137 static SysFreeStringFunc sys_free_string_ms = NULL;
1138
1139 static gboolean
1140 init_com_provider_ms (void)
1141 {
1142 static gboolean initialized = FALSE;
1143 char *error_msg;
1144 MonoDl *module = NULL;
1145 const char* scope = "liboleaut32.so";
1146
1147 if (initialized)
1148 return TRUE;
1149
1150 module = mono_dl_open(scope, MONO_DL_LAZY, &error_msg);
1151 if (error_msg) {
1152 g_warning ("Error loading COM support library '%s': %s", scope, error_msg);
1153 g_assert_not_reached ();
1154 return FALSE;
1155 }
1156 error_msg = mono_dl_symbol (module, "SysAllocStringLen", (gpointer*)&sys_alloc_string_len_ms);
1157 if (error_msg) {
1158 g_warning ("Error loading entry point '%s' in COM support library '%s': %s", "SysAllocStringLen", scope, error_msg);
1159 g_assert_not_reached ();
1160 return FALSE;
1161 }
1162
1163 error_msg = mono_dl_symbol (module, "SysStringLen", (gpointer*)&sys_string_len_ms);
1164 if (error_msg) {
1165 g_warning ("Error loading entry point '%s' in COM support library '%s': %s", "SysStringLen", scope, error_msg);
1166 g_assert_not_reached ();
1167 return FALSE;
1168 }
1169
1170 error_msg = mono_dl_symbol (module, "SysFreeString", (gpointer*)&sys_free_string_ms);
1171 if (error_msg) {
1172 g_warning ("Error loading entry point '%s' in COM support library '%s': %s", "SysFreeString", scope, error_msg);
1173 g_assert_not_reached ();
1174 return FALSE;
1175 }
1176
1177 initialized = TRUE;
1178 return TRUE;
1179 }
1180
1181 gpointer
1182 mono_string_to_bstr (MonoString *string_obj)
1183 {
1184 if (!string_obj)
1185 return NULL;
1186 #ifdef PLATFORM_WIN32
1187 return SysAllocStringLen (mono_string_chars (string_obj), mono_string_length (string_obj));
1188 #else
1189 if (com_provider == MONO_COM_DEFAULT) {
1190 int slen = mono_string_length (string_obj);
1191 /* allocate len + 1 utf16 characters plus 4 byte integer for length*/
1192 char *ret = g_malloc ((slen + 1) * sizeof(gunichar2) + sizeof(guint32));
1193 if (ret == NULL)
1194 return NULL;
1195 memcpy (ret + sizeof(guint32), mono_string_chars (string_obj), slen * sizeof(gunichar2));
1196 * ((guint32 *) ret) = slen * sizeof(gunichar2);
1197 ret [4 + slen * sizeof(gunichar2)] = 0;
1198 ret [5 + slen * sizeof(gunichar2)] = 0;
1199
1200 return ret + 4;
1201 } else if (com_provider == MONO_COM_MS && init_com_provider_ms ()) {
1202 gpointer ret = NULL;
1203 gunichar* str = NULL;
1204 guint32 len;
1205 len = mono_string_length (string_obj);
1206 str = g_utf16_to_ucs4 (mono_string_chars (string_obj), len,
1207 NULL, NULL, NULL);
1208 ret = sys_alloc_string_len_ms (str, len);
1209 g_free(str);
1210 return ret;
1211 } else {
1212 g_assert_not_reached ();
1213 }
1214 #endif
1215 }
1216
1217 MonoString *
1218 mono_string_from_bstr (gpointer bstr)
1219 {
1220 if (!bstr)
1221 return NULL;
1222 #ifdef PLATFORM_WIN32
1223 return mono_string_new_utf16 (mono_domain_get (), bstr, SysStringLen (bstr));
1224 #else
1225 if (com_provider == MONO_COM_DEFAULT) {
1226 return mono_string_new_utf16 (mono_domain_get (), bstr, *((guint32 *)bstr - 1) / sizeof(gunichar2));
1227 } else if (com_provider == MONO_COM_MS && init_com_provider_ms ()) {
1228 MonoString* str = NULL;
1229 glong written = 0;
1230 gunichar2* utf16 = NULL;
1231
1232 utf16 = g_ucs4_to_utf16 (bstr, sys_string_len_ms (bstr), NULL, &written, NULL);
1233 str = mono_string_new_utf16 (mono_domain_get (), utf16, written);
1234 g_free (utf16);
1235 return str;
1236 } else {
1237 g_assert_not_reached ();
1238 }
1239
1240 #endif
1241 }
1242
1243 void
1244 mono_free_bstr (gpointer bstr)
1245 {
1246 if (!bstr)
1247 return;
1248 #ifdef PLATFORM_WIN32
1249 SysFreeString ((BSTR)bstr);
1250 #else
1251 if (com_provider == MONO_COM_DEFAULT) {
1252 g_free (((char *)bstr) - 4);
1253 } else if (com_provider == MONO_COM_MS && init_com_provider_ms ()) {
1254 sys_free_string_ms (bstr);
1255 } else {
1256 g_assert_not_reached ();
1257 }
1258
1259 #endif
1260 }
1261
1262 /**
1263 * mono_string_to_byvalstr:
1264 * @dst: Where to store the null-terminated utf8 decoded string.
1265 * @src: the MonoString to copy.
1266 * @size: the maximum number of bytes to copy.
1267 *
1268 * Copies the MonoString pointed to by @src as a utf8 string
1269 * into @dst, it copies at most @size bytes into the destination.
1270 */
1271 void
1272 mono_string_to_byvalstr (gpointer dst, MonoString *src, int size)
1273 {
1274 char *s;
1275 int len;
1276
1277 g_assert (dst != NULL);
1278 g_assert (size > 0);
1279
1280 memset (dst, 0, size);
1281 if (!src)
1282 return;
1283
1284 s = mono_string_to_utf8 (src);
1285 len = MIN (size, strlen (s));
1286 if (len >= size)
1287 len--;
1288 memcpy (dst, s, len);
1289 g_free (s);
1290 }
1291
1292 /**
1293 * mono_string_to_byvalwstr:
1294 * @dst: Where to store the null-terminated utf16 decoded string.
1295 * @src: the MonoString to copy.
1296 * @size: the maximum number of bytes to copy.
1297 *
1298 * Copies the MonoString pointed to by @src as a utf16 string into
1299 * @dst, it copies at most @size bytes into the destination (including
1300 * a terminating 16-bit zero terminator).
1301 */
1302 void
1303 mono_string_to_byvalwstr (gpointer dst, MonoString *src, int size)
1304 {
1305 int len;
1306
1307 g_assert (dst != NULL);
1308 g_assert (size > 1);
1309
1310 if (!src) {
1311 memset (dst, 0, size * 2);
1312 return;
1313 }
1314
1315 len = MIN (size, (mono_string_length (src)));
1316 memcpy (dst, mono_string_chars (src), size * 2);
1317 if (size <= mono_string_length (src))
1318 len--;
1319 *((gunichar2 *) dst + len) = 0;
1320 }
1321
1322 static int
1323 mono_mb_emit_proxy_check (MonoMethodBuilder *mb, int branch_code)
1324 {
1325 int pos;
1326 mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoObject, vtable));
1327 mono_mb_emit_byte (mb, CEE_LDIND_I);
1328 mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoVTable, klass));
1329 mono_mb_emit_byte (mb, CEE_ADD);
1330 mono_mb_emit_byte (mb, CEE_LDIND_I);
1331 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
1332 mono_mb_emit_byte (mb, CEE_MONO_CLASSCONST);
1333 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, mono_defaults.transparent_proxy_class));
1334 pos = mono_mb_emit_branch (mb, branch_code);
1335 return pos;
1336 }
1337
1338 static int
1339 mono_mb_emit_xdomain_check (MonoMethodBuilder *mb, int branch_code)
1340 {
1341 int pos;
1342 mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoTransparentProxy, rp));
1343 mono_mb_emit_byte (mb, CEE_LDIND_REF);
1344 mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoRealProxy, target_domain_id));
1345 mono_mb_emit_byte (mb, CEE_LDIND_I4);
1346 mono_mb_emit_icon (mb, -1);
1347 pos = mono_mb_emit_branch (mb, branch_code);
1348 return pos;
1349 }
1350
1351 static int
1352 mono_mb_emit_contextbound_check (MonoMethodBuilder *mb, int branch_code)
1353 {
1354 static int offset = -1;
1355 static guint8 mask;
1356
1357 if (offset < 0)
1358 mono_marshal_find_bitfield_offset (MonoClass, contextbound, &offset, &mask);
1359
1360 mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoTransparentProxy, remote_class));
1361 mono_mb_emit_byte (mb, CEE_LDIND_REF);
1362 mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoRemoteClass, proxy_class));
1363 mono_mb_emit_byte (mb, CEE_LDIND_REF);
1364 mono_mb_emit_ldflda (mb, offset);
1365 mono_mb_emit_byte (mb, CEE_LDIND_U1);
1366 mono_mb_emit_icon (mb, mask);
1367 mono_mb_emit_byte (mb, CEE_AND);
1368 mono_mb_emit_icon (mb, 0);
1369 return mono_mb_emit_branch (mb, branch_code);
1370 }
1371
1372 #ifndef DISABLE_COM
1373
1374 static void
1375 mono_mb_emit_cominterop_call (MonoMethodBuilder *mb, MonoMethodSignature *sig, MonoMethod* method)
1376 {
1377 // get function pointer from 1st arg, the COM interface pointer
1378 mono_mb_emit_ldarg (mb, 0);
1379 mono_mb_emit_icon (mb, cominterop_get_com_slot_for_method (method));
1380 mono_mb_emit_icall (mb, cominterop_get_function_pointer);
1381
1382 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
1383 mono_mb_emit_byte (mb, CEE_MONO_SAVE_LMF);
1384 mono_mb_emit_calli (mb, sig);
1385 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
1386 mono_mb_emit_byte (mb, CEE_MONO_RESTORE_LMF);
1387 }
1388
1389 #endif /* DISABLE_COM */
1390
1391 static void
1392 mono_mb_emit_exception_marshal_directive (MonoMethodBuilder *mb, const char *msg)
1393 {
1394 mono_mb_emit_exception_full (mb, "System.Runtime.InteropServices", "MarshalDirectiveException", msg);
1395 }
1396
1397 guint
1398 mono_type_to_ldind (MonoType *type)
1399 {
1400 if (type->byref)
1401 return CEE_LDIND_I;
1402
1403 handle_enum:
1404 switch (type->type) {
1405 case MONO_TYPE_I1:
1406 return CEE_LDIND_I1;
1407 case MONO_TYPE_U1:
1408 case MONO_TYPE_BOOLEAN:
1409 return CEE_LDIND_U1;
1410 case MONO_TYPE_I2:
1411 return CEE_LDIND_I2;
1412 case MONO_TYPE_U2:
1413 case MONO_TYPE_CHAR:
1414 return CEE_LDIND_U2;
1415 case MONO_TYPE_I4:
1416 return CEE_LDIND_I4;
1417 case MONO_TYPE_U4:
1418 return CEE_LDIND_U4;
1419 case MONO_TYPE_I:
1420 case MONO_TYPE_U:
1421 case MONO_TYPE_PTR:
1422 case MONO_TYPE_FNPTR:
1423 return CEE_LDIND_I;
1424 case MONO_TYPE_CLASS:
1425 case MONO_TYPE_STRING:
1426 case MONO_TYPE_OBJECT:
1427 case MONO_TYPE_SZARRAY:
1428 case MONO_TYPE_ARRAY:
1429 return CEE_LDIND_REF;
1430 case MONO_TYPE_I8:
1431 case MONO_TYPE_U8:
1432 return CEE_LDIND_I8;
1433 case MONO_TYPE_R4:
1434 return CEE_LDIND_R4;
1435 case MONO_TYPE_R8:
1436 return CEE_LDIND_R8;
1437 case MONO_TYPE_VALUETYPE:
1438 if (type->data.klass->enumtype) {
1439 type = type->data.klass->enum_basetype;
1440 goto handle_enum;
1441 }
1442 return CEE_LDOBJ;
1443 case MONO_TYPE_TYPEDBYREF:
1444 return CEE_LDOBJ;
1445 case MONO_TYPE_GENERICINST:
1446 type = &type->data.generic_class->container_class->byval_arg;
1447 goto handle_enum;
1448 default:
1449 g_error ("unknown type 0x%02x in type_to_ldind", type->type);
1450 }
1451 return -1;
1452 }
1453
1454 guint
1455 mono_type_to_stind (MonoType *type)
1456 {
1457 if (type->byref)
1458 return CEE_STIND_I;
1459
1460 handle_enum:
1461 switch (type->type) {
1462 case MONO_TYPE_I1:
1463 case MONO_TYPE_U1:
1464 case MONO_TYPE_BOOLEAN:
1465 return CEE_STIND_I1;
1466 case MONO_TYPE_I2:
1467 case MONO_TYPE_U2:
1468 case MONO_TYPE_CHAR:
1469 return CEE_STIND_I2;
1470 case MONO_TYPE_I4:
1471 case MONO_TYPE_U4:
1472 return CEE_STIND_I4;
1473 case MONO_TYPE_I:
1474 case MONO_TYPE_U:
1475 case MONO_TYPE_PTR:
1476 case MONO_TYPE_FNPTR:
1477 return CEE_STIND_I;
1478 case MONO_TYPE_CLASS:
1479 case MONO_TYPE_STRING:
1480 case MONO_TYPE_OBJECT:
1481 case MONO_TYPE_SZARRAY:
1482 case MONO_TYPE_ARRAY:
1483 return CEE_STIND_REF;
1484 case MONO_TYPE_I8:
1485 case MONO_TYPE_U8:
1486 return CEE_STIND_I8;
1487 case MONO_TYPE_R4:
1488 return CEE_STIND_R4;
1489 case MONO_TYPE_R8:
1490 return CEE_STIND_R8;
1491 case MONO_TYPE_VALUETYPE:
1492 if (type->data.klass->enumtype) {
1493 type = type->data.klass->enum_basetype;
1494 goto handle_enum;
1495 }
1496 return CEE_STOBJ;
1497 case MONO_TYPE_TYPEDBYREF:
1498 return CEE_STOBJ;
1499 case MONO_TYPE_GENERICINST:
1500 type = &type->data.generic_class->container_class->byval_arg;
1501 goto handle_enum;
1502 default:
1503 g_error ("unknown type 0x%02x in type_to_stind", type->type);
1504 }
1505 return -1;
1506 }
1507
1508 static void
1509 emit_ptr_to_object_conv (MonoMethodBuilder *mb, MonoType *type, MonoMarshalConv conv, MonoMarshalSpec *mspec)
1510 {
1511 switch (conv) {
1512 case MONO_MARSHAL_CONV_BOOL_I4:
1513 mono_mb_emit_ldloc (mb, 1);
1514 mono_mb_emit_ldloc (mb, 0);
1515 mono_mb_emit_byte (mb, CEE_LDIND_I4);
1516 mono_mb_emit_byte (mb, CEE_BRFALSE_S);
1517 mono_mb_emit_byte (mb, 3);
1518 mono_mb_emit_byte (mb, CEE_LDC_I4_1);
1519 mono_mb_emit_byte (mb, CEE_BR_S);
1520 mono_mb_emit_byte (mb, 1);
1521 mono_mb_emit_byte (mb, CEE_LDC_I4_0);
1522 mono_mb_emit_byte (mb, CEE_STIND_I1);
1523 break;
1524 case MONO_MARSHAL_CONV_BOOL_VARIANTBOOL:
1525 mono_mb_emit_ldloc (mb, 1);
1526 mono_mb_emit_ldloc (mb, 0);
1527 mono_mb_emit_byte (mb, CEE_LDIND_I2);
1528 mono_mb_emit_byte (mb, CEE_BRFALSE_S);
1529 mono_mb_emit_byte (mb, 3);
1530 mono_mb_emit_byte (mb, CEE_LDC_I4_1);
1531 mono_mb_emit_byte (mb, CEE_BR_S);
1532 mono_mb_emit_byte (mb, 1);
1533 mono_mb_emit_byte (mb, CEE_LDC_I4_0);
1534 mono_mb_emit_byte (mb, CEE_STIND_I1);
1535 break;
1536 case MONO_MARSHAL_CONV_ARRAY_BYVALARRAY: {
1537 MonoClass *eklass = NULL;
1538 int esize;
1539
1540 if (type->type == MONO_TYPE_SZARRAY) {
1541 eklass = type->data.klass;
1542 } else {
1543 g_assert_not_reached ();
1544 }
1545
1546 esize = mono_class_native_size (eklass, NULL);
1547
1548 /* create a new array */
1549 mono_mb_emit_ldloc (mb, 1);
1550 mono_mb_emit_icon (mb, mspec->data.array_data.num_elem);
1551 mono_mb_emit_op (mb, CEE_NEWARR, eklass);
1552 mono_mb_emit_byte (mb, CEE_STIND_I);
1553
1554 if (eklass->blittable) {
1555 /* copy the elements */
1556 mono_mb_emit_ldloc (mb, 1);
1557 mono_mb_emit_byte (mb, CEE_LDIND_I);
1558 mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoArray, vector));
1559 mono_mb_emit_byte (mb, CEE_ADD);
1560 mono_mb_emit_ldloc (mb, 0);
1561 mono_mb_emit_icon (mb, mspec->data.array_data.num_elem * esize);
1562 mono_mb_emit_byte (mb, CEE_PREFIX1);
1563 mono_mb_emit_byte (mb, CEE_CPBLK);
1564 }
1565 else {
1566 int array_var, src_var, dst_var, index_var;
1567 guint32 label2, label3;
1568
1569 array_var = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
1570 src_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
1571 dst_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
1572
1573 /* set array_var */
1574 mono_mb_emit_ldloc (mb, 1);
1575 mono_mb_emit_byte (mb, CEE_LDIND_REF);
1576 mono_mb_emit_stloc (mb, array_var);
1577
1578 /* save the old src pointer */
1579 mono_mb_emit_ldloc (mb, 0);
1580 mono_mb_emit_stloc (mb, src_var);
1581 /* save the old dst pointer */
1582 mono_mb_emit_ldloc (mb, 1);
1583 mono_mb_emit_stloc (mb, dst_var);
1584
1585 /* Emit marshalling loop */
1586 index_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
1587 mono_mb_emit_byte (mb, CEE_LDC_I4_0);
1588 mono_mb_emit_stloc (mb, index_var);
1589
1590 /* Loop header */
1591 label2 = mono_mb_get_label (mb);
1592 mono_mb_emit_ldloc (mb, index_var);
1593 mono_mb_emit_ldloc (mb, array_var);
1594 mono_mb_emit_byte (mb, CEE_LDLEN);
1595 label3 = mono_mb_emit_branch (mb, CEE_BGE);
1596
1597 /* src is already set */
1598
1599 /* Set dst */
1600 mono_mb_emit_ldloc (mb, array_var);
1601 mono_mb_emit_ldloc (mb, index_var);
1602 mono_mb_emit_op (mb, CEE_LDELEMA, eklass);
1603 mono_mb_emit_stloc (mb, 1);
1604
1605 /* Do the conversion */
1606 emit_struct_conv (mb, eklass, TRUE);
1607
1608 /* Loop footer */
1609 mono_mb_emit_add_to_local (mb, index_var, 1);
1610
1611 mono_mb_emit_branch_label (mb, CEE_BR, label2);
1612
1613 mono_mb_patch_branch (mb, label3);
1614
1615 /* restore the old src pointer */
1616 mono_mb_emit_ldloc (mb, src_var);
1617 mono_mb_emit_stloc (mb, 0);
1618 /* restore the old dst pointer */
1619 mono_mb_emit_ldloc (mb, dst_var);
1620 mono_mb_emit_stloc (mb, 1);
1621 }
1622 break;
1623 }
1624 case MONO_MARSHAL_CONV_ARRAY_BYVALCHARARRAY: {
1625 MonoClass *eclass = mono_defaults.char_class;
1626
1627 /* create a new array */
1628 mono_mb_emit_ldloc (mb, 1);
1629 mono_mb_emit_icon (mb, mspec->data.array_data.num_elem);
1630 mono_mb_emit_op (mb, CEE_NEWARR, eclass);
1631 mono_mb_emit_byte (mb, CEE_STIND_REF);
1632
1633 mono_mb_emit_ldloc (mb, 1);
1634 mono_mb_emit_byte (mb, CEE_LDIND_REF);
1635 mono_mb_emit_ldloc (mb, 0);
1636 mono_mb_emit_ptr (mb, mono_defaults.byte_class);
1637 mono_mb_emit_icon (mb, mspec->data.array_data.num_elem);
1638 mono_mb_emit_icall (mb, mono_byvalarray_to_array);
1639 break;
1640 }
1641 case MONO_MARSHAL_CONV_STR_BYVALSTR:
1642 mono_mb_emit_ldloc (mb, 1);
1643 mono_mb_emit_ldloc (mb, 0);
1644 mono_mb_emit_icall (mb, mono_string_new_wrapper);
1645 mono_mb_emit_byte (mb, CEE_STIND_REF);
1646 break;
1647 case MONO_MARSHAL_CONV_STR_BYVALWSTR:
1648 mono_mb_emit_ldloc (mb, 1);
1649 mono_mb_emit_ldloc (mb, 0);
1650 mono_mb_emit_icall (mb, mono_string_from_utf16);
1651 mono_mb_emit_byte (mb, CEE_STIND_REF);
1652 break;
1653 case MONO_MARSHAL_CONV_STR_LPTSTR:
1654 mono_mb_emit_ldloc (mb, 1);
1655 mono_mb_emit_ldloc (mb, 0);
1656 mono_mb_emit_byte (mb, CEE_LDIND_I);
1657 #ifdef PLATFORM_WIN32
1658 mono_mb_emit_icall (mb, mono_string_from_utf16);
1659 #else
1660 mono_mb_emit_icall (mb, mono_string_new_wrapper);
1661 #endif
1662 mono_mb_emit_byte (mb, CEE_STIND_REF);
1663 break;
1664 case MONO_MARSHAL_CONV_STR_LPSTR:
1665 mono_mb_emit_ldloc (mb, 1);
1666 mono_mb_emit_ldloc (mb, 0);
1667 mono_mb_emit_byte (mb, CEE_LDIND_I);
1668 mono_mb_emit_icall (mb, mono_string_new_wrapper);
1669 mono_mb_emit_byte (mb, CEE_STIND_REF);
1670 break;
1671 case MONO_MARSHAL_CONV_STR_LPWSTR:
1672 mono_mb_emit_ldloc (mb, 1);
1673 mono_mb_emit_ldloc (mb, 0);
1674 mono_mb_emit_byte (mb, CEE_LDIND_I);
1675 mono_mb_emit_icall (mb, mono_string_from_utf16);
1676 mono_mb_emit_byte (mb, CEE_STIND_REF);
1677 break;
1678 case MONO_MARSHAL_CONV_OBJECT_STRUCT: {
1679 MonoClass *klass = mono_class_from_mono_type (type);
1680 int src_var, dst_var;
1681
1682 src_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
1683 dst_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
1684
1685 /* *dst = new object */
1686 mono_mb_emit_ldloc (mb, 1);
1687 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
1688 mono_mb_emit_op (mb, CEE_MONO_NEWOBJ, klass);
1689 mono_mb_emit_byte (mb, CEE_STIND_REF);
1690
1691 /* save the old src pointer */
1692 mono_mb_emit_ldloc (mb, 0);
1693 mono_mb_emit_stloc (mb, src_var);
1694 /* save the old dst pointer */
1695 mono_mb_emit_ldloc (mb, 1);
1696 mono_mb_emit_stloc (mb, dst_var);
1697
1698 /* dst = pointer to newly created object data */
1699 mono_mb_emit_ldloc (mb, 1);
1700 mono_mb_emit_byte (mb, CEE_LDIND_I);
1701 mono_mb_emit_icon (mb, sizeof (MonoObject));
1702 mono_mb_emit_byte (mb, CEE_ADD);
1703 mono_mb_emit_stloc (mb, 1);
1704
1705 emit_struct_conv (mb, klass, TRUE);
1706
1707 /* restore the old src pointer */
1708 mono_mb_emit_ldloc (mb, src_var);
1709 mono_mb_emit_stloc (mb, 0);
1710 /* restore the old dst pointer */
1711 mono_mb_emit_ldloc (mb, dst_var);
1712 mono_mb_emit_stloc (mb, 1);
1713 break;
1714 }
1715 case MONO_MARSHAL_CONV_DEL_FTN: {
1716 MonoClass *klass = mono_class_from_mono_type (type);
1717
1718 mono_mb_emit_ldloc (mb, 1);
1719 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
1720 mono_mb_emit_op (mb, CEE_MONO_CLASSCONST, klass);
1721 mono_mb_emit_ldloc (mb, 0);
1722 mono_mb_emit_byte (mb, CEE_LDIND_I);
1723 mono_mb_emit_icall (mb, mono_ftnptr_to_delegate);
1724 mono_mb_emit_byte (mb, CEE_STIND_REF);
1725 break;
1726 }
1727 case MONO_MARSHAL_CONV_ARRAY_LPARRAY:
1728 g_error ("Structure field of type %s can't be marshalled as LPArray", mono_class_from_mono_type (type)->name);
1729 break;
1730
1731 #ifndef DISABLE_COM
1732 case MONO_MARSHAL_CONV_OBJECT_INTERFACE:
1733 case MONO_MARSHAL_CONV_OBJECT_IUNKNOWN:
1734 case MONO_MARSHAL_CONV_OBJECT_IDISPATCH: {
1735 static MonoClass* com_interop_proxy_class = NULL;
1736 static MonoMethod* com_interop_proxy_get_proxy = NULL;
1737 static MonoMethod* get_transparent_proxy = NULL;
1738 int real_proxy;
1739 guint32 pos_null = 0, pos_ccw = 0, pos_end = 0;
1740 MonoClass *klass = NULL;
1741
1742 /* COM types are initialized lazily */
1743 mono_init_com_types ();
1744
1745 klass = mono_class_from_mono_type (type);
1746
1747 mono_mb_emit_ldloc (mb, 1);
1748 mono_mb_emit_byte (mb, CEE_LDNULL);
1749 mono_mb_emit_byte (mb, CEE_STIND_REF);
1750
1751 mono_mb_emit_ldloc (mb, 0);
1752 mono_mb_emit_byte (mb, CEE_LDIND_I);
1753 pos_null = mono_mb_emit_short_branch (mb, CEE_BRFALSE_S);
1754
1755 /* load dst to store later */
1756 mono_mb_emit_ldloc (mb, 1);
1757
1758 mono_mb_emit_ldloc (mb, 0);
1759 mono_mb_emit_byte (mb, CEE_LDIND_I);
1760 mono_mb_emit_icon (mb, TRUE);
1761 mono_mb_emit_icall (mb, cominterop_get_ccw_object);
1762 pos_ccw = mono_mb_emit_short_branch (mb, CEE_BRTRUE_S);
1763
1764 if (!com_interop_proxy_class)
1765 com_interop_proxy_class = mono_class_from_name (mono_defaults.corlib, "Mono.Interop", "ComInteropProxy");
1766 if (!com_interop_proxy_get_proxy)
1767 com_interop_proxy_get_proxy = mono_class_get_method_from_name_flags (com_interop_proxy_class, "GetProxy", 2, METHOD_ATTRIBUTE_PRIVATE);
1768 if (!get_transparent_proxy)
1769 get_transparent_proxy = mono_class_get_method_from_name (mono_defaults.real_proxy_class, "GetTransparentProxy", 0);
1770
1771 real_proxy = mono_mb_add_local (mb, &com_interop_proxy_class->byval_arg);
1772
1773 mono_mb_emit_ldloc (mb, 0);
1774 mono_mb_emit_byte (mb, CEE_LDIND_I);
1775 mono_mb_emit_ptr (mb, &mono_defaults.com_object_class->byval_arg);
1776 mono_mb_emit_icall (mb, type_from_handle);
1777 mono_mb_emit_managed_call (mb, com_interop_proxy_get_proxy, NULL);
1778 mono_mb_emit_managed_call (mb, get_transparent_proxy, NULL);
1779 if (conv == MONO_MARSHAL_CONV_OBJECT_INTERFACE) {
1780 g_assert (klass);
1781 mono_mb_emit_op (mb, CEE_CASTCLASS, klass);
1782 }
1783 mono_mb_emit_byte (mb, CEE_STIND_REF);
1784 pos_end = mono_mb_emit_short_branch (mb, CEE_BR_S);
1785
1786 /* is already managed object */
1787 mono_mb_patch_short_branch (mb, pos_ccw);
1788 mono_mb_emit_ldloc (mb, 0);
1789 mono_mb_emit_byte (mb, CEE_LDIND_I);
1790 mono_mb_emit_icon (mb, TRUE);
1791 mono_mb_emit_icall (mb, cominterop_get_ccw_object);
1792
1793 if (conv == MONO_MARSHAL_CONV_OBJECT_INTERFACE) {
1794 g_assert (klass);
1795 mono_mb_emit_op (mb, CEE_CASTCLASS, klass);
1796 }
1797 mono_mb_emit_byte (mb, CEE_STIND_REF);
1798
1799 mono_mb_patch_short_branch (mb, pos_end);
1800 /* case if null */
1801 mono_mb_patch_short_branch (mb, pos_null);
1802 break;
1803 }
1804 #endif /* DISABLE_COM */
1805
1806 case MONO_MARSHAL_CONV_SAFEHANDLE: {
1807 /*
1808 * Passing SafeHandles as ref does not allow the unmanaged code
1809 * to change the SafeHandle value. If the value is changed,
1810 * we should issue a diagnostic exception (NotSupportedException)
1811 * that informs the user that changes to handles in unmanaged code
1812 * is not supported.
1813 *
1814 * Since we currently have no access to the original
1815 * SafeHandle that was used during the marshalling,
1816 * for now we just ignore this, and ignore/discard any
1817 * changes that might have happened to the handle.
1818 */
1819 break;
1820 }
1821
1822 case MONO_MARSHAL_CONV_HANDLEREF: {
1823 /*
1824 * Passing HandleRefs in a struct that is ref()ed does not
1825 * copy the values back to the HandleRef
1826 */
1827 break;
1828 }
1829
1830 case MONO_MARSHAL_CONV_STR_BSTR:
1831 case MONO_MARSHAL_CONV_STR_ANSIBSTR:
1832 case MONO_MARSHAL_CONV_STR_TBSTR:
1833 case MONO_MARSHAL_CONV_ARRAY_SAVEARRAY:
1834 default:
1835 g_warning ("marshaling conversion %d not implemented", conv);
1836 g_assert_not_reached ();
1837 }
1838 }
1839
1840 static gpointer
1841 conv_to_icall (MonoMarshalConv conv)
1842 {
1843 switch (conv) {
1844 case MONO_MARSHAL_CONV_STR_LPWSTR:
1845 return mono_marshal_string_to_utf16;
1846 case MONO_MARSHAL_CONV_LPWSTR_STR:
1847 return mono_string_from_utf16;
1848 case MONO_MARSHAL_CONV_LPSTR_STR:
1849 return mono_string_new_wrapper;
1850 case MONO_MARSHAL_CONV_STR_LPTSTR:
1851 #ifdef PLATFORM_WIN32
1852 return mono_marshal_string_to_utf16;
1853 #else
1854 return mono_string_to_lpstr;
1855 #endif
1856 case MONO_MARSHAL_CONV_STR_LPSTR:
1857 return mono_string_to_lpstr;
1858 case MONO_MARSHAL_CONV_STR_BSTR:
1859 return mono_string_to_bstr;
1860 case MONO_MARSHAL_CONV_BSTR_STR:
1861 return mono_string_from_bstr;
1862 case MONO_MARSHAL_CONV_STR_TBSTR:
1863 case MONO_MARSHAL_CONV_STR_ANSIBSTR:
1864 return mono_string_to_ansibstr;
1865 case MONO_MARSHAL_CONV_SB_LPSTR:
1866 return mono_string_builder_to_utf8;
1867 case MONO_MARSHAL_CONV_SB_LPTSTR:
1868 #ifdef PLATFORM_WIN32
1869 return mono_string_builder_to_utf16;
1870 #else
1871 return mono_string_builder_to_utf8;
1872 #endif
1873 case MONO_MARSHAL_CONV_SB_LPWSTR:
1874 return mono_string_builder_to_utf16;
1875 case MONO_MARSHAL_CONV_ARRAY_SAVEARRAY:
1876 return mono_array_to_savearray;
1877 case MONO_MARSHAL_CONV_ARRAY_LPARRAY:
1878 return mono_array_to_lparray;
1879 case MONO_MARSHAL_CONV_DEL_FTN:
1880 return mono_delegate_to_ftnptr;
1881 case MONO_MARSHAL_CONV_FTN_DEL:
1882 return mono_ftnptr_to_delegate;
1883 case MONO_MARSHAL_CONV_LPSTR_SB:
1884 return mono_string_utf8_to_builder;
1885 case MONO_MARSHAL_CONV_LPTSTR_SB:
1886 #ifdef PLATFORM_WIN32
1887 return mono_string_utf16_to_builder;
1888 #else
1889 return mono_string_utf8_to_builder;
1890 #endif
1891 case MONO_MARSHAL_CONV_LPWSTR_SB:
1892 return mono_string_utf16_to_builder;
1893 case MONO_MARSHAL_FREE_ARRAY:
1894 return mono_marshal_free_array;
1895 case MONO_MARSHAL_CONV_STR_BYVALSTR:
1896 return mono_string_to_byvalstr;
1897 case MONO_MARSHAL_CONV_STR_BYVALWSTR:
1898 return mono_string_to_byvalwstr;
1899 default:
1900 g_assert_not_reached ();
1901 }
1902
1903 return NULL;
1904 }
1905
1906 static void
1907 emit_object_to_ptr_conv (MonoMethodBuilder *mb, MonoType *type, MonoMarshalConv conv, MonoMarshalSpec *mspec)
1908 {
1909 int pos;
1910
1911 switch (conv) {
1912 case MONO_MARSHAL_CONV_BOOL_I4:
1913 mono_mb_emit_ldloc (mb, 1);
1914 mono_mb_emit_ldloc (mb, 0);
1915 mono_mb_emit_byte (mb, CEE_LDIND_U1);
1916 mono_mb_emit_byte (mb, CEE_STIND_I4);
1917 break;
1918 case MONO_MARSHAL_CONV_BOOL_VARIANTBOOL:
1919 mono_mb_emit_ldloc (mb, 1);
1920 mono_mb_emit_ldloc (mb, 0);
1921 mono_mb_emit_byte (mb, CEE_LDIND_U1);
1922 mono_mb_emit_byte (mb, CEE_NEG);
1923 mono_mb_emit_byte (mb, CEE_STIND_I2);
1924 break;
1925 case MONO_MARSHAL_CONV_STR_LPWSTR:
1926 case MONO_MARSHAL_CONV_STR_LPSTR:
1927 case MONO_MARSHAL_CONV_STR_LPTSTR:
1928 case MONO_MARSHAL_CONV_STR_BSTR:
1929 case MONO_MARSHAL_CONV_STR_ANSIBSTR:
1930 case MONO_MARSHAL_CONV_STR_TBSTR: {
1931 int pos;
1932
1933 /* free space if free == true */
1934 mono_mb_emit_ldloc (mb, 2);
1935 pos = mono_mb_emit_short_branch (mb, CEE_BRFALSE_S);
1936 mono_mb_emit_ldloc (mb, 1);
1937 mono_mb_emit_byte (mb, CEE_LDIND_I);
1938 mono_mb_emit_icall (mb, g_free);
1939 mono_mb_patch_short_branch (mb, pos);
1940
1941 mono_mb_emit_ldloc (mb, 1);
1942 mono_mb_emit_ldloc (mb, 0);
1943 mono_mb_emit_byte (mb, CEE_LDIND_REF);
1944 mono_mb_emit_icall (mb, conv_to_icall (conv));
1945 mono_mb_emit_byte (mb, CEE_STIND_I);
1946 break;
1947 }
1948 case MONO_MARSHAL_CONV_ARRAY_SAVEARRAY:
1949 case MONO_MARSHAL_CONV_ARRAY_LPARRAY:
1950 case MONO_MARSHAL_CONV_DEL_FTN:
1951 mono_mb_emit_ldloc (mb, 1);
1952 mono_mb_emit_ldloc (mb, 0);
1953 mono_mb_emit_byte (mb, CEE_LDIND_REF);
1954 mono_mb_emit_icall (mb, conv_to_icall (conv));
1955 mono_mb_emit_byte (mb, CEE_STIND_I);
1956 break;
1957 case MONO_MARSHAL_CONV_STR_BYVALSTR:
1958 case MONO_MARSHAL_CONV_STR_BYVALWSTR: {
1959 g_assert (mspec);
1960
1961 mono_mb_emit_ldloc (mb, 1); /* dst */
1962 mono_mb_emit_ldloc (mb, 0);
1963 mono_mb_emit_byte (mb, CEE_LDIND_REF); /* src String */
1964 mono_mb_emit_icon (mb, mspec->data.array_data.num_elem);
1965 mono_mb_emit_icall (mb, conv_to_icall (conv));
1966 break;
1967 }
1968 case MONO_MARSHAL_CONV_ARRAY_BYVALARRAY: {
1969 MonoClass *eklass = NULL;
1970 int esize;
1971
1972 if (type->type == MONO_TYPE_SZARRAY) {
1973 eklass = type->data.klass;
1974 } else {
1975 g_assert_not_reached ();
1976 }
1977
1978 if (eklass->valuetype)
1979 esize = mono_class_native_size (eklass, NULL);
1980 else
1981 esize = sizeof (gpointer);
1982
1983 mono_mb_emit_ldloc (mb, 0);
1984 mono_mb_emit_byte (mb, CEE_LDIND_REF);
1985 pos = mono_mb_emit_branch (mb, CEE_BRFALSE);
1986
1987 if (eklass->blittable) {
1988 mono_mb_emit_ldloc (mb, 1);
1989 mono_mb_emit_ldloc (mb, 0);
1990 mono_mb_emit_byte (mb, CEE_LDIND_REF);
1991 mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoArray, vector));
1992 mono_mb_emit_icon (mb, mspec->data.array_data.num_elem * esize);
1993 mono_mb_emit_byte (mb, CEE_PREFIX1);
1994 mono_mb_emit_byte (mb, CEE_CPBLK);
1995 } else {
1996 int array_var, src_var, dst_var, index_var;
1997 guint32 label2, label3;
1998
1999 array_var = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
2000 src_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
2001 dst_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
2002
2003 /* set array_var */
2004 mono_mb_emit_ldloc (mb, 0);
2005 mono_mb_emit_byte (mb, CEE_LDIND_REF);
2006 mono_mb_emit_stloc (mb, array_var);
2007
2008 /* save the old src pointer */
2009 mono_mb_emit_ldloc (mb, 0);
2010 mono_mb_emit_stloc (mb, src_var);
2011 /* save the old dst pointer */
2012 mono_mb_emit_ldloc (mb, 1);
2013 mono_mb_emit_stloc (mb, dst_var);
2014
2015 /* Emit marshalling loop */
2016 index_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
2017 mono_mb_emit_byte (mb, CEE_LDC_I4_0);
2018 mono_mb_emit_stloc (mb, index_var);
2019
2020 /* Loop header */
2021 label2 = mono_mb_get_label (mb);
2022 mono_mb_emit_ldloc (mb, index_var);
2023 mono_mb_emit_ldloc (mb, array_var);
2024 mono_mb_emit_byte (mb, CEE_LDLEN);
2025 label3 = mono_mb_emit_branch (mb, CEE_BGE);
2026
2027 /* Set src */
2028 mono_mb_emit_ldloc (mb, array_var);
2029 mono_mb_emit_ldloc (mb, index_var);
2030 mono_mb_emit_op (mb, CEE_LDELEMA, eklass);
2031 mono_mb_emit_stloc (mb, 0);
2032
2033 /* dst is already set */
2034
2035 /* Do the conversion */
2036 emit_struct_conv (mb, eklass, FALSE);
2037
2038 /* Loop footer */
2039 mono_mb_emit_add_to_local (mb, index_var, 1);
2040
2041 mono_mb_emit_branch_label (mb, CEE_BR, label2);
2042
2043 mono_mb_patch_branch (mb, label3);
2044
2045 /* restore the old src pointer */
2046 mono_mb_emit_ldloc (mb, src_var);
2047 mono_mb_emit_stloc (mb, 0);
2048 /* restore the old dst pointer */
2049 mono_mb_emit_ldloc (mb, dst_var);
2050 mono_mb_emit_stloc (mb, 1);
2051 }
2052
2053 mono_mb_patch_branch (mb, pos);
2054 break;
2055 }
2056 case MONO_MARSHAL_CONV_ARRAY_BYVALCHARARRAY: {
2057 mono_mb_emit_ldloc (mb, 0);
2058 mono_mb_emit_byte (mb, CEE_LDIND_REF);
2059 pos = mono_mb_emit_short_branch (mb, CEE_BRFALSE_S);
2060
2061 mono_mb_emit_ldloc (mb, 1);
2062 mono_mb_emit_ldloc (mb, 0);
2063 mono_mb_emit_byte (mb, CEE_LDIND_REF);
2064 mono_mb_emit_ptr (mb, mono_defaults.byte_class);
2065 mono_mb_emit_icon (mb, mspec->data.array_data.num_elem);
2066 mono_mb_emit_icall (mb, mono_array_to_byvalarray);
2067 mono_mb_patch_short_branch (mb, pos);
2068 break;
2069 }
2070 case MONO_MARSHAL_CONV_OBJECT_STRUCT: {
2071 int src_var, dst_var;
2072
2073 src_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
2074 dst_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
2075
2076 mono_mb_emit_ldloc (mb, 0);
2077 mono_mb_emit_byte (mb, CEE_LDIND_I);
2078 pos = mono_mb_emit_branch (mb, CEE_BRFALSE);
2079
2080 /* save the old src pointer */
2081 mono_mb_emit_ldloc (mb, 0);
2082 mono_mb_emit_stloc (mb, src_var);
2083 /* save the old dst pointer */
2084 mono_mb_emit_ldloc (mb, 1);
2085 mono_mb_emit_stloc (mb, dst_var);
2086
2087 /* src = pointer to object data */
2088 mono_mb_emit_ldloc (mb, 0);
2089 mono_mb_emit_byte (mb, CEE_LDIND_I);
2090 mono_mb_emit_icon (mb, sizeof (MonoObject));
2091 mono_mb_emit_byte (mb, CEE_ADD);
2092 mono_mb_emit_stloc (mb, 0);
2093
2094 emit_struct_conv (mb, mono_class_from_mono_type (type), FALSE);
2095
2096 /* restore the old src pointer */
2097 mono_mb_emit_ldloc (mb, src_var);
2098 mono_mb_emit_stloc (mb, 0);
2099 /* restore the old dst pointer */
2100 mono_mb_emit_ldloc (mb, dst_var);
2101 mono_mb_emit_stloc (mb, 1);
2102
2103 mono_mb_patch_branch (mb, pos);
2104 break;
2105 }
2106
2107 #ifndef DISABLE_COM
2108 case MONO_MARSHAL_CONV_OBJECT_INTERFACE:
2109 case MONO_MARSHAL_CONV_OBJECT_IDISPATCH:
2110 case MONO_MARSHAL_CONV_OBJECT_IUNKNOWN: {
2111 guint32 pos_null = 0, pos_rcw = 0, pos_end = 0;
2112
2113 /* COM types are initialized lazily */
2114 mono_init_com_types ();
2115
2116
2117 mono_mb_emit_ldloc (mb, 1);
2118 mono_mb_emit_icon (mb, 0);
2119 mono_mb_emit_byte (mb, CEE_CONV_U);
2120 mono_mb_emit_byte (mb, CEE_STIND_I);
2121
2122 mono_mb_emit_ldloc (mb, 0);
2123 mono_mb_emit_byte (mb, CEE_LDIND_REF);
2124
2125 // if null just break, dst was already inited to 0
2126 pos_null = mono_mb_emit_short_branch (mb, CEE_BRFALSE_S);
2127
2128 mono_mb_emit_ldloc (mb, 0);
2129 mono_mb_emit_byte (mb, CEE_LDIND_REF);
2130 mono_mb_emit_icall (mb, cominterop_object_is_rcw);
2131 pos_rcw = mono_mb_emit_short_branch (mb, CEE_BRFALSE_S);
2132
2133 // load dst to store later
2134 mono_mb_emit_ldloc (mb, 1);
2135
2136 // load src
2137 mono_mb_emit_ldloc (mb, 0);
2138 mono_mb_emit_byte (mb, CEE_LDIND_REF);
2139 mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoTransparentProxy, rp));
2140 mono_mb_emit_byte (mb, CEE_LDIND_REF);
2141
2142 /* load the RCW from the ComInteropProxy*/
2143 mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoComInteropProxy, com_object));
2144 mono_mb_emit_byte (mb, CEE_LDIND_REF);
2145
2146 if (conv == MONO_MARSHAL_CONV_OBJECT_INTERFACE) {
2147 mono_mb_emit_ptr (mb, mono_type_get_class (type));
2148 mono_mb_emit_icon (mb, TRUE);
2149 mono_mb_emit_icall (mb, cominterop_get_interface);
2150
2151 }
2152 else if (conv == MONO_MARSHAL_CONV_OBJECT_IUNKNOWN) {
2153 static MonoProperty* iunknown = NULL;
2154
2155 if (!iunknown)
2156 iunknown = mono_class_get_property_from_name (mono_defaults.com_object_class, "IUnknown");
2157 mono_mb_emit_managed_call (mb, iunknown->get, NULL);
2158 }
2159 else if (conv == MONO_MARSHAL_CONV_OBJECT_IDISPATCH) {
2160 static MonoProperty* idispatch = NULL;
2161
2162 if (!idispatch)
2163 idispatch = mono_class_get_property_from_name (mono_defaults.com_object_class, "IDispatch");
2164 mono_mb_emit_managed_call (mb, idispatch->get, NULL);
2165 }
2166 else {
2167 g_assert_not_reached ();
2168 }
2169 mono_mb_emit_byte (mb, CEE_STIND_I);
2170 pos_end = mono_mb_emit_short_branch (mb, CEE_BR_S);
2171
2172 // if not rcw
2173 mono_mb_patch_short_branch (mb, pos_rcw);
2174 /* load dst to store later */
2175 mono_mb_emit_ldloc (mb, 1);
2176 /* load src */
2177 mono_mb_emit_ldloc (mb, 0);
2178 mono_mb_emit_byte (mb, CEE_LDIND_REF);
2179
2180 if (conv == MONO_MARSHAL_CONV_OBJECT_INTERFACE)
2181 mono_mb_emit_ptr (mb, mono_type_get_class (type));
2182 else if (conv == MONO_MARSHAL_CONV_OBJECT_IUNKNOWN)
2183 mono_mb_emit_ptr (mb, mono_defaults.iunknown_class);
2184 else if (conv == MONO_MARSHAL_CONV_OBJECT_IDISPATCH)
2185 mono_mb_emit_ptr (mb, mono_defaults.idispatch_class);
2186 else
2187 g_assert_not_reached ();
2188 mono_mb_emit_icall (mb, cominterop_get_ccw);
2189 mono_mb_emit_byte (mb, CEE_STIND_I);
2190
2191 mono_mb_patch_short_branch (mb, pos_end);
2192 mono_mb_patch_short_branch (mb, pos_null);
2193 break;
2194 }
2195 #endif /* DISABLE_COM */
2196
2197 case MONO_MARSHAL_CONV_SAFEHANDLE: {
2198 int dar_release_slot, pos;
2199
2200 dar_release_slot = mono_mb_add_local (mb, &mono_defaults.boolean_class->byval_arg);
2201
2202 /*
2203 * The following is ifdefed-out, because I have no way of doing the
2204 * DangerousRelease when destroying the structure
2205 */
2206 #if 0
2207 /* set release = false */
2208 mono_mb_emit_icon (mb, 0);
2209 mono_mb_emit_stloc (mb, dar_release_slot);
2210 if (!sh_dangerous_add_ref)
2211 init_safe_handle ();
2212
2213 /* safehandle.DangerousAddRef (ref release) */
2214 mono_mb_emit_ldloc (mb, 0); /* the source */
2215 mono_mb_emit_byte (mb, CEE_LDIND_I);
2216 mono_mb_emit_ldloc_addr (mb, dar_release_slot);
2217 mono_mb_emit_managed_call (mb, sh_dangerous_add_ref, NULL);
2218 #endif
2219 mono_mb_emit_ldloc (mb, 0);
2220 mono_mb_emit_byte (mb, CEE_LDIND_I);
2221 pos = mono_mb_emit_branch (mb, CEE_BRTRUE);
2222 mono_mb_emit_exception (mb, "ArgumentNullException", NULL);
2223 mono_mb_patch_branch (mb, pos);
2224
2225 /* Pull the handle field from SafeHandle */
2226 mono_mb_emit_ldloc (mb, 1);
2227 mono_mb_emit_ldloc (mb, 0);
2228 mono_mb_emit_byte (mb, CEE_LDIND_I);
2229 mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoSafeHandle, handle));
2230 mono_mb_emit_byte (mb, CEE_LDIND_I);
2231 mono_mb_emit_byte (mb, CEE_STIND_I);
2232 break;
2233 }
2234
2235 case MONO_MARSHAL_CONV_HANDLEREF: {
2236 mono_mb_emit_ldloc (mb, 1);
2237 mono_mb_emit_ldloc (mb, 0);
2238 mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoHandleRef, handle));
2239 mono_mb_emit_byte (mb, CEE_ADD);
2240 mono_mb_emit_byte (mb, CEE_LDIND_I);
2241 mono_mb_emit_byte (mb, CEE_STIND_I);
2242 break;
2243 }
2244
2245 default: {
2246 char *msg = g_strdup_printf ("marshalling conversion %d not implemented", conv);
2247 MonoException *exc = mono_get_exception_not_implemented (msg);
2248 g_warning (msg);
2249 g_free (msg);
2250 mono_raise_exception (exc);
2251 }
2252 }
2253 }
2254
2255 static void
2256 emit_struct_conv (MonoMethodBuilder *mb, MonoClass *klass, gboolean to_object)
2257 {
2258 MonoMarshalType *info;
2259 int i;
2260
2261 if (klass->parent)
2262 emit_struct_conv(mb, klass->parent, to_object);
2263
2264 info = mono_marshal_load_type_info (klass);
2265
2266 if (info->native_size == 0)
2267 return;
2268
2269 if (klass->blittable) {
2270 int msize = mono_class_value_size (klass, NULL);
2271 g_assert (msize == info->native_size);
2272 mono_mb_emit_ldloc (mb, 1);
2273 mono_mb_emit_ldloc (mb, 0);
2274 mono_mb_emit_icon (mb, msize);
2275 mono_mb_emit_byte (mb, CEE_PREFIX1);
2276 mono_mb_emit_byte (mb, CEE_CPBLK);
2277
2278 mono_mb_emit_add_to_local (mb, 0, msize);
2279 mono_mb_emit_add_to_local (mb, 1, msize);
2280 return;
2281 }
2282
2283 for (i = 0; i < info->num_fields; i++) {
2284 MonoMarshalNative ntype;
2285 MonoMarshalConv conv;
2286 MonoType *ftype = info->fields [i].field->type;
2287 int msize = 0;
2288 int usize = 0;
2289 gboolean last_field = i < (info->num_fields -1) ? 0 : 1;
2290
2291 if (ftype->attrs & FIELD_ATTRIBUTE_STATIC)
2292 continue;
2293
2294 ntype = mono_type_to_unmanaged (ftype, info->fields [i].mspec, TRUE, klass->unicode, &conv);
2295
2296 if (last_field) {
2297 msize = klass->instance_size - info->fields [i].field->offset;
2298 usize = info->native_size - info->fields [i].offset;
2299 } else {
2300 msize = info->fields [i + 1].field->offset - info->fields [i].field->offset;
2301 usize = info->fields [i + 1].offset - info->fields [i].offset;
2302 }
2303
2304 if (klass != mono_defaults.safehandle_class){
2305 /*
2306 * FIXME: Should really check for usize==0 and msize>0, but we apply
2307 * the layout to the managed structure as well.
2308 */
2309
2310 if (((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) && (usize == 0)) {
2311 if (MONO_TYPE_IS_REFERENCE (info->fields [i].field->type) ||
2312 ((!last_field && MONO_TYPE_IS_REFERENCE (info->fields [i + 1].field->type))))
2313 g_error ("Type %s which has an [ExplicitLayout] attribute cannot have a "
2314 "reference field at the same offset as another field.",
2315 mono_type_full_name (&klass->byval_arg));
2316 }
2317
2318 if ((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_AUTO_LAYOUT)
2319 g_error ("Type %s which is passed to unmanaged code must have a StructLayout attribute",
2320 mono_type_full_name (&klass->byval_arg));
2321
2322 }
2323
2324 switch (conv) {
2325 case MONO_MARSHAL_CONV_NONE: {
2326 int t;
2327
2328 if (ftype->byref || ftype->type == MONO_TYPE_I ||
2329 ftype->type == MONO_TYPE_U) {
2330 mono_mb_emit_ldloc (mb, 1);
2331 mono_mb_emit_ldloc (mb, 0);
2332 mono_mb_emit_byte (mb, CEE_LDIND_I);
2333 mono_mb_emit_byte (mb, CEE_STIND_I);
2334 break;
2335 }
2336
2337 handle_enum:
2338 t = ftype->type;
2339 switch (t) {
2340 case MONO_TYPE_I4:
2341 case MONO_TYPE_U4:
2342 case MONO_TYPE_I1:
2343 case MONO_TYPE_U1:
2344 case MONO_TYPE_BOOLEAN:
2345 case MONO_TYPE_I2:
2346 case MONO_TYPE_U2:
2347 case MONO_TYPE_CHAR:
2348 case MONO_TYPE_I8:
2349 case MONO_TYPE_U8:
2350 case MONO_TYPE_PTR:
2351 case MONO_TYPE_R4:
2352 case MONO_TYPE_R8:
2353 mono_mb_emit_ldloc (mb, 1);
2354 mono_mb_emit_ldloc (mb, 0);
2355 mono_mb_emit_byte (mb, mono_type_to_ldind (ftype));
2356 mono_mb_emit_byte (mb, mono_type_to_stind (ftype));
2357 break;
2358 case MONO_TYPE_VALUETYPE: {
2359 int src_var, dst_var;
2360
2361 if (ftype->data.klass->enumtype) {
2362 ftype = ftype->data.klass->enum_basetype;
2363 goto handle_enum;
2364 }
2365
2366 src_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
2367 dst_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
2368
2369 /* save the old src pointer */
2370 mono_mb_emit_ldloc (mb, 0);
2371 mono_mb_emit_stloc (mb, src_var);
2372 /* save the old dst pointer */
2373 mono_mb_emit_ldloc (mb, 1);
2374 mono_mb_emit_stloc (mb, dst_var);
2375
2376 emit_struct_conv (mb, ftype->data.klass, to_object);
2377
2378 /* restore the old src pointer */
2379 mono_mb_emit_ldloc (mb, src_var);
2380 mono_mb_emit_stloc (mb, 0);
2381 /* restore the old dst pointer */
2382 mono_mb_emit_ldloc (mb, dst_var);
2383 mono_mb_emit_stloc (mb, 1);
2384 break;
2385 }
2386 case MONO_TYPE_OBJECT: {
2387 mono_init_com_types ();
2388 if (to_object) {
2389 static MonoMethod *variant_clear = NULL;
2390 static MonoMethod *get_object_for_native_variant = NULL;
2391
2392 if (!variant_clear)
2393 variant_clear = mono_class_get_method_from_name (mono_defaults.variant_class, "Clear", 0);
2394 if (!get_object_for_native_variant)
2395 get_object_for_native_variant = mono_class_get_method_from_name (mono_defaults.marshal_class, "GetObjectForNativeVariant", 1);
2396 mono_mb_emit_ldloc (mb, 1);
2397 mono_mb_emit_ldloc (mb, 0);
2398 mono_mb_emit_managed_call (mb, get_object_for_native_variant, NULL);
2399 mono_mb_emit_byte (mb, CEE_STIND_REF);
2400
2401 mono_mb_emit_ldloc (mb, 0);
2402 mono_mb_emit_managed_call (mb, variant_clear, NULL);
2403 }
2404 else {
2405 static MonoMethod *get_native_variant_for_object = NULL;
2406
2407 if (!get_native_variant_for_object)
2408 get_native_variant_for_object = mono_class_get_method_from_name (mono_defaults.marshal_class, "GetNativeVariantForObject", 2);
2409
2410 mono_mb_emit_ldloc (mb, 0);
2411 mono_mb_emit_byte(mb, CEE_LDIND_REF);
2412 mono_mb_emit_ldloc (mb, 1);
2413 mono_mb_emit_managed_call (mb, get_native_variant_for_object, NULL);
2414 }
2415 break;
2416 }
2417
2418 default:
2419 g_warning ("marshaling type %02x not implemented", ftype->type);
2420 g_assert_not_reached ();
2421 }
2422 break;
2423 }
2424 default: {
2425 int src_var, dst_var;
2426
2427 src_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
2428 dst_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
2429
2430 /* save the old src pointer */
2431 mono_mb_emit_ldloc (mb, 0);
2432 mono_mb_emit_stloc (mb, src_var);
2433 /* save the old dst pointer */
2434 mono_mb_emit_ldloc (mb, 1);
2435 mono_mb_emit_stloc (mb, dst_var);
2436
2437 if (to_object)
2438 emit_ptr_to_object_conv (mb, ftype, conv, info->fields [i].mspec);
2439 else
2440 emit_object_to_ptr_conv (mb, ftype, conv, info->fields [i].mspec);
2441
2442 /* restore the old src pointer */
2443 mono_mb_emit_ldloc (mb, src_var);
2444 mono_mb_emit_stloc (mb, 0);
2445 /* restore the old dst pointer */
2446 mono_mb_emit_ldloc (mb, dst_var);
2447 mono_mb_emit_stloc (mb, 1);
2448 }
2449 }
2450
2451 if (to_object) {
2452 mono_mb_emit_add_to_local (mb, 0, usize);
2453 mono_mb_emit_add_to_local (mb, 1, msize);
2454 } else {
2455 mono_mb_emit_add_to_local (mb, 0, msize);
2456 mono_mb_emit_add_to_local (mb, 1, usize);
2457 }
2458 }
2459 }
2460
2461 static void
2462 emit_struct_free (MonoMethodBuilder *mb, MonoClass *klass, int struct_var)
2463 {
2464 /* Call DestroyStructure */
2465 /* FIXME: Only do this if needed */
2466 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
2467 mono_mb_emit_op (mb, CEE_MONO_CLASSCONST, klass);
2468 mono_mb_emit_ldloc (mb, struct_var);
2469 mono_mb_emit_icall (mb, mono_struct_delete_old);
2470 }
2471
2472 static void
2473 emit_thread_interrupt_checkpoint_call (MonoMethodBuilder *mb, gpointer checkpoint_func)
2474 {
2475 int pos_noabort;
2476
2477 mono_mb_emit_ptr (mb, (gpointer) mono_thread_interruption_request_flag ());
2478 mono_mb_emit_byte (mb, CEE_LDIND_U4);
2479 pos_noabort = mono_mb_emit_branch (mb, CEE_BRFALSE);
2480
2481 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
2482 mono_mb_emit_byte (mb, CEE_MONO_NOT_TAKEN);
2483
2484 mono_mb_emit_icall (mb, checkpoint_func);
2485
2486 mono_mb_patch_branch (mb, pos_noabort);
2487 }
2488
2489 static void
2490 emit_thread_interrupt_checkpoint (MonoMethodBuilder *mb)
2491 {
2492 if (strstr (mb->name, "mono_thread_interruption_checkpoint"))
2493 return;
2494
2495 emit_thread_interrupt_checkpoint_call (mb, mono_thread_interruption_checkpoint);
2496 }
2497
2498 static void
2499 emit_thread_force_interrupt_checkpoint (MonoMethodBuilder *mb)
2500 {
2501 emit_thread_interrupt_checkpoint_call (mb, mono_thread_force_interruption_checkpoint);
2502 }
2503
2504 static MonoAsyncResult *
2505 mono_delegate_begin_invoke (MonoDelegate *delegate, gpointer *params)
2506 {
2507 MonoMethodMessage *msg;
2508 MonoDelegate *async_callback;
2509 MonoObject *state;
2510 MonoMethod *im;
2511 MonoClass *klass;
2512 MonoMethod *method = NULL, *method2 = NULL;
2513
2514 g_assert (delegate);
2515
2516 if (delegate->target && mono_object_class (delegate->target) == mono_defaults.transparent_proxy_class) {
2517
2518 MonoTransparentProxy* tp = (MonoTransparentProxy *)delegate->target;
2519 if (!tp->remote_class->proxy_class->contextbound || tp->rp->context != (MonoObject *) mono_context_get ()) {
2520
2521 /* If the target is a proxy, make a direct call. Is proxy's work
2522 // to make the call asynchronous.
2523 */
2524 MonoAsyncResult *ares;
2525 MonoObject *exc;
2526 MonoArray *out_args;
2527 HANDLE handle;
2528 method = delegate->method;
2529
2530 msg = mono_method_call_message_new (mono_marshal_method_from_wrapper (method), params, NULL, &async_callback, &state);
2531 handle = CreateEvent (NULL, TRUE, FALSE, NULL);
2532 g_assert(handle != NULL);
2533 ares = mono_async_result_new (mono_domain_get (), handle, state, handle, NULL);
2534 MONO_OBJECT_SETREF (ares, async_delegate, (MonoObject *)delegate);
2535 MONO_OBJECT_SETREF (ares, async_callback, (MonoObject *)async_callback);
2536 MONO_OBJECT_SETREF (msg, async_result, ares);
2537 msg->call_type = CallType_BeginInvoke;
2538
2539 mono_remoting_invoke ((MonoObject *)tp->rp, msg, &exc, &out_args);
2540 return ares;
2541 }
2542 }
2543
2544 klass = delegate->object.vtable->klass;
2545
2546 method = mono_get_delegate_invoke (klass);
2547 method2 = mono_class_get_method_from_name (klass, "BeginInvoke", -1);
2548 if (method2)
2549 method = method2;
2550 g_assert (method != NULL);
2551
2552 im = mono_get_delegate_invoke (method->klass);
2553 msg = mono_method_call_message_new (method, params, im, &async_callback, &state);
2554
2555 return mono_thread_pool_add ((MonoObject *)delegate, msg, async_callback, state);
2556 }
2557
2558 static int
2559 mono_mb_emit_save_args (MonoMethodBuilder *mb, MonoMethodSignature *sig, gboolean save_this)
2560 {
2561 int i, params_var, tmp_var;
2562
2563 /* allocate local (pointer) *params[] */
2564 params_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
2565 /* allocate local (pointer) tmp */
2566 tmp_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
2567
2568 /* alloate space on stack to store an array of pointers to the arguments */
2569 mono_mb_emit_icon (mb, sizeof (gpointer) * (sig->param_count + 1));
2570 mono_mb_emit_byte (mb, CEE_PREFIX1);
2571 mono_mb_emit_byte (mb, CEE_LOCALLOC);
2572 mono_mb_emit_stloc (mb, params_var);
2573
2574 /* tmp = params */
2575 mono_mb_emit_ldloc (mb, params_var);
2576 mono_mb_emit_stloc (mb, tmp_var);
2577
2578 if (save_this && sig->hasthis) {
2579 mono_mb_emit_ldloc (mb, tmp_var);
2580 mono_mb_emit_ldarg_addr (mb, 0);
2581 mono_mb_emit_byte (mb, CEE_STIND_I);
2582 /* tmp = tmp + sizeof (gpointer) */
2583 if (sig->param_count)
2584 mono_mb_emit_add_to_local (mb, tmp_var, sizeof (gpointer));
2585
2586 }
2587
2588 for (i = 0; i < sig->param_count; i++) {
2589 mono_mb_emit_ldloc (mb, tmp_var);
2590 mono_mb_emit_ldarg_addr (mb, i + sig->hasthis);
2591 mono_mb_emit_byte (mb, CEE_STIND_I);
2592 /* tmp = tmp + sizeof (gpointer) */
2593 if (i < (sig->param_count - 1))
2594 mono_mb_emit_add_to_local (mb, tmp_var, sizeof (gpointer));
2595 }
2596
2597 return params_var;
2598 }
2599
2600 static char*
2601 mono_signature_to_name (MonoMethodSignature *sig, const char *prefix)
2602 {
2603 int i;
2604 char *result;
2605 GString *res = g_string_new ("");
2606
2607 if (prefix) {
2608 g_string_append (res, prefix);
2609 g_string_append_c (res, '_');
2610 }
2611
2612 mono_type_get_desc (res, sig->ret, FALSE);
2613
2614 if (sig->hasthis)
2615 g_string_append (res, "__this__");
2616
2617 for (i = 0; i < sig->param_count; ++i) {
2618 g_string_append_c (res, '_');
2619 mono_type_get_desc (res, sig->params [i], FALSE);
2620 }
2621 result = res->str;
2622 g_string_free (res, FALSE);
2623 return result;
2624 }
2625
2626 /**
2627 * mono_marshal_get_string_encoding:
2628 *
2629 * Return the string encoding which should be used for a given parameter.
2630 */
2631 static MonoMarshalNative
2632 mono_marshal_get_string_encoding (MonoMethodPInvoke *piinfo, MonoMarshalSpec *spec)
2633 {
2634 /* First try the parameter marshal info */
2635 if (spec) {
2636 if (spec->native == MONO_NATIVE_LPARRAY) {
2637 if ((spec->data.array_data.elem_type != 0) && (spec->data.array_data.elem_type != MONO_NATIVE_MAX))
2638 return spec->data.array_data.elem_type;
2639 }
2640 else
2641 return spec->native;
2642 }
2643
2644 if (!piinfo)
2645 return MONO_NATIVE_LPSTR;
2646
2647 /* Then try the method level marshal info */
2648 switch (piinfo->piflags & PINVOKE_ATTRIBUTE_CHAR_SET_MASK) {
2649 case PINVOKE_ATTRIBUTE_CHAR_SET_ANSI:
2650 return MONO_NATIVE_LPSTR;
2651 case PINVOKE_ATTRIBUTE_CHAR_SET_UNICODE:
2652 return MONO_NATIVE_LPWSTR;
2653 case PINVOKE_ATTRIBUTE_CHAR_SET_AUTO:
2654 #ifdef PLATFORM_WIN32
2655 return MONO_NATIVE_LPWSTR;
2656 #else
2657 return MONO_NATIVE_LPSTR;
2658 #endif
2659 default:
2660 return MONO_NATIVE_LPSTR;
2661 }
2662 }
2663
2664 static MonoMarshalConv
2665 mono_marshal_get_string_to_ptr_conv (MonoMethodPInvoke *piinfo, MonoMarshalSpec *spec)
2666 {
2667 MonoMarshalNative encoding = mono_marshal_get_string_encoding (piinfo, spec);
2668
2669 switch (encoding) {
2670 case MONO_NATIVE_LPWSTR:
2671 return MONO_MARSHAL_CONV_STR_LPWSTR;
2672 case MONO_NATIVE_LPSTR:
2673 return MONO_MARSHAL_CONV_STR_LPSTR;
2674 case MONO_NATIVE_LPTSTR:
2675 return MONO_MARSHAL_CONV_STR_LPTSTR;
2676 case MONO_NATIVE_BSTR:
2677 return MONO_MARSHAL_CONV_STR_BSTR;
2678 default:
2679 return -1;
2680 }
2681 }
2682
2683 static MonoMarshalConv
2684 mono_marshal_get_stringbuilder_to_ptr_conv (MonoMethodPInvoke *piinfo, MonoMarshalSpec *spec)
2685 {
2686 MonoMarshalNative encoding = mono_marshal_get_string_encoding (piinfo, spec);
2687
2688 switch (encoding) {
2689 case MONO_NATIVE_LPWSTR:
2690 return MONO_MARSHAL_CONV_SB_LPWSTR;
2691 break;
2692 case MONO_NATIVE_LPSTR:
2693 return MONO_MARSHAL_CONV_SB_LPSTR;
2694 break;
2695 case MONO_NATIVE_LPTSTR:
2696 return MONO_MARSHAL_CONV_SB_LPTSTR;
2697 break;
2698 default:
2699 return -1;
2700 }
2701 }
2702
2703 static MonoMarshalConv
2704 mono_marshal_get_ptr_to_string_conv (MonoMethodPInvoke *piinfo, MonoMarshalSpec *spec, gboolean *need_free)
2705 {
2706 MonoMarshalNative encoding = mono_marshal_get_string_encoding (piinfo, spec);
2707
2708 *need_free = TRUE;
2709
2710 switch (encoding) {
2711 case MONO_NATIVE_LPWSTR:
2712 *need_free = FALSE;
2713 return MONO_MARSHAL_CONV_LPWSTR_STR;
2714 case MONO_NATIVE_LPSTR:
2715 return MONO_MARSHAL_CONV_LPSTR_STR;
2716 case MONO_NATIVE_LPTSTR:
2717 return MONO_MARSHAL_CONV_LPTSTR_STR;
2718 case MONO_NATIVE_BSTR:
2719 return MONO_MARSHAL_CONV_BSTR_STR;
2720 default:
2721 return -1;
2722 }
2723 }
2724
2725 static MonoMarshalConv
2726 mono_marshal_get_ptr_to_stringbuilder_conv (MonoMethodPInvoke *piinfo, MonoMarshalSpec *spec, gboolean *need_free)
2727 {
2728 MonoMarshalNative encoding = mono_marshal_get_string_encoding (piinfo, spec);
2729
2730 *need_free = TRUE;
2731
2732 switch (encoding) {
2733 case MONO_NATIVE_LPWSTR:
2734 /*
2735 * mono_string_builder_to_utf16 does not allocate a
2736 * new buffer, so no need to free it.
2737 */
2738 *need_free = FALSE;
2739 return MONO_MARSHAL_CONV_LPWSTR_SB;
2740 case MONO_NATIVE_LPSTR:
2741 return MONO_MARSHAL_CONV_LPSTR_SB;
2742 break;
2743 case MONO_NATIVE_LPTSTR:
2744 return MONO_MARSHAL_CONV_LPTSTR_SB;
2745 break;
2746 default:
2747 return -1;
2748 }
2749 }
2750
2751 /*
2752 * Return whenever a field of a native structure or an array member needs to
2753 * be freed.
2754 */
2755 static gboolean
2756 mono_marshal_need_free (MonoType *t, MonoMethodPInvoke *piinfo, MonoMarshalSpec *spec)
2757 {
2758 MonoMarshalNative encoding;
2759 MonoMarshalConv conv;
2760
2761 switch (t->type) {
2762 case MONO_TYPE_VALUETYPE:
2763 /* FIXME: Optimize this */
2764 return TRUE;
2765 case MONO_TYPE_OBJECT:
2766 case MONO_TYPE_CLASS:
2767 if (t->data.klass == mono_defaults.stringbuilder_class) {
2768 gboolean need_free;
2769 conv = mono_marshal_get_ptr_to_stringbuilder_conv (piinfo, spec, &need_free);
2770 return need_free;
2771 }
2772 return FALSE;
2773 case MONO_TYPE_STRING:
2774 encoding = mono_marshal_get_string_encoding (piinfo, spec);
2775 return (encoding == MONO_NATIVE_LPWSTR) ? FALSE : TRUE;
2776 default:
2777 return FALSE;
2778 }
2779 }
2780
2781 /*
2782 * Return the hash table pointed to by VAR, lazily creating it if neccesary.
2783 */
2784 static GHashTable*
2785 get_cache (GHashTable **var, GHashFunc hash_func, GCompareFunc equal_func)
2786 {
2787 if (!(*var)) {
2788 mono_marshal_lock ();
2789 if (!(*var)) {
2790 GHashTable *cache =
2791 g_hash_table_new (hash_func, equal_func);
2792 mono_memory_barrier ();
2793 *var = cache;
2794 }
2795 mono_marshal_unlock ();
2796 }
2797 return *var;
2798 }
2799
2800 static inline MonoMethod*
2801 mono_marshal_find_in_cache (GHashTable *cache, gpointer key)
2802 {
2803 MonoMethod *res;
2804
2805 mono_marshal_lock ();
2806 res = g_hash_table_lookup (cache, key);
2807 mono_marshal_unlock ();
2808 return res;
2809 }
2810
2811 static void
2812 mono_marshal_method_set_wrapper_data (MonoMethod *method, gpointer data)
2813 {
2814 void **datav;
2815 /* assert */
2816 if (method->wrapper_type == MONO_WRAPPER_NONE || method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD)
2817 return;
2818
2819 datav = ((MonoMethodWrapper *)method)->method_data;
2820 datav [1] = data;
2821 }
2822
2823 /* Create the method from the builder and place it in the cache */
2824 static inline MonoMethod*
2825 mono_mb_create_and_cache (GHashTable *cache, gpointer key,
2826 MonoMethodBuilder *mb, MonoMethodSignature *sig,
2827 int max_stack)
2828 {
2829 MonoMethod *res;
2830
2831 mono_marshal_lock ();
2832 res = g_hash_table_lookup (cache, key);
2833 mono_marshal_unlock ();
2834 if (!res) {
2835 MonoMethod *newm;
2836 newm = mono_mb_create_method (mb, sig, max_stack);
2837 mono_marshal_lock ();
2838 res = g_hash_table_lookup (cache, key);
2839 if (!res) {
2840 res = newm;
2841 g_hash_table_insert (cache, key, res);
2842 mono_marshal_method_set_wrapper_data (res, key);
2843 mono_marshal_unlock ();
2844 } else {
2845 mono_marshal_unlock ();
2846 mono_free_method (newm);
2847 }
2848 }
2849
2850 return res;
2851 }
2852
2853
2854 static inline MonoMethod*
2855 mono_marshal_remoting_find_in_cache (MonoMethod *method, int wrapper_type)
2856 {
2857 MonoMethod *res = NULL;
2858 MonoRemotingMethods *wrps;
2859
2860 mono_marshal_lock ();
2861 if (method->klass->image->remoting_invoke_cache)
2862 wrps = g_hash_table_lookup (method->klass->image->remoting_invoke_cache, method);
2863 else
2864 wrps = NULL;
2865
2866 if (wrps) {
2867 switch (wrapper_type) {
2868 case MONO_WRAPPER_REMOTING_INVOKE: res = wrps->invoke; break;
2869 case MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK: res = wrps->invoke_with_check; break;
2870 case MONO_WRAPPER_XDOMAIN_INVOKE: res = wrps->xdomain_invoke; break;
2871 case MONO_WRAPPER_XDOMAIN_DISPATCH: res = wrps->xdomain_dispatch; break;
2872 }
2873 }
2874
2875 /* it is important to do the unlock after the load from wrps, since in
2876 * mono_remoting_mb_create_and_cache () we drop the marshal lock to be able
2877 * to take the loader lock and some other thread may set the fields.
2878 */
2879 mono_marshal_unlock ();
2880 return res;
2881 }
2882
2883 /* Create the method from the builder and place it in the cache */
2884 static inline MonoMethod*
2885 mono_remoting_mb_create_and_cache (MonoMethod *key, MonoMethodBuilder *mb,
2886 MonoMethodSignature *sig, int max_stack)
2887 {
2888 MonoMethod **res = NULL;
2889 MonoRemotingMethods *wrps;
2890 GHashTable *cache = get_cache (&key->klass->image->remoting_invoke_cache, mono_aligned_addr_hash, NULL);
2891
2892 mono_marshal_lock ();
2893 wrps = g_hash_table_lookup (cache, key);
2894 if (!wrps) {
2895 wrps = g_new0 (MonoRemotingMethods, 1);
2896 g_hash_table_insert (cache, key, wrps);
2897 }
2898
2899 switch (mb->method->wrapper_type) {
2900 case MONO_WRAPPER_REMOTING_INVOKE: res = &wrps->invoke; break;
2901 case MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK: res = &wrps->invoke_with_check; break;
2902 case MONO_WRAPPER_XDOMAIN_INVOKE: res = &wrps->xdomain_invoke; break;
2903 case MONO_WRAPPER_XDOMAIN_DISPATCH: res = &wrps->xdomain_dispatch; break;
2904 default: g_assert_not_reached (); break;
2905 }
2906 mono_marshal_unlock ();
2907
2908 if (*res == NULL) {
2909 MonoMethod *newm;
2910 newm = mono_mb_create_method (mb, sig, max_stack);
2911
2912 mono_marshal_lock ();
2913 if (!*res) {
2914 *res = newm;
2915 mono_marshal_method_set_wrapper_data (*res, key);
2916 mono_marshal_unlock ();
2917 } else {
2918 mono_marshal_unlock ();
2919 mono_free_method (newm);
2920 }
2921 }
2922
2923 return *res;
2924 }
2925
2926 MonoMethod *
2927 mono_marshal_method_from_wrapper (MonoMethod *wrapper)
2928 {
2929 gpointer res;
2930
2931 if (wrapper->wrapper_type == MONO_WRAPPER_NONE || wrapper->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD)
2932 return wrapper;
2933
2934 res = mono_method_get_wrapper_data (wrapper, 1);
2935 if (res == NULL)
2936 return wrapper;
2937 return res;
2938 }
2939
2940 MonoMethod *
2941 mono_marshal_get_delegate_begin_invoke (MonoMethod *method)
2942 {
2943 MonoMethodSignature *sig;
2944 MonoMethodBuilder *mb;
2945 MonoMethod *res;
2946 GHashTable *cache;
2947 int params_var;
2948 char *name;
2949
2950 g_assert (method && method->klass->parent == mono_defaults.multicastdelegate_class &&
2951 !strcmp (method->name, "BeginInvoke"));
2952
2953 sig = mono_signature_no_pinvoke (method);
2954
2955 cache = get_cache (&method->klass->image->delegate_begin_invoke_cache,
2956 (GHashFunc)mono_signature_hash,
2957 (GCompareFunc)mono_metadata_signature_equal);
2958 if ((res = mono_marshal_find_in_cache (cache, sig)))
2959 return res;
2960
2961 g_assert (sig->hasthis);
2962
2963 name = mono_signature_to_name (sig, "begin_invoke");
2964 mb = mono_mb_new (method->klass, name, MONO_WRAPPER_DELEGATE_BEGIN_INVOKE);
2965 g_free (name);
2966
2967 params_var = mono_mb_emit_save_args (mb, sig, FALSE);
2968
2969 mono_mb_emit_ldarg (mb, 0);
2970 mono_mb_emit_ldloc (mb, params_var);
2971 mono_mb_emit_icall (mb, mono_delegate_begin_invoke);
2972 mono_mb_emit_byte (mb, CEE_RET);
2973
2974 res = mono_mb_create_and_cache (cache, sig, mb, sig, sig->param_count + 16);
2975 mono_mb_free (mb);
2976 return res;
2977 }
2978
2979 static MonoObject *
2980 mono_delegate_end_invoke (MonoDelegate *delegate, gpointer *params)
2981 {
2982 MonoDomain *domain = mono_domain_get ();
2983 MonoAsyncResult *ares;
2984 MonoMethod *method = NULL;
2985 MonoMethodSignature *sig;
2986 MonoMethodMessage *msg;
2987 MonoObject *res, *exc;
2988 MonoArray *out_args;
2989 MonoClass *klass;
2990
2991 g_assert (delegate);
2992
2993 if (!delegate->method_info) {
2994 g_assert (delegate->method);
2995 MONO_OBJECT_SETREF (delegate, method_info, mono_method_get_object (domain, delegate->method, NULL));
2996 }
2997
2998 if (!delegate->method_info || !delegate->method_info->method)
2999 g_assert_not_reached ();
3000
3001 klass = delegate->object.vtable->klass;
3002
3003 method = mono_class_get_method_from_name (klass, "EndInvoke", -1);
3004 g_assert (method != NULL);
3005
3006 sig = mono_signature_no_pinvoke (method);
3007
3008 msg = mono_method_call_message_new (method, params, NULL, NULL, NULL);
3009
3010 ares = mono_array_get (msg->args, gpointer, sig->param_count - 1);
3011 if (ares == NULL)
3012 mono_raise_exception (mono_exception_from_name_msg (mono_defaults.corlib, "System.Runtime.Remoting", "RemotingException", "The async result object is null or of an unexpected type."));
3013
3014 if (ares->async_delegate != (MonoObject*)delegate && mono_framework_version () >= 2) {
3015 mono_raise_exception (mono_get_exception_invalid_operation (
3016 "The IAsyncResult object provided does not match this delegate."));
3017 return NULL;
3018 }
3019
3020 if (delegate->target && mono_object_class (delegate->target) == mono_defaults.transparent_proxy_class) {
3021 MonoTransparentProxy* tp = (MonoTransparentProxy *)delegate->target;
3022 msg = (MonoMethodMessage *)mono_object_new (domain, mono_defaults.mono_method_message_class);
3023 mono_message_init (domain, msg, delegate->method_info, NULL);
3024 msg->call_type = CallType_EndInvoke;
3025 MONO_OBJECT_SETREF (msg, async_result, ares);
3026 res = mono_remoting_invoke ((MonoObject *)tp->rp, msg, &exc, &out_args);
3027 } else {
3028 res = mono_thread_pool_finish (ares, &out_args, &exc);
3029 }
3030
3031 if (exc) {
3032 if (((MonoException*)exc)->stack_trace) {
3033 char *strace = mono_string_to_utf8 (((MonoException*)exc)->stack_trace);
3034 char *tmp;
3035 tmp = g_strdup_printf ("%s\nException Rethrown at:\n", strace);
3036 g_free (strace);
3037 MONO_OBJECT_SETREF (((MonoException*)exc), stack_trace, mono_string_new (domain, tmp));
3038 g_free (tmp);
3039 }
3040 mono_raise_exception ((MonoException*)exc);
3041 }
3042
3043 mono_method_return_message_restore (method, params, out_args);
3044 return res;
3045 }
3046
3047 static void
3048 mono_mb_emit_restore_result (MonoMethodBuilder *mb, MonoType *return_type)
3049 {
3050 MonoType *t = mono_type_get_underlying_type (return_type);
3051
3052 if (return_type->byref)
3053 return_type = &mono_defaults.int_class->byval_arg;
3054
3055 switch (t->type) {
3056 case MONO_TYPE_VOID:
3057 g_assert_not_reached ();
3058 break;
3059 case MONO_TYPE_PTR:
3060 case MONO_TYPE_STRING:
3061 case MONO_TYPE_CLASS:
3062 case MONO_TYPE_OBJECT:
3063 case MONO_TYPE_ARRAY:
3064 case MONO_TYPE_SZARRAY:
3065 /* nothing to do */
3066 break;
3067 case MONO_TYPE_U1:
3068 case MONO_TYPE_BOOLEAN:
3069 case MONO_TYPE_I1:
3070 case MONO_TYPE_U2:
3071 case MONO_TYPE_CHAR:
3072 case MONO_TYPE_I2:
3073 case MONO_TYPE_I:
3074 case MONO_TYPE_U:
3075 case MONO_TYPE_I4:
3076 case MONO_TYPE_U4:
3077 case MONO_TYPE_U8:
3078 case MONO_TYPE_I8:
3079 case MONO_TYPE_R4:
3080 case MONO_TYPE_R8:
3081 mono_mb_emit_op (mb, CEE_UNBOX, mono_class_from_mono_type (return_type));
3082 mono_mb_emit_byte (mb, mono_type_to_ldind (return_type));
3083 break;
3084 case MONO_TYPE_GENERICINST:
3085 if (!mono_type_generic_inst_is_valuetype (return_type))
3086 break;
3087 /* fall through */
3088 case MONO_TYPE_VALUETYPE: {
3089 MonoClass *klass = mono_class_from_mono_type (return_type);
3090 mono_mb_emit_op (mb, CEE_UNBOX, klass);
3091 mono_mb_emit_op (mb, CEE_LDOBJ, klass);
3092 break;
3093 }
3094 default:
3095 g_warning ("type 0x%x not handled", return_type->type);
3096 g_assert_not_reached ();
3097 }
3098
3099 mono_mb_emit_byte (mb, CEE_RET);
3100 }
3101
3102 MonoMethod *
3103 mono_marshal_get_delegate_end_invoke (MonoMethod *method)
3104 {
3105 MonoMethodSignature *sig;
3106 MonoMethodBuilder *mb;
3107 MonoMethod *res;
3108 GHashTable *cache;
3109 int params_var;
3110 char *name;
3111
3112 g_assert (method && method->klass->parent == mono_defaults.multicastdelegate_class &&
3113 !strcmp (method->name, "EndInvoke"));
3114
3115 sig = mono_signature_no_pinvoke (method);
3116
3117 cache = get_cache (&method->klass->image->delegate_end_invoke_cache,
3118 (GHashFunc)mono_signature_hash,
3119 (GCompareFunc)mono_metadata_signature_equal);
3120 if ((res = mono_marshal_find_in_cache (cache, sig)))
3121 return res;
3122
3123 g_assert (sig->hasthis);
3124
3125 name = mono_signature_to_name (sig, "end_invoke");
3126 mb = mono_mb_new (method->klass, name, MONO_WRAPPER_DELEGATE_END_INVOKE);
3127 g_free (name);
3128
3129 params_var = mono_mb_emit_save_args (mb, sig, FALSE);
3130
3131 mono_mb_emit_ldarg (mb, 0);
3132 mono_mb_emit_ldloc (mb, params_var);
3133 mono_mb_emit_icall (mb, mono_delegate_end_invoke);
3134
3135 if (sig->ret->type == MONO_TYPE_VOID) {
3136 mono_mb_emit_byte (mb, CEE_POP);
3137 mono_mb_emit_byte (mb, CEE_RET);
3138 } else
3139 mono_mb_emit_restore_result (mb, sig->ret);
3140
3141 res = mono_mb_create_and_cache (cache, sig,
3142 mb, sig, sig->param_count + 16);
3143 mono_mb_free (mb);
3144
3145 return res;
3146 }
3147
3148 static MonoObject *
3149 mono_remoting_wrapper (MonoMethod *method, gpointer *params)
3150 {
3151 MonoMethodMessage *msg;
3152 MonoTransparentProxy *this;
3153 MonoObject *res, *exc;
3154 MonoArray *out_args;
3155
3156 this = *((MonoTransparentProxy **)params [0]);
3157
3158 g_assert (this);
3159 g_assert (((MonoObject *)this)->vtable->klass == mono_defaults.transparent_proxy_class);
3160
3161 /* skip the this pointer */
3162 params++;
3163
3164 if (this->remote_class->proxy_class->contextbound && this->rp->context == (MonoObject *) mono_context_get ())
3165 {
3166 int i;
3167 MonoMethodSignature *sig = mono_method_signature (method);
3168 int count = sig->param_count;
3169 gpointer* mparams = (gpointer*) alloca(count*sizeof(gpointer));
3170
3171 for (i=0; i<count; i++) {
3172 MonoClass *class = mono_class_from_mono_type (sig->params [i]);
3173 if (class->valuetype) {
3174 if (sig->params [i]->byref) {
3175 mparams[i] = *((gpointer *)params [i]);
3176 } else {
3177 /* runtime_invoke expects a boxed instance */
3178 if (mono_class_is_nullable (mono_class_from_mono_type (sig->params [i])))
3179 mparams[i] = mono_nullable_box (params [i], class);
3180 else
3181 mparams[i] = params [i];
3182 }
3183 } else {
3184 mparams[i] = *((gpointer**)params [i]);
3185 }
3186 }
3187
3188 return mono_runtime_invoke (method, method->klass->valuetype? mono_object_unbox ((MonoObject*)this): this, mparams, NULL);
3189 }
3190
3191 msg = mono_method_call_message_new (method, params, NULL, NULL, NULL);
3192
3193 res = mono_remoting_invoke ((MonoObject *)this->rp, msg, &exc, &out_args);
3194
3195 if (exc)
3196 mono_raise_exception ((MonoException *)exc);
3197
3198 mono_method_return_message_restore (method, params, out_args);
3199
3200 return res;
3201 }
3202
3203 #ifndef DISABLE_COM
3204
3205 /**
3206 * cominterop_get_native_wrapper_adjusted:
3207 * @method: managed COM Interop method
3208 *
3209 * Returns: the generated method to call with signature matching
3210 * the unmanaged COM Method signature
3211 */
3212 static MonoMethod *
3213 cominterop_get_native_wrapper_adjusted (MonoMethod *method)
3214 {
3215 MonoMethod *res;
3216 MonoMethodBuilder *mb_native;
3217 MonoMarshalSpec **mspecs;
3218 MonoMethodSignature *sig, *sig_native;
3219 MonoMethodPInvoke *piinfo = (MonoMethodPInvoke *) method;
3220 int i;
3221
3222 sig = mono_method_signature (method);
3223
3224 // create unmanaged wrapper
3225 mb_native = mono_mb_new (method->klass, method->name, MONO_WRAPPER_MANAGED_TO_NATIVE);
3226 sig_native = cominterop_method_signature (method);
3227
3228 mspecs = g_new (MonoMarshalSpec*, sig_native->param_count+1);
3229 memset (mspecs, 0, sizeof(MonoMarshalSpec*)*(sig_native->param_count+1));
3230
3231 mono_method_get_marshal_info (method, mspecs);
3232
3233 // move managed args up one
3234 for (i = sig->param_count; i >= 1; i--)
3235 mspecs[i+1] = mspecs[i];
3236
3237 // first arg is IntPtr for interface
3238 mspecs[1] = NULL;
3239
3240 if (!(method->iflags & METHOD_IMPL_ATTRIBUTE_PRESERVE_SIG)) {
3241 // move return spec to last param
3242 if (!MONO_TYPE_IS_VOID (sig->ret))
3243 mspecs[sig_native->param_count] = mspecs[0];
3244
3245 mspecs[0] = NULL;
3246 }
3247
3248 for (i = 1; i < sig_native->param_count; i++) {
3249 int mspec_index = i + 1;
3250 if (mspecs[mspec_index] == NULL) {
3251 // default object to VARIANT
3252 if (sig_native->params[i]->type == MONO_TYPE_OBJECT) {
3253 mspecs[mspec_index] = g_new0 (MonoMarshalSpec, 1);
3254 mspecs[mspec_index]->native = MONO_NATIVE_STRUCT;
3255 }
3256 else if (sig_native->params[i]->type == MONO_TYPE_STRING) {
3257 mspecs[mspec_index] = g_new0 (MonoMarshalSpec, 1);
3258 mspecs[mspec_index]->native = MONO_NATIVE_BSTR;
3259 }
3260 else if (sig_native->params[i]->type == MONO_TYPE_CLASS) {
3261 mspecs[mspec_index] = g_new0 (MonoMarshalSpec, 1);
3262 mspecs[mspec_index]->native = MONO_NATIVE_INTERFACE;
3263 }
3264 }
3265 }
3266
3267 if (method->iflags & METHOD_IMPL_ATTRIBUTE_PRESERVE_SIG) {
3268 // move return spec to last param
3269 if (!MONO_TYPE_IS_VOID (sig->ret) && mspecs[0] == NULL) {
3270 // default object to VARIANT
3271 if (sig->ret->type == MONO_TYPE_OBJECT) {
3272 mspecs[0] = g_new0 (MonoMarshalSpec, 1);
3273 mspecs[0]->native = MONO_NATIVE_STRUCT;
3274 }
3275 else if (sig->ret->type == MONO_TYPE_STRING) {
3276 mspecs[0] = g_new0 (MonoMarshalSpec, 1);
3277 mspecs[0]->native = MONO_NATIVE_BSTR;
3278 }
3279 else if (sig->ret->type == MONO_TYPE_CLASS) {
3280 mspecs[0] = g_new0 (MonoMarshalSpec, 1);
3281 mspecs[0]->native = MONO_NATIVE_INTERFACE;
3282 }
3283 }
3284 }
3285
3286 mono_marshal_emit_native_wrapper (method->klass->image, mb_native, sig_native, piinfo, mspecs, piinfo->addr, FALSE, TRUE);
3287
3288 res = mono_mb_create_method (mb_native, sig_native, sig_native->param_count + 16);
3289
3290 mono_mb_free (mb_native);
3291
3292 for (i = sig_native->param_count; i >= 0; i--)
3293 if (mspecs [i])
3294 mono_metadata_free_marshal_spec (mspecs [i]);
3295 g_free (mspecs);
3296
3297 return res;
3298 }
3299
3300 /**
3301 * cominterop_get_native_wrapper:
3302 * @method: managed method
3303 *
3304 * Returns: the generated method to call
3305 */
3306 static MonoMethod *
3307 cominterop_get_native_wrapper (MonoMethod *method)
3308 {
3309 MonoMethod *res;
3310 GHashTable *cache;
3311 MonoMethodBuilder *mb;
3312 MonoMethodSignature *sig, *csig;
3313
3314 g_assert (method);
3315
3316 cache = get_cache (&method->klass->image->cominterop_wrapper_cache, mono_aligned_addr_hash, NULL);
3317 if ((res = mono_marshal_find_in_cache (cache, method)))
3318 return res;
3319
3320 mono_init_com_types ();
3321
3322 if (!method->klass->vtable)
3323 mono_class_setup_vtable (method->klass);
3324
3325 if (!method->klass->methods)
3326 mono_class_setup_methods (method->klass);
3327
3328 sig = mono_method_signature (method);
3329 mb = mono_mb_new (method->klass, method->name, MONO_WRAPPER_COMINTEROP);
3330
3331 /* if method klass is import, that means method
3332 * is really a com call. let interop system emit it.
3333 */
3334 if (MONO_CLASS_IS_IMPORT(method->klass)) {
3335 /* FIXME: we have to call actual class .ctor
3336 * instead of just __ComObject .ctor.
3337 */
3338 if (!strcmp(method->name, ".ctor")) {
3339 static MonoMethod *ctor = NULL;
3340
3341 if (!ctor)
3342 ctor = mono_class_get_method_from_name (mono_defaults.com_object_class, ".ctor", 0);
3343 mono_mb_emit_ldarg (mb, 0);
3344 mono_mb_emit_managed_call (mb, ctor, NULL);
3345 mono_mb_emit_byte (mb, CEE_RET);
3346 }
3347 else {
3348 static MonoMethod * ThrowExceptionForHR = NULL;
3349 MonoMethod *adjusted_method;
3350 int retval = 0;
3351 int ptr_this;
3352 int i;
3353 gboolean preserve_sig = method->iflags & METHOD_IMPL_ATTRIBUTE_PRESERVE_SIG;
3354
3355 // add local variables
3356 ptr_this = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
3357 if (!MONO_TYPE_IS_VOID (sig->ret))
3358 retval = mono_mb_add_local (mb, sig->ret);
3359
3360 // get the type for the interface the method is defined on
3361 // and then get the underlying COM interface for that type
3362 mono_mb_emit_ldarg (mb, 0);
3363 mono_mb_emit_ptr (mb, method);
3364 mono_mb_emit_icall (mb, cominterop_get_method_interface);
3365 mono_mb_emit_icon (mb, TRUE);
3366 mono_mb_emit_icall (mb, cominterop_get_interface);
3367 mono_mb_emit_stloc (mb, ptr_this);
3368
3369 // arg 1 is unmanaged this pointer
3370 mono_mb_emit_ldloc (mb, ptr_this);
3371
3372 // load args
3373 for (i = 1; i <= sig->param_count; i++)
3374 mono_mb_emit_ldarg (mb, i);
3375
3376 // push managed return value as byref last argument
3377 if (!MONO_TYPE_IS_VOID (sig->ret) && !preserve_sig)
3378 mono_mb_emit_ldloc_addr (mb, retval);
3379
3380 adjusted_method = cominterop_get_native_wrapper_adjusted (method);
3381 mono_mb_emit_managed_call (mb, adjusted_method, NULL);
3382
3383 if (!preserve_sig) {
3384 if (!ThrowExceptionForHR)
3385 ThrowExceptionForHR = mono_class_get_method_from_name (mono_defaults.marshal_class, "ThrowExceptionForHR", 1);
3386 mono_mb_emit_managed_call (mb, ThrowExceptionForHR, NULL);
3387
3388 // load return value managed is expecting
3389 if (!MONO_TYPE_IS_VOID (sig->ret))
3390 mono_mb_emit_ldloc (mb, retval);
3391 }
3392
3393 mono_mb_emit_byte (mb, CEE_RET);
3394 }
3395
3396
3397 }
3398 /* Does this case ever get hit? */
3399 else {
3400 char *msg = g_strdup ("non imported interfaces on \
3401 imported classes is not yet implemented.");
3402 mono_mb_emit_exception (mb, "NotSupportedException", msg);
3403 }
3404 csig = signature_dup (method->klass->image, sig);
3405 csig->pinvoke = 0;
3406 res = mono_mb_create_and_cache (cache, method,
3407 mb, csig, csig->param_count + 16);
3408 mono_mb_free (mb);
3409 return res;
3410 }
3411
3412 /**
3413 * cominterop_get_invoke:
3414 * @method: managed method
3415 *
3416 * Returns: the generated method that calls the underlying __ComObject
3417 * rather than the proxy object.
3418 */
3419 static MonoMethod *
3420 cominterop_get_invoke (MonoMethod *method)
3421 {
3422 MonoMethodSignature *sig;
3423 MonoMethodBuilder *mb;
3424 MonoMethod *res;
3425 int i, temp_obj;
3426 GHashTable* cache = get_cache (&method->klass->image->cominterop_invoke_cache, mono_aligned_addr_hash, NULL);
3427
3428 g_assert (method);
3429
3430 if ((res = mono_marshal_find_in_cache (cache, method)))
3431 return res;
3432
3433 sig = mono_signature_no_pinvoke (method);
3434
3435 /* we cant remote methods without this pointer */
3436 if (!sig->hasthis)
3437 return method;
3438
3439 mb = mono_mb_new (method->klass, method->name, MONO_WRAPPER_COMINTEROP_INVOKE);
3440
3441 /* get real proxy object, which is a ComInteropProxy in this case*/
3442 temp_obj = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
3443 mono_mb_emit_ldarg (mb, 0);
3444 mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoTransparentProxy, rp));
3445 mono_mb_emit_byte (mb, CEE_LDIND_REF);
3446
3447 /* load the RCW from the ComInteropProxy*/
3448 mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoComInteropProxy, com_object));
3449 mono_mb_emit_byte (mb, CEE_LDIND_REF);
3450
3451 /* load args and make the call on the RCW */
3452 for (i = 1; i <= sig->param_count; i++)
3453 mono_mb_emit_ldarg (mb, i);
3454
3455 if (method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) {
3456 MonoMethod * native_wrapper = cominterop_get_native_wrapper(method);
3457 mono_mb_emit_managed_call (mb, native_wrapper, NULL);
3458 }
3459 else {
3460 if (method->flags & METHOD_ATTRIBUTE_VIRTUAL)
3461 mono_mb_emit_op (mb, CEE_CALLVIRT, method);
3462 else
3463 mono_mb_emit_op (mb, CEE_CALL, method);
3464 }
3465
3466 if (!strcmp(method->name, ".ctor")) {
3467 static MonoClass *com_interop_proxy_class = NULL;
3468 static MonoMethod *cache_proxy = NULL;
3469
3470 if (!com_interop_proxy_class)
3471 com_interop_proxy_class = mono_class_from_name (mono_defaults.corlib, "Mono.Interop", "ComInteropProxy");
3472 if (!cache_proxy)
3473 cache_proxy = mono_class_get_method_from_name (com_interop_proxy_class, "CacheProxy", 0);
3474
3475 mono_mb_emit_ldarg (mb, 0);
3476 mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoTransparentProxy, rp));
3477 mono_mb_emit_byte (mb, CEE_LDIND_REF);
3478 mono_mb_emit_managed_call (mb, cache_proxy, NULL);
3479 }
3480
3481 emit_thread_interrupt_checkpoint (mb);
3482
3483 mono_mb_emit_byte (mb, CEE_RET);
3484
3485 res = mono_mb_create_and_cache (cache, method, mb, sig, sig->param_count + 16);
3486 mono_mb_free (mb);
3487
3488 return res;
3489 }
3490
3491 #endif /* DISABLE_COM */
3492
3493 /* Maps a managed object to its unmanaged representation
3494 * i.e. it's COM Callable Wrapper (CCW).
3495 * Key: MonoObject*
3496 * Value: MonoCCW*
3497 */
3498 static GHashTable* ccw_hash = NULL;
3499
3500 /* Maps a CCW interface to it's containing CCW.
3501 * Note that a CCW support many interfaces.
3502 * Key: MonoCCW*
3503 * Value: MonoCCWInterface*
3504 */
3505 static GHashTable* ccw_interface_hash = NULL;
3506
3507 /* Maps the IUnknown value of a RCW to
3508 * it's MonoComInteropProxy*.
3509 * Key: void*
3510 * Value: gchandle
3511 */
3512 static GHashTable* rcw_hash = NULL;
3513
3514 MonoMethod *
3515 mono_marshal_get_remoting_invoke (MonoMethod *method)
3516 {
3517 MonoMethodSignature *sig;
3518 MonoMethodBuilder *mb;
3519 MonoMethod *res;
3520 int params_var;
3521
3522 g_assert (method);
3523
3524 if (method->wrapper_type == MONO_WRAPPER_REMOTING_INVOKE || method->wrapper_type == MONO_WRAPPER_XDOMAIN_INVOKE)
3525 return method;
3526
3527 /* this seems to be the best plase to put this, as all remoting invokes seem to get filtered through here */
3528 if ((method->klass->is_com_object || method->klass == mono_defaults.com_object_class) && !mono_class_vtable (mono_domain_get (), method->klass)->remote) {
3529 #ifndef DISABLE_COM
3530 return cominterop_get_invoke(method);
3531 #else
3532 g_assert_not_reached ();
3533 #endif
3534 }
3535
3536 sig = mono_signature_no_pinvoke (method);
3537
3538 /* we cant remote methods without this pointer */
3539 if (!sig->hasthis)
3540 return method;
3541
3542 if ((res = mono_marshal_remoting_find_in_cache (method, MONO_WRAPPER_REMOTING_INVOKE)))
3543 return res;
3544
3545 mb = mono_mb_new (method->klass, method->name, MONO_WRAPPER_REMOTING_INVOKE);
3546 mb->method->save_lmf = 1;
3547
3548 params_var = mono_mb_emit_save_args (mb, sig, TRUE);
3549
3550 mono_mb_emit_ptr (mb, method);
3551 mono_mb_emit_ldloc (mb, params_var);
3552 mono_mb_emit_icall (mb, mono_remoting_wrapper);
3553 emit_thread_interrupt_checkpoint (mb);
3554
3555 if (sig->ret->type == MONO_TYPE_VOID) {
3556 mono_mb_emit_byte (mb, CEE_POP);
3557 mono_mb_emit_byte (mb, CEE_RET);
3558 } else {
3559 mono_mb_emit_restore_result (mb, sig->ret);
3560 }
3561
3562 res = mono_remoting_mb_create_and_cache (method, mb, sig, sig->param_count + 16);
3563 mono_mb_free (mb);
3564
3565 return res;
3566 }
3567
3568 /* mono_get_xdomain_marshal_type()
3569 * Returns the kind of marshalling that a type needs for cross domain calls.
3570 */
3571 static MonoXDomainMarshalType
3572 mono_get_xdomain_marshal_type (MonoType *t)
3573 {
3574 switch (t->type) {
3575 case MONO_TYPE_VOID:
3576 g_assert_not_reached ();
3577 break;
3578 case MONO_TYPE_U1:
3579 case MONO_TYPE_I1:
3580 case MONO_TYPE_BOOLEAN:
3581 case MONO_TYPE_U2:
3582 case MONO_TYPE_I2:
3583 case MONO_TYPE_CHAR:
3584 case MONO_TYPE_U4:
3585 case MONO_TYPE_I4:
3586 case MONO_TYPE_I8:
3587 case MONO_TYPE_U8:
3588 case MONO_TYPE_R4:
3589 case MONO_TYPE_R8:
3590 return MONO_MARSHAL_NONE;
3591 case MONO_TYPE_STRING:
3592 return MONO_MARSHAL_COPY;
3593 case MONO_TYPE_ARRAY:
3594 case MONO_TYPE_SZARRAY: {
3595 MonoClass *elem_class = mono_class_from_mono_type (t)->element_class;
3596 if (mono_get_xdomain_marshal_type (&(elem_class->byval_arg)) != MONO_MARSHAL_SERIALIZE)
3597 return MONO_MARSHAL_COPY;
3598 break;
3599 }
3600 }
3601
3602 return MONO_MARSHAL_SERIALIZE;
3603 }
3604
3605
3606 /* mono_marshal_xdomain_copy_value
3607 * Makes a copy of "val" suitable for the current domain.
3608 */
3609 static MonoObject *
3610 mono_marshal_xdomain_copy_value (MonoObject *val)
3611 {
3612 MonoDomain *domain;
3613 if (val == NULL) return NULL;
3614
3615 domain = mono_domain_get ();
3616
3617 switch (mono_object_class (val)->byval_arg.type) {
3618 case MONO_TYPE_VOID:
3619 g_assert_not_reached ();
3620 break;
3621 case MONO_TYPE_U1:
3622 case MONO_TYPE_I1:
3623 case MONO_TYPE_BOOLEAN:
3624 case MONO_TYPE_U2:
3625 case MONO_TYPE_I2:
3626 case MONO_TYPE_CHAR:
3627 case MONO_TYPE_U4:
3628 case MONO_TYPE_I4:
3629 case MONO_TYPE_I8:
3630 case MONO_TYPE_U8:
3631 case MONO_TYPE_R4:
3632 case MONO_TYPE_R8: {
3633 return mono_value_box (domain, mono_object_class (val), ((char*)val) + sizeof(MonoObject));
3634 }
3635 case MONO_TYPE_STRING: {
3636 MonoString *str = (MonoString *) val;
3637 return (MonoObject *) mono_string_new_utf16 (domain, mono_string_chars (str), mono_string_length (str));
3638 }
3639 case MONO_TYPE_ARRAY:
3640 case MONO_TYPE_SZARRAY: {
3641 MonoArray *acopy;
3642 MonoXDomainMarshalType mt = mono_get_xdomain_marshal_type (&(mono_object_class (val)->element_class->byval_arg));
3643 if (mt == MONO_MARSHAL_SERIALIZE) return NULL;
3644 acopy = mono_array_clone_in_domain (domain, (MonoArray *) val);
3645 if (mt == MONO_MARSHAL_COPY) {
3646 int i, len = mono_array_length (acopy);
3647 for (i = 0; i < len; i++) {
3648 MonoObject *item = mono_array_get (acopy, gpointer, i);
3649 mono_array_setref (acopy, i, mono_marshal_xdomain_copy_value (item));
3650 }
3651 }
3652 return (MonoObject *) acopy;
3653 }
3654 }
3655
3656 if (mono_object_class (val) == mono_defaults.stringbuilder_class) {
3657 MonoStringBuilder *oldsb = (MonoStringBuilder *) val;
3658 MonoStringBuilder *newsb = (MonoStringBuilder *) mono_object_new (domain, mono_defaults.stringbuilder_class);
3659 MONO_OBJECT_SETREF (newsb, str, mono_string_new_utf16 (domain, mono_string_chars (oldsb->str), mono_string_length (oldsb->str)));
3660 newsb->length = oldsb->length;
3661 newsb->max_capacity = (gint32)0x7fffffff;
3662 return (MonoObject *) newsb;
3663 }
3664 return NULL;
3665 }
3666
3667 /* mono_marshal_xdomain_copy_out_value()
3668 * Copies the contents of the src instance into the dst instance. src and dst
3669 * must have the same type, and if they are arrays, the same size.
3670 */
3671 static void
3672 mono_marshal_xdomain_copy_out_value (MonoObject *src, MonoObject *dst)
3673 {
3674 if (src == NULL || dst == NULL) return;
3675
3676 g_assert (mono_object_class (src) == mono_object_class (dst));
3677
3678 switch (mono_object_class (src)->byval_arg.type) {
3679 case MONO_TYPE_ARRAY:
3680 case MONO_TYPE_SZARRAY: {
3681 int mt = mono_get_xdomain_marshal_type (&(mono_object_class (src)->element_class->byval_arg));
3682 if (mt == MONO_MARSHAL_SERIALIZE) return;
3683 if (mt == MONO_MARSHAL_COPY) {
3684 int i, len = mono_array_length ((MonoArray *)dst);
3685 for (i = 0; i < len; i++) {
3686 MonoObject *item = mono_array_get ((MonoArray *)src, gpointer, i);
3687 mono_array_setref ((MonoArray *)dst, i, mono_marshal_xdomain_copy_value (item));
3688 }
3689 } else {
3690 mono_array_full_copy ((MonoArray *)src, (MonoArray *)dst);
3691 }
3692 return;
3693 }
3694 }
3695
3696 if (mono_object_class (src) == mono_defaults.stringbuilder_class) {
3697 MonoStringBuilder *src_sb = (MonoStringBuilder *) src;
3698 MonoStringBuilder *dst_sb = (MonoStringBuilder *) dst;
3699
3700 MONO_OBJECT_SETREF (dst_sb, str, mono_string_new_utf16 (mono_object_domain (dst), mono_string_chars (src_sb->str), mono_string_length (src_sb->str)));
3701 dst_sb->cached_str = NULL;
3702 dst_sb->length = src_sb->length;
3703 }
3704 }
3705
3706 static void
3707 mono_marshal_emit_xdomain_copy_value (MonoMethodBuilder *mb, MonoClass *pclass)
3708 {
3709 mono_mb_emit_icall (mb, mono_marshal_xdomain_copy_value);
3710 mono_mb_emit_op (mb, CEE_CASTCLASS, pclass);
3711 }
3712
3713 static void
3714 mono_marshal_emit_xdomain_copy_out_value (MonoMethodBuilder *mb, MonoClass *pclass)
3715 {
3716 mono_mb_emit_icall (mb, mono_marshal_xdomain_copy_out_value);
3717 }
3718
3719 /* mono_marshal_supports_fast_xdomain()
3720 * Returns TRUE if the method can use the fast xdomain wrapper.
3721 */
3722 static gboolean
3723 mono_marshal_supports_fast_xdomain (MonoMethod *method)
3724 {
3725 return !method->klass->contextbound &&
3726 !((method->flags & METHOD_ATTRIBUTE_SPECIAL_NAME) && (strcmp (".ctor", method->name) == 0));
3727 }
3728
3729 static gint32
3730 mono_marshal_set_domain_by_id (gint32 id, MonoBoolean push)
3731 {
3732 MonoDomain *current_domain = mono_domain_get ();
3733 MonoDomain *domain = mono_domain_get_by_id (id);
3734
3735 if (!domain || !mono_domain_set (domain, FALSE))
3736 mono_raise_exception (mono_get_exception_appdomain_unloaded ());
3737
3738 if (push)
3739 mono_thread_push_appdomain_ref (domain);
3740 else
3741 mono_thread_pop_appdomain_ref ();
3742
3743 return current_domain->domain_id;
3744 }
3745
3746 static void
3747 mono_marshal_emit_switch_domain (MonoMethodBuilder *mb)
3748 {
3749 mono_mb_emit_icall (mb, mono_marshal_set_domain_by_id);
3750 }
3751
3752 /* mono_marshal_emit_load_domain_method ()
3753 * Loads into the stack a pointer to the code of the provided method for
3754 * the current domain.
3755 */
3756 static void
3757 mono_marshal_emit_load_domain_method (MonoMethodBuilder *mb, MonoMethod *method)
3758 {
3759 /* We need a pointer to the method for the running domain (not the domain
3760 * that compiles the method).
3761 */
3762 mono_mb_emit_ptr (mb, method);
3763 mono_mb_emit_icall (mb, mono_compile_method);
3764 }
3765
3766 /* mono_marshal_check_domain_image ()
3767 * Returns TRUE if the image is loaded in the specified
3768 * application domain.
3769 */
3770 static gboolean
3771 mono_marshal_check_domain_image (gint32 domain_id, MonoImage *image)
3772 {
3773 MonoAssembly* ass;
3774 GSList *tmp;
3775
3776 MonoDomain *domain = mono_domain_get_by_id (domain_id);
3777 if (!domain)
3778 return FALSE;
3779
3780 mono_domain_assemblies_lock (domain);
3781 for (tmp = domain->domain_assemblies; tmp; tmp = tmp->next) {
3782 ass = tmp->data;
3783 if (ass->image == image)
3784 break;
3785 }
3786 mono_domain_assemblies_unlock (domain);
3787
3788 return tmp != NULL;
3789 }
3790
3791 /* mono_marshal_get_xappdomain_dispatch ()
3792 * Generates a method that dispatches a method call from another domain into
3793 * the current domain.
3794 */
3795 static MonoMethod *
3796 mono_marshal_get_xappdomain_dispatch (MonoMethod *method, int *marshal_types, int complex_count, int complex_out_count, int ret_marshal_type)
3797 {
3798 MonoMethodSignature *sig, *csig;
3799 MonoMethodBuilder *mb;
3800 MonoMethod *res;
3801 int i, j, param_index, copy_locals_base;
3802 MonoClass *ret_class = NULL;
3803 int loc_array=0, loc_return=0, loc_serialized_exc=0;
3804 MonoExceptionClause *main_clause;
3805 MonoMethodHeader *header;
3806 int pos, pos_leave;
3807 gboolean copy_return;
3808
3809 if ((res = mono_marshal_remoting_find_in_cache (method, MONO_WRAPPER_XDOMAIN_DISPATCH)))
3810 return res;
3811
3812 sig = mono_method_signature (method);
3813 copy_return = (sig->ret->type != MONO_TYPE_VOID && ret_marshal_type != MONO_MARSHAL_SERIALIZE);
3814
3815 j = 0;
3816 csig = mono_metadata_signature_alloc (mono_defaults.corlib, 3 + sig->param_count - complex_count);
3817 csig->params [j++] = &mono_defaults.object_class->byval_arg;
3818 csig->params [j++] = &byte_array_class->this_arg;
3819 csig->params [j++] = &byte_array_class->this_arg;
3820 for (i = 0; i < sig->param_count; i++) {
3821 if (marshal_types [i] != MONO_MARSHAL_SERIALIZE)
3822 csig->params [j++] = sig->params [i];
3823 }
3824 if (copy_return)
3825 csig->ret = sig->ret;
3826 else
3827 csig->ret = &mono_defaults.void_class->byval_arg;
3828 csig->pinvoke = 1;
3829 csig->hasthis = FALSE;
3830
3831 mb = mono_mb_new (method->klass, method->name, MONO_WRAPPER_XDOMAIN_DISPATCH);
3832 mb->method->save_lmf = 1;
3833
3834 /* Locals */
3835
3836 loc_serialized_exc = mono_mb_add_local (mb, &byte_array_class->byval_arg);
3837 if (complex_count > 0)
3838 loc_array = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
3839 if (sig->ret->type != MONO_TYPE_VOID) {
3840 loc_return = mono_mb_add_local (mb, sig->ret);
3841 ret_class = mono_class_from_mono_type (sig->ret);
3842 }
3843
3844 /* try */
3845
3846 mono_loader_lock ();
3847 main_clause = mono_image_alloc0 (method->klass->image, sizeof (MonoExceptionClause));
3848 mono_loader_unlock ();
3849 main_clause->try_offset = mono_mb_get_label (mb);
3850
3851 /* Clean the call context */
3852
3853 mono_mb_emit_byte (mb, CEE_LDNULL);
3854 mono_mb_emit_managed_call (mb, method_set_call_context, NULL);
3855 mono_mb_emit_byte (mb, CEE_POP);
3856
3857 /* Deserialize call data */
3858
3859 mono_mb_emit_ldarg (mb, 1);
3860 mono_mb_emit_byte (mb, CEE_LDIND_REF);
3861 mono_mb_emit_byte (mb, CEE_DUP);
3862 pos = mono_mb_emit_short_branch (mb, CEE_BRFALSE_S);
3863
3864 mono_marshal_emit_xdomain_copy_value (mb, byte_array_class);
3865 mono_mb_emit_managed_call (mb, method_rs_deserialize, NULL);
3866
3867 if (complex_count > 0)
3868 mono_mb_emit_stloc (mb, loc_array);
3869 else
3870 mono_mb_emit_byte (mb, CEE_POP);
3871
3872 mono_mb_patch_short_branch (mb, pos);
3873
3874 /* Get the target object */
3875
3876 mono_mb_emit_ldarg (mb, 0);
3877 mono_mb_emit_managed_call (mb, method_rs_appdomain_target, NULL);
3878
3879 /* Load the arguments */
3880
3881 copy_locals_base = mb->locals;
3882 param_index = 3; // Index of the first non-serialized parameter of this wrapper
3883 j = 0;
3884 for (i = 0; i < sig->param_count; i++) {
3885 MonoType *pt = sig->params [i];
3886 MonoClass *pclass = mono_class_from_mono_type (pt);
3887 switch (marshal_types [i]) {
3888 case MONO_MARSHAL_SERIALIZE: {
3889 /* take the value from the serialized array */
3890 mono_mb_emit_ldloc (mb, loc_array);
3891 mono_mb_emit_icon (mb, j++);
3892 if (pt->byref) {
3893 if (pclass->valuetype) {
3894 mono_mb_emit_byte (mb, CEE_LDELEM_REF);
3895 mono_mb_emit_op (mb, CEE_UNBOX, pclass);
3896 } else {
3897 mono_mb_emit_op (mb, CEE_LDELEMA, pclass);
3898 }
3899 } else {
3900 if (pclass->valuetype) {
3901 mono_mb_emit_byte (mb, CEE_LDELEM_REF);
3902 mono_mb_emit_op (mb, CEE_UNBOX, pclass);
3903 mono_mb_emit_op (mb, CEE_LDOBJ, pclass);
3904 } else {
3905 mono_mb_emit_byte (mb, CEE_LDELEM_REF);
3906 if (pclass != mono_defaults.object_class) {
3907 mono_mb_emit_op (mb, CEE_CASTCLASS, pclass);
3908 }
3909 }
3910 }
3911 break;
3912 }
3913 case MONO_MARSHAL_COPY_OUT: {
3914 /* Keep a local copy of the value since we need to copy it back after the call */
3915 int copy_local = mono_mb_add_local (mb, &(pclass->byval_arg));
3916 mono_mb_emit_ldarg (mb, param_index++);
3917 mono_marshal_emit_xdomain_copy_value (mb, pclass);
3918 mono_mb_emit_byte (mb, CEE_DUP);
3919 mono_mb_emit_stloc (mb, copy_local);
3920 break;
3921 }
3922 case MONO_MARSHAL_COPY: {
3923 mono_mb_emit_ldarg (mb, param_index);
3924 if (pt->byref) {
3925 mono_mb_emit_byte (mb, CEE_DUP);
3926 mono_mb_emit_byte (mb, CEE_DUP);
3927 mono_mb_emit_byte (mb, CEE_LDIND_REF);
3928 mono_marshal_emit_xdomain_copy_value (mb, pclass);
3929 mono_mb_emit_byte (mb, CEE_STIND_REF);
3930 } else {
3931 mono_marshal_emit_xdomain_copy_value (mb, pclass);
3932 }
3933 param_index++;
3934 break;
3935 }
3936 case MONO_MARSHAL_NONE:
3937 mono_mb_emit_ldarg (mb, param_index++);
3938 break;
3939 }
3940 }
3941
3942 /* Make the call to the real object */
3943
3944 emit_thread_force_interrupt_checkpoint (mb);
3945
3946 mono_mb_emit_op (mb, CEE_CALLVIRT, method);
3947
3948 if (sig->ret->type != MONO_TYPE_VOID)
3949 mono_mb_emit_stloc (mb, loc_return);
3950
3951 /* copy back MONO_MARSHAL_COPY_OUT parameters */
3952
3953 j = 0;
3954 param_index = 3;
3955 for (i = 0; i < sig->param_count; i++) {
3956 if (marshal_types [i] == MONO_MARSHAL_SERIALIZE) continue;
3957 if (marshal_types [i] == MONO_MARSHAL_COPY_OUT) {
3958 mono_mb_emit_ldloc (mb, copy_locals_base + (j++));
3959 mono_mb_emit_ldarg (mb, param_index);
3960 mono_marshal_emit_xdomain_copy_out_value (mb, mono_class_from_mono_type (sig->params [i]));
3961 }
3962 param_index++;
3963 }
3964
3965 /* Serialize the return values */
3966
3967 if (complex_out_count > 0) {
3968 /* Reset parameters in the array that don't need to be serialized back */
3969 j = 0;
3970 for (i = 0; i < sig->param_count; i++) {
3971 if (marshal_types[i] != MONO_MARSHAL_SERIALIZE) continue;
3972 if (!sig->params [i]->byref) {
3973 mono_mb_emit_ldloc (mb, loc_array);
3974 mono_mb_emit_icon (mb, j);
3975 mono_mb_emit_byte (mb, CEE_LDNULL);
3976 mono_mb_emit_byte (mb, CEE_STELEM_REF);
3977 }
3978 j++;
3979 }
3980
3981 /* Add the return value to the array */
3982
3983 if (ret_marshal_type == MONO_MARSHAL_SERIALIZE) {
3984 mono_mb_emit_ldloc (mb, loc_array);
3985 mono_mb_emit_icon (mb, complex_count); /* The array has an additional slot to hold the ret value */
3986 mono_mb_emit_ldloc (mb, loc_return);
3987 if (ret_class->valuetype) {
3988 mono_mb_emit_op (mb, CEE_BOX, ret_class);
3989 }
3990 mono_mb_emit_byte (mb, CEE_STELEM_REF);
3991 }
3992
3993 /* Serialize */
3994
3995 mono_mb_emit_ldarg (mb, 1);
3996 mono_mb_emit_ldloc (mb, loc_array);
3997 mono_mb_emit_managed_call (mb, method_rs_serialize, NULL);
3998 mono_mb_emit_byte (mb, CEE_STIND_REF);
3999 } else if (ret_marshal_type == MONO_MARSHAL_SERIALIZE) {
4000 mono_mb_emit_ldarg (mb, 1);
4001 mono_mb_emit_ldloc (mb, loc_return);
4002 if (ret_class->valuetype) {
4003 mono_mb_emit_op (mb, CEE_BOX, ret_class);
4004 }
4005 mono_mb_emit_managed_call (mb, method_rs_serialize, NULL);
4006 mono_mb_emit_byte (mb, CEE_STIND_REF);
4007 } else {
4008 mono_mb_emit_ldarg (mb, 1);
4009 mono_mb_emit_byte (mb, CEE_LDNULL);
4010 mono_mb_emit_managed_call (mb, method_rs_serialize, NULL);
4011 mono_mb_emit_byte (mb, CEE_STIND_REF);
4012 }
4013
4014 mono_mb_emit_ldarg (mb, 2);
4015 mono_mb_emit_byte (mb, CEE_LDNULL);
4016 mono_mb_emit_byte (mb, CEE_STIND_REF);
4017 pos_leave = mono_mb_emit_branch (mb, CEE_LEAVE);
4018
4019 /* Main exception catch */
4020 main_clause->flags = MONO_EXCEPTION_CLAUSE_NONE;
4021 main_clause->try_len = mono_mb_get_pos (mb) - main_clause->try_offset;
4022 main_clause->data.catch_class = mono_defaults.object_class;
4023
4024 /* handler code */
4025 main_clause->handler_offset = mono_mb_get_label (mb);
4026 mono_mb_emit_managed_call (mb, method_rs_serialize_exc, NULL);
4027 mono_mb_emit_stloc (mb, loc_serialized_exc);
4028 mono_mb_emit_ldarg (mb, 2);
4029 mono_mb_emit_ldloc (mb, loc_serialized_exc);
4030 mono_mb_emit_byte (mb, CEE_STIND_REF);
4031 mono_mb_emit_branch (mb, CEE_LEAVE);
4032 main_clause->handler_len = mono_mb_get_pos (mb) - main_clause->handler_offset;
4033 /* end catch */
4034
4035 mono_mb_patch_branch (mb, pos_leave);
4036
4037 if (copy_return)
4038 mono_mb_emit_ldloc (mb, loc_return);
4039
4040 mono_mb_emit_byte (mb, CEE_RET);
4041
4042 res = mono_remoting_mb_create_and_cache (method, mb, csig, csig->param_count + 16);
4043 mono_mb_free (mb);
4044
4045 header = ((MonoMethodNormal *)res)->header;
4046 header->num_clauses = 1;
4047 header->clauses = main_clause;
4048
4049 return res;
4050 }
4051
4052 /* mono_marshal_get_xappdomain_invoke ()
4053 * Generates a fast remoting wrapper for cross app domain calls.
4054 */
4055 MonoMethod *
4056 mono_marshal_get_xappdomain_invoke (MonoMethod *method)
4057 {
4058 MonoMethodSignature *sig;
4059 MonoMethodBuilder *mb;
4060 MonoMethod *res;
4061 int i, j, complex_count, complex_out_count, copy_locals_base;
4062 int *marshal_types;
4063 MonoClass *ret_class = NULL;
4064 MonoMethod *xdomain_method;
4065 int ret_marshal_type = MONO_MARSHAL_NONE;
4066 int loc_array=0, loc_serialized_data=-1, loc_real_proxy;
4067 int loc_old_domainid, loc_domainid, loc_return=0, loc_serialized_exc=0, loc_context;
4068 int pos, pos_dispatch, pos_noex;
4069 gboolean copy_return = FALSE;
4070
4071 g_assert (method);
4072
4073 if (method->wrapper_type == MONO_WRAPPER_REMOTING_INVOKE || method->wrapper_type == MONO_WRAPPER_XDOMAIN_INVOKE)
4074 return method;
4075
4076 /* we cant remote methods without this pointer */
4077 if (!mono_method_signature (method)->hasthis)
4078 return method;
4079
4080 if (!mono_marshal_supports_fast_xdomain (method))
4081 return mono_marshal_get_remoting_invoke (method);
4082
4083 mono_remoting_marshal_init ();
4084
4085 if ((res = mono_marshal_remoting_find_in_cache (method, MONO_WRAPPER_XDOMAIN_INVOKE)))
4086 return res;
4087
4088 sig = mono_signature_no_pinvoke (method);
4089
4090 mb = mono_mb_new (method->klass, method->name, MONO_WRAPPER_XDOMAIN_INVOKE);
4091 mb->method->save_lmf = 1;
4092
4093 /* Count the number of parameters that need to be serialized */
4094
4095 marshal_types = alloca (sizeof (int) * sig->param_count);
4096 complex_count = complex_out_count = 0;
4097 for (i = 0; i < sig->param_count; i++) {
4098 MonoType *ptype = sig->params[i];
4099 int mt = mono_get_xdomain_marshal_type (ptype);
4100
4101 /* If the [Out] attribute is applied to a parameter that can be internally copied,
4102 * the copy will be made by reusing the original object instance
4103 */
4104 if ((ptype->attrs & PARAM_ATTRIBUTE_OUT) != 0 && mt == MONO_MARSHAL_COPY && !ptype->byref)
4105 mt = MONO_MARSHAL_COPY_OUT;
4106 else if (mt == MONO_MARSHAL_SERIALIZE) {
4107 complex_count++;
4108 if (ptype->byref) complex_out_count++;
4109 }
4110 marshal_types [i] = mt;
4111 }
4112
4113 if (sig->ret->type != MONO_TYPE_VOID) {
4114 ret_marshal_type = mono_get_xdomain_marshal_type (sig->ret);
4115 ret_class = mono_class_from_mono_type (sig->ret);
4116 copy_return = ret_marshal_type != MONO_MARSHAL_SERIALIZE;
4117 }
4118
4119 /* Locals */
4120
4121 if (complex_count > 0)
4122 loc_array = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
4123 loc_serialized_data = mono_mb_add_local (mb, &byte_array_class->byval_arg);
4124 loc_real_proxy = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
4125 if (copy_return)
4126 loc_return = mono_mb_add_local (mb, sig->ret);
4127 loc_old_domainid = mono_mb_add_local (mb, &mono_defaults.int32_class->byval_arg);
4128 loc_domainid = mono_mb_add_local (mb, &mono_defaults.int32_class->byval_arg);
4129 loc_serialized_exc = mono_mb_add_local (mb, &byte_array_class->byval_arg);
4130 loc_context = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
4131
4132 /* Save thread domain data */
4133
4134 mono_mb_emit_icall (mb, mono_context_get);
4135 mono_mb_emit_byte (mb, CEE_DUP);
4136 mono_mb_emit_stloc (mb, loc_context);
4137
4138 /* If the thread is not running in the default context, it needs to go
4139 * through the whole remoting sink, since the context is going to change
4140 */
4141 mono_mb_emit_managed_call (mb, method_needs_context_sink, NULL);
4142 pos = mono_mb_emit_short_branch (mb, CEE_BRTRUE_S);
4143
4144 /* Another case in which the fast path can't be used: when the target domain
4145 * has a different image for the same assembly.
4146 */
4147
4148 /* Get the target domain id */
4149
4150 mono_mb_emit_ldarg (mb, 0);
4151 mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoTransparentProxy, rp));
4152 mono_mb_emit_byte (mb, CEE_LDIND_REF);
4153 mono_mb_emit_byte (mb, CEE_DUP);
4154 mono_mb_emit_stloc (mb, loc_real_proxy);
4155
4156 mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoRealProxy, target_domain_id));
4157 mono_mb_emit_byte (mb, CEE_LDIND_I4);
4158 mono_mb_emit_stloc (mb, loc_domainid);
4159
4160 /* Check if the target domain has the same image for the required assembly */
4161
4162 mono_mb_emit_ldloc (mb, loc_domainid);
4163 mono_mb_emit_ptr (mb, method->klass->image);
4164 mono_mb_emit_icall (mb, mono_marshal_check_domain_image);
4165 pos_dispatch = mono_mb_emit_short_branch (mb, CEE_BRTRUE_S);
4166
4167 /* Use the whole remoting sink to dispatch this message */
4168
4169 mono_mb_patch_short_branch (mb, pos);
4170
4171 mono_mb_emit_ldarg (mb, 0);
4172 for (i = 0; i < sig->param_count; i++)
4173 mono_mb_emit_ldarg (mb, i + 1);
4174
4175 mono_mb_emit_managed_call (mb, mono_marshal_get_remoting_invoke (method), NULL);
4176 mono_mb_emit_byte (mb, CEE_RET);
4177 mono_mb_patch_short_branch (mb, pos_dispatch);
4178
4179 /* Create the array that will hold the parameters to be serialized */
4180
4181 if (complex_count > 0) {
4182 mono_mb_emit_icon (mb, (ret_marshal_type == MONO_MARSHAL_SERIALIZE && complex_out_count > 0) ? complex_count + 1 : complex_count); /* +1 for the return type */
4183 mono_mb_emit_op (mb, CEE_NEWARR, mono_defaults.object_class);
4184
4185 j = 0;
4186 for (i = 0; i < sig->param_count; i++) {
4187 MonoClass *pclass;
4188 if (marshal_types [i] != MONO_MARSHAL_SERIALIZE) continue;
4189 pclass = mono_class_from_mono_type (sig->params[i]);
4190 mono_mb_emit_byte (mb, CEE_DUP);
4191 mono_mb_emit_icon (mb, j);
4192 mono_mb_emit_ldarg (mb, i + 1); /* 0=this */
4193 if (sig->params[i]->byref) {
4194 if (pclass->valuetype)
4195 mono_mb_emit_op (mb, CEE_LDOBJ, pclass);
4196 else
4197 mono_mb_emit_byte (mb, CEE_LDIND_REF);
4198 }
4199 if (pclass->valuetype)
4200 mono_mb_emit_op (mb, CEE_BOX, pclass);
4201 mono_mb_emit_byte (mb, CEE_STELEM_REF);
4202 j++;
4203 }
4204 mono_mb_emit_stloc (mb, loc_array);
4205
4206 /* Serialize parameters */
4207
4208 mono_mb_emit_ldloc (mb, loc_array);
4209 mono_mb_emit_managed_call (mb, method_rs_serialize, NULL);
4210 mono_mb_emit_stloc (mb, loc_serialized_data);
4211 } else {
4212 mono_mb_emit_byte (mb, CEE_LDNULL);
4213 mono_mb_emit_managed_call (mb, method_rs_serialize, NULL);
4214 mono_mb_emit_stloc (mb, loc_serialized_data);
4215 }
4216
4217 /* switch domain */
4218
4219 mono_mb_emit_ldloc (mb, loc_domainid);
4220 mono_mb_emit_byte (mb, CEE_LDC_I4_1);
4221 mono_marshal_emit_switch_domain (mb);
4222 mono_mb_emit_stloc (mb, loc_old_domainid);
4223
4224 /* Load the arguments */
4225
4226 mono_mb_emit_ldloc (mb, loc_real_proxy);
4227 mono_mb_emit_ldloc_addr (mb, loc_serialized_data);
4228 mono_mb_emit_ldloc_addr (mb, loc_serialized_exc);
4229
4230 copy_locals_base = mb->locals;
4231 for (i = 0; i < sig->param_count; i++) {
4232 switch (marshal_types [i]) {
4233 case MONO_MARSHAL_SERIALIZE:
4234 continue;
4235 case MONO_MARSHAL_COPY: {
4236 mono_mb_emit_ldarg (mb, i+1);
4237 if (sig->params [i]->byref) {
4238 /* make a local copy of the byref parameter. The real parameter
4239 * will be updated after the xdomain call
4240 */
4241 MonoClass *pclass = mono_class_from_mono_type (sig->params [i]);
4242 int copy_local = mono_mb_add_local (mb, &(pclass->byval_arg));
4243 mono_mb_emit_byte (mb, CEE_LDIND_REF);
4244 mono_mb_emit_stloc (mb, copy_local);
4245 mono_mb_emit_ldloc_addr (mb, copy_local);
4246 }
4247 break;
4248 }
4249 case MONO_MARSHAL_COPY_OUT:
4250 case MONO_MARSHAL_NONE:
4251 mono_mb_emit_ldarg (mb, i+1);
4252 break;
4253 }
4254 }
4255
4256 /* Make the call to the invoke wrapper in the target domain */
4257
4258 xdomain_method = mono_marshal_get_xappdomain_dispatch (method, marshal_types, complex_count, complex_out_count, ret_marshal_type);
4259 mono_marshal_emit_load_domain_method (mb, xdomain_method);
4260 mono_mb_emit_calli (mb, mono_method_signature (xdomain_method));
4261
4262 if (copy_return)
4263 mono_mb_emit_stloc (mb, loc_return);
4264
4265 /* Switch domain */
4266
4267 mono_mb_emit_ldloc (mb, loc_old_domainid);
4268 mono_mb_emit_byte (mb, CEE_LDC_I4_0);
4269 mono_marshal_emit_switch_domain (mb);
4270 mono_mb_emit_byte (mb, CEE_POP);
4271
4272 /* Restore thread domain data */
4273
4274 mono_mb_emit_ldloc (mb, loc_context);
4275 mono_mb_emit_icall (mb, mono_context_set);
4276
4277 /* if (loc_serialized_exc != null) ... */
4278
4279 mono_mb_emit_ldloc (mb, loc_serialized_exc);
4280 pos_noex = mono_mb_emit_short_branch (mb, CEE_BRFALSE_S);
4281
4282 mono_mb_emit_ldloc (mb, loc_serialized_exc);
4283 mono_marshal_emit_xdomain_copy_value (mb, byte_array_class);
4284 mono_mb_emit_managed_call (mb, method_rs_deserialize, NULL);
4285 mono_mb_emit_op (mb, CEE_CASTCLASS, mono_defaults.exception_class);
4286 mono_mb_emit_managed_call (mb, method_exc_fixexc, NULL);
4287 mono_mb_emit_byte (mb, CEE_THROW);
4288 mono_mb_patch_short_branch (mb, pos_noex);
4289
4290 /* copy back non-serialized output parameters */
4291
4292 j = 0;
4293 for (i = 0; i < sig->param_count; i++) {
4294 if (!sig->params [i]->byref || marshal_types [i] != MONO_MARSHAL_COPY) continue;
4295 mono_mb_emit_ldarg (mb, i + 1);
4296 mono_mb_emit_ldloc (mb, copy_locals_base + (j++));
4297 mono_marshal_emit_xdomain_copy_value (mb, mono_class_from_mono_type (sig->params [i]));
4298 mono_mb_emit_byte (mb, CEE_STIND_REF);
4299 }
4300
4301 /* Deserialize out parameters */
4302
4303 if (complex_out_count > 0) {
4304 mono_mb_emit_ldloc (mb, loc_serialized_data);
4305 mono_marshal_emit_xdomain_copy_value (mb, byte_array_class);
4306 mono_mb_emit_managed_call (mb, method_rs_deserialize, NULL);
4307 mono_mb_emit_stloc (mb, loc_array);
4308
4309 /* Copy back output parameters and return type */
4310
4311 j = 0;
4312 for (i = 0; i < sig->param_count; i++) {
4313 if (marshal_types [i] != MONO_MARSHAL_SERIALIZE) continue;
4314 if (sig->params[i]->byref) {
4315 MonoClass *pclass = mono_class_from_mono_type (sig->params [i]);
4316 mono_mb_emit_ldarg (mb, i + 1);
4317 mono_mb_emit_ldloc (mb, loc_array);
4318 mono_mb_emit_icon (mb, j);
4319 mono_mb_emit_byte (mb, CEE_LDELEM_REF);
4320 if (pclass->valuetype) {
4321 mono_mb_emit_op (mb, CEE_UNBOX, pclass);
4322 mono_mb_emit_op (mb, CEE_LDOBJ, pclass);
4323 mono_mb_emit_op (mb, CEE_STOBJ, pclass);
4324 } else {
4325 if (pclass != mono_defaults.object_class)
4326 mono_mb_emit_op (mb, CEE_CASTCLASS, pclass);
4327 mono_mb_emit_byte (mb, CEE_STIND_REF);
4328 }
4329 }
4330 j++;
4331 }
4332
4333 if (ret_marshal_type == MONO_MARSHAL_SERIALIZE) {
4334 mono_mb_emit_ldloc (mb, loc_array);
4335 mono_mb_emit_icon (mb, complex_count);
4336 mono_mb_emit_byte (mb, CEE_LDELEM_REF);
4337 if (ret_class->valuetype) {
4338 mono_mb_emit_op (mb, CEE_UNBOX, ret_class);
4339 mono_mb_emit_op (mb, CEE_LDOBJ, ret_class);
4340 }
4341 }
4342 } else if (ret_marshal_type == MONO_MARSHAL_SERIALIZE) {
4343 mono_mb_emit_ldloc (mb, loc_serialized_data);
4344 mono_marshal_emit_xdomain_copy_value (mb, byte_array_class);
4345 mono_mb_emit_managed_call (mb, method_rs_deserialize, NULL);
4346 if (ret_class->valuetype) {
4347 mono_mb_emit_op (mb, CEE_UNBOX, ret_class);
4348 mono_mb_emit_op (mb, CEE_LDOBJ, ret_class);
4349 } else if (ret_class != mono_defaults.object_class) {
4350 mono_mb_emit_op (mb, CEE_CASTCLASS, ret_class);
4351 }
4352 } else {
4353 mono_mb_emit_ldloc (mb, loc_serialized_data);
4354 mono_mb_emit_byte (mb, CEE_DUP);
4355 pos = mono_mb_emit_short_branch (mb, CEE_BRFALSE_S);
4356 mono_marshal_emit_xdomain_copy_value (mb, byte_array_class);
4357
4358 mono_mb_patch_short_branch (mb, pos);
4359 mono_mb_emit_managed_call (mb, method_rs_deserialize, NULL);
4360 mono_mb_emit_byte (mb, CEE_POP);
4361 }
4362
4363 if (copy_return) {
4364 mono_mb_emit_ldloc (mb, loc_return);
4365 if (ret_marshal_type == MONO_MARSHAL_COPY)
4366 mono_marshal_emit_xdomain_copy_value (mb, ret_class);
4367 }
4368
4369 mono_mb_emit_byte (mb, CEE_RET);
4370
4371 res = mono_remoting_mb_create_and_cache (method, mb, sig, sig->param_count + 16);
4372 mono_mb_free (mb);
4373
4374 return res;
4375 }
4376
4377 MonoMethod *
4378 mono_marshal_get_remoting_invoke_for_target (MonoMethod *method, MonoRemotingTarget target_type)
4379 {
4380 if (target_type == MONO_REMOTING_TARGET_APPDOMAIN) {
4381 return mono_marshal_get_xappdomain_invoke (method);
4382 } else if (target_type == MONO_REMOTING_TARGET_COMINTEROP) {
4383 #ifndef DISABLE_COM
4384 return cominterop_get_invoke (method);
4385 #else
4386 g_assert_not_reached ();
4387 #endif
4388 } else {
4389 return mono_marshal_get_remoting_invoke (method);
4390 }
4391 }
4392
4393 G_GNUC_UNUSED static gpointer
4394 mono_marshal_load_remoting_wrapper (MonoRealProxy *rp, MonoMethod *method)
4395 {
4396 if (rp->target_domain_id != -1)
4397 return mono_compile_method (mono_marshal_get_xappdomain_invoke (method));
4398 else
4399 return mono_compile_method (mono_marshal_get_remoting_invoke (method));
4400 }
4401
4402 MonoMethod *
4403 mono_marshal_get_remoting_invoke_with_check (MonoMethod *method)
4404 {
4405 MonoMethodSignature *sig;
4406 MonoMethodBuilder *mb;
4407 MonoMethod *res, *native;
4408 int i, pos, pos_rem;
4409
4410 g_assert (method);
4411
4412 if (method->wrapper_type == MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK)
4413 return method;
4414
4415 /* we cant remote methods without this pointer */
4416 g_assert (mono_method_signature (method)->hasthis);
4417
4418 if ((res = mono_marshal_remoting_find_in_cache (method, MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK)))
4419 return res;
4420
4421 sig = mono_signature_no_pinvoke (method);
4422
4423 mb = mono_mb_new (method->klass, method->name, MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK);
4424
4425 for (i = 0; i <= sig->param_count; i++)
4426 mono_mb_emit_ldarg (mb, i);
4427
4428 mono_mb_emit_ldarg (mb, 0);
4429 pos = mono_mb_emit_proxy_check (mb, CEE_BNE_UN);
4430
4431 if (mono_marshal_supports_fast_xdomain (method)) {
4432 mono_mb_emit_ldarg (mb, 0);
4433 pos_rem = mono_mb_emit_xdomain_check (mb, CEE_BEQ);
4434
4435 /* wrapper for cross app domain calls */
4436 native = mono_marshal_get_xappdomain_invoke (method);
4437 mono_mb_emit_managed_call (mb, native, mono_method_signature (native));
4438 mono_mb_emit_byte (mb, CEE_RET);
4439
4440 mono_mb_patch_branch (mb, pos_rem);
4441 }
4442 /* wrapper for normal remote calls */
4443 native = mono_marshal_get_remoting_invoke (method);
4444 mono_mb_emit_managed_call (mb, native, mono_method_signature (native));
4445 mono_mb_emit_byte (mb, CEE_RET);
4446
4447 /* not a proxy */
4448 mono_mb_patch_branch (mb, pos);
4449 mono_mb_emit_managed_call (mb, method, mono_method_signature (method));
4450 mono_mb_emit_byte (mb, CEE_RET);
4451
4452 res = mono_remoting_mb_create_and_cache (method, mb, sig, sig->param_count + 16);
4453 mono_mb_free (mb);
4454
4455 return res;
4456 }
4457
4458 typedef struct
4459 {
4460 MonoMethodSignature *sig;
4461 MonoMethod *method;
4462 } SignatureMethodPair;
4463
4464 static guint
4465 signature_method_pair_hash (gconstpointer data)
4466 {
4467 SignatureMethodPair *pair = (SignatureMethodPair*)data;
4468
4469 return mono_signature_hash (pair->sig) ^ mono_aligned_addr_hash (pair->method);
4470 }
4471
4472 static gboolean
4473 signature_method_pair_equal (SignatureMethodPair *pair1, SignatureMethodPair *pair2)
4474 {
4475 return mono_metadata_signature_equal (pair1->sig, pair2->sig) && (pair1->method == pair2->method);
4476 }
4477
4478 static void
4479 free_signature_method_pair (SignatureMethodPair *pair)
4480 {
4481 g_free (pair);
4482 }
4483
4484 /*
4485 * the returned method invokes all methods in a multicast delegate.
4486 */
4487 MonoMethod *
4488 mono_marshal_get_delegate_invoke (MonoMethod *method, MonoDelegate *del)
4489 {
4490 MonoMethodSignature *sig, *static_sig;
4491 int i;
4492 MonoMethodBuilder *mb;
4493 MonoMethod *res, *newm;
4494 GHashTable *cache;
4495 SignatureMethodPair key;
4496 SignatureMethodPair *new_key;
4497 int local_prev, local_target;
4498 int pos0;
4499 char *name;
4500 MonoMethod *target_method = NULL;
4501 MonoClass *target_class = NULL;
4502 gboolean callvirt = FALSE;
4503
4504 /*
4505 * If the delegate target is null, and the target method is not static, a virtual
4506 * call is made to that method with the first delegate argument as this. This is
4507 * a non-documented .NET feature.
4508 */
4509 if (del && !del->target && del->method && mono_method_signature (del->method)->hasthis) {
4510 callvirt = TRUE;
4511 target_method = del->method;
4512 if (target_method->is_inflated) {
4513 MonoType *target_type;
4514
4515 g_assert (method->signature->hasthis);
4516 target_type = mono_class_inflate_generic_type (method->signature->params [0],
4517 mono_method_get_context (method));
4518 target_class = mono_class_from_mono_type (target_type);
4519 } else {
4520 target_class = del->method->klass;
4521 }
4522 }
4523
4524 g_assert (method && method->klass->parent == mono_defaults.multicastdelegate_class &&
4525 !strcmp (method->name, "Invoke"));
4526
4527 sig = mono_signature_no_pinvoke (method);
4528
4529 if (callvirt) {
4530 /* We need to cache the signature+method pair */
4531 mono_marshal_lock ();
4532 if (!method->klass->image->delegate_abstract_invoke_cache)
4533 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);
4534 cache = method->klass->image->delegate_abstract_invoke_cache;
4535 key.sig = sig;
4536 key.method = target_method;
4537 res = g_hash_table_lookup (cache, &key);
4538 mono_marshal_unlock ();
4539 if (res)
4540 return res;
4541 } else {
4542 cache = get_cache (&method->klass->image->delegate_invoke_cache,
4543 (GHashFunc)mono_signature_hash,
4544 (GCompareFunc)mono_metadata_signature_equal);
4545 if ((res = mono_marshal_find_in_cache (cache, sig)))
4546 return res;
4547 }
4548
4549 static_sig = signature_dup (method->klass->image, sig);
4550 static_sig->hasthis = 0;
4551
4552 name = mono_signature_to_name (sig, "invoke");
4553 mb = mono_mb_new (method->klass, name, MONO_WRAPPER_DELEGATE_INVOKE);
4554 g_free (name);
4555
4556 /* allocate local 0 (object) */
4557 local_target = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
4558 local_prev = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
4559
4560 g_assert (sig->hasthis);
4561
4562 /*
4563 * if (prev != null)
4564 * prev.Invoke( args .. );
4565 * return this.<target>( args .. );
4566 */
4567
4568 /* this wrapper can be used in unmanaged-managed transitions */
4569 emit_thread_interrupt_checkpoint (mb);
4570
4571 /* get this->prev */
4572 mono_mb_emit_ldarg (mb, 0);
4573 mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoMulticastDelegate, prev));
4574 mono_mb_emit_byte (mb, CEE_LDIND_REF);
4575 mono_mb_emit_stloc (mb, local_prev);
4576 mono_mb_emit_ldloc (mb, local_prev);
4577
4578 /* if prev != null */
4579 pos0 = mono_mb_emit_branch (mb, CEE_BRFALSE);
4580
4581 /* then recurse */
4582
4583 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
4584 mono_mb_emit_byte (mb, CEE_MONO_NOT_TAKEN);
4585
4586 mono_mb_emit_ldloc (mb, local_prev);
4587 for (i = 0; i < sig->param_count; i++)
4588 mono_mb_emit_ldarg (mb, i + 1);
4589 mono_mb_emit_op (mb, CEE_CALLVIRT, method);
4590 if (sig->ret->type != MONO_TYPE_VOID)
4591 mono_mb_emit_byte (mb, CEE_POP);
4592
4593 /* continued or prev == null */
4594 mono_mb_patch_branch (mb, pos0);
4595
4596 /* get this->target */
4597 mono_mb_emit_ldarg (mb, 0);
4598 mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoDelegate, target));
4599 mono_mb_emit_byte (mb, CEE_LDIND_REF);
4600 mono_mb_emit_stloc (mb, local_target);
4601
4602 /* if target != null */
4603 mono_mb_emit_ldloc (mb, local_target);
4604 pos0 = mono_mb_emit_branch (mb, CEE_BRFALSE);
4605
4606 /* then call this->method_ptr nonstatic */
4607 if (callvirt) {
4608 // FIXME:
4609 mono_mb_emit_exception_full (mb, "System", "NotImplementedException", "");
4610 } else {
4611 mono_mb_emit_ldloc (mb, local_target);
4612 for (i = 0; i < sig->param_count; ++i)
4613 mono_mb_emit_ldarg (mb, i + 1);
4614 mono_mb_emit_ldarg (mb, 0);
4615 mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoDelegate, method_ptr));
4616 mono_mb_emit_byte (mb, CEE_LDIND_I );
4617 mono_mb_emit_op (mb, CEE_CALLI, sig);
4618
4619 mono_mb_emit_byte (mb, CEE_RET);
4620 }
4621
4622 /* else [target == null] call this->method_ptr static */
4623 mono_mb_patch_branch (mb, pos0);
4624
4625 if (callvirt) {
4626 mono_mb_emit_ldarg (mb, 1);
4627 mono_mb_emit_op (mb, CEE_CASTCLASS, target_class);
4628 for (i = 1; i < sig->param_count; ++i)
4629 mono_mb_emit_ldarg (mb, i + 1);
4630 mono_mb_emit_op (mb, CEE_CALLVIRT, target_method);
4631 } else {
4632 for (i = 0; i < sig->param_count; ++i)
4633 mono_mb_emit_ldarg (mb, i + 1);
4634 mono_mb_emit_ldarg (mb, 0);
4635 mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoDelegate, method_ptr));
4636 mono_mb_emit_byte (mb, CEE_LDIND_I );
4637 mono_mb_emit_op (mb, CEE_CALLI, static_sig);
4638 }
4639
4640 mono_mb_emit_byte (mb, CEE_RET);
4641
4642 if (callvirt) {
4643 // From mono_mb_create_and_cache
4644 newm = mono_mb_create_method (mb, sig, sig->param_count + 16);
4645 newm->skip_visibility = 1;
4646 /*We perform double checked locking, so must fence before publishing*/
4647 mono_memory_barrier ();
4648 mono_marshal_lock ();
4649 res = g_hash_table_lookup (cache, &key);
4650 if (!res) {
4651 res = newm;
4652 new_key = g_new0 (SignatureMethodPair, 1);
4653 new_key->sig = sig;
4654 new_key->method = target_method;
4655 g_hash_table_insert (cache, new_key, res);
4656 mono_marshal_method_set_wrapper_data (res, new_key);
4657 mono_marshal_unlock ();
4658 } else {
4659 mono_marshal_unlock ();
4660 mono_free_method (newm);
4661 }
4662 } else {
4663 res = mono_mb_create_and_cache (cache, sig, mb, sig, sig->param_count + 16);
4664 res->skip_visibility = 1;
4665 }
4666 mono_mb_free (mb);
4667
4668 return res;
4669 }
4670
4671 /*
4672 * signature_dup_add_this:
4673 *
4674 * Make a copy of @sig, adding an explicit this argument.
4675 */
4676 static MonoMethodSignature*
4677 signature_dup_add_this (MonoMethodSignature *sig, MonoClass *klass)
4678 {
4679 MonoMethodSignature *res;
4680 int i;
4681
4682 res = mono_metadata_signature_alloc (klass->image, sig->param_count + 1);
4683 memcpy (res, sig, sizeof (MonoMethodSignature));
4684 res->param_count = sig->param_count + 1;
4685 res->hasthis = FALSE;
4686 for (i = sig->param_count - 1; i >= 0; i --)
4687 res->params [i + 1] = sig->params [i];
4688 res->params [0] = &mono_ptr_class_get (&klass->byval_arg)->byval_arg;
4689
4690 return res;
4691 }
4692
4693 typedef struct {
4694 MonoMethodSignature *ctor_sig;
4695 MonoMethodSignature *sig;
4696 } CtorSigPair;
4697
4698 /* protected by the marshal lock, contains CtorSigPair pointers */
4699 static GSList *strsig_list = NULL;
4700
4701 static MonoMethodSignature *
4702 lookup_string_ctor_signature (MonoMethodSignature *sig)
4703 {
4704 MonoMethodSignature *callsig;
4705 CtorSigPair *cs;
4706 GSList *item;
4707
4708 mono_marshal_lock ();
4709 callsig = NULL;
4710 for (item = strsig_list; item; item = item->next) {
4711 cs = item->data;
4712 /* mono_metadata_signature_equal () is safe to call with the marshal lock
4713 * because it is lock-free.
4714 */
4715 if (mono_metadata_signature_equal (sig, cs->ctor_sig)) {
4716 callsig = cs->sig;
4717 break;
4718 }
4719 }
4720 mono_marshal_unlock ();
4721 return callsig;
4722 }
4723
4724 static MonoMethodSignature *
4725 add_string_ctor_signature (MonoMethod *method)
4726 {
4727 MonoMethodSignature *callsig;
4728 CtorSigPair *cs;
4729
4730 callsig = signature_dup (method->klass->image, mono_method_signature (method));
4731 callsig->ret = &mono_defaults.string_class->byval_arg;
4732 cs = g_new (CtorSigPair, 1);
4733 cs->sig = callsig;
4734 cs->ctor_sig = mono_method_signature (method);
4735
4736 mono_marshal_lock ();
4737 strsig_list = g_slist_prepend (strsig_list, cs);
4738 mono_marshal_unlock ();
4739 return callsig;
4740 }
4741
4742 static MonoType*
4743 get_runtime_invoke_type (MonoType *t)
4744 {
4745 if (t->byref)
4746 return &mono_defaults.int_class->byval_arg;
4747
4748 switch (t->type) {
4749 case MONO_TYPE_U1:
4750 return &mono_defaults.sbyte_class->byval_arg;
4751 case MONO_TYPE_U2:
4752 return &mono_defaults.int16_class->byval_arg;
4753 case MONO_TYPE_U4:
4754 return &mono_defaults.int32_class->byval_arg;
4755 case MONO_TYPE_U8:
4756 return &mono_defaults.int64_class->byval_arg;
4757 case MONO_TYPE_BOOLEAN:
4758 return &mono_defaults.byte_class->byval_arg;
4759 case MONO_TYPE_CHAR:
4760 return &mono_defaults.int16_class->byval_arg;
4761 case MONO_TYPE_U:
4762 return &mono_defaults.int_class->byval_arg;
4763 case MONO_TYPE_VALUETYPE:
4764 if (t->data.klass->enumtype)
4765 return mono_type_get_underlying_type (t);
4766 else
4767 return t;
4768 default:
4769 if (MONO_TYPE_IS_REFERENCE (t))
4770 return &mono_defaults.object_class->byval_arg;
4771 return t;
4772 }
4773 }
4774
4775 /*
4776 * mono_marshal_get_runtime_invoke_sig:
4777 *
4778 * Return a common signature used for sharing runtime invoke wrappers.
4779 */
4780 static MonoMethodSignature*
4781 mono_marshal_get_runtime_invoke_sig (MonoMethodSignature *sig)
4782 {
4783 MonoMethodSignature *res = mono_metadata_signature_dup (sig);
4784 int i;
4785
4786 res->ret = get_runtime_invoke_type (sig->ret);
4787 for (i = 0; i < res->param_count; ++i)
4788 res->params [i] = get_runtime_invoke_type (sig->params [i]);
4789
4790 return res;
4791 }
4792
4793 static gboolean
4794 runtime_invoke_signature_equal (MonoMethodSignature *sig1, MonoMethodSignature *sig2)
4795 {
4796 /* Can't share wrappers which return a vtype since it needs to be boxed */
4797 if (sig1->ret != sig2->ret && !(MONO_TYPE_IS_REFERENCE (sig1->ret) && MONO_TYPE_IS_REFERENCE (sig2->ret)))
4798 return FALSE;
4799 else
4800 return mono_metadata_signature_equal (sig1, sig2);
4801 }
4802
4803 /*
4804 * generates IL code for the runtime invoke function
4805 * MonoObject *runtime_invoke (MonoObject *this, void **params, MonoObject **exc, void* method)
4806 *
4807 * we also catch exceptions if exc != null
4808 */
4809 MonoMethod *
4810 mono_marshal_get_runtime_invoke (MonoMethod *method)
4811 {
4812 MonoMethodSignature *sig, *csig, *callsig;
4813 MonoExceptionClause *clause;
4814 MonoMethodHeader *header;
4815 MonoMethodBuilder *mb;
4816 GHashTable *cache = NULL;
4817 MonoClass *target_klass;
4818 MonoMethod *res = NULL;
4819 static MonoString *string_dummy = NULL;
4820 static MonoMethodSignature *cctor_signature = NULL;
4821 static MonoMethodSignature *finalize_signature = NULL;
4822 int i, pos, posna;
4823 char *name;
4824 gboolean need_direct_wrapper = FALSE;
4825
4826 g_assert (method);
4827
4828 if (!cctor_signature) {
4829 cctor_signature = mono_metadata_signature_alloc (mono_defaults.corlib, 0);
4830 cctor_signature->ret = &mono_defaults.void_class->byval_arg;
4831 }
4832 if (!finalize_signature) {
4833 finalize_signature = mono_metadata_signature_alloc (mono_defaults.corlib, 0);
4834 finalize_signature->ret = &mono_defaults.void_class->byval_arg;
4835 finalize_signature->hasthis = 1;
4836 }
4837
4838 /*
4839 * Use a separate cache indexed by methods to speed things up and to avoid the
4840 * boundless mempool growth caused by the signature_dup stuff below.
4841 */
4842 cache = get_cache (&method->klass->image->runtime_invoke_direct_cache, mono_aligned_addr_hash, NULL);
4843 res = mono_marshal_find_in_cache (cache, method);
4844 if (res)
4845 return res;
4846
4847 if (method->klass->rank && (method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) &&
4848 (method->iflags & METHOD_IMPL_ATTRIBUTE_NATIVE)) {
4849 /*
4850 * Array Get/Set/Address methods. The JIT implements them using inline code
4851 * so we need to create an invoke wrapper which calls the method directly.
4852 */
4853 need_direct_wrapper = TRUE;
4854 }
4855
4856 if (method->string_ctor) {
4857 callsig = lookup_string_ctor_signature (mono_method_signature (method));
4858 if (!callsig)
4859 callsig = add_string_ctor_signature (method);
4860 } else {
4861 if (method->klass->valuetype && mono_method_signature (method)->hasthis) {
4862 /*
4863 * Valuetype methods receive a managed pointer as the this argument.
4864 * Create a new signature to reflect this.
4865 */
4866 callsig = signature_dup_add_this (mono_method_signature (method), method->klass);
4867 } else {
4868 if (method->dynamic)
4869 callsig = signature_dup (method->klass->image, mono_method_signature (method));
4870 else
4871 callsig = mono_method_signature (method);
4872 }
4873 }
4874
4875 /*
4876 * We try to share runtime invoke wrappers between different methods but have to
4877 * be careful about methods whose klass has a type cctor, since putting the wrapper
4878 * into that klass would mean that calling a method of klass A might invoke the
4879 * type initializer of class B, or throw an exception if the type initializer
4880 * was called before and failed. See #349621 for an example.
4881 * We avoid that for mscorlib methods by putting every wrapper into the object class.
4882 */
4883 if (method->klass->image == mono_defaults.corlib)
4884 target_klass = mono_defaults.object_class;
4885 else {
4886 /* Try to share wrappers for non-corlib methods with simple signatures */
4887 if (mono_metadata_signature_equal (callsig, cctor_signature)) {
4888 callsig = cctor_signature;
4889 target_klass = mono_defaults.object_class;
4890 } else if (mono_metadata_signature_equal (callsig, finalize_signature)) {
4891 callsig = finalize_signature;
4892 target_klass = mono_defaults.object_class;
4893 } else {
4894 // FIXME: This breaks too many things
4895 /*
4896 if (mono_class_get_cctor (method->klass))
4897 need_direct_wrapper = TRUE;
4898 */
4899
4900 /*
4901 * Can't put these wrappers into object, since they reference non-corlib
4902 * metadata (callsig).
4903 */
4904 target_klass = method->klass;
4905 }
4906 }
4907
4908 if (need_direct_wrapper) {
4909 /* Already searched at the start */
4910 } else {
4911 callsig = mono_marshal_get_runtime_invoke_sig (callsig);
4912
4913 cache = get_cache (&target_klass->image->runtime_invoke_cache,
4914 (GHashFunc)mono_signature_hash,
4915 (GCompareFunc)runtime_invoke_signature_equal);
4916
4917 /* from mono_marshal_find_in_cache */
4918 mono_marshal_lock ();
4919 res = g_hash_table_lookup (cache, callsig);
4920 mono_marshal_unlock ();
4921
4922 if (res) {
4923 g_free (callsig);
4924 return res;
4925 }
4926
4927 // FIXME: When to free callsig ?
4928 }
4929
4930 /* to make it work with our special string constructors */
4931 if (!string_dummy) {
4932 MONO_GC_REGISTER_ROOT (string_dummy);
4933 string_dummy = mono_string_new_wrapper ("dummy");
4934 }
4935
4936 sig = mono_method_signature (method);
4937
4938 csig = mono_metadata_signature_alloc (target_klass->image, 4);
4939
4940 csig->ret = &mono_defaults.object_class->byval_arg;
4941 if (method->klass->valuetype && mono_method_signature (method)->hasthis)
4942 csig->params [0] = callsig->params [0];
4943 else
4944 csig->params [0] = &mono_defaults.object_class->byval_arg;
4945 csig->params [1] = &mono_defaults.int_class->byval_arg;
4946 csig->params [2] = &mono_defaults.int_class->byval_arg;
4947 csig->params [3] = &mono_defaults.int_class->byval_arg;
4948
4949 name = mono_signature_to_name (callsig, "runtime_invoke");
4950 mb = mono_mb_new (target_klass, name, MONO_WRAPPER_RUNTIME_INVOKE);
4951 g_free (name);
4952
4953 /* allocate local 0 (object) tmp */
4954 mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
4955 /* allocate local 1 (object) exc */
4956 mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
4957
4958 /* cond set *exc to null */
4959 mono_mb_emit_byte (mb, CEE_LDARG_2);
4960 mono_mb_emit_byte (mb, CEE_BRFALSE_S);
4961 mono_mb_emit_byte (mb, 3);
4962 mono_mb_emit_byte (mb, CEE_LDARG_2);
4963 mono_mb_emit_byte (mb, CEE_LDNULL);
4964 mono_mb_emit_byte (mb, CEE_STIND_REF);
4965
4966 emit_thread_force_interrupt_checkpoint (mb);
4967
4968 if (sig->hasthis) {
4969 if (method->string_ctor) {
4970 mono_mb_emit_ptr (mb, string_dummy);
4971 } else {
4972 mono_mb_emit_ldarg (mb, 0);
4973 }
4974 }
4975
4976 for (i = 0; i < sig->param_count; i++) {
4977 MonoType *t = sig->params [i];
4978 int type;
4979
4980 mono_mb_emit_ldarg (mb, 1);
4981 if (i) {
4982 mono_mb_emit_icon (mb, sizeof (gpointer) * i);
4983 mono_mb_emit_byte (mb, CEE_ADD);
4984 }
4985
4986 if (t->byref) {
4987 mono_mb_emit_byte (mb, CEE_LDIND_I);
4988 /* A Nullable<T> type don't have a boxed form, it's either null or a boxed T.
4989 * So to make this work we unbox it to a local variablee and push a reference to that.
4990 */
4991 if (t->type == MONO_TYPE_GENERICINST && mono_class_is_nullable (mono_class_from_mono_type (t))) {
4992 int tmp_nullable_local = mono_mb_add_local (mb, &mono_class_from_mono_type (t)->byval_arg);
4993
4994 mono_mb_emit_op (mb, CEE_UNBOX_ANY, mono_class_from_mono_type (t));
4995 mono_mb_emit_stloc (mb, tmp_nullable_local);
4996 mono_mb_emit_ldloc_addr (mb, tmp_nullable_local);
4997 }
4998 continue;
4999 }
5000
5001 type = sig->params [i]->type;
5002 handle_enum:
5003 switch (type) {
5004 case MONO_TYPE_I1:
5005 case MONO_TYPE_BOOLEAN:
5006 case MONO_TYPE_U1:
5007 case MONO_TYPE_I2:
5008 case MONO_TYPE_U2:
5009 case MONO_TYPE_CHAR:
5010 case MONO_TYPE_I:
5011 case MONO_TYPE_U:
5012 case MONO_TYPE_I4:
5013 case MONO_TYPE_U4:
5014 case MONO_TYPE_R4:
5015 case MONO_TYPE_R8:
5016 case MONO_TYPE_I8:
5017 case MONO_TYPE_U8:
5018 mono_mb_emit_byte (mb, CEE_LDIND_I);
5019 mono_mb_emit_byte (mb, mono_type_to_ldind (sig->params [i]));
5020 break;
5021 case MONO_TYPE_STRING:
5022 case MONO_TYPE_CLASS:
5023 case MONO_TYPE_ARRAY:
5024 case MONO_TYPE_PTR:
5025 case MONO_TYPE_SZARRAY:
5026 case MONO_TYPE_OBJECT:
5027 mono_mb_emit_byte (mb, mono_type_to_ldind (sig->params [i]));
5028 break;
5029 case MONO_TYPE_GENERICINST:
5030 if (!mono_type_generic_inst_is_valuetype (sig->params [i])) {
5031 mono_mb_emit_byte (mb, CEE_LDIND_I);
5032 break;
5033 }
5034
5035 /* fall through */
5036 case MONO_TYPE_VALUETYPE:
5037 if (type == MONO_TYPE_VALUETYPE && t->data.klass->enumtype) {
5038 type = t->data.klass->enum_basetype->type;
5039 goto handle_enum;
5040 }
5041 mono_mb_emit_byte (mb, CEE_LDIND_I);
5042 if (mono_class_is_nullable (mono_class_from_mono_type (sig->params [i]))) {
5043 /* Need to convert a boxed vtype to an mp to a Nullable struct */
5044 mono_mb_emit_op (mb, CEE_UNBOX, mono_class_from_mono_type (sig->params [i]));
5045 mono_mb_emit_op (mb, CEE_LDOBJ, mono_class_from_mono_type (sig->params [i]));
5046 } else {
5047 mono_mb_emit_op (mb, CEE_LDOBJ, mono_class_from_mono_type (sig->params [i]));
5048 }
5049 break;
5050 default:
5051 g_assert_not_reached ();
5052 }
5053 }
5054
5055 if (need_direct_wrapper) {
5056 mono_mb_emit_op (mb, CEE_CALL, method);
5057 } else {
5058 mono_mb_emit_ldarg (mb, 3);
5059 mono_mb_emit_calli (mb, callsig);
5060 }
5061
5062 if (sig->ret->byref) {
5063 /* fixme: */
5064 g_assert_not_reached ();
5065 }
5066
5067
5068 switch (sig->ret->type) {
5069 case MONO_TYPE_VOID:
5070 if (!method->string_ctor)
5071 mono_mb_emit_byte (mb, CEE_LDNULL);
5072 break;
5073 case MONO_TYPE_BOOLEAN:
5074 case MONO_TYPE_CHAR:
5075 case MONO_TYPE_I1:
5076 case MONO_TYPE_U1:
5077 case MONO_TYPE_I2:
5078 case MONO_TYPE_U2:
5079 case MONO_TYPE_I4:
5080 case MONO_TYPE_U4:
5081 case MONO_TYPE_I:
5082 case MONO_TYPE_U:
5083 case MONO_TYPE_R4:
5084 case MONO_TYPE_R8:
5085 case MONO_TYPE_I8:
5086 case MONO_TYPE_U8:
5087 case MONO_TYPE_VALUETYPE:
5088 case MONO_TYPE_TYPEDBYREF:
5089 case MONO_TYPE_GENERICINST:
5090 /* box value types */
5091 mono_mb_emit_op (mb, CEE_BOX, mono_class_from_mono_type (sig->ret));
5092 break;
5093 case MONO_TYPE_STRING:
5094 case MONO_TYPE_CLASS:
5095 case MONO_TYPE_ARRAY:
5096 case MONO_TYPE_SZARRAY:
5097 case MONO_TYPE_OBJECT:
5098 /* nothing to do */
5099 break;
5100 case MONO_TYPE_PTR:
5101 default:
5102 g_assert_not_reached ();
5103 }
5104
5105 mono_mb_emit_stloc (mb, 0);
5106
5107 pos = mono_mb_emit_branch (mb, CEE_LEAVE);
5108
5109 mono_loader_lock ();
5110 clause = mono_image_alloc0 (target_klass->image, sizeof (MonoExceptionClause));
5111 mono_loader_unlock ();
5112 clause->flags = MONO_EXCEPTION_CLAUSE_FILTER;
5113 clause->try_len = mono_mb_get_label (mb);
5114
5115 /* filter code */
5116 clause->data.filter_offset = mono_mb_get_label (mb);
5117
5118 mono_mb_emit_byte (mb, CEE_POP);
5119 mono_mb_emit_byte (mb, CEE_LDARG_2);
5120 mono_mb_emit_byte (mb, CEE_LDC_I4_0);
5121 mono_mb_emit_byte (mb, CEE_PREFIX1);
5122 mono_mb_emit_byte (mb, CEE_CGT_UN);
5123 mono_mb_emit_byte (mb, CEE_PREFIX1);
5124 mono_mb_emit_byte (mb, CEE_ENDFILTER);
5125
5126 clause->handler_offset = mono_mb_get_label (mb);
5127
5128 /* handler code */
5129 /* store exception */
5130 mono_mb_emit_stloc (mb, 1);
5131
5132 mono_mb_emit_byte (mb, CEE_LDARG_2);
5133 mono_mb_emit_ldloc (mb, 1);
5134 mono_mb_emit_byte (mb, CEE_STIND_REF);
5135
5136 mono_mb_emit_byte (mb, CEE_LDNULL);
5137 mono_mb_emit_stloc (mb, 0);
5138
5139 /* Check for the abort exception */
5140 mono_mb_emit_ldloc (mb, 1);
5141 mono_mb_emit_op (mb, CEE_ISINST, mono_defaults.threadabortexception_class);
5142 posna = mono_mb_emit_short_branch (mb, CEE_BRFALSE_S);
5143
5144 /* Delay the abort exception */
5145 mono_mb_emit_icall (mb, ves_icall_System_Threading_Thread_ResetAbort);
5146
5147 mono_mb_patch_short_branch (mb, posna);
5148 mono_mb_emit_branch (mb, CEE_LEAVE);
5149
5150 clause->handler_len = mono_mb_get_pos (mb) - clause->handler_offset;
5151
5152 /* return result */
5153 mono_mb_patch_branch (mb, pos);
5154 mono_mb_emit_ldloc (mb, 0);
5155 mono_mb_emit_byte (mb, CEE_RET);
5156
5157 if (need_direct_wrapper) {
5158 res = mono_mb_create_and_cache (cache, method, mb, csig, sig->param_count + 16);
5159 } else {
5160 /* taken from mono_mb_create_and_cache */
5161 mono_marshal_lock ();
5162 res = g_hash_table_lookup (cache, callsig);
5163 mono_marshal_unlock ();
5164
5165 /* Somebody may have created it before us */
5166 if (!res) {
5167 MonoMethod *newm;
5168 newm = mono_mb_create_method (mb, csig, sig->param_count + 16);
5169
5170 mono_marshal_lock ();
5171 res = g_hash_table_lookup (cache, callsig);
5172 if (!res) {
5173 res = newm;
5174 g_hash_table_insert (cache, callsig, res);
5175 /* Can't insert it into wrapper_hash since the key is a signature */
5176 g_hash_table_insert (method->klass->image->runtime_invoke_direct_cache, method, res);
5177 } else {
5178 mono_free_method (newm);
5179 }
5180 mono_marshal_unlock ();
5181 }
5182
5183 /* end mono_mb_create_and_cache */
5184 }
5185
5186 mono_mb_free (mb);
5187
5188 header = ((MonoMethodNormal *)res)->header;
5189 header->num_clauses = 1;
5190 header->clauses = clause;
5191
5192 return res;
5193 }
5194
5195 /*
5196 * mono_marshal_get_static_rgctx_invoke:
5197 * @method: a method
5198 *
5199 * Generates a wrapper for calling a generic shared method, either
5200 * static or generic. We need this for virtual generic method lookup
5201 * and ldftn when we do generic code sharing. Instead of producing
5202 * the address of the method we produce the address of a wrapper for
5203 * the method because the wrapper passes the (method) runtime generic
5204 * context argument which calli cannot do.
5205 */
5206 MonoMethod *
5207 mono_marshal_get_static_rgctx_invoke (MonoMethod *method)
5208 {
5209 static gboolean inited = FALSE;
5210 static int num_wrappers = 0;
5211
5212 MonoMethodBuilder *mb;
5213 MonoMethod *res;
5214 MonoClass *target_klass = method->klass;
5215 MonoMethodSignature *sig = mono_method_signature (method);
5216 int i;
5217 char *name;
5218 GHashTable *cache;
5219 MonoImage *image = method->klass->image;
5220
5221 cache = get_cache (&image->static_rgctx_invoke_cache, mono_aligned_addr_hash, NULL);
5222 if ((res = mono_marshal_find_in_cache (cache, method)))
5223 return res;
5224
5225 if (!inited) {
5226 mono_counters_register ("static rgctx invoke wrappers",
5227 MONO_COUNTER_GENERICS | MONO_COUNTER_INT, &num_wrappers);
5228 inited = TRUE;
5229 }
5230 ++num_wrappers;
5231
5232 name = mono_signature_to_name (mono_method_signature (method), "static_rgctx_invoke");
5233 mb = mono_mb_new (target_klass, name, MONO_WRAPPER_STATIC_RGCTX_INVOKE);
5234 g_free (name);
5235
5236 for (i = 0; i < sig->param_count + sig->hasthis; i++)
5237 mono_mb_emit_ldarg (mb, i);
5238 mono_mb_emit_op (mb, CEE_CALL, method);
5239 mono_mb_emit_byte (mb, CEE_RET);
5240
5241 res = mono_mb_create_and_cache (cache, method, mb, mono_method_signature (method),
5242 sig->param_count + sig->hasthis + 4);
5243 res->skip_visibility = TRUE;
5244 res->flags = method->flags;
5245
5246 mono_mb_free (mb);
5247
5248 return res;
5249 }
5250
5251 static void
5252 mono_mb_emit_auto_layout_exception (MonoMethodBuilder *mb, MonoClass *klass)
5253 {
5254 char *msg = g_strdup_printf ("The type `%s.%s' layout needs to be Sequential or Explicit",
5255 klass->name_space, klass->name);
5256
5257 mono_mb_emit_exception_marshal_directive (mb, msg);
5258 }
5259
5260 /*
5261 * mono_marshal_get_ldfld_remote_wrapper:
5262 * @klass: The return type
5263 *
5264 * This method generates a wrapper for calling mono_load_remote_field_new.
5265 * The return type is ignored for now, as mono_load_remote_field_new () always
5266 * returns an object. In the future, to optimize some codepaths, we might
5267 * call a different function that takes a pointer to a valuetype, instead.
5268 */
5269 MonoMethod *
5270 mono_marshal_get_ldfld_remote_wrapper (MonoClass *klass)
5271 {
5272 MonoMethodSignature *sig, *csig;
5273 MonoMethodBuilder *mb;
5274 MonoMethod *res;
5275 static MonoMethod* cached = NULL;
5276
5277 mono_marshal_lock ();
5278 if (cached) {
5279 mono_marshal_unlock ();
5280 return cached;
5281 }
5282 mono_marshal_unlock ();
5283
5284 mb = mono_mb_new_no_dup_name (mono_defaults.object_class, "__mono_load_remote_field_new_wrapper", MONO_WRAPPER_LDFLD_REMOTE);
5285
5286 mb->method->save_lmf = 1;
5287
5288 sig = mono_metadata_signature_alloc (mono_defaults.corlib, 3);
5289 sig->params [0] = &mono_defaults.object_class->byval_arg;
5290 sig->params [1] = &mono_defaults.int_class->byval_arg;
5291 sig->params [2] = &mono_defaults.int_class->byval_arg;
5292 sig->ret = &mono_defaults.object_class->byval_arg;
5293
5294 mono_mb_emit_ldarg (mb, 0);
5295 mono_mb_emit_ldarg (mb, 1);
5296 mono_mb_emit_ldarg (mb, 2);
5297
5298 csig = mono_metadata_signature_alloc (mono_defaults.corlib, 3);
5299 csig->params [0] = &mono_defaults.object_class->byval_arg;
5300 csig->params [1] = &mono_defaults.int_class->byval_arg;
5301 csig->params [2] = &mono_defaults.int_class->byval_arg;
5302 csig->ret = &mono_defaults.object_class->byval_arg;
5303 csig->pinvoke = 1;
5304
5305 mono_mb_emit_native_call (mb, csig, mono_load_remote_field_new);
5306 emit_thread_interrupt_checkpoint (mb);
5307
5308 mono_mb_emit_byte (mb, CEE_RET);
5309
5310 mono_marshal_lock ();
5311 res = cached;
5312 mono_marshal_unlock ();
5313 if (!res) {
5314 MonoMethod *newm;
5315 newm = mono_mb_create_method (mb, sig, 4);
5316 mono_marshal_lock ();
5317 res = cached;
5318 if (!res) {
5319 res = newm;
5320 cached = res;
5321 mono_marshal_unlock ();
5322 } else {
5323 mono_marshal_unlock ();
5324 mono_free_method (newm);
5325 }
5326 }
5327 mono_mb_free (mb);
5328
5329 return res;
5330 }
5331
5332 /*
5333 * mono_marshal_get_ldfld_wrapper:
5334 * @type: the type of the field
5335 *
5336 * This method generates a function which can be use to load a field with type
5337 * @type from an object. The generated function has the following signature:
5338 * <@type> ldfld_wrapper (MonoObject *this, MonoClass *class, MonoClassField *field, int offset)
5339 */
5340 MonoMethod *
5341 mono_marshal_get_ldfld_wrapper (MonoType *type)
5342 {
5343 MonoMethodSignature *sig;
5344 MonoMethodBuilder *mb;
5345 MonoMethod *res;
5346 MonoClass *klass;
5347 GHashTable *cache;
5348 char *name;
5349 int t, pos0, pos1 = 0;
5350
5351 type = mono_type_get_underlying_type (type);
5352
5353 t = type->type;
5354
5355 if (!type->byref) {
5356 if (type->type == MONO_TYPE_SZARRAY) {
5357 klass = mono_defaults.array_class;
5358 } else if (type->type == MONO_TYPE_VALUETYPE) {
5359 klass = type->data.klass;
5360 } else if (t == MONO_TYPE_OBJECT || t == MONO_TYPE_CLASS || t == MONO_TYPE_STRING) {
5361 klass = mono_defaults.object_class;
5362 } else if (t == MONO_TYPE_PTR || t == MONO_TYPE_FNPTR) {
5363 klass = mono_defaults.int_class;
5364 } else if (t == MONO_TYPE_GENERICINST) {
5365 if (mono_type_generic_inst_is_valuetype (type))
5366 klass = mono_class_from_mono_type (type);
5367 else
5368 klass = mono_defaults.object_class;
5369 } else {
5370 klass = mono_class_from_mono_type (type);
5371 }
5372 } else {
5373 klass = mono_defaults.int_class;
5374 }
5375
5376 cache = get_cache (&klass->image->ldfld_wrapper_cache, mono_aligned_addr_hash, NULL);
5377 if ((res = mono_marshal_find_in_cache (cache, klass)))
5378 return res;
5379
5380 /* we add the %p pointer value of klass because class names are not unique */
5381 name = g_strdup_printf ("__ldfld_wrapper_%p_%s.%s", klass, klass->name_space, klass->name);
5382 mb = mono_mb_new (mono_defaults.object_class, name, MONO_WRAPPER_LDFLD);
5383 g_free (name);
5384
5385 sig = mono_metadata_signature_alloc (mono_defaults.corlib, 4);
5386 sig->params [0] = &mono_defaults.object_class->byval_arg;
5387 sig->params [1] = &mono_defaults.int_class->byval_arg;
5388 sig->params [2] = &mono_defaults.int_class->byval_arg;
5389 sig->params [3] = &mono_defaults.int_class->byval_arg;
5390 sig->ret = &klass->byval_arg;
5391
5392 mono_mb_emit_ldarg (mb, 0);
5393 pos0 = mono_mb_emit_proxy_check (mb, CEE_BNE_UN);
5394
5395 mono_mb_emit_ldarg (mb, 0);
5396 mono_mb_emit_ldarg (mb, 1);
5397 mono_mb_emit_ldarg (mb, 2);
5398
5399 mono_mb_emit_managed_call (mb, mono_marshal_get_ldfld_remote_wrapper (klass), NULL);
5400
5401 /*
5402 csig = mono_metadata_signature_alloc (mono_defaults.corlib, 3);
5403 csig->params [0] = &mono_defaults.object_class->byval_arg;
5404 csig->params [1] = &mono_defaults.int_class->byval_arg;
5405 csig->params [2] = &mono_defaults.int_class->byval_arg;
5406 csig->ret = &klass->this_arg;
5407 csig->pinvoke = 1;
5408
5409 mono_mb_emit_native_call (mb, csig, mono_load_remote_field_new);
5410 emit_thread_interrupt_checkpoint (mb);
5411 */
5412
5413 if (klass->valuetype) {
5414 mono_mb_emit_op (mb, CEE_UNBOX, klass);
5415 pos1 = mono_mb_emit_branch (mb, CEE_BR);
5416 } else {
5417 mono_mb_emit_byte (mb, CEE_RET);
5418 }
5419
5420
5421 mono_mb_patch_branch (mb, pos0);
5422
5423 mono_mb_emit_ldarg (mb, 0);
5424 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
5425 mono_mb_emit_byte (mb, CEE_MONO_OBJADDR);
5426 mono_mb_emit_ldarg (mb, 3);
5427 mono_mb_emit_byte (mb, CEE_ADD);
5428
5429 if (klass->valuetype)
5430 mono_mb_patch_branch (mb, pos1);
5431
5432 switch (t) {
5433 case MONO_TYPE_I1:
5434 case MONO_TYPE_U1:
5435 case MONO_TYPE_BOOLEAN:
5436 case MONO_TYPE_CHAR:
5437 case MONO_TYPE_I2:
5438 case MONO_TYPE_U2:
5439 case MONO_TYPE_I4:
5440 case MONO_TYPE_U4:
5441 case MONO_TYPE_I8:
5442 case MONO_TYPE_U8:
5443 case MONO_TYPE_R4:
5444 case MONO_TYPE_R8:
5445 case MONO_TYPE_ARRAY:
5446 case MONO_TYPE_SZARRAY:
5447 case MONO_TYPE_OBJECT:
5448 case MONO_TYPE_CLASS:
5449 case MONO_TYPE_STRING:
5450 case MONO_TYPE_I:
5451 case MONO_TYPE_U:
5452 case MONO_TYPE_PTR:
5453 case MONO_TYPE_FNPTR:
5454 mono_mb_emit_byte (mb, mono_type_to_ldind (type));
5455 break;
5456 case MONO_TYPE_VALUETYPE:
5457 g_assert (!klass->enumtype);
5458 mono_mb_emit_op (mb, CEE_LDOBJ, klass);
5459 break;
5460 case MONO_TYPE_GENERICINST:
5461 if (mono_type_generic_inst_is_valuetype (type)) {
5462 mono_mb_emit_op (mb, CEE_LDOBJ, klass);
5463 } else {
5464 mono_mb_emit_byte (mb, CEE_LDIND_REF);
5465 }
5466 break;
5467 default:
5468 g_warning ("type %x not implemented", type->type);
5469 g_assert_not_reached ();
5470 }
5471
5472 mono_mb_emit_byte (mb, CEE_RET);
5473
5474 res = mono_mb_create_and_cache (cache, klass,
5475 mb, sig, sig->param_count + 16);
5476 mono_mb_free (mb);
5477
5478 return res;
5479 }
5480
5481 /*
5482 * mono_marshal_get_ldflda_wrapper:
5483 * @type: the type of the field
5484 *
5485 * This method generates a function which can be used to load a field address
5486 * from an object. The generated function has the following signature:
5487 * gpointer ldflda_wrapper (MonoObject *this, MonoClass *class, MonoClassField *field, int offset);
5488 */
5489 MonoMethod *
5490 mono_marshal_get_ldflda_wrapper (MonoType *type)
5491 {
5492 MonoMethodSignature *sig;
5493 MonoMethodBuilder *mb;
5494 MonoMethod *res;
5495 MonoClass *klass;
5496 GHashTable *cache;
5497 char *name;
5498 int t, pos0, pos1, pos2, pos3;
5499
5500 type = mono_type_get_underlying_type (type);
5501 t = type->type;
5502
5503 if (!type->byref) {
5504 if (type->type == MONO_TYPE_SZARRAY) {
5505 klass = mono_defaults.array_class;
5506 } else if (type->type == MONO_TYPE_VALUETYPE) {
5507 klass = type->data.klass;
5508 } else if (t == MONO_TYPE_OBJECT || t == MONO_TYPE_CLASS || t == MONO_TYPE_STRING ||
5509 t == MONO_TYPE_CLASS) {
5510 klass = mono_defaults.object_class;
5511 } else if (t == MONO_TYPE_PTR || t == MONO_TYPE_FNPTR) {
5512 klass = mono_defaults.int_class;
5513 } else if (t == MONO_TYPE_GENERICINST) {
5514 if (mono_type_generic_inst_is_valuetype (type))
5515 klass = mono_class_from_mono_type (type);
5516 else
5517 klass = mono_defaults.object_class;
5518 } else {
5519 klass = mono_class_from_mono_type (type);
5520 }
5521 } else {
5522 klass = mono_defaults.int_class;
5523 }
5524
5525 cache = get_cache (&klass->image->ldflda_wrapper_cache, mono_aligned_addr_hash, NULL);
5526 if ((res = mono_marshal_find_in_cache (cache, klass)))
5527 return res;
5528
5529 /* we add the %p pointer value of klass because class names are not unique */
5530 name = g_strdup_printf ("__ldflda_wrapper_%p_%s.%s", klass, klass->name_space, klass->name);
5531 mb = mono_mb_new (mono_defaults.object_class, name, MONO_WRAPPER_LDFLDA);
5532 g_free (name);
5533
5534 sig = mono_metadata_signature_alloc (mono_defaults.corlib, 4);
5535 sig->params [0] = &mono_defaults.object_class->byval_arg;
5536 sig->params [1] = &mono_defaults.int_class->byval_arg;
5537 sig->params [2] = &mono_defaults.int_class->byval_arg;
5538 sig->params [3] = &mono_defaults.int_class->byval_arg;
5539 sig->ret = &mono_defaults.int_class->byval_arg;
5540
5541 /* if typeof (this) != transparent_proxy goto pos0 */
5542 mono_mb_emit_ldarg (mb, 0);
5543 pos0 = mono_mb_emit_proxy_check (mb, CEE_BNE_UN);
5544
5545 /* if same_appdomain goto pos1 */
5546 mono_mb_emit_ldarg (mb, 0);
5547 pos1 = mono_mb_emit_xdomain_check (mb, CEE_BEQ);
5548
5549 mono_mb_emit_exception_full (mb, "System", "InvalidOperationException", "Attempt to load field address from object in another appdomain.");
5550
5551 /* same app domain */
5552 mono_mb_patch_branch (mb, pos1);
5553
5554 /* if typeof (this) != contextbound goto pos2 */
5555 mono_mb_emit_ldarg (mb, 0);
5556 pos2 = mono_mb_emit_contextbound_check (mb, CEE_BEQ);
5557
5558 /* if this->rp->context == mono_context_get goto pos3 */
5559 mono_mb_emit_ldarg (mb, 0);
5560 mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoTransparentProxy, rp));
5561 mono_mb_emit_byte (mb, CEE_LDIND_REF);
5562 mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoRealProxy, context));
5563 mono_mb_emit_byte (mb, CEE_LDIND_REF);
5564 mono_mb_emit_icall (mb, mono_context_get);
5565 pos3 = mono_mb_emit_branch (mb, CEE_BEQ);
5566
5567 mono_mb_emit_exception_full (mb, "System", "InvalidOperationException", "Attempt to load field address from object in another context.");
5568
5569 mono_mb_patch_branch (mb, pos2);
5570 mono_mb_patch_branch (mb, pos3);
5571
5572 /* return the address of the field from this->rp->unwrapped_server */
5573 mono_mb_emit_ldarg (mb, 0);
5574 mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoTransparentProxy, rp));
5575 mono_mb_emit_byte (mb, CEE_LDIND_REF);
5576 mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoRealProxy, unwrapped_server));
5577 mono_mb_emit_byte (mb, CEE_LDIND_REF);
5578 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
5579 mono_mb_emit_byte (mb, CEE_MONO_OBJADDR);
5580 mono_mb_emit_ldarg (mb, 3);
5581 mono_mb_emit_byte (mb, CEE_ADD);
5582 mono_mb_emit_byte (mb, CEE_RET);
5583
5584 /* not a proxy: return the address of the field directly */
5585 mono_mb_patch_branch (mb, pos0);
5586
5587 mono_mb_emit_ldarg (mb, 0);
5588 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
5589 mono_mb_emit_byte (mb, CEE_MONO_OBJADDR);
5590 mono_mb_emit_ldarg (mb, 3);
5591 mono_mb_emit_byte (mb, CEE_ADD);
5592
5593 mono_mb_emit_byte (mb, CEE_RET);
5594
5595 res = mono_mb_create_and_cache (cache, klass,
5596 mb, sig, sig->param_count + 16);
5597 mono_mb_free (mb);
5598
5599 return res;
5600 }
5601
5602 /*
5603 * mono_marshal_get_stfld_remote_wrapper:
5604 * klass: The type of the field
5605 *
5606 * This function generates a wrapper for calling mono_store_remote_field_new
5607 * with the appropriate signature.
5608 * Similarly to mono_marshal_get_ldfld_remote_wrapper () this doesn't depend on the
5609 * klass argument anymore.
5610 */
5611 MonoMethod *
5612 mono_marshal_get_stfld_remote_wrapper (MonoClass *klass)
5613 {
5614 MonoMethodSignature *sig, *csig;
5615 MonoMethodBuilder *mb;
5616 MonoMethod *res;
5617 static MonoMethod *cached = NULL;
5618
5619 mono_marshal_lock ();
5620 if (cached) {
5621 mono_marshal_unlock ();
5622 return cached;
5623 }
5624 mono_marshal_unlock ();
5625
5626 mb = mono_mb_new_no_dup_name (mono_defaults.object_class, "__mono_store_remote_field_new_wrapper", MONO_WRAPPER_STFLD_REMOTE);
5627
5628 mb->method->save_lmf = 1;
5629
5630 sig = mono_metadata_signature_alloc (mono_defaults.corlib, 4);
5631 sig->params [0] = &mono_defaults.object_class->byval_arg;
5632 sig->params [1] = &mono_defaults.int_class->byval_arg;
5633 sig->params [2] = &mono_defaults.int_class->byval_arg;
5634 sig->params [3] = &mono_defaults.object_class->byval_arg;
5635 sig->ret = &mono_defaults.void_class->byval_arg;
5636
5637 mono_mb_emit_ldarg (mb, 0);
5638 mono_mb_emit_ldarg (mb, 1);
5639 mono_mb_emit_ldarg (mb, 2);
5640 mono_mb_emit_ldarg (mb, 3);
5641
5642 csig = mono_metadata_signature_alloc (mono_defaults.corlib, 4);
5643 csig->params [0] = &mono_defaults.object_class->byval_arg;
5644 csig->params [1] = &mono_defaults.int_class->byval_arg;
5645 csig->params [2] = &mono_defaults.int_class->byval_arg;
5646 csig->params [3] = &mono_defaults.object_class->byval_arg;
5647 csig->ret = &mono_defaults.void_class->byval_arg;
5648 csig->pinvoke = 1;
5649
5650 mono_mb_emit_native_call (mb, csig, mono_store_remote_field_new);
5651 emit_thread_interrupt_checkpoint (mb);
5652
5653 mono_mb_emit_byte (mb, CEE_RET);
5654
5655 mono_marshal_lock ();
5656 res = cached;
5657 mono_marshal_unlock ();
5658 if (!res) {
5659 MonoMethod *newm;
5660 newm = mono_mb_create_method (mb, sig, 6);
5661 mono_marshal_lock ();
5662 res = cached;
5663 if (!res) {
5664 res = newm;
5665 cached = res;
5666 mono_marshal_unlock ();
5667 } else {
5668 mono_marshal_unlock ();
5669 mono_free_method (newm);
5670 }
5671 }
5672 mono_mb_free (mb);
5673
5674 return res;
5675 }
5676
5677 /*
5678 * mono_marshal_get_stfld_wrapper:
5679 * @type: the type of the field
5680 *
5681 * This method generates a function which can be use to store a field with type
5682 * @type. The generated function has the following signature:
5683 * void stfld_wrapper (MonoObject *this, MonoClass *class, MonoClassField *field, int offset, <@type> val)
5684 */
5685 MonoMethod *
5686 mono_marshal_get_stfld_wrapper (MonoType *type)
5687 {
5688 MonoMethodSignature *sig;
5689 MonoMethodBuilder *mb;
5690 MonoMethod *res;
5691 MonoClass *klass;
5692 GHashTable *cache;
5693 char *name;
5694 int t, pos;
5695
5696 type = mono_type_get_underlying_type (type);
5697 t = type->type;
5698
5699 if (!type->byref) {
5700 if (type->type == MONO_TYPE_SZARRAY) {
5701 klass = mono_defaults.array_class;
5702 } else if (type->type == MONO_TYPE_VALUETYPE) {
5703 klass = type->data.klass;
5704 } else if (t == MONO_TYPE_OBJECT || t == MONO_TYPE_CLASS || t == MONO_TYPE_STRING) {
5705 klass = mono_defaults.object_class;
5706 } else if (t == MONO_TYPE_PTR || t == MONO_TYPE_FNPTR) {
5707 klass = mono_defaults.int_class;
5708 } else if (t == MONO_TYPE_GENERICINST) {
5709 if (mono_type_generic_inst_is_valuetype (type))
5710 klass = mono_class_from_mono_type (type);
5711 else
5712 klass = mono_defaults.object_class;
5713 } else {
5714 klass = mono_class_from_mono_type (type);
5715 }
5716 } else {
5717 klass = mono_defaults.int_class;
5718 }
5719
5720 cache = get_cache (&klass->image->stfld_wrapper_cache, mono_aligned_addr_hash, NULL);
5721 if ((res = mono_marshal_find_in_cache (cache, klass)))
5722 return res;
5723
5724 /* we add the %p pointer value of klass because class names are not unique */
5725 name = g_strdup_printf ("__stfld_wrapper_%p_%s.%s", klass, klass->name_space, klass->name);
5726 mb = mono_mb_new (mono_defaults.object_class, name, MONO_WRAPPER_STFLD);
5727 g_free (name);
5728
5729 sig = mono_metadata_signature_alloc (mono_defaults.corlib, 5);
5730 sig->params [0] = &mono_defaults.object_class->byval_arg;
5731 sig->params [1] = &mono_defaults.int_class->byval_arg;
5732 sig->params [2] = &mono_defaults.int_class->byval_arg;
5733 sig->params [3] = &mono_defaults.int_class->byval_arg;
5734 sig->params [4] = &klass->byval_arg;
5735 sig->ret = &mono_defaults.void_class->byval_arg;
5736
5737 mono_mb_emit_ldarg (mb, 0);
5738 pos = mono_mb_emit_proxy_check (mb, CEE_BNE_UN);
5739
5740 mono_mb_emit_ldarg (mb, 0);
5741 mono_mb_emit_ldarg (mb, 1);
5742 mono_mb_emit_ldarg (mb, 2);
5743 mono_mb_emit_ldarg (mb, 4);
5744 if (klass->valuetype)
5745 mono_mb_emit_op (mb, CEE_BOX, klass);
5746
5747 mono_mb_emit_managed_call (mb, mono_marshal_get_stfld_remote_wrapper (klass), NULL);
5748
5749 mono_mb_emit_byte (mb, CEE_RET);
5750
5751 mono_mb_patch_branch (mb, pos);
5752
5753 mono_mb_emit_ldarg (mb, 0);
5754 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
5755 mono_mb_emit_byte (mb, CEE_MONO_OBJADDR);
5756 mono_mb_emit_ldarg (mb, 3);
5757 mono_mb_emit_byte (mb, CEE_ADD);
5758 mono_mb_emit_ldarg (mb, 4);
5759
5760 switch (t) {
5761 case MONO_TYPE_I1:
5762 case MONO_TYPE_U1:
5763 case MONO_TYPE_BOOLEAN:
5764 case MONO_TYPE_CHAR:
5765 case MONO_TYPE_I2:
5766 case MONO_TYPE_U2:
5767 case MONO_TYPE_I4:
5768 case MONO_TYPE_U4:
5769 case MONO_TYPE_I8:
5770 case MONO_TYPE_U8:
5771 case MONO_TYPE_R4:
5772 case MONO_TYPE_R8:
5773 case MONO_TYPE_ARRAY:
5774 case MONO_TYPE_SZARRAY:
5775 case MONO_TYPE_OBJECT:
5776 case MONO_TYPE_CLASS:
5777 case MONO_TYPE_STRING:
5778 case MONO_TYPE_I:
5779 case MONO_TYPE_U:
5780 case MONO_TYPE_PTR:
5781 case MONO_TYPE_FNPTR:
5782 mono_mb_emit_byte (mb, mono_type_to_stind (type));
5783 break;
5784 case MONO_TYPE_VALUETYPE:
5785 g_assert (!klass->enumtype);
5786 mono_mb_emit_op (mb, CEE_STOBJ, klass);
5787 break;
5788 case MONO_TYPE_GENERICINST:
5789 mono_mb_emit_op (mb, CEE_STOBJ, klass);
5790 break;
5791 default:
5792 g_warning ("type %x not implemented", type->type);
5793 g_assert_not_reached ();
5794 }
5795
5796 mono_mb_emit_byte (mb, CEE_RET);
5797
5798 res = mono_mb_create_and_cache (cache, klass,
5799 mb, sig, sig->param_count + 16);
5800 mono_mb_free (mb);
5801
5802 return res;
5803 }
5804
5805 /*
5806 * generates IL code for the icall wrapper (the generated method
5807 * calls the unmanaged code in func)
5808 */
5809 MonoMethod *
5810 mono_marshal_get_icall_wrapper (MonoMethodSignature *sig, const char *name, gconstpointer func, gboolean check_exceptions)
5811 {
5812 MonoMethodSignature *csig;
5813 MonoMethodBuilder *mb;
5814 MonoMethod *res;
5815 int i;
5816
5817 g_assert (sig->pinvoke);
5818
5819 mb = mono_mb_new (mono_defaults.object_class, name, MONO_WRAPPER_MANAGED_TO_NATIVE);
5820
5821 mb->method->save_lmf = 1;
5822
5823 /* we copy the signature, so that we can modify it */
5824
5825 if (sig->hasthis)
5826 mono_mb_emit_byte (mb, CEE_LDARG_0);
5827
5828 for (i = 0; i < sig->param_count; i++)
5829 mono_mb_emit_ldarg (mb, i + sig->hasthis);
5830
5831 mono_mb_emit_native_call (mb, sig, (gpointer) func);
5832 if (check_exceptions)
5833 emit_thread_interrupt_checkpoint (mb);
5834 mono_mb_emit_byte (mb, CEE_RET);
5835
5836 csig = signature_dup (mono_defaults.corlib, sig);
5837 csig->pinvoke = 0;
5838 if (csig->call_convention == MONO_CALL_VARARG)
5839 csig->call_convention = 0;
5840
5841 res = mono_mb_create_method (mb, csig, csig->param_count + 16);
5842 mono_mb_free (mb);
5843
5844 return res;
5845 }
5846
5847 typedef struct {
5848 MonoMethodBuilder *mb;
5849 MonoMethodSignature *sig;
5850 MonoMethodPInvoke *piinfo;
5851 int *orig_conv_args; /* Locals containing the original values of byref args */
5852 int retobj_var;
5853 MonoClass *retobj_class;
5854 MonoMethodSignature *csig; /* Might need to be changed due to MarshalAs directives */
5855 MonoImage *image; /* The image to use for looking up custom marshallers */
5856 } EmitMarshalContext;
5857
5858 typedef enum {
5859 /*
5860 * This is invoked to convert arguments from the current types to
5861 * the underlying types expected by the platform routine. If required,
5862 * the methods create a temporary variable with the proper type, and return
5863 * the location for it (either the passed argument, or the newly allocated
5864 * local slot).
5865 */
5866 MARSHAL_ACTION_CONV_IN,
5867
5868 /*
5869 * This operation is called to push the actual value that was optionally
5870 * converted on the first stage
5871 */
5872 MARSHAL_ACTION_PUSH,
5873
5874 /*
5875 * Convert byref arguments back or free resources allocated during the
5876 * CONV_IN stage
5877 */
5878 MARSHAL_ACTION_CONV_OUT,
5879
5880 /*
5881 * The result from the unmanaged call is at the top of the stack when
5882 * this action is invoked. The result should be stored in the
5883 * third local variable slot.
5884 */
5885 MARSHAL_ACTION_CONV_RESULT,
5886
5887 MARSHAL_ACTION_MANAGED_CONV_IN,
5888 MARSHAL_ACTION_MANAGED_CONV_OUT,
5889 MARSHAL_ACTION_MANAGED_CONV_RESULT
5890 } MarshalAction;
5891
5892 static int
5893 emit_marshal_custom (EmitMarshalContext *m, int argnum, MonoType *t,
5894 MonoMarshalSpec *spec,
5895 int conv_arg, MonoType **conv_arg_type,
5896 MarshalAction action)
5897 {
5898 MonoType *mtype;
5899 MonoClass *mklass;
5900 static MonoClass *ICustomMarshaler = NULL;
5901 static MonoMethod *cleanup_native, *cleanup_managed;
5902 static MonoMethod *marshal_managed_to_native, *marshal_native_to_managed;
5903 MonoMethod *get_instance;
5904 MonoMethodBuilder *mb = m->mb;
5905 char *exception_msg = NULL;
5906 guint32 loc1;
5907 int pos2;
5908
5909 if (!ICustomMarshaler) {
5910 ICustomMarshaler = mono_class_from_name (mono_defaults.corlib, "System.Runtime.InteropServices", "ICustomMarshaler");
5911 g_assert (ICustomMarshaler);
5912
5913 cleanup_native = mono_class_get_method_from_name (ICustomMarshaler, "CleanUpNativeData", 1);
5914 g_assert (cleanup_native);
5915 cleanup_managed = mono_class_get_method_from_name (ICustomMarshaler, "CleanUpManagedData", 1);
5916 g_assert (cleanup_managed);
5917 marshal_managed_to_native = mono_class_get_method_from_name (ICustomMarshaler, "MarshalManagedToNative", 1);
5918 g_assert (marshal_managed_to_native);
5919 marshal_native_to_managed = mono_class_get_method_from_name (ICustomMarshaler, "MarshalNativeToManaged", 1);
5920 g_assert (marshal_native_to_managed);
5921 }
5922
5923 mtype = mono_reflection_type_from_name (spec->data.custom_data.custom_name, m->image);
5924 g_assert (mtype != NULL);
5925 mklass = mono_class_from_mono_type (mtype);
5926 g_assert (mklass != NULL);
5927
5928 if (!mono_class_is_assignable_from (ICustomMarshaler, mklass))
5929 exception_msg = g_strdup_printf ("Custom marshaler '%s' does not implement the ICustomMarshaler interface.", mklass->name);
5930
5931 get_instance = mono_class_get_method_from_name_flags (mklass, "GetInstance", 1, METHOD_ATTRIBUTE_STATIC);
5932 if (get_instance) {
5933 MonoMethodSignature *get_sig = mono_method_signature (get_instance);
5934 if ((get_sig->ret->type != MONO_TYPE_CLASS) ||
5935 (mono_class_from_mono_type (get_sig->ret) != ICustomMarshaler) ||
5936 (get_sig->params [0]->type != MONO_TYPE_STRING))
5937 get_instance = NULL;
5938 }
5939
5940 if (!get_instance)
5941 exception_msg = g_strdup_printf ("Custom marshaler '%s' does not implement a static GetInstance method that takes a single string parameter and returns an ICustomMarshaler.", mklass->name);
5942
5943 /* Throw exception and emit compensation code if neccesary */
5944 if (exception_msg) {
5945 switch (action) {
5946 case MARSHAL_ACTION_CONV_IN:
5947 case MARSHAL_ACTION_CONV_RESULT:
5948 case MARSHAL_ACTION_MANAGED_CONV_RESULT:
5949 if ((action == MARSHAL_ACTION_CONV_RESULT) || (action == MARSHAL_ACTION_MANAGED_CONV_RESULT))
5950 mono_mb_emit_byte (mb, CEE_POP);
5951
5952 mono_mb_emit_exception_full (mb, "System", "ApplicationException", exception_msg);
5953 g_free (exception_msg);
5954
5955 break;
5956 case MARSHAL_ACTION_PUSH:
5957 mono_mb_emit_byte (mb, CEE_LDNULL);
5958 break;
5959 default:
5960 break;
5961 }
5962 return 0;
5963 }
5964
5965 /* FIXME: MS.NET seems to create one instance for each klass + cookie pair */
5966 /* FIXME: MS.NET throws an exception if GetInstance returns null */
5967
5968 switch (action) {
5969 case MARSHAL_ACTION_CONV_IN:
5970 switch (t->type) {
5971 case MONO_TYPE_CLASS:
5972 case MONO_TYPE_OBJECT:
5973 case MONO_TYPE_STRING:
5974 case MONO_TYPE_ARRAY:
5975 case MONO_TYPE_SZARRAY:
5976 case MONO_TYPE_VALUETYPE:
5977 break;
5978
5979 default:
5980 g_warning ("custom marshalling of type %x is currently not supported", t->type);
5981 g_assert_not_reached ();
5982 break;
5983 }
5984
5985 conv_arg = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
5986
5987 mono_mb_emit_byte (mb, CEE_LDNULL);
5988 mono_mb_emit_stloc (mb, conv_arg);
5989
5990 if (t->byref && (t->attrs & PARAM_ATTRIBUTE_OUT))
5991 break;
5992
5993 /* Minic MS.NET behavior */
5994 if (!t->byref && (t->attrs & PARAM_ATTRIBUTE_OUT) && !(t->attrs & PARAM_ATTRIBUTE_IN))
5995 break;
5996
5997 /* Check for null */
5998 mono_mb_emit_ldarg (mb, argnum);
5999 if (t->byref)
6000 mono_mb_emit_byte (mb, CEE_LDIND_I);
6001 pos2 = mono_mb_emit_branch (mb, CEE_BRFALSE);
6002
6003 mono_mb_emit_ldstr (mb, g_strdup (spec->data.custom_data.cookie));
6004
6005 mono_mb_emit_op (mb, CEE_CALL, get_instance);
6006
6007 mono_mb_emit_ldarg (mb, argnum);
6008 if (t->byref)
6009 mono_mb_emit_byte (mb, CEE_LDIND_REF);
6010
6011 if (t->type == MONO_TYPE_VALUETYPE) {
6012 /*
6013 * Since we can't determine the type of the argument, we
6014 * will assume the unmanaged function takes a pointer.
6015 */
6016 *conv_arg_type = &mono_defaults.int_class->byval_arg;
6017
6018 mono_mb_emit_op (mb, CEE_BOX, mono_class_from_mono_type (t));
6019 }
6020
6021 mono_mb_emit_op (mb, CEE_CALLVIRT, marshal_managed_to_native);
6022 mono_mb_emit_stloc (mb, conv_arg);
6023
6024 mono_mb_patch_branch (mb, pos2);
6025 break;
6026
6027 case MARSHAL_ACTION_CONV_OUT:
6028 /* Check for null */
6029 mono_mb_emit_ldloc (mb, conv_arg);
6030 pos2 = mono_mb_emit_branch (mb, CEE_BRFALSE);
6031
6032 if (t->byref) {
6033 mono_mb_emit_ldarg (mb, argnum);
6034
6035 mono_mb_emit_ldstr (mb, g_strdup (spec->data.custom_data.cookie));
6036
6037 mono_mb_emit_op (mb, CEE_CALL, get_instance);
6038
6039 mono_mb_emit_ldloc (mb, conv_arg);
6040 mono_mb_emit_op (mb, CEE_CALLVIRT, marshal_native_to_managed);
6041 mono_mb_emit_byte (mb, CEE_STIND_REF);
6042 } else {
6043 mono_mb_emit_ldstr (mb, g_strdup (spec->data.custom_data.cookie));
6044
6045 mono_mb_emit_op (mb, CEE_CALL, get_instance);
6046
6047 mono_mb_emit_ldloc (mb, conv_arg);
6048 mono_mb_emit_op (mb, CEE_CALLVIRT, marshal_native_to_managed);
6049
6050 /* We have nowhere to store the result */
6051 mono_mb_emit_byte (mb, CEE_POP);
6052 }
6053
6054 mono_mb_emit_ldstr (mb, g_strdup (spec->data.custom_data.cookie));
6055
6056 mono_mb_emit_op (mb, CEE_CALL, get_instance);
6057
6058 mono_mb_emit_ldloc (mb, conv_arg);
6059
6060 mono_mb_emit_op (mb, CEE_CALLVIRT, cleanup_native);
6061
6062 mono_mb_patch_branch (mb, pos2);
6063 break;
6064
6065 case MARSHAL_ACTION_PUSH:
6066 if (t->byref)
6067 mono_mb_emit_ldloc_addr (mb, conv_arg);
6068 else
6069 mono_mb_emit_ldloc (mb, conv_arg);
6070 break;
6071
6072 case MARSHAL_ACTION_CONV_RESULT:
6073 loc1 = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
6074
6075 mono_mb_emit_stloc (mb, 3);
6076
6077 mono_mb_emit_ldloc (mb, 3);
6078 mono_mb_emit_stloc (mb, loc1);
6079
6080 /* Check for null */
6081 mono_mb_emit_ldloc (mb, 3);
6082 pos2 = mono_mb_emit_branch (mb, CEE_BRFALSE);
6083
6084 mono_mb_emit_ldstr (mb, g_strdup (spec->data.custom_data.cookie));
6085
6086 mono_mb_emit_op (mb, CEE_CALL, get_instance);
6087 mono_mb_emit_byte (mb, CEE_DUP);
6088
6089 mono_mb_emit_ldloc (mb, 3);
6090 mono_mb_emit_op (mb, CEE_CALLVIRT, marshal_native_to_managed);
6091 mono_mb_emit_stloc (mb, 3);
6092
6093 mono_mb_emit_ldloc (mb, loc1);
6094 mono_mb_emit_op (mb, CEE_CALLVIRT, cleanup_native);
6095
6096 mono_mb_patch_branch (mb, pos2);
6097 break;
6098
6099 case MARSHAL_ACTION_MANAGED_CONV_IN:
6100 conv_arg = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
6101
6102 mono_mb_emit_byte (mb, CEE_LDNULL);
6103 mono_mb_emit_stloc (mb, conv_arg);
6104
6105 if (t->byref && t->attrs & PARAM_ATTRIBUTE_OUT)
6106 break;
6107
6108 /* Check for null */
6109 mono_mb_emit_ldarg (mb, argnum);
6110 if (t->byref)
6111 mono_mb_emit_byte (mb, CEE_LDIND_I);
6112 pos2 = mono_mb_emit_branch (mb, CEE_BRFALSE);
6113
6114 mono_mb_emit_ldstr (mb, g_strdup (spec->data.custom_data.cookie));
6115 mono_mb_emit_op (mb, CEE_CALL, get_instance);
6116
6117 mono_mb_emit_ldarg (mb, argnum);
6118 if (t->byref)
6119 mono_mb_emit_byte (mb, CEE_LDIND_I);
6120
6121 mono_mb_emit_op (mb, CEE_CALLVIRT, marshal_native_to_managed);
6122 mono_mb_emit_stloc (mb, conv_arg);
6123
6124 mono_mb_patch_branch (mb, pos2);
6125 break;
6126
6127 case MARSHAL_ACTION_MANAGED_CONV_RESULT:
6128 g_assert (!t->byref);
6129
6130 loc1 = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
6131
6132 mono_mb_emit_stloc (mb, 3);
6133
6134 mono_mb_emit_ldloc (mb, 3);
6135 mono_mb_emit_stloc (mb, loc1);
6136
6137 /* Check for null */
6138 mono_mb_emit_ldloc (mb, 3);
6139 pos2 = mono_mb_emit_branch (mb, CEE_BRFALSE);
6140
6141 mono_mb_emit_ldstr (mb, g_strdup (spec->data.custom_data.cookie));
6142 mono_mb_emit_op (mb, CEE_CALL, get_instance);
6143 mono_mb_emit_byte (mb, CEE_DUP);
6144
6145 mono_mb_emit_ldloc (mb, 3);
6146 mono_mb_emit_op (mb, CEE_CALLVIRT, marshal_managed_to_native);
6147 mono_mb_emit_stloc (mb, 3);
6148
6149 mono_mb_emit_ldloc (mb, loc1);
6150 mono_mb_emit_op (mb, CEE_CALLVIRT, cleanup_managed);
6151
6152 mono_mb_patch_branch (mb, pos2);
6153 break;
6154
6155 case MARSHAL_ACTION_MANAGED_CONV_OUT:
6156
6157 /* Check for null */
6158 mono_mb_emit_ldloc (mb, conv_arg);
6159 pos2 = mono_mb_emit_branch (mb, CEE_BRFALSE);
6160
6161 if (t->byref) {
6162 mono_mb_emit_ldarg (mb, argnum);
6163
6164 mono_mb_emit_ldstr (mb, g_strdup (spec->data.custom_data.cookie));
6165
6166 mono_mb_emit_op (mb, CEE_CALL, get_instance);
6167
6168 mono_mb_emit_ldloc (mb, conv_arg);
6169 mono_mb_emit_op (mb, CEE_CALLVIRT, marshal_managed_to_native);
6170 mono_mb_emit_byte (mb, CEE_STIND_I);
6171 }
6172
6173 /* Call CleanUpManagedData */
6174 mono_mb_emit_ldstr (mb, g_strdup (spec->data.custom_data.cookie));
6175
6176 mono_mb_emit_op (mb, CEE_CALL, get_instance);
6177
6178 mono_mb_emit_ldloc (mb, conv_arg);
6179 mono_mb_emit_op (mb, CEE_CALLVIRT, cleanup_managed);
6180
6181 mono_mb_patch_branch (mb, pos2);
6182 break;
6183
6184 default:
6185 g_assert_not_reached ();
6186 }
6187
6188 return conv_arg;
6189 }
6190
6191 static int
6192 emit_marshal_asany (EmitMarshalContext *m, int argnum, MonoType *t,
6193 MonoMarshalSpec *spec,
6194 int conv_arg, MonoType **conv_arg_type,
6195 MarshalAction action)
6196 {
6197 MonoMethodBuilder *mb = m->mb;
6198
6199 switch (action) {
6200 case MARSHAL_ACTION_CONV_IN: {
6201 MonoMarshalNative encoding = mono_marshal_get_string_encoding (m->piinfo, NULL);
6202
6203 g_assert (t->type == MONO_TYPE_OBJECT);
6204 g_assert (!t->byref);
6205
6206 conv_arg = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
6207 mono_mb_emit_ldarg (mb, argnum);
6208 mono_mb_emit_icon (mb, encoding);
6209 mono_mb_emit_icon (mb, t->attrs);
6210 mono_mb_emit_icall (mb, mono_marshal_asany);
6211 mono_mb_emit_stloc (mb, conv_arg);
6212 break;
6213 }
6214
6215 case MARSHAL_ACTION_PUSH:
6216 mono_mb_emit_ldloc (mb, conv_arg);
6217 break;
6218
6219 case MARSHAL_ACTION_CONV_OUT: {
6220 MonoMarshalNative encoding = mono_marshal_get_string_encoding (m->piinfo, NULL);
6221
6222 mono_mb_emit_ldarg (mb, argnum);
6223 mono_mb_emit_ldloc (mb, conv_arg);
6224 mono_mb_emit_icon (mb, encoding);
6225 mono_mb_emit_icon (mb, t->attrs);
6226 mono_mb_emit_icall (mb, mono_marshal_free_asany);
6227 break;
6228 }
6229
6230 default:
6231 g_assert_not_reached ();
6232 }
6233
6234 return conv_arg;
6235 }
6236
6237 static int
6238 emit_marshal_vtype (EmitMarshalContext *m, int argnum, MonoType *t,
6239 MonoMarshalSpec *spec,
6240 int conv_arg, MonoType **conv_arg_type,
6241 MarshalAction action)
6242 {
6243 MonoMethodBuilder *mb = m->mb;
6244 MonoClass *klass;
6245 int pos = 0, pos2;
6246
6247 klass = mono_class_from_mono_type (t);
6248
6249 switch (action) {
6250 case MARSHAL_ACTION_CONV_IN:
6251 if (((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) ||
6252 klass->blittable || klass->enumtype)
6253 break;
6254
6255 conv_arg = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
6256
6257 /* store the address of the source into local variable 0 */
6258 if (t->byref)
6259 mono_mb_emit_ldarg (mb, argnum);
6260 else
6261 mono_mb_emit_ldarg_addr (mb, argnum);
6262
6263 mono_mb_emit_stloc (mb, 0);
6264
6265 /* allocate space for the native struct and
6266 * store the address into local variable 1 (dest) */
6267 mono_mb_emit_icon (mb, mono_class_native_size (klass, NULL));
6268 mono_mb_emit_byte (mb, CEE_PREFIX1);
6269 mono_mb_emit_byte (mb, CEE_LOCALLOC);
6270 mono_mb_emit_stloc (mb, conv_arg);
6271
6272 if (t->byref) {
6273 mono_mb_emit_ldloc (mb, 0);
6274 pos = mono_mb_emit_branch (mb, CEE_BRFALSE);
6275 }
6276
6277 if (!(t->byref && !(t->attrs & PARAM_ATTRIBUTE_IN) && (t->attrs & PARAM_ATTRIBUTE_OUT))) {
6278 /* set dst_ptr */
6279 mono_mb_emit_ldloc (mb, conv_arg);
6280 mono_mb_emit_stloc (mb, 1);
6281
6282 /* emit valuetype conversion code */
6283 emit_struct_conv (mb, klass, FALSE);
6284 }
6285
6286 if (t->byref)
6287 mono_mb_patch_branch (mb, pos);
6288 break;
6289
6290 case MARSHAL_ACTION_PUSH:
6291 if (spec && spec->native == MONO_NATIVE_LPSTRUCT) {
6292 /* FIXME: */
6293 g_assert (!t->byref);
6294
6295 /* Have to change the signature since the vtype is passed byref */
6296 m->csig->params [argnum - m->csig->hasthis] = &mono_defaults.int_class->byval_arg;
6297
6298 if (((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) ||
6299 klass->blittable || klass->enumtype)
6300 mono_mb_emit_ldarg_addr (mb, argnum);
6301 else
6302 mono_mb_emit_ldloc (mb, conv_arg);
6303 break;
6304 }
6305
6306 if (((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) ||
6307 klass->blittable || klass->enumtype) {
6308 mono_mb_emit_ldarg (mb, argnum);
6309 break;
6310 }
6311 mono_mb_emit_ldloc (mb, conv_arg);
6312 if (!t->byref) {
6313 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
6314 mono_mb_emit_op (mb, CEE_MONO_LDNATIVEOBJ, klass);
6315 }
6316 break;
6317
6318 case MARSHAL_ACTION_CONV_OUT:
6319 if (((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) ||
6320 klass->blittable || klass->enumtype)
6321 break;
6322
6323 if (t->byref) {
6324 /* dst = argument */
6325 mono_mb_emit_ldarg (mb, argnum);
6326 mono_mb_emit_stloc (mb, 1);
6327
6328 mono_mb_emit_ldloc (mb, 1);
6329 pos = mono_mb_emit_branch (mb, CEE_BRFALSE);
6330
6331 if (!((t->attrs & PARAM_ATTRIBUTE_IN) && !(t->attrs & PARAM_ATTRIBUTE_OUT))) {
6332 /* src = tmp_locals [i] */
6333 mono_mb_emit_ldloc (mb, conv_arg);
6334 mono_mb_emit_stloc (mb, 0);
6335
6336 /* emit valuetype conversion code */
6337 emit_struct_conv (mb, klass, TRUE);
6338 }
6339 }
6340
6341 emit_struct_free (mb, klass, conv_arg);
6342
6343 if (t->byref)
6344 mono_mb_patch_branch (mb, pos);
6345 break;
6346
6347 case MARSHAL_ACTION_CONV_RESULT:
6348 if (((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) ||
6349 klass->blittable) {
6350 mono_mb_emit_stloc (mb, 3);
6351 break;
6352 }
6353 /* load pointer to returned value type */
6354 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
6355 mono_mb_emit_byte (mb, CEE_MONO_VTADDR);
6356 /* store the address of the source into local variable 0 */
6357 mono_mb_emit_stloc (mb, 0);
6358 /* set dst_ptr */
6359 mono_mb_emit_ldloc_addr (mb, 3);
6360 mono_mb_emit_stloc (mb, 1);
6361
6362 /* emit valuetype conversion code */
6363 emit_struct_conv (mb, klass, TRUE);
6364 break;
6365
6366 case MARSHAL_ACTION_MANAGED_CONV_IN:
6367 if (((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) ||
6368 klass->blittable || klass->enumtype) {
6369 conv_arg = 0;
6370 break;
6371 }
6372
6373 conv_arg = mono_mb_add_local (mb, &klass->byval_arg);
6374
6375 if (t->attrs & PARAM_ATTRIBUTE_OUT)
6376 break;
6377
6378 if (t->byref)
6379 mono_mb_emit_ldarg (mb, argnum);
6380 else
6381 mono_mb_emit_ldarg_addr (mb, argnum);
6382 mono_mb_emit_stloc (mb, 0);
6383
6384 if (t->byref) {
6385 mono_mb_emit_ldloc (mb, 0);
6386 pos = mono_mb_emit_branch (mb, CEE_BRFALSE);
6387 }
6388
6389 mono_mb_emit_ldloc_addr (mb, conv_arg);
6390 mono_mb_emit_stloc (mb, 1);
6391
6392 /* emit valuetype conversion code */
6393 emit_struct_conv (mb, klass, TRUE);
6394
6395 if (t->byref)
6396 mono_mb_patch_branch (mb, pos);
6397 break;
6398
6399 case MARSHAL_ACTION_MANAGED_CONV_OUT:
6400 if (((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) ||
6401 klass->blittable || klass->enumtype) {
6402 break;
6403 }
6404
6405 /* Check for null */
6406 mono_mb_emit_ldarg (mb, argnum);
6407 pos2 = mono_mb_emit_branch (mb, CEE_BRFALSE);
6408
6409 /* Set src */
6410 mono_mb_emit_ldloc_addr (mb, conv_arg);
6411 mono_mb_emit_stloc (mb, 0);
6412
6413 /* Set dest */
6414 mono_mb_emit_ldarg (mb, argnum);
6415 mono_mb_emit_stloc (mb, 1);
6416
6417 /* emit valuetype conversion code */
6418 emit_struct_conv (mb, klass, FALSE);
6419
6420 mono_mb_patch_branch (mb, pos2);
6421 break;
6422
6423 case MARSHAL_ACTION_MANAGED_CONV_RESULT:
6424 if (((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) ||
6425 klass->blittable || klass->enumtype) {
6426 mono_mb_emit_stloc (mb, 3);
6427 m->retobj_var = 0;
6428 break;
6429 }
6430
6431 /* load pointer to returned value type */
6432 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
6433 mono_mb_emit_byte (mb, CEE_MONO_VTADDR);
6434
6435 /* store the address of the source into local variable 0 */
6436 mono_mb_emit_stloc (mb, 0);
6437 /* allocate space for the native struct and
6438 * store the address into dst_ptr */
6439 m->retobj_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
6440 m->retobj_class = klass;
6441 g_assert (m->retobj_var);
6442 mono_mb_emit_icon (mb, mono_class_native_size (klass, NULL));
6443 mono_mb_emit_byte (mb, CEE_CONV_I);
6444 mono_mb_emit_icall (mb, mono_marshal_alloc);
6445 mono_mb_emit_stloc (mb, 1);
6446 mono_mb_emit_ldloc (mb, 1);
6447 mono_mb_emit_stloc (mb, m->retobj_var);
6448
6449 /* emit valuetype conversion code */
6450 emit_struct_conv (mb, klass, FALSE);
6451 break;
6452
6453 default:
6454 g_assert_not_reached ();
6455 }
6456
6457 return conv_arg;
6458 }
6459
6460 static int
6461 emit_marshal_string (EmitMarshalContext *m, int argnum, MonoType *t,
6462 MonoMarshalSpec *spec,
6463 int conv_arg, MonoType **conv_arg_type,
6464 MarshalAction action)
6465 {
6466 MonoMethodBuilder *mb = m->mb;
6467 MonoMarshalNative encoding = mono_marshal_get_string_encoding (m->piinfo, spec);
6468 MonoMarshalConv conv = mono_marshal_get_string_to_ptr_conv (m->piinfo, spec);
6469 gboolean need_free;
6470
6471 switch (action) {
6472 case MARSHAL_ACTION_CONV_IN:
6473 *conv_arg_type = &mono_defaults.int_class->byval_arg;
6474 conv_arg = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
6475
6476 if (t->byref) {
6477 if (t->attrs & PARAM_ATTRIBUTE_OUT)
6478 break;
6479
6480 mono_mb_emit_ldarg (mb, argnum);
6481 mono_mb_emit_byte (mb, CEE_LDIND_I);
6482 } else {
6483 mono_mb_emit_ldarg (mb, argnum);
6484 }
6485
6486 if (conv == -1) {
6487 char *msg = g_strdup_printf ("string marshalling conversion %d not implemented", encoding);
6488 MonoException *exc = mono_get_exception_not_implemented (msg);
6489 g_warning (msg);
6490 g_free (msg);
6491 mono_raise_exception (exc);
6492 }
6493 else
6494 mono_mb_emit_icall (mb, conv_to_icall (conv));
6495
6496 mono_mb_emit_stloc (mb, conv_arg);
6497 break;
6498
6499 case MARSHAL_ACTION_CONV_OUT:
6500 conv = mono_marshal_get_ptr_to_string_conv (m->piinfo, spec, &need_free);
6501 if (conv == -1) {
6502 char *msg = g_strdup_printf ("string marshalling conversion %d not implemented", encoding);
6503 mono_mb_emit_exception_marshal_directive (mb, msg);
6504 break;
6505 }
6506
6507 if (t->byref && (t->attrs & PARAM_ATTRIBUTE_OUT)) {
6508 mono_mb_emit_ldarg (mb, argnum);
6509 mono_mb_emit_ldloc (mb, conv_arg);
6510 mono_mb_emit_icall (mb, conv_to_icall (conv));
6511 mono_mb_emit_byte (mb, CEE_STIND_REF);
6512 }
6513
6514 if (need_free || (t->byref && (t->attrs & PARAM_ATTRIBUTE_OUT))) {
6515 mono_mb_emit_ldloc (mb, conv_arg);
6516 if (conv == MONO_MARSHAL_CONV_BSTR_STR)
6517 mono_mb_emit_icall (mb, mono_free_bstr);
6518 else
6519 mono_mb_emit_icall (mb, mono_marshal_free);
6520 }
6521 break;
6522
6523 case MARSHAL_ACTION_PUSH:
6524 if (t->byref)
6525 mono_mb_emit_ldloc_addr (mb, conv_arg);
6526 else
6527 mono_mb_emit_ldloc (mb, conv_arg);
6528 break;
6529
6530 case MARSHAL_ACTION_CONV_RESULT:
6531 mono_mb_emit_stloc (mb, 0);
6532
6533 conv = mono_marshal_get_ptr_to_string_conv (m->piinfo, spec, &need_free);
6534 if (conv == -1) {
6535 char *msg = g_strdup_printf ("string marshalling conversion %d not implemented", encoding);
6536 mono_mb_emit_exception_marshal_directive (mb, msg);
6537 break;
6538 }
6539
6540 mono_mb_emit_ldloc (mb, 0);
6541 mono_mb_emit_icall (mb, conv_to_icall (conv));
6542 mono_mb_emit_stloc (mb, 3);
6543
6544 /* free the string */
6545 mono_mb_emit_ldloc (mb, 0);
6546 if (conv == MONO_MARSHAL_CONV_BSTR_STR)
6547 mono_mb_emit_icall (mb, mono_free_bstr);
6548 else
6549 mono_mb_emit_icall (mb, mono_marshal_free);
6550 break;
6551
6552 case MARSHAL_ACTION_MANAGED_CONV_IN:
6553 conv_arg = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
6554
6555 *conv_arg_type = &mono_defaults.int_class->byval_arg;
6556
6557 conv = mono_marshal_get_ptr_to_string_conv (m->piinfo, spec, &need_free);
6558 if (conv == -1) {
6559 char *msg = g_strdup_printf ("string marshalling conversion %d not implemented", encoding);
6560 mono_mb_emit_exception_marshal_directive (mb, msg);
6561 break;
6562 }
6563
6564 mono_mb_emit_ldarg (mb, argnum);
6565 if (t->byref)
6566 mono_mb_emit_byte (mb, CEE_LDIND_I);
6567 mono_mb_emit_icall (mb, conv_to_icall (conv));
6568 mono_mb_emit_stloc (mb, conv_arg);
6569 break;
6570
6571 case MARSHAL_ACTION_MANAGED_CONV_OUT:
6572 if (t->byref) {
6573 if (conv_arg) {
6574 mono_mb_emit_ldarg (mb, argnum);
6575 mono_mb_emit_ldloc (mb, conv_arg);
6576 mono_mb_emit_icall (mb, conv_to_icall (conv));
6577 mono_mb_emit_byte (mb, CEE_STIND_I);
6578 }
6579 }
6580 break;
6581
6582 case MARSHAL_ACTION_MANAGED_CONV_RESULT:
6583 if (conv_to_icall (conv) == mono_marshal_string_to_utf16)
6584 /* We need to make a copy so the caller is able to free it */
6585 mono_mb_emit_icall (mb, mono_marshal_string_to_utf16_copy);
6586 else
6587 mono_mb_emit_icall (mb, conv_to_icall (conv));
6588 mono_mb_emit_stloc (mb, 3);
6589 break;
6590
6591 default:
6592 g_assert_not_reached ();
6593 }
6594
6595 return conv_arg;
6596 }
6597
6598 static int
6599 emit_marshal_safehandle (EmitMarshalContext *m, int argnum, MonoType *t,
6600 MonoMarshalSpec *spec, int conv_arg,
6601 MonoType **conv_arg_type, MarshalAction action)
6602 {
6603 MonoMethodBuilder *mb = m->mb;
6604
6605 switch (action){
6606 case MARSHAL_ACTION_CONV_IN: {
6607 MonoType *intptr_type;
6608 int dar_release_slot, pos;
6609
6610 intptr_type = &mono_defaults.int_class->byval_arg;
6611 conv_arg = mono_mb_add_local (mb, intptr_type);
6612 *conv_arg_type = intptr_type;
6613
6614 if (!sh_dangerous_add_ref)
6615 init_safe_handle ();
6616
6617 mono_mb_emit_ldarg (mb, argnum);
6618 pos = mono_mb_emit_branch (mb, CEE_BRTRUE);
6619 mono_mb_emit_exception (mb, "ArgumentNullException", NULL);
6620
6621 mono_mb_patch_branch (mb, pos);
6622 if (t->byref){
6623 /*
6624 * My tests in show that ref SafeHandles are not really
6625 * passed as ref objects. Instead a NULL is passed as the
6626 * value of the ref
6627 */
6628 mono_mb_emit_icon (mb, 0);
6629 mono_mb_emit_stloc (mb, conv_arg);
6630 break;
6631 }
6632
6633 /* Create local to hold the ref parameter to DangerousAddRef */
6634 dar_release_slot = mono_mb_add_local (mb, &mono_defaults.boolean_class->byval_arg);
6635
6636 /* set release = false; */
6637 mono_mb_emit_icon (mb, 0);
6638 mono_mb_emit_stloc (mb, dar_release_slot);
6639
6640 /* safehandle.DangerousAddRef (ref release) */
6641 mono_mb_emit_ldarg (mb, argnum);
6642 mono_mb_emit_ldloc_addr (mb, dar_release_slot);
6643 mono_mb_emit_managed_call (mb, sh_dangerous_add_ref, NULL);
6644
6645 /* Pull the handle field from SafeHandle */
6646 mono_mb_emit_ldarg (mb, argnum);
6647 mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoSafeHandle, handle));
6648 mono_mb_emit_byte (mb, CEE_LDIND_I);
6649 mono_mb_emit_stloc (mb, conv_arg);
6650
6651 break;
6652 }
6653
6654 case MARSHAL_ACTION_PUSH:
6655 if (t->byref)
6656 mono_mb_emit_ldloc_addr (mb, conv_arg);
6657 else
6658 mono_mb_emit_ldloc (mb, conv_arg);
6659 break;
6660
6661 case MARSHAL_ACTION_CONV_OUT: {
6662 /* The slot for the boolean is the next temporary created after conv_arg, see the CONV_IN code */
6663 int dar_release_slot = conv_arg + 1;
6664 int label_next;
6665
6666 if (!sh_dangerous_release)
6667 init_safe_handle ();
6668
6669 if (t->byref){
6670 MonoMethod *ctor;
6671
6672 /*
6673 * My tests indicate that ref SafeHandles parameters are not actually
6674 * passed by ref, but instead a new Handle is created regardless of
6675 * whether a change happens in the unmanaged side.
6676 *
6677 * Also, the Handle is created before calling into unmanaged code,
6678 * but we do not support that mechanism (getting to the original
6679 * handle) and it makes no difference where we create this
6680 */
6681 ctor = mono_class_get_method_from_name (t->data.klass, ".ctor", 0);
6682 if (ctor == NULL){
6683 mono_mb_emit_exception (mb, "MissingMethodException", "paramterless constructor required");
6684 break;
6685 }
6686 /* refval = new SafeHandleDerived ()*/
6687 mono_mb_emit_ldarg (mb, argnum);
6688 mono_mb_emit_op (mb, CEE_NEWOBJ, ctor);
6689 mono_mb_emit_byte (mb, CEE_STIND_REF);
6690
6691 /* refval.handle = returned_handle */
6692 mono_mb_emit_ldarg (mb, argnum);
6693 mono_mb_emit_byte (mb, CEE_LDIND_REF);
6694 mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoSafeHandle, handle));
6695 mono_mb_emit_ldloc (mb, conv_arg);
6696 mono_mb_emit_byte (mb, CEE_STIND_I);
6697 } else {
6698 mono_mb_emit_ldloc (mb, dar_release_slot);
6699 label_next = mono_mb_emit_branch (mb, CEE_BRFALSE);
6700 mono_mb_emit_ldarg (mb, argnum);
6701 mono_mb_emit_managed_call (mb, sh_dangerous_release, NULL);
6702 mono_mb_patch_branch (mb, label_next);
6703 }
6704 break;
6705 }
6706
6707 case MARSHAL_ACTION_CONV_RESULT: {
6708 MonoMethod *ctor = NULL;
6709 int intptr_handle_slot;
6710
6711 if (t->data.klass->flags & TYPE_ATTRIBUTE_ABSTRACT){
6712 mono_mb_emit_byte (mb, CEE_POP);
6713 mono_mb_emit_exception_marshal_directive (mb, "Returned SafeHandles should not be abstract");
6714 break;
6715 }
6716
6717 ctor = mono_class_get_method_from_name (t->data.klass, ".ctor", 0);
6718 if (ctor == NULL){
6719 mono_mb_emit_byte (mb, CEE_POP);
6720 mono_mb_emit_exception (mb, "MissingMethodException", "paramterless constructor required");
6721 break;
6722 }
6723 /* Store the IntPtr results into a local */
6724 intptr_handle_slot = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
6725 mono_mb_emit_stloc (mb, intptr_handle_slot);
6726
6727 /* Create return value */
6728 mono_mb_emit_op (mb, CEE_NEWOBJ, ctor);
6729 mono_mb_emit_stloc (mb, 3);
6730
6731 /* Set the return.handle to the value, am using ldflda, not sure if thats a good idea */
6732 mono_mb_emit_ldloc (mb, 3);
6733 mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoSafeHandle, handle));
6734 mono_mb_emit_ldloc (mb, intptr_handle_slot);
6735 mono_mb_emit_byte (mb, CEE_STIND_I);
6736 break;
6737 }
6738
6739 case MARSHAL_ACTION_MANAGED_CONV_IN:
6740 fprintf (stderr, "mono/marshal: SafeHandles missing MANAGED_CONV_IN\n");
6741 break;
6742
6743 case MARSHAL_ACTION_MANAGED_CONV_OUT:
6744 fprintf (stderr, "mono/marshal: SafeHandles missing MANAGED_CONV_OUT\n");
6745 break;
6746
6747 case MARSHAL_ACTION_MANAGED_CONV_RESULT:
6748 fprintf (stderr, "mono/marshal: SafeHandles missing MANAGED_CONV_RESULT\n");
6749 break;
6750 default:
6751 printf ("Unhandled case for MarshalAction: %d\n", action);
6752 }
6753
6754 return conv_arg;
6755 }
6756
6757 static int
6758 emit_marshal_handleref (EmitMarshalContext *m, int argnum, MonoType *t,
6759 MonoMarshalSpec *spec, int conv_arg,
6760 MonoType **conv_arg_type, MarshalAction action)
6761 {
6762 MonoMethodBuilder *mb = m->mb;
6763
6764 switch (action){
6765 case MARSHAL_ACTION_CONV_IN: {
6766 MonoType *intptr_type;
6767
6768 intptr_type = &mono_defaults.int_class->byval_arg;
6769 conv_arg = mono_mb_add_local (mb, intptr_type);
6770 *conv_arg_type = intptr_type;
6771
6772 if (t->byref){
6773 mono_mb_emit_exception_marshal_directive (mb,
6774 "HandleRefs can not be returned from unmanaged code (or passed by ref)");
6775 break;
6776 }
6777 mono_mb_emit_ldarg_addr (mb, argnum);
6778 mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoHandleRef, handle));
6779 mono_mb_emit_byte (mb, CEE_ADD);
6780 mono_mb_emit_byte (mb, CEE_LDIND_I);
6781 mono_mb_emit_stloc (mb, conv_arg);
6782 break;
6783 }
6784
6785 case MARSHAL_ACTION_PUSH:
6786 mono_mb_emit_ldloc (mb, conv_arg);
6787 break;
6788
6789 case MARSHAL_ACTION_CONV_OUT: {
6790 /* no resource release required */
6791 break;
6792 }
6793
6794 case MARSHAL_ACTION_CONV_RESULT: {
6795 mono_mb_emit_exception_marshal_directive (mb,
6796 "HandleRefs can not be returned from unmanaged code (or passed by ref)");
6797 break;
6798 }
6799
6800 case MARSHAL_ACTION_MANAGED_CONV_IN:
6801 fprintf (stderr, "mono/marshal: SafeHandles missing MANAGED_CONV_IN\n");
6802 break;
6803
6804 case MARSHAL_ACTION_MANAGED_CONV_OUT:
6805 fprintf (stderr, "mono/marshal: SafeHandles missing MANAGED_CONV_OUT\n");
6806 break;
6807
6808 case MARSHAL_ACTION_MANAGED_CONV_RESULT:
6809 fprintf (stderr, "mono/marshal: SafeHandles missing MANAGED_CONV_RESULT\n");
6810 break;
6811 default:
6812 fprintf (stderr, "Unhandled case for MarshalAction: %d\n", action);
6813 }
6814
6815 return conv_arg;
6816 }
6817
6818 static int
6819 emit_marshal_object (EmitMarshalContext *m, int argnum, MonoType *t,
6820 MonoMarshalSpec *spec,
6821 int conv_arg, MonoType **conv_arg_type,
6822 MarshalAction action)
6823 {
6824 MonoMethodBuilder *mb = m->mb;
6825 MonoClass *klass = mono_class_from_mono_type (t);
6826 int pos, pos2, loc;
6827
6828 if (mono_class_from_mono_type (t) == mono_defaults.object_class) {
6829 mono_raise_exception (mono_get_exception_not_implemented ("Marshalling of type object is not implemented"));
6830 }
6831
6832 switch (action) {
6833 case MARSHAL_ACTION_CONV_IN:
6834 *conv_arg_type = &mono_defaults.int_class->byval_arg;
6835 conv_arg = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
6836
6837 m->orig_conv_args [argnum] = 0;
6838
6839 if (klass->delegate) {
6840 if (t->byref) {
6841 if (!(t->attrs & PARAM_ATTRIBUTE_OUT)) {
6842 char *msg = g_strdup_printf ("Byref marshalling of delegates is not implemented.");
6843 mono_mb_emit_exception_marshal_directive (mb, msg);
6844 }
6845 mono_mb_emit_byte (mb, CEE_LDNULL);
6846 mono_mb_emit_stloc (mb, conv_arg);
6847 } else {
6848 mono_mb_emit_ldarg (mb, argnum);
6849 mono_mb_emit_icall (mb, conv_to_icall (MONO_MARSHAL_CONV_DEL_FTN));
6850 mono_mb_emit_stloc (mb, conv_arg);
6851 }
6852 } else if (klass == mono_defaults.stringbuilder_class) {
6853 MonoMarshalNative encoding = mono_marshal_get_string_encoding (m->piinfo, spec);
6854 MonoMarshalConv conv = mono_marshal_get_stringbuilder_to_ptr_conv (m->piinfo, spec);
6855
6856 g_assert (!t->byref);
6857 mono_mb_emit_ldarg (mb, argnum);
6858
6859 if (conv != -1)
6860 mono_mb_emit_icall (mb, conv_to_icall (conv));
6861 else {
6862 char *msg = g_strdup_printf ("stringbuilder marshalling conversion %d not implemented", encoding);
6863 MonoException *exc = mono_get_exception_not_implemented (msg);
6864 g_warning (msg);
6865 g_free (msg);
6866 mono_raise_exception (exc);
6867 }
6868
6869 mono_mb_emit_stloc (mb, conv_arg);
6870 } else if (klass->blittable) {
6871 mono_mb_emit_byte (mb, CEE_LDNULL);
6872 mono_mb_emit_stloc (mb, conv_arg);
6873
6874 mono_mb_emit_ldarg (mb, argnum);
6875 pos = mono_mb_emit_branch (mb, CEE_BRFALSE);
6876
6877 mono_mb_emit_ldarg (mb, argnum);
6878 mono_mb_emit_ldflda (mb, sizeof (MonoObject));
6879 mono_mb_emit_stloc (mb, conv_arg);
6880
6881 mono_mb_patch_branch (mb, pos);
6882 break;
6883 } else {
6884 mono_mb_emit_byte (mb, CEE_LDNULL);
6885 mono_mb_emit_stloc (mb, conv_arg);
6886
6887 if (t->byref) {
6888 /* we dont need any conversions for out parameters */
6889 if (t->attrs & PARAM_ATTRIBUTE_OUT)
6890 break;
6891
6892 mono_mb_emit_ldarg (mb, argnum);
6893 mono_mb_emit_byte (mb, CEE_LDIND_I);
6894
6895 } else {
6896 mono_mb_emit_ldarg (mb, argnum);
6897 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
6898 mono_mb_emit_byte (mb, CEE_MONO_OBJADDR);
6899 }
6900
6901 /* store the address of the source into local variable 0 */
6902 mono_mb_emit_stloc (mb, 0);
6903 mono_mb_emit_ldloc (mb, 0);
6904 pos = mono_mb_emit_branch (mb, CEE_BRFALSE);
6905
6906 /* allocate space for the native struct and store the address */
6907 mono_mb_emit_icon (mb, mono_class_native_size (klass, NULL));
6908 mono_mb_emit_byte (mb, CEE_PREFIX1);
6909 mono_mb_emit_byte (mb, CEE_LOCALLOC);
6910 mono_mb_emit_stloc (mb, conv_arg);
6911
6912 if (t->byref) {
6913 /* Need to store the original buffer so we can free it later */
6914 m->orig_conv_args [argnum] = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
6915 mono_mb_emit_ldloc (mb, conv_arg);
6916 mono_mb_emit_stloc (mb, m->orig_conv_args [argnum]);
6917 }
6918
6919 /* set the src_ptr */
6920 mono_mb_emit_ldloc (mb, 0);
6921 mono_mb_emit_ldflda (mb, sizeof (MonoObject));
6922 mono_mb_emit_stloc (mb, 0);
6923
6924 /* set dst_ptr */
6925 mono_mb_emit_ldloc (mb, conv_arg);
6926 mono_mb_emit_stloc (mb, 1);
6927
6928 /* emit valuetype conversion code */
6929 emit_struct_conv (mb, klass, FALSE);
6930
6931 mono_mb_patch_branch (mb, pos);
6932 }
6933 break;
6934
6935 case MARSHAL_ACTION_CONV_OUT:
6936 if (klass == mono_defaults.stringbuilder_class) {
6937 gboolean need_free;
6938 MonoMarshalNative encoding;
6939 MonoMarshalConv conv;
6940
6941 encoding = mono_marshal_get_string_encoding (m->piinfo, spec);
6942 conv = mono_marshal_get_ptr_to_stringbuilder_conv (m->piinfo, spec, &need_free);
6943
6944 g_assert (!t->byref);
6945 g_assert (encoding != -1);
6946
6947 mono_mb_emit_ldarg (mb, argnum);
6948 mono_mb_emit_ldloc (mb, conv_arg);
6949
6950 mono_mb_emit_icall (mb, conv_to_icall (conv));
6951
6952 if (need_free) {
6953 mono_mb_emit_ldloc (mb, conv_arg);
6954 mono_mb_emit_icall (mb, mono_marshal_free);
6955 }
6956 break;
6957 }
6958
6959 if (klass->delegate) {
6960 if (t->byref) {
6961 mono_mb_emit_ldarg (mb, argnum);
6962 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
6963 mono_mb_emit_op (mb, CEE_MONO_CLASSCONST, klass);
6964 mono_mb_emit_ldloc (mb, conv_arg);
6965 mono_mb_emit_icall (mb, conv_to_icall (MONO_MARSHAL_CONV_FTN_DEL));
6966 mono_mb_emit_byte (mb, CEE_STIND_REF);
6967 }
6968 break;
6969 }
6970
6971 if (t->byref && (t->attrs & PARAM_ATTRIBUTE_OUT)) {
6972 /* allocate a new object */
6973 mono_mb_emit_ldarg (mb, argnum);
6974 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
6975 mono_mb_emit_op (mb, CEE_MONO_NEWOBJ, klass);
6976 mono_mb_emit_byte (mb, CEE_STIND_REF);
6977 }
6978
6979 /* dst = *argument */
6980 mono_mb_emit_ldarg (mb, argnum);
6981
6982 if (t->byref)
6983 mono_mb_emit_byte (mb, CEE_LDIND_I);
6984
6985 mono_mb_emit_stloc (mb, 1);
6986
6987 mono_mb_emit_ldloc (mb, 1);
6988 pos = mono_mb_emit_branch (mb, CEE_BRFALSE);
6989
6990 if (t->byref || (t->attrs & PARAM_ATTRIBUTE_OUT)) {
6991 mono_mb_emit_ldloc (mb, 1);
6992 mono_mb_emit_icon (mb, sizeof (MonoObject));
6993 mono_mb_emit_byte (mb, CEE_ADD);
6994 mono_mb_emit_stloc (mb, 1);
6995
6996 /* src = tmp_locals [i] */
6997 mono_mb_emit_ldloc (mb, conv_arg);
6998 mono_mb_emit_stloc (mb, 0);
6999
7000 /* emit valuetype conversion code */
7001 emit_struct_conv (mb, klass, TRUE);
7002
7003 /* Free the structure returned by the native code */
7004 emit_struct_free (mb, klass, conv_arg);
7005
7006 if (m->orig_conv_args [argnum]) {
7007 /*
7008 * If the native function changed the pointer, then free
7009 * the original structure plus the new pointer.
7010 */
7011 mono_mb_emit_ldloc (mb, m->orig_conv_args [argnum]);
7012 mono_mb_emit_ldloc (mb, conv_arg);
7013 pos2 = mono_mb_emit_branch (mb, CEE_BEQ);
7014
7015 if (!(t->attrs & PARAM_ATTRIBUTE_OUT)) {
7016 g_assert (m->orig_conv_args [argnum]);
7017
7018 emit_struct_free (mb, klass, m->orig_conv_args [argnum]);
7019 }
7020
7021 mono_mb_emit_ldloc (mb, conv_arg);
7022 mono_mb_emit_icall (mb, g_free);
7023
7024 mono_mb_patch_branch (mb, pos2);
7025 }
7026 }
7027 else
7028 /* Free the original structure passed to native code */
7029 emit_struct_free (mb, klass, conv_arg);
7030
7031 mono_mb_patch_branch (mb, pos);
7032 break;
7033
7034 case MARSHAL_ACTION_PUSH:
7035 if (t->byref)
7036 mono_mb_emit_ldloc_addr (mb, conv_arg);
7037 else
7038 mono_mb_emit_ldloc (mb, conv_arg);
7039 break;
7040
7041 case MARSHAL_ACTION_CONV_RESULT:
7042 if (klass->delegate) {
7043 g_assert (!t->byref);
7044 mono_mb_emit_stloc (mb, 0);
7045 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
7046 mono_mb_emit_op (mb, CEE_MONO_CLASSCONST, klass);
7047 mono_mb_emit_ldloc (mb, 0);
7048 mono_mb_emit_icall (mb, conv_to_icall (MONO_MARSHAL_CONV_FTN_DEL));
7049 mono_mb_emit_stloc (mb, 3);
7050 } else {
7051 /* set src */
7052 mono_mb_emit_stloc (mb, 0);
7053
7054 /* Make a copy since emit_conv modifies local 0 */
7055 loc = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
7056 mono_mb_emit_ldloc (mb, 0);
7057 mono_mb_emit_stloc (mb, loc);
7058
7059 mono_mb_emit_byte (mb, CEE_LDNULL);
7060 mono_mb_emit_stloc (mb, 3);
7061
7062 mono_mb_emit_ldloc (mb, 0);
7063 pos = mono_mb_emit_branch (mb, CEE_BRFALSE);
7064
7065 /* allocate result object */
7066
7067 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
7068 mono_mb_emit_op (mb, CEE_MONO_NEWOBJ, klass);
7069 mono_mb_emit_stloc (mb, 3);
7070
7071 /* set dst */
7072
7073 mono_mb_emit_ldloc (mb, 3);
7074 mono_mb_emit_ldflda (mb, sizeof (MonoObject));
7075 mono_mb_emit_stloc (mb, 1);
7076
7077 /* emit conversion code */
7078 emit_struct_conv (mb, klass, TRUE);
7079
7080 emit_struct_free (mb, klass, loc);
7081
7082 /* Free the pointer allocated by unmanaged code */
7083 mono_mb_emit_ldloc (mb, loc);
7084 mono_mb_emit_icall (mb, g_free);
7085 mono_mb_patch_branch (mb, pos);
7086 }
7087 break;
7088
7089 case MARSHAL_ACTION_MANAGED_CONV_IN:
7090 conv_arg = mono_mb_add_local (mb, &klass->byval_arg);
7091
7092 if (klass->delegate) {
7093 g_assert (!t->byref);
7094 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
7095 mono_mb_emit_op (mb, CEE_MONO_CLASSCONST, klass);
7096 mono_mb_emit_ldarg (mb, argnum);
7097 mono_mb_emit_icall (mb, conv_to_icall (MONO_MARSHAL_CONV_FTN_DEL));
7098 mono_mb_emit_stloc (mb, conv_arg);
7099 break;
7100 }
7101
7102 if (klass == mono_defaults.stringbuilder_class) {
7103 MonoMarshalNative encoding;
7104
7105 encoding = mono_marshal_get_string_encoding (m->piinfo, spec);
7106
7107 // FIXME:
7108 g_assert (encoding == MONO_NATIVE_LPSTR);
7109
7110 g_assert (!t->byref);
7111 g_assert (encoding != -1);
7112
7113 mono_mb_emit_ldarg (mb, argnum);
7114 mono_mb_emit_icall (mb, mono_string_utf8_to_builder2);
7115 mono_mb_emit_stloc (mb, conv_arg);
7116 break;
7117 }
7118
7119 /* The class can not have an automatic layout */
7120 if ((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_AUTO_LAYOUT) {
7121 mono_mb_emit_auto_layout_exception (mb, klass);
7122 break;
7123 }
7124
7125 if (t->attrs & PARAM_ATTRIBUTE_OUT) {
7126 mono_mb_emit_byte (mb, CEE_LDNULL);
7127 mono_mb_emit_stloc (mb, conv_arg);
7128 break;
7129 }
7130
7131 /* Set src */
7132 mono_mb_emit_ldarg (mb, argnum);
7133 if (t->byref) {
7134 int pos2;
7135
7136 /* Check for NULL and raise an exception */
7137 pos2 = mono_mb_emit_branch (mb, CEE_BRTRUE);
7138
7139 mono_mb_emit_exception (mb, "ArgumentNullException", NULL);
7140
7141 mono_mb_patch_branch (mb, pos2);
7142 mono_mb_emit_ldarg (mb, argnum);
7143 mono_mb_emit_byte (mb, CEE_LDIND_I);
7144 }
7145
7146 mono_mb_emit_stloc (mb, 0);
7147
7148 mono_mb_emit_byte (mb, CEE_LDC_I4_0);
7149 mono_mb_emit_stloc (mb, conv_arg);
7150
7151 mono_mb_emit_ldloc (mb, 0);
7152 pos = mono_mb_emit_branch (mb, CEE_BRFALSE);
7153
7154 /* Create and set dst */
7155 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
7156 mono_mb_emit_op (mb, CEE_MONO_NEWOBJ, klass);
7157 mono_mb_emit_stloc (mb, conv_arg);
7158 mono_mb_emit_ldloc (mb, conv_arg);
7159 mono_mb_emit_ldflda (mb, sizeof (MonoObject));
7160 mono_mb_emit_stloc (mb, 1);
7161
7162 /* emit valuetype conversion code */
7163 emit_struct_conv (mb, klass, TRUE);
7164
7165 mono_mb_patch_branch (mb, pos);
7166 break;
7167
7168 case MARSHAL_ACTION_MANAGED_CONV_OUT:
7169 if (t->byref) {
7170 /* Check for null */
7171 mono_mb_emit_ldloc (mb, conv_arg);
7172 pos = mono_mb_emit_branch (mb, CEE_BRTRUE);
7173 mono_mb_emit_ldarg (mb, argnum);
7174 mono_mb_emit_byte (mb, CEE_LDC_I4_0);
7175 mono_mb_emit_byte (mb, CEE_STIND_REF);
7176 pos2 = mono_mb_emit_branch (mb, CEE_BR);
7177
7178 mono_mb_patch_branch (mb, pos);
7179
7180 /* Set src */
7181 mono_mb_emit_ldloc (mb, conv_arg);
7182 mono_mb_emit_ldflda (mb, sizeof (MonoObject));
7183 mono_mb_emit_stloc (mb, 0);
7184
7185 /* Allocate and set dest */
7186 mono_mb_emit_icon (mb, mono_class_native_size (klass, NULL));
7187 mono_mb_emit_byte (mb, CEE_CONV_I);
7188 mono_mb_emit_icall (mb, mono_marshal_alloc);
7189 mono_mb_emit_stloc (mb, 1);
7190
7191 /* Update argument pointer */
7192 mono_mb_emit_ldarg (mb, argnum);
7193 mono_mb_emit_ldloc (mb, 1);
7194 mono_mb_emit_byte (mb, CEE_STIND_I);
7195
7196 /* emit valuetype conversion code */
7197 emit_struct_conv (mb, klass, FALSE);
7198
7199 mono_mb_patch_branch (mb, pos2);
7200 } else {
7201 /* byval [Out] marshalling */
7202
7203 /* FIXME: Handle null */
7204
7205 /* Set src */
7206 mono_mb_emit_ldloc (mb, conv_arg);
7207 mono_mb_emit_ldflda (mb, sizeof (MonoObject));
7208 mono_mb_emit_stloc (mb, 0);
7209
7210 /* Set dest */
7211 mono_mb_emit_ldarg (mb, argnum);
7212 mono_mb_emit_stloc (mb, 1);
7213
7214 /* emit valuetype conversion code */
7215 emit_struct_conv (mb, klass, FALSE);
7216 }
7217 break;
7218
7219 case MARSHAL_ACTION_MANAGED_CONV_RESULT:
7220 if (klass->delegate) {
7221 mono_mb_emit_icall (mb, conv_to_icall (MONO_MARSHAL_CONV_DEL_FTN));
7222 mono_mb_emit_stloc (mb, 3);
7223 break;
7224 }
7225
7226 /* The class can not have an automatic layout */
7227 if ((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_AUTO_LAYOUT) {
7228 mono_mb_emit_auto_layout_exception (mb, klass);
7229 break;
7230 }
7231
7232 mono_mb_emit_stloc (mb, 0);
7233 /* Check for null */
7234 mono_mb_emit_ldloc (mb, 0);
7235 pos = mono_mb_emit_branch (mb, CEE_BRTRUE);
7236 mono_mb_emit_byte (mb, CEE_LDNULL);
7237 mono_mb_emit_stloc (mb, 3);
7238 pos2 = mono_mb_emit_branch (mb, CEE_BR);
7239
7240 mono_mb_patch_branch (mb, pos);
7241
7242 /* Set src */
7243 mono_mb_emit_ldloc (mb, 0);
7244 mono_mb_emit_ldflda (mb, sizeof (MonoObject));
7245 mono_mb_emit_stloc (mb, 0);
7246
7247 /* Allocate and set dest */
7248 mono_mb_emit_icon (mb, mono_class_native_size (klass, NULL));
7249 mono_mb_emit_byte (mb, CEE_CONV_I);
7250 mono_mb_emit_icall (mb, mono_marshal_alloc);
7251 mono_mb_emit_byte (mb, CEE_DUP);
7252 mono_mb_emit_stloc (mb, 1);
7253 mono_mb_emit_stloc (mb, 3);
7254
7255 emit_struct_conv (mb, klass, FALSE);
7256
7257 mono_mb_patch_branch (mb, pos2);
7258 break;
7259
7260 default:
7261 g_assert_not_reached ();
7262 }
7263
7264 return conv_arg;
7265 }
7266
7267 #ifndef DISABLE_COM
7268
7269 static int
7270 emit_marshal_com_interface (EmitMarshalContext *m, int argnum, MonoType *t,
7271 MonoMarshalSpec *spec,
7272 int conv_arg, MonoType **conv_arg_type,
7273 MarshalAction action)
7274 {
7275 MonoMethodBuilder *mb = m->mb;
7276 MonoClass *klass = t->data.klass;
7277 static MonoMethod* get_object_for_iunknown = NULL;
7278 static MonoMethod* get_iunknown_for_object_internal = NULL;
7279 static MonoMethod* get_com_interface_for_object_internal = NULL;
7280 static MonoMethod* get_idispatch_for_object_internal = NULL;
7281 static MonoMethod* marshal_release = NULL;
7282 static MonoMethod* AddRef = NULL;
7283 if (!get_object_for_iunknown)
7284 get_object_for_iunknown = mono_class_get_method_from_name (mono_defaults.marshal_class, "GetObjectForIUnknown", 1);
7285 if (!get_iunknown_for_object_internal)
7286 get_iunknown_for_object_internal = mono_class_get_method_from_name (mono_defaults.marshal_class, "GetIUnknownForObjectInternal", 1);
7287 if (!get_idispatch_for_object_internal)
7288 get_idispatch_for_object_internal = mono_class_get_method_from_name (mono_defaults.marshal_class, "GetIDispatchForObjectInternal", 1);
7289 if (!get_com_interface_for_object_internal)
7290 get_com_interface_for_object_internal = mono_class_get_method_from_name (mono_defaults.marshal_class, "GetComInterfaceForObjectInternal", 2);
7291 if (!marshal_release)
7292 marshal_release = mono_class_get_method_from_name (mono_defaults.marshal_class, "Release", 1);
7293
7294 /* COM types are initialized lazily */
7295 mono_init_com_types ();
7296
7297 switch (action) {
7298 case MARSHAL_ACTION_CONV_IN: {
7299 guint32 pos_null = 0;
7300
7301 *conv_arg_type = &mono_defaults.int_class->byval_arg;
7302 conv_arg = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
7303
7304 mono_mb_emit_ptr (mb, NULL);
7305 mono_mb_emit_stloc (mb, conv_arg);
7306
7307 /* we dont need any conversions for out parameters */
7308 if (t->byref && t->attrs & PARAM_ATTRIBUTE_OUT)
7309 break;
7310
7311 mono_mb_emit_ldarg (mb, argnum);
7312 if (t->byref)
7313 mono_mb_emit_byte (mb, CEE_LDIND_REF);
7314 /* if null just break, conv arg was already inited to 0 */
7315 pos_null = mono_mb_emit_short_branch (mb, CEE_BRFALSE_S);
7316
7317 mono_mb_emit_ldarg (mb, argnum);
7318 if (t->byref)
7319 mono_mb_emit_byte (mb, CEE_LDIND_REF);
7320
7321 if (klass && klass != mono_defaults.object_class) {
7322 mono_mb_emit_ptr (mb, t);
7323 mono_mb_emit_icall (mb, type_from_handle);
7324 mono_mb_emit_managed_call (mb, get_com_interface_for_object_internal, NULL);
7325 }
7326 else if (spec->native == MONO_NATIVE_IUNKNOWN)
7327 mono_mb_emit_managed_call (mb, get_iunknown_for_object_internal, NULL);
7328 else if (spec->native == MONO_NATIVE_IDISPATCH)
7329 mono_mb_emit_managed_call (mb, get_idispatch_for_object_internal, NULL);
7330 else if (!klass && spec->native == MONO_NATIVE_INTERFACE)
7331 mono_mb_emit_managed_call (mb, get_iunknown_for_object_internal, NULL);
7332 else
7333 g_assert_not_reached ();
7334 mono_mb_emit_stloc (mb, conv_arg);
7335 mono_mb_patch_short_branch (mb, pos_null);
7336 break;
7337 }
7338
7339 case MARSHAL_ACTION_CONV_OUT: {
7340 if (t->byref && (t->attrs & PARAM_ATTRIBUTE_OUT)) {
7341 int ccw_obj;
7342 guint32 pos_null = 0, pos_ccw = 0, pos_end = 0;
7343 ccw_obj = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
7344
7345 mono_mb_emit_ldarg (mb, argnum);
7346 mono_mb_emit_byte (mb, CEE_LDNULL);
7347 mono_mb_emit_byte (mb, CEE_STIND_REF);
7348
7349 mono_mb_emit_ldloc (mb, conv_arg);
7350 pos_null = mono_mb_emit_short_branch (mb, CEE_BRFALSE_S);
7351
7352 mono_mb_emit_ldloc (mb, conv_arg);
7353 mono_mb_emit_icon (mb, TRUE);
7354 mono_mb_emit_icall (mb, cominterop_get_ccw_object);
7355 mono_mb_emit_stloc (mb, ccw_obj);
7356 mono_mb_emit_ldloc (mb, ccw_obj);
7357 pos_ccw = mono_mb_emit_short_branch (mb, CEE_BRTRUE_S);
7358
7359 mono_mb_emit_ldarg (mb, argnum);
7360 mono_mb_emit_ldloc (mb, conv_arg);
7361 mono_mb_emit_managed_call (mb, get_object_for_iunknown, NULL);
7362
7363 if (klass && klass != mono_defaults.object_class)
7364 mono_mb_emit_op (mb, CEE_CASTCLASS, klass);
7365 mono_mb_emit_byte (mb, CEE_STIND_REF);
7366
7367 pos_end = mono_mb_emit_short_branch (mb, CEE_BR_S);
7368
7369 /* is already managed object */
7370 mono_mb_patch_short_branch (mb, pos_ccw);
7371 mono_mb_emit_ldarg (mb, argnum);
7372 mono_mb_emit_ldloc (mb, ccw_obj);
7373
7374 if (klass && klass != mono_defaults.object_class)
7375 mono_mb_emit_op (mb, CEE_CASTCLASS, klass);
7376 mono_mb_emit_byte (mb, CEE_STIND_REF);
7377
7378 mono_mb_patch_short_branch (mb, pos_end);
7379
7380 /* need to call Release to follow COM rules of ownership */
7381 mono_mb_emit_ldloc (mb, conv_arg);
7382 mono_mb_emit_managed_call (mb, marshal_release, NULL);
7383 mono_mb_emit_byte (mb, CEE_POP);
7384
7385 /* case if null */
7386 mono_mb_patch_short_branch (mb, pos_null);
7387 }
7388 break;
7389 }
7390 case MARSHAL_ACTION_PUSH:
7391 if (t->byref)
7392 mono_mb_emit_ldloc_addr (mb, conv_arg);
7393 else
7394 mono_mb_emit_ldloc (mb, conv_arg);
7395 break;
7396
7397 case MARSHAL_ACTION_CONV_RESULT: {
7398 int ccw_obj, ret_ptr;
7399 guint32 pos_null = 0, pos_ccw = 0, pos_end = 0;
7400 ccw_obj = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
7401 ret_ptr = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
7402
7403 /* store return value */
7404 mono_mb_emit_stloc (mb, ret_ptr);
7405
7406 mono_mb_emit_ldloc (mb, ret_ptr);
7407 pos_null = mono_mb_emit_short_branch (mb, CEE_BRFALSE_S);
7408
7409 mono_mb_emit_ldloc (mb, ret_ptr);
7410 mono_mb_emit_icon (mb, TRUE);
7411 mono_mb_emit_icall (mb, cominterop_get_ccw_object);
7412 mono_mb_emit_stloc (mb, ccw_obj);
7413 mono_mb_emit_ldloc (mb, ccw_obj);
7414 pos_ccw = mono_mb_emit_short_branch (mb, CEE_BRTRUE_S);
7415
7416 mono_mb_emit_ldloc (mb, ret_ptr);
7417 mono_mb_emit_managed_call (mb, get_object_for_iunknown, NULL);
7418
7419 if (klass && klass != mono_defaults.object_class)
7420 mono_mb_emit_op (mb, CEE_CASTCLASS, klass);
7421 mono_mb_emit_stloc (mb, 3);
7422
7423 pos_end = mono_mb_emit_short_branch (mb, CEE_BR_S);
7424
7425 /* is already managed object */
7426 mono_mb_patch_short_branch (mb, pos_ccw);
7427 mono_mb_emit_ldloc (mb, ccw_obj);
7428
7429 if (klass && klass != mono_defaults.object_class)
7430 mono_mb_emit_op (mb, CEE_CASTCLASS, klass);
7431 mono_mb_emit_stloc (mb, 3);
7432
7433 mono_mb_patch_short_branch (mb, pos_end);
7434
7435 /* need to call Release to follow COM rules of ownership */
7436 mono_mb_emit_ldloc (mb, ret_ptr);
7437 mono_mb_emit_managed_call (mb, marshal_release, NULL);
7438 mono_mb_emit_byte (mb, CEE_POP);
7439
7440 /* case if null */
7441 mono_mb_patch_short_branch (mb, pos_null);
7442 break;
7443 }
7444
7445 case MARSHAL_ACTION_MANAGED_CONV_IN: {
7446 int ccw_obj;
7447 guint32 pos_null = 0, pos_ccw = 0, pos_end = 0;
7448 ccw_obj = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
7449
7450 klass = mono_class_from_mono_type (t);
7451 conv_arg = mono_mb_add_local (mb, &klass->byval_arg);
7452 *conv_arg_type = &mono_defaults.int_class->byval_arg;
7453
7454 mono_mb_emit_byte (mb, CEE_LDNULL);
7455 mono_mb_emit_stloc (mb, conv_arg);
7456 if (t->attrs & PARAM_ATTRIBUTE_OUT)
7457 break;
7458
7459 mono_mb_emit_ldarg (mb, argnum);
7460 if (t->byref)
7461 mono_mb_emit_byte (mb, CEE_LDIND_REF);
7462 pos_null = mono_mb_emit_short_branch (mb, CEE_BRFALSE_S);
7463
7464 mono_mb_emit_ldarg (mb, argnum);
7465 if (t->byref)
7466 mono_mb_emit_byte (mb, CEE_LDIND_REF);
7467 mono_mb_emit_icon (mb, TRUE);
7468 mono_mb_emit_icall (mb, cominterop_get_ccw_object);
7469 mono_mb_emit_stloc (mb, ccw_obj);
7470 mono_mb_emit_ldloc (mb, ccw_obj);
7471 pos_ccw = mono_mb_emit_short_branch (mb, CEE_BRTRUE_S);
7472
7473
7474 mono_mb_emit_ldarg (mb, argnum);
7475 if (t->byref)
7476 mono_mb_emit_byte (mb, CEE_LDIND_REF);
7477 mono_mb_emit_managed_call (mb, get_object_for_iunknown, NULL);
7478
7479 if (klass && klass != mono_defaults.object_class)
7480 mono_mb_emit_op (mb, CEE_CASTCLASS, klass);
7481 mono_mb_emit_stloc (mb, conv_arg);
7482 pos_end = mono_mb_emit_short_branch (mb, CEE_BR_S);
7483
7484 /* is already managed object */
7485 mono_mb_patch_short_branch (mb, pos_ccw);
7486 mono_mb_emit_ldloc (mb, ccw_obj);
7487 if (klass && klass != mono_defaults.object_class)
7488 mono_mb_emit_op (mb, CEE_CASTCLASS, klass);
7489 mono_mb_emit_stloc (mb, conv_arg);
7490
7491 mono_mb_patch_short_branch (mb, pos_end);
7492 /* case if null */
7493 mono_mb_patch_short_branch (mb, pos_null);
7494 break;
7495 }
7496
7497 case MARSHAL_ACTION_MANAGED_CONV_OUT: {
7498 if (t->byref && t->attrs & PARAM_ATTRIBUTE_OUT) {
7499 guint32 pos_null = 0;
7500
7501 if (!AddRef)
7502 AddRef = mono_class_get_method_from_name (mono_defaults.marshal_class, "AddRef", 1);
7503
7504 mono_mb_emit_ldloc (mb, conv_arg);
7505 /* if null just break, conv arg was already inited to 0 */
7506 pos_null = mono_mb_emit_short_branch (mb, CEE_BRFALSE_S);
7507
7508 /* to store later */
7509 mono_mb_emit_ldarg (mb, argnum);
7510 mono_mb_emit_ldloc (mb, conv_arg);
7511 if (klass && klass != mono_defaults.object_class) {
7512 mono_mb_emit_ptr (mb, t);
7513 mono_mb_emit_icall (mb, type_from_handle);
7514 mono_mb_emit_managed_call (mb, get_com_interface_for_object_internal, NULL);
7515 }
7516 else if (spec->native == MONO_NATIVE_IUNKNOWN)
7517 mono_mb_emit_managed_call (mb, get_iunknown_for_object_internal, NULL);
7518 else if (spec->native == MONO_NATIVE_IDISPATCH)
7519 mono_mb_emit_managed_call (mb, get_idispatch_for_object_internal, NULL);
7520 else if (!klass && spec->native == MONO_NATIVE_INTERFACE)
7521 mono_mb_emit_managed_call (mb, get_iunknown_for_object_internal, NULL);
7522 else
7523 g_assert_not_reached ();
7524 mono_mb_emit_byte (mb, CEE_STIND_I);
7525
7526 mono_mb_emit_ldarg (mb, argnum);
7527 mono_mb_emit_byte (mb, CEE_LDIND_I);
7528 mono_mb_emit_managed_call (mb, AddRef, NULL);
7529 mono_mb_emit_byte (mb, CEE_POP);
7530
7531 mono_mb_patch_short_branch (mb, pos_null);
7532 }
7533 break;
7534 }
7535
7536 case MARSHAL_ACTION_MANAGED_CONV_RESULT: {
7537 guint32 pos_null = 0;
7538 int ccw_obj;
7539 ccw_obj = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
7540
7541 if (!AddRef)
7542 AddRef = mono_class_get_method_from_name (mono_defaults.marshal_class, "AddRef", 1);
7543
7544 /* store return value */
7545 mono_mb_emit_stloc (mb, ccw_obj);
7546
7547 mono_mb_emit_ldloc (mb, ccw_obj);
7548
7549 /* if null just break, conv arg was already inited to 0 */
7550 pos_null = mono_mb_emit_short_branch (mb, CEE_BRFALSE_S);
7551
7552 /* to store later */
7553 mono_mb_emit_ldloc (mb, ccw_obj);
7554 if (klass && klass != mono_defaults.object_class) {
7555 mono_mb_emit_ptr (mb, t);
7556 mono_mb_emit_icall (mb, type_from_handle);
7557 mono_mb_emit_managed_call (mb, get_com_interface_for_object_internal, NULL);
7558 }
7559 else if (spec->native == MONO_NATIVE_IUNKNOWN)
7560 mono_mb_emit_managed_call (mb, get_iunknown_for_object_internal, NULL);
7561 else if (spec->native == MONO_NATIVE_IDISPATCH)
7562 mono_mb_emit_managed_call (mb, get_idispatch_for_object_internal, NULL);
7563 else if (!klass && spec->native == MONO_NATIVE_INTERFACE)
7564 mono_mb_emit_managed_call (mb, get_iunknown_for_object_internal, NULL);
7565 else
7566 g_assert_not_reached ();
7567 mono_mb_emit_stloc (mb, 3);
7568 mono_mb_emit_ldloc (mb, 3);
7569
7570 mono_mb_emit_managed_call (mb, AddRef, NULL);
7571 mono_mb_emit_byte (mb, CEE_POP);
7572
7573 mono_mb_patch_short_branch (mb, pos_null);
7574 break;
7575 }
7576
7577 default:
7578 g_assert_not_reached ();
7579 }
7580
7581 return conv_arg;
7582 }
7583
7584 #endif /* DISABLE_COM */
7585
7586 static int
7587 emit_marshal_variant (EmitMarshalContext *m, int argnum, MonoType *t,
7588 MonoMarshalSpec *spec,
7589 int conv_arg, MonoType **conv_arg_type,
7590 MarshalAction action)
7591 {
7592 MonoMethodBuilder *mb = m->mb;
7593 static MonoMethod *get_object_for_native_variant = NULL;
7594 static MonoMethod *get_native_variant_for_object = NULL;
7595
7596 mono_init_com_types ();
7597
7598 if (!get_object_for_native_variant)
7599 get_object_for_native_variant = mono_class_get_method_from_name (mono_defaults.marshal_class, "GetObjectForNativeVariant", 1);
7600 g_assert (get_object_for_native_variant);
7601
7602 if (!get_native_variant_for_object)
7603 get_native_variant_for_object = mono_class_get_method_from_name (mono_defaults.marshal_class, "GetNativeVariantForObject", 2);
7604 g_assert (get_native_variant_for_object);
7605
7606 switch (action) {
7607 case MARSHAL_ACTION_CONV_IN: {
7608 conv_arg = mono_mb_add_local (mb, &mono_defaults.variant_class->byval_arg);
7609
7610 if (t->byref)
7611 *conv_arg_type = &mono_defaults.variant_class->this_arg;
7612 else
7613 *conv_arg_type = &mono_defaults.variant_class->byval_arg;
7614
7615 if (t->byref && !(t->attrs & PARAM_ATTRIBUTE_IN) && t->attrs & PARAM_ATTRIBUTE_OUT)
7616 break;
7617
7618 mono_mb_emit_ldarg (mb, argnum);
7619 if (t->byref)
7620 mono_mb_emit_byte(mb, CEE_LDIND_REF);
7621 mono_mb_emit_ldloc_addr (mb, conv_arg);
7622 mono_mb_emit_managed_call (mb, get_native_variant_for_object, NULL);
7623 break;
7624 }
7625
7626 case MARSHAL_ACTION_CONV_OUT: {
7627 static MonoMethod *variant_clear = NULL;
7628
7629 if (!variant_clear)
7630 variant_clear = mono_class_get_method_from_name (mono_defaults.variant_class, "Clear", 0);
7631 g_assert (variant_clear);
7632
7633
7634 if (t->byref && (t->attrs & PARAM_ATTRIBUTE_OUT || !(t->attrs & PARAM_ATTRIBUTE_IN))) {
7635 mono_mb_emit_ldarg (mb, argnum);
7636 mono_mb_emit_ldloc_addr (mb, conv_arg);
7637 mono_mb_emit_managed_call (mb, get_object_for_native_variant, NULL);
7638 mono_mb_emit_byte (mb, CEE_STIND_REF);
7639 }
7640
7641 mono_mb_emit_ldloc_addr (mb, conv_arg);
7642 mono_mb_emit_managed_call (mb, variant_clear, NULL);
7643 break;
7644 }
7645
7646 case MARSHAL_ACTION_PUSH:
7647 if (t->byref)
7648 mono_mb_emit_ldloc_addr (mb, conv_arg);
7649 else
7650 mono_mb_emit_ldloc (mb, conv_arg);
7651 break;
7652
7653 case MARSHAL_ACTION_CONV_RESULT: {
7654 char *msg = g_strdup ("Marshalling of VARIANT not supported as a return type.");
7655 mono_mb_emit_exception_marshal_directive (mb, msg);
7656 break;
7657 }
7658
7659 case MARSHAL_ACTION_MANAGED_CONV_IN: {
7660 conv_arg = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
7661
7662 if (t->byref)
7663 *conv_arg_type = &mono_defaults.variant_class->this_arg;
7664 else
7665 *conv_arg_type = &mono_defaults.variant_class->byval_arg;
7666
7667 if (t->byref && !(t->attrs & PARAM_ATTRIBUTE_IN) && t->attrs & PARAM_ATTRIBUTE_OUT)
7668 break;
7669
7670 if (t->byref)
7671 mono_mb_emit_ldarg (mb, argnum);
7672 else
7673 mono_mb_emit_ldarg_addr (mb, argnum);
7674 mono_mb_emit_managed_call (mb, get_object_for_native_variant, NULL);
7675 mono_mb_emit_stloc (mb, conv_arg);
7676 break;
7677 }
7678
7679 case MARSHAL_ACTION_MANAGED_CONV_OUT: {
7680 if (t->byref && (t->attrs & PARAM_ATTRIBUTE_OUT || !(t->attrs & PARAM_ATTRIBUTE_IN))) {
7681 mono_mb_emit_ldloc (mb, conv_arg);
7682 mono_mb_emit_ldarg (mb, argnum);
7683 mono_mb_emit_managed_call (mb, get_native_variant_for_object, NULL);
7684 }
7685 break;
7686 }
7687
7688 case MARSHAL_ACTION_MANAGED_CONV_RESULT: {
7689 char *msg = g_strdup ("Marshalling of VARIANT not supported as a return type.");
7690 mono_mb_emit_exception_marshal_directive (mb, msg);
7691 break;
7692 }
7693
7694 default:
7695 g_assert_not_reached ();
7696 }
7697
7698 return conv_arg;
7699 }
7700
7701 static int
7702 emit_marshal_array (EmitMarshalContext *m, int argnum, MonoType *t,
7703 MonoMarshalSpec *spec,
7704 int conv_arg, MonoType **conv_arg_type,
7705 MarshalAction action)
7706 {
7707 MonoMethodBuilder *mb = m->mb;
7708 MonoClass *klass = mono_class_from_mono_type (t);
7709 gboolean need_convert, need_free;
7710 MonoMarshalNative encoding;
7711
7712 encoding = mono_marshal_get_string_encoding (m->piinfo, spec);
7713
7714 switch (action) {
7715 case MARSHAL_ACTION_CONV_IN:
7716 *conv_arg_type = &mono_defaults.object_class->byval_arg;
7717 conv_arg = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
7718
7719 if (klass->element_class->blittable) {
7720 mono_mb_emit_ldarg (mb, argnum);
7721 if (t->byref)
7722 mono_mb_emit_byte (mb, CEE_LDIND_I);
7723 mono_mb_emit_icall (mb, conv_to_icall (MONO_MARSHAL_CONV_ARRAY_LPARRAY));
7724 mono_mb_emit_stloc (mb, conv_arg);
7725 } else {
7726 MonoClass *eklass;
7727 guint32 label1, label2, label3;
7728 int index_var, src_var, dest_ptr, esize;
7729 MonoMarshalConv conv;
7730 gboolean is_string = FALSE;
7731
7732 dest_ptr = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
7733
7734 eklass = klass->element_class;
7735
7736 if (eklass == mono_defaults.string_class) {
7737 is_string = TRUE;
7738 conv = mono_marshal_get_string_to_ptr_conv (m->piinfo, spec);
7739 }
7740 else if (eklass == mono_defaults.stringbuilder_class) {
7741 is_string = TRUE;
7742 conv = mono_marshal_get_stringbuilder_to_ptr_conv (m->piinfo, spec);
7743 }
7744 else
7745 conv = -1;
7746
7747 src_var = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
7748 mono_mb_emit_ldarg (mb, argnum);
7749 if (t->byref)
7750 mono_mb_emit_byte (mb, CEE_LDIND_I);
7751 mono_mb_emit_stloc (mb, src_var);
7752
7753 /* Check null */
7754 mono_mb_emit_ldloc (mb, src_var);
7755 mono_mb_emit_stloc (mb, conv_arg);
7756 mono_mb_emit_ldloc (mb, src_var);
7757 label1 = mono_mb_emit_branch (mb, CEE_BRFALSE);
7758
7759 if (is_string) {
7760 if (conv == -1) {
7761 char *msg = g_strdup_printf ("string/stringbuilder marshalling conversion %d not implemented", encoding);
7762 MonoException *exc = mono_get_exception_not_implemented (msg);
7763 g_warning (msg);
7764 g_free (msg);
7765 mono_raise_exception (exc);
7766 }
7767 }
7768
7769 if (is_string)
7770 esize = sizeof (gpointer);
7771 else
7772 esize = mono_class_native_size (eklass, NULL);
7773
7774 /* allocate space for the native struct and store the address */
7775 mono_mb_emit_icon (mb, esize);
7776 mono_mb_emit_ldloc (mb, src_var);
7777 mono_mb_emit_byte (mb, CEE_LDLEN);
7778
7779 if (eklass == mono_defaults.string_class) {
7780 /* Make the array bigger for the terminating null */
7781 mono_mb_emit_byte (mb, CEE_LDC_I4_1);
7782 mono_mb_emit_byte (mb, CEE_ADD);
7783 }
7784 mono_mb_emit_byte (mb, CEE_MUL);
7785 mono_mb_emit_byte (mb, CEE_PREFIX1);
7786 mono_mb_emit_byte (mb, CEE_LOCALLOC);
7787 mono_mb_emit_stloc (mb, conv_arg);
7788
7789 mono_mb_emit_ldloc (mb, conv_arg);
7790 mono_mb_emit_stloc (mb, dest_ptr);
7791
7792 /* Emit marshalling loop */
7793 index_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
7794 mono_mb_emit_byte (mb, CEE_LDC_I4_0);
7795 mono_mb_emit_stloc (mb, index_var);
7796 label2 = mono_mb_get_label (mb);
7797 mono_mb_emit_ldloc (mb, index_var);
7798 mono_mb_emit_ldloc (mb, src_var);
7799 mono_mb_emit_byte (mb, CEE_LDLEN);
7800 label3 = mono_mb_emit_branch (mb, CEE_BGE);
7801
7802 /* Emit marshalling code */
7803
7804 if (is_string) {
7805 mono_mb_emit_ldloc (mb, dest_ptr);
7806 mono_mb_emit_ldloc (mb, src_var);
7807 mono_mb_emit_ldloc (mb, index_var);
7808 mono_mb_emit_byte (mb, CEE_LDELEM_REF);
7809 mono_mb_emit_icall (mb, conv_to_icall (conv));
7810 mono_mb_emit_byte (mb, CEE_STIND_I);
7811 } else {
7812 /* set the src_ptr */
7813 mono_mb_emit_ldloc (mb, src_var);
7814 mono_mb_emit_ldloc (mb, index_var);
7815 mono_mb_emit_op (mb, CEE_LDELEMA, eklass);
7816 mono_mb_emit_stloc (mb, 0);
7817
7818 /* set dst_ptr */
7819 mono_mb_emit_ldloc (mb, dest_ptr);
7820 mono_mb_emit_stloc (mb, 1);
7821
7822 /* emit valuetype conversion code */
7823 emit_struct_conv (mb, eklass, FALSE);
7824 }
7825
7826 mono_mb_emit_add_to_local (mb, index_var, 1);
7827 mono_mb_emit_add_to_local (mb, dest_ptr, esize);
7828
7829 mono_mb_emit_branch_label (mb, CEE_BR, label2);
7830
7831 mono_mb_patch_branch (mb, label3);
7832
7833 if (eklass == mono_defaults.string_class) {
7834 /* Null terminate */
7835 mono_mb_emit_ldloc (mb, dest_ptr);
7836 mono_mb_emit_byte (mb, CEE_LDC_I4_0);
7837 mono_mb_emit_byte (mb, CEE_STIND_REF);
7838 }
7839
7840 mono_mb_patch_branch (mb, label1);
7841 }
7842
7843 break;
7844
7845 case MARSHAL_ACTION_CONV_OUT:
7846 /* Unicode character arrays are implicitly marshalled as [Out] under MS.NET */
7847 need_convert = ((klass->element_class == mono_defaults.char_class) && (encoding == MONO_NATIVE_LPWSTR)) || (klass->element_class == mono_defaults.stringbuilder_class) || (t->attrs & PARAM_ATTRIBUTE_OUT);
7848 need_free = mono_marshal_need_free (&klass->element_class->byval_arg,
7849 m->piinfo, spec);
7850
7851 if (need_convert || need_free) {
7852 /* FIXME: Optimize blittable case */
7853 MonoClass *eklass;
7854 guint32 label1, label2, label3;
7855 int index_var, src_ptr, loc, esize;
7856
7857 eklass = klass->element_class;
7858 if ((eklass == mono_defaults.stringbuilder_class) || (eklass == mono_defaults.string_class))
7859 esize = sizeof (gpointer);
7860 else
7861 esize = mono_class_native_size (eklass, NULL);
7862 src_ptr = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
7863 loc = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
7864
7865 /* Check null */
7866 mono_mb_emit_ldarg (mb, argnum);
7867 if (t->byref)
7868 mono_mb_emit_byte (mb, CEE_LDIND_I);
7869 label1 = mono_mb_emit_branch (mb, CEE_BRFALSE);
7870
7871 mono_mb_emit_ldloc (mb, conv_arg);
7872 mono_mb_emit_stloc (mb, src_ptr);
7873
7874 /* Emit marshalling loop */
7875 index_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
7876 mono_mb_emit_byte (mb, CEE_LDC_I4_0);
7877 mono_mb_emit_stloc (mb, index_var);
7878 label2 = mono_mb_get_label (mb);
7879 mono_mb_emit_ldloc (mb, index_var);
7880 mono_mb_emit_ldarg (mb, argnum);
7881 if (t->byref)
7882 mono_mb_emit_byte (mb, CEE_LDIND_REF);
7883 mono_mb_emit_byte (mb, CEE_LDLEN);
7884 label3 = mono_mb_emit_branch (mb, CEE_BGE);
7885
7886 /* Emit marshalling code */
7887
7888 if (eklass == mono_defaults.stringbuilder_class) {
7889 gboolean need_free2;
7890 MonoMarshalConv conv = mono_marshal_get_ptr_to_stringbuilder_conv (m->piinfo, spec, &need_free2);
7891
7892 g_assert (conv != -1);
7893
7894 /* dest */
7895 mono_mb_emit_ldarg (mb, argnum);
7896 if (t->byref)
7897 mono_mb_emit_byte (mb, CEE_LDIND_I);
7898 mono_mb_emit_ldloc (mb, index_var);
7899 mono_mb_emit_byte (mb, CEE_LDELEM_REF);
7900
7901 /* src */
7902 mono_mb_emit_ldloc (mb, src_ptr);
7903 mono_mb_emit_byte (mb, CEE_LDIND_I);
7904
7905 mono_mb_emit_icall (mb, conv_to_icall (conv));
7906
7907 if (need_free) {
7908 /* src */
7909 mono_mb_emit_ldloc (mb, src_ptr);
7910 mono_mb_emit_byte (mb, CEE_LDIND_I);
7911
7912 mono_mb_emit_icall (mb, mono_marshal_free);
7913 }
7914 }
7915 else if (eklass == mono_defaults.string_class) {
7916 if (need_free) {
7917 /* src */
7918 mono_mb_emit_ldloc (mb, src_ptr);
7919 mono_mb_emit_byte (mb, CEE_LDIND_I);
7920
7921 mono_mb_emit_icall (mb, mono_marshal_free);
7922 }
7923 }
7924 else {
7925 if (need_convert) {
7926 /* set the src_ptr */
7927 mono_mb_emit_ldloc (mb, src_ptr);
7928 mono_mb_emit_stloc (mb, 0);
7929
7930 /* set dst_ptr */
7931 mono_mb_emit_ldarg (mb, argnum);
7932 if (t->byref)
7933 mono_mb_emit_byte (mb, CEE_LDIND_REF);
7934 mono_mb_emit_ldloc (mb, index_var);
7935 mono_mb_emit_op (mb, CEE_LDELEMA, eklass);
7936 mono_mb_emit_stloc (mb, 1);
7937
7938 /* emit valuetype conversion code */
7939 emit_struct_conv (mb, eklass, TRUE);
7940 }
7941
7942 if (need_free) {
7943 mono_mb_emit_ldloc (mb, src_ptr);
7944 mono_mb_emit_stloc (mb, loc);
7945 mono_mb_emit_ldloc (mb, loc);
7946
7947 emit_struct_free (mb, eklass, loc);
7948 }
7949 }
7950
7951 mono_mb_emit_add_to_local (mb, index_var, 1);
7952 mono_mb_emit_add_to_local (mb, src_ptr, esize);
7953
7954 mono_mb_emit_branch_label (mb, CEE_BR, label2);
7955
7956 mono_mb_patch_branch (mb, label1);
7957 mono_mb_patch_branch (mb, label3);
7958 }
7959 break;
7960
7961 case MARSHAL_ACTION_PUSH:
7962 if (t->byref)
7963 mono_mb_emit_ldloc_addr (mb, conv_arg);
7964 else
7965 mono_mb_emit_ldloc (mb, conv_arg);
7966 break;
7967
7968 case MARSHAL_ACTION_CONV_RESULT:
7969 /* fixme: we need conversions here */
7970 mono_mb_emit_stloc (mb, 3);
7971 break;
7972
7973 case MARSHAL_ACTION_MANAGED_CONV_IN: {
7974 MonoClass *eklass;
7975 guint32 label1, label2, label3;
7976 int index_var, src_ptr, loc, esize, param_num, num_elem;
7977 MonoMarshalConv conv;
7978 gboolean is_string = FALSE;
7979
7980 conv_arg = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
7981 *conv_arg_type = &mono_defaults.int_class->byval_arg;
7982
7983 if (t->byref) {
7984 char *msg = g_strdup ("Byref array marshalling to managed code is not implemented.");
7985 mono_mb_emit_exception_marshal_directive (mb, msg);
7986 return conv_arg;
7987 }
7988 if (!spec) {
7989 char *msg = g_strdup ("[MarshalAs] attribute required to marshal arrays to managed code.");
7990 mono_mb_emit_exception_marshal_directive (mb, msg);
7991 return conv_arg;
7992 }
7993 if (spec->native != MONO_NATIVE_LPARRAY) {
7994 char *msg = g_strdup ("Non LPArray marshalling of arrays to managed code is not implemented.");
7995 mono_mb_emit_exception_marshal_directive (mb, msg);
7996 return conv_arg;
7997 }
7998
7999 /* FIXME: t is from the method which is wrapped, not the delegate type */
8000 /* g_assert (t->attrs & PARAM_ATTRIBUTE_IN); */
8001
8002 param_num = spec->data.array_data.param_num;
8003 num_elem = spec->data.array_data.num_elem;
8004 if (spec->data.array_data.elem_mult == 0)
8005 /* param_num is not specified */
8006 param_num = -1;
8007
8008 if (param_num == -1) {
8009 if (num_elem <= 0) {
8010 char *msg = g_strdup ("Either SizeConst or SizeParamIndex should be specified when marshalling arrays to managed code.");
8011 mono_mb_emit_exception_marshal_directive (mb, msg);
8012 return conv_arg;
8013 }
8014 }
8015
8016 /* FIXME: Optimize blittable case */
8017
8018 eklass = klass->element_class;
8019 if (eklass == mono_defaults.string_class) {
8020 is_string = TRUE;
8021 conv = mono_marshal_get_ptr_to_string_conv (m->piinfo, spec, &need_free);
8022 }
8023 else if (eklass == mono_defaults.stringbuilder_class) {
8024 is_string = TRUE;
8025 conv = mono_marshal_get_ptr_to_stringbuilder_conv (m->piinfo, spec, &need_free);
8026 }
8027 else
8028 conv = -1;
8029
8030 mono_marshal_load_type_info (eklass);
8031
8032 if (is_string)
8033 esize = sizeof (gpointer);
8034 else
8035 esize = mono_class_native_size (eklass, NULL);
8036 src_ptr = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
8037 loc = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
8038
8039 mono_mb_emit_byte (mb, CEE_LDNULL);
8040 mono_mb_emit_stloc (mb, conv_arg);
8041
8042 /* Check param index */
8043 if (param_num != -1) {
8044 if (param_num >= m->sig->param_count) {
8045 char *msg = g_strdup ("Array size control parameter index is out of range.");
8046 mono_mb_emit_exception_marshal_directive (mb, msg);
8047 return conv_arg;
8048 }
8049 switch (m->sig->params [param_num]->type) {
8050 case MONO_TYPE_I1:
8051 case MONO_TYPE_U1:
8052 case MONO_TYPE_I2:
8053 case MONO_TYPE_U2:
8054 case MONO_TYPE_I4:
8055 case MONO_TYPE_U4:
8056 case MONO_TYPE_I:
8057 case MONO_TYPE_U:
8058 case MONO_TYPE_I8:
8059 case MONO_TYPE_U8:
8060 break;
8061 default: {
8062 char *msg = g_strdup ("Array size control parameter must be an integral type.");
8063 mono_mb_emit_exception_marshal_directive (mb, msg);
8064 return conv_arg;
8065 }
8066 }
8067 }
8068
8069 /* Check null */
8070 mono_mb_emit_ldarg (mb, argnum);
8071 label1 = mono_mb_emit_branch (mb, CEE_BRFALSE);
8072
8073 mono_mb_emit_ldarg (mb, argnum);
8074 mono_mb_emit_stloc (mb, src_ptr);
8075
8076 /* Create managed array */
8077 /*
8078 * The LPArray marshalling spec says that sometimes param_num starts
8079 * from 1, sometimes it starts from 0. But MS seems to allways start
8080 * from 0.
8081 */
8082
8083 if (param_num == -1)
8084 mono_mb_emit_icon (mb, num_elem);
8085 else {
8086 /* FIXME: Add the two together */
8087 mono_mb_emit_ldarg (mb, param_num);
8088 if (num_elem > 0) {
8089 mono_mb_emit_icon (mb, num_elem);
8090 mono_mb_emit_byte (mb, CEE_ADD);
8091 }
8092 }
8093
8094 mono_mb_emit_op (mb, CEE_NEWARR, eklass);
8095 mono_mb_emit_stloc (mb, conv_arg);
8096
8097 if (eklass->blittable) {
8098 mono_mb_emit_ldloc (mb, conv_arg);
8099 mono_mb_emit_byte (mb, CEE_CONV_I);
8100 mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoArray, vector));
8101 mono_mb_emit_byte (mb, CEE_ADD);
8102 mono_mb_emit_ldarg (mb, argnum);
8103 mono_mb_emit_ldloc (mb, conv_arg);
8104 mono_mb_emit_byte (mb, CEE_LDLEN);
8105 mono_mb_emit_icon (mb, esize);
8106 mono_mb_emit_byte (mb, CEE_MUL);
8107 mono_mb_emit_byte (mb, CEE_PREFIX1);
8108 mono_mb_emit_byte (mb, CEE_CPBLK);
8109 break;
8110 }
8111
8112 /* Emit marshalling loop */
8113 index_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
8114 mono_mb_emit_byte (mb, CEE_LDC_I4_0);
8115 mono_mb_emit_stloc (mb, index_var);
8116 label2 = mono_mb_get_label (mb);
8117 mono_mb_emit_ldloc (mb, index_var);
8118 mono_mb_emit_ldloc (mb, conv_arg);
8119 mono_mb_emit_byte (mb, CEE_LDLEN);
8120 label3 = mono_mb_emit_branch (mb, CEE_BGE);
8121
8122 /* Emit marshalling code */
8123 if (is_string) {
8124 g_assert (conv != -1);
8125
8126 mono_mb_emit_ldloc (mb, conv_arg);
8127 mono_mb_emit_ldloc (mb, index_var);
8128
8129 mono_mb_emit_ldloc (mb, src_ptr);
8130 mono_mb_emit_byte (mb, CEE_LDIND_I);
8131
8132 mono_mb_emit_icall (mb, conv_to_icall (conv));
8133 mono_mb_emit_byte (mb, CEE_STELEM_REF);
8134 }
8135 else {
8136 char *msg = g_strdup ("Marshalling of non-string and non-blittable arrays to managed code is not implemented.");
8137 mono_mb_emit_exception_marshal_directive (mb, msg);
8138 return conv_arg;
8139 }
8140
8141 mono_mb_emit_add_to_local (mb, index_var, 1);
8142 mono_mb_emit_add_to_local (mb, src_ptr, esize);
8143
8144 mono_mb_emit_branch_label (mb, CEE_BR, label2);
8145
8146 mono_mb_patch_branch (mb, label1);
8147 mono_mb_patch_branch (mb, label3);
8148
8149 break;
8150 }
8151 case MARSHAL_ACTION_MANAGED_CONV_OUT: {
8152 MonoClass *eklass;
8153 guint32 label1, label2, label3;
8154 int index_var, dest_ptr, loc, esize, param_num, num_elem;
8155 MonoMarshalConv conv;
8156 gboolean is_string = FALSE;
8157
8158 if (!spec)
8159 /* Already handled in CONV_IN */
8160 break;
8161
8162 /* These are already checked in CONV_IN */
8163 g_assert (!t->byref);
8164 g_assert (spec->native == MONO_NATIVE_LPARRAY);
8165 g_assert (t->attrs & PARAM_ATTRIBUTE_OUT);
8166
8167 param_num = spec->data.array_data.param_num;
8168 num_elem = spec->data.array_data.num_elem;
8169
8170 if (spec->data.array_data.elem_mult == 0)
8171 /* param_num is not specified */
8172 param_num = -1;
8173
8174 if (param_num == -1) {
8175 if (num_elem <= 0) {
8176 g_assert_not_reached ();
8177 }
8178 }
8179
8180 /* FIXME: Optimize blittable case */
8181
8182 eklass = klass->element_class;
8183 if (eklass == mono_defaults.string_class) {
8184 is_string = TRUE;
8185 conv = mono_marshal_get_string_to_ptr_conv (m->piinfo, spec);
8186 }
8187 else if (eklass == mono_defaults.stringbuilder_class) {
8188 is_string = TRUE;
8189 conv = mono_marshal_get_stringbuilder_to_ptr_conv (m->piinfo, spec);
8190 }
8191 else
8192 conv = -1;
8193
8194 mono_marshal_load_type_info (eklass);
8195
8196 if (is_string)
8197 esize = sizeof (gpointer);
8198 else
8199 esize = mono_class_native_size (eklass, NULL);
8200
8201 dest_ptr = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
8202 loc = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
8203
8204 /* Check null */
8205 mono_mb_emit_ldloc (mb, conv_arg);
8206 label1 = mono_mb_emit_branch (mb, CEE_BRFALSE);
8207
8208 mono_mb_emit_ldarg (mb, argnum);
8209 mono_mb_emit_stloc (mb, dest_ptr);
8210
8211 if (eklass->blittable) {
8212 /* dest */
8213 mono_mb_emit_ldarg (mb, argnum);
8214 /* src */
8215 mono_mb_emit_ldloc (mb, conv_arg);
8216 mono_mb_emit_byte (mb, CEE_CONV_I);
8217 mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoArray, vector));
8218 mono_mb_emit_byte (mb, CEE_ADD);
8219 /* length */
8220 mono_mb_emit_ldloc (mb, conv_arg);
8221 mono_mb_emit_byte (mb, CEE_LDLEN);
8222 mono_mb_emit_icon (mb, esize);
8223 mono_mb_emit_byte (mb, CEE_MUL);
8224 mono_mb_emit_byte (mb, CEE_PREFIX1);
8225 mono_mb_emit_byte (mb, CEE_CPBLK);
8226 break;
8227 }
8228
8229 /* Emit marshalling loop */
8230 index_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
8231 mono_mb_emit_byte (mb, CEE_LDC_I4_0);
8232 mono_mb_emit_stloc (mb, index_var);
8233 label2 = mono_mb_get_label (mb);
8234 mono_mb_emit_ldloc (mb, index_var);
8235 mono_mb_emit_ldloc (mb, conv_arg);
8236 mono_mb_emit_byte (mb, CEE_LDLEN);
8237 label3 = mono_mb_emit_branch (mb, CEE_BGE);
8238
8239 /* Emit marshalling code */
8240 if (is_string) {
8241 g_assert (conv != -1);
8242
8243 /* dest */
8244 mono_mb_emit_ldloc (mb, dest_ptr);
8245
8246 /* src */
8247 mono_mb_emit_ldloc (mb, conv_arg);
8248 mono_mb_emit_ldloc (mb, index_var);
8249
8250 mono_mb_emit_byte (mb, CEE_LDELEM_REF);
8251
8252 mono_mb_emit_icall (mb, conv_to_icall (conv));
8253 mono_mb_emit_byte (mb, CEE_STIND_I);
8254 }
8255 else {
8256 char *msg = g_strdup ("Marshalling of non-string and non-blittable arrays to managed code is not implemented.");
8257 mono_mb_emit_exception_marshal_directive (mb, msg);
8258 return conv_arg;
8259 }
8260
8261 mono_mb_emit_add_to_local (mb, index_var, 1);
8262 mono_mb_emit_add_to_local (mb, dest_ptr, esize);
8263
8264 mono_mb_emit_branch_label (mb, CEE_BR, label2);
8265
8266 mono_mb_patch_branch (mb, label1);
8267 mono_mb_patch_branch (mb, label3);
8268
8269 break;
8270 }
8271 case MARSHAL_ACTION_MANAGED_CONV_RESULT: {
8272 MonoClass *eklass;
8273 guint32 label1, label2, label3;
8274 int index_var, src, dest, esize;
8275 MonoMarshalConv conv = -1;
8276 gboolean is_string = FALSE;
8277
8278 g_assert (!t->byref);
8279
8280 eklass = klass->element_class;
8281
8282 mono_marshal_load_type_info (eklass);
8283
8284 if (eklass == mono_defaults.string_class) {
8285 is_string = TRUE;
8286 conv = mono_marshal_get_string_to_ptr_conv (m->piinfo, spec);
8287 }
8288 else {
8289 g_assert_not_reached ();
8290 }
8291
8292 if (is_string)
8293 esize = sizeof (gpointer);
8294 else
8295 esize = mono_class_native_size (eklass, NULL);
8296
8297 src = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
8298 dest = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
8299
8300 mono_mb_emit_stloc (mb, src);
8301 mono_mb_emit_ldloc (mb, src);
8302 mono_mb_emit_stloc (mb, 3);
8303
8304 /* Check for null */
8305 mono_mb_emit_ldloc (mb, src);
8306 label1 = mono_mb_emit_branch (mb, CEE_BRFALSE);
8307
8308 /* Allocate native array */
8309 mono_mb_emit_icon (mb, esize);
8310 mono_mb_emit_ldloc (mb, src);
8311 mono_mb_emit_byte (mb, CEE_LDLEN);
8312
8313 if (eklass == mono_defaults.string_class) {
8314 /* Make the array bigger for the terminating null */
8315 mono_mb_emit_byte (mb, CEE_LDC_I4_1);
8316 mono_mb_emit_byte (mb, CEE_ADD);
8317 }
8318 mono_mb_emit_byte (mb, CEE_MUL);
8319 mono_mb_emit_icall (mb, mono_marshal_alloc);
8320 mono_mb_emit_stloc (mb, dest);
8321 mono_mb_emit_ldloc (mb, dest);
8322 mono_mb_emit_stloc (mb, 3);
8323
8324 /* Emit marshalling loop */
8325 index_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
8326 mono_mb_emit_byte (mb, CEE_LDC_I4_0);
8327 mono_mb_emit_stloc (mb, index_var);
8328 label2 = mono_mb_get_label (mb);
8329 mono_mb_emit_ldloc (mb, index_var);
8330 mono_mb_emit_ldloc (mb, src);
8331 mono_mb_emit_byte (mb, CEE_LDLEN);
8332 label3 = mono_mb_emit_branch (mb, CEE_BGE);
8333
8334 /* Emit marshalling code */
8335 if (is_string) {
8336 g_assert (conv != -1);
8337
8338 /* dest */
8339 mono_mb_emit_ldloc (mb, dest);
8340
8341 /* src */
8342 mono_mb_emit_ldloc (mb, src);
8343 mono_mb_emit_ldloc (mb, index_var);
8344
8345 mono_mb_emit_byte (mb, CEE_LDELEM_REF);
8346
8347 mono_mb_emit_icall (mb, conv_to_icall (conv));
8348 mono_mb_emit_byte (mb, CEE_STIND_I);
8349 }
8350 else {
8351 char *msg = g_strdup ("Marshalling of non-string arrays to managed code is not implemented.");
8352 mono_mb_emit_exception_marshal_directive (mb, msg);
8353 return conv_arg;
8354 }
8355
8356 mono_mb_emit_add_to_local (mb, index_var, 1);
8357 mono_mb_emit_add_to_local (mb, dest, esize);
8358
8359 mono_mb_emit_branch_label (mb, CEE_BR, label2);
8360
8361 mono_mb_patch_branch (mb, label3);
8362 mono_mb_patch_branch (mb, label1);
8363 break;
8364 }
8365 default:
8366 g_assert_not_reached ();
8367 }
8368
8369 return conv_arg;
8370 }
8371
8372 static int
8373 emit_marshal_boolean (EmitMarshalContext *m, int argnum, MonoType *t,
8374 MonoMarshalSpec *spec,
8375 int conv_arg, MonoType **conv_arg_type,
8376 MarshalAction action)
8377 {
8378 MonoMethodBuilder *mb = m->mb;
8379
8380 switch (action) {
8381 case MARSHAL_ACTION_CONV_IN: {
8382 MonoType *local_type;
8383 int variant_bool = 0;
8384 if (!t->byref)
8385 break;
8386 if (spec == NULL) {
8387 local_type = &mono_defaults.int32_class->byval_arg;
8388 } else {
8389 switch (spec->native) {
8390 case MONO_NATIVE_I1:
8391 case MONO_NATIVE_U1:
8392 local_type = &mono_defaults.byte_class->byval_arg;
8393 break;
8394 case MONO_NATIVE_VARIANTBOOL:
8395 local_type = &mono_defaults.int16_class->byval_arg;
8396 variant_bool = 1;
8397 break;
8398 default:
8399 g_warning ("marshalling bool as native type %x is currently not supported", spec->native);
8400 local_type = &mono_defaults.int32_class->byval_arg;
8401 break;
8402 }
8403 }
8404 *conv_arg_type = &mono_defaults.int_class->byval_arg;
8405 conv_arg = mono_mb_add_local (mb, local_type);
8406 mono_mb_emit_ldarg (mb, argnum);
8407 mono_mb_emit_byte (mb, CEE_LDIND_I1);
8408 if (variant_bool)
8409 mono_mb_emit_byte (mb, CEE_NEG);
8410 mono_mb_emit_stloc (mb, conv_arg);
8411 break;
8412 }
8413
8414 case MARSHAL_ACTION_CONV_OUT:
8415 if (!t->byref)
8416 break;
8417 mono_mb_emit_ldarg (mb, argnum);
8418 mono_mb_emit_ldloc (mb, conv_arg);
8419 if (spec != NULL && spec->native == MONO_NATIVE_VARIANTBOOL)
8420 mono_mb_emit_byte (mb, CEE_NEG);
8421 mono_mb_emit_byte (mb, CEE_STIND_I1);
8422 break;
8423
8424 case MARSHAL_ACTION_PUSH:
8425 if (t->byref)
8426 mono_mb_emit_ldloc_addr (mb, conv_arg);
8427 else
8428 mono_mb_emit_ldarg (mb, argnum);
8429 break;
8430
8431 case MARSHAL_ACTION_CONV_RESULT:
8432 /* maybe we need to make sure that it fits within 8 bits */
8433 mono_mb_emit_stloc (mb, 3);
8434 break;
8435
8436 default:
8437 g_assert_not_reached ();
8438 }
8439
8440 return conv_arg;
8441 }
8442
8443 static int
8444 emit_marshal_ptr (EmitMarshalContext *m, int argnum, MonoType *t,
8445 MonoMarshalSpec *spec, int conv_arg,
8446 MonoType **conv_arg_type, MarshalAction action)
8447 {
8448 MonoMethodBuilder *mb = m->mb;
8449
8450 switch (action) {
8451 case MARSHAL_ACTION_CONV_IN:
8452 if (MONO_TYPE_ISSTRUCT (t->data.type)) {
8453 char *msg = g_strdup_printf ("Can not marshal 'parameter #%d': Pointers can not reference marshaled structures. Use byref instead.", argnum + 1);
8454 mono_mb_emit_exception_marshal_directive (m->mb, msg);
8455 }
8456 break;
8457
8458 case MARSHAL_ACTION_PUSH:
8459 mono_mb_emit_ldarg (mb, argnum);
8460 break;
8461
8462 case MARSHAL_ACTION_CONV_RESULT:
8463 /* no conversions necessary */
8464 mono_mb_emit_stloc (mb, 3);
8465 break;
8466
8467 default:
8468 break;
8469 }
8470
8471 return conv_arg;
8472 }
8473
8474 static int
8475 emit_marshal_char (EmitMarshalContext *m, int argnum, MonoType *t,
8476 MonoMarshalSpec *spec, int conv_arg,
8477 MonoType **conv_arg_type, MarshalAction action)
8478 {
8479 MonoMethodBuilder *mb = m->mb;
8480
8481 switch (action) {
8482 case MARSHAL_ACTION_PUSH:
8483 /* fixme: dont know how to marshal that. We cant simply
8484 * convert it to a one byte UTF8 character, because an
8485 * unicode character may need more that one byte in UTF8 */
8486 mono_mb_emit_ldarg (mb, argnum);
8487 break;
8488
8489 case MARSHAL_ACTION_CONV_RESULT:
8490 /* fixme: we need conversions here */
8491 mono_mb_emit_stloc (mb, 3);
8492 break;
8493
8494 default:
8495 break;
8496 }
8497
8498 return conv_arg;
8499 }
8500
8501 static int
8502 emit_marshal_scalar (EmitMarshalContext *m, int argnum, MonoType *t,
8503 MonoMarshalSpec *spec, int conv_arg,
8504 MonoType **conv_arg_type, MarshalAction action)
8505 {
8506 MonoMethodBuilder *mb = m->mb;
8507
8508 switch (action) {
8509 case MARSHAL_ACTION_PUSH:
8510 mono_mb_emit_ldarg (mb, argnum);
8511 break;
8512
8513 case MARSHAL_ACTION_CONV_RESULT:
8514 /* no conversions necessary */
8515 mono_mb_emit_stloc (mb, 3);
8516 break;
8517
8518 default:
8519 break;
8520 }
8521
8522 return conv_arg;
8523 }
8524
8525 static int
8526 emit_marshal (EmitMarshalContext *m, int argnum, MonoType *t,
8527 MonoMarshalSpec *spec, int conv_arg,
8528 MonoType **conv_arg_type, MarshalAction action)
8529 {
8530 /* Ensure that we have marshalling info for this param */
8531 mono_marshal_load_type_info (mono_class_from_mono_type (t));
8532
8533 if (spec && spec->native == MONO_NATIVE_CUSTOM)
8534 return emit_marshal_custom (m, argnum, t, spec, conv_arg, conv_arg_type, action);
8535
8536 if (spec && spec->native == MONO_NATIVE_ASANY)
8537 return emit_marshal_asany (m, argnum, t, spec, conv_arg, conv_arg_type, action);
8538
8539 switch (t->type) {
8540 case MONO_TYPE_VALUETYPE:
8541 if (t->data.klass == mono_defaults.handleref_class)
8542 return emit_marshal_handleref (m, argnum, t, spec, conv_arg, conv_arg_type, action);
8543
8544 return emit_marshal_vtype (m, argnum, t, spec, conv_arg, conv_arg_type, action);
8545 case MONO_TYPE_STRING:
8546 return emit_marshal_string (m, argnum, t, spec, conv_arg, conv_arg_type, action);
8547 case MONO_TYPE_CLASS:
8548 case MONO_TYPE_OBJECT:
8549 if (spec && spec->native == MONO_NATIVE_STRUCT)
8550 return emit_marshal_variant (m, argnum, t, spec, conv_arg, conv_arg_type, action);
8551
8552 #ifndef DISABLE_COM
8553 if (spec && (spec->native == MONO_NATIVE_IUNKNOWN ||
8554 spec->native == MONO_NATIVE_IDISPATCH ||
8555 spec->native == MONO_NATIVE_INTERFACE))
8556 return emit_marshal_com_interface (m, argnum, t, spec, conv_arg, conv_arg_type, action);
8557 #endif
8558
8559 if (mono_defaults.safehandle_class != NULL &&
8560 mono_class_is_subclass_of (t->data.klass, mono_defaults.safehandle_class, FALSE))
8561 return emit_marshal_safehandle (m, argnum, t, spec, conv_arg, conv_arg_type, action);
8562
8563 return emit_marshal_object (m, argnum, t, spec, conv_arg, conv_arg_type, action);
8564 case MONO_TYPE_ARRAY:
8565 case MONO_TYPE_SZARRAY:
8566 return emit_marshal_array (m, argnum, t, spec, conv_arg, conv_arg_type, action);
8567 case MONO_TYPE_BOOLEAN:
8568 return emit_marshal_boolean (m, argnum, t, spec, conv_arg, conv_arg_type, action);
8569 case MONO_TYPE_PTR:
8570 return emit_marshal_ptr (m, argnum, t, spec, conv_arg, conv_arg_type, action);
8571 case MONO_TYPE_CHAR:
8572 return emit_marshal_char (m, argnum, t, spec, conv_arg, conv_arg_type, action);
8573 case MONO_TYPE_I1:
8574 case MONO_TYPE_U1:
8575 case MONO_TYPE_I2:
8576 case MONO_TYPE_U2:
8577 case MONO_TYPE_I4:
8578 case MONO_TYPE_U4:
8579 case MONO_TYPE_I:
8580 case MONO_TYPE_U:
8581 case MONO_TYPE_R4:
8582 case MONO_TYPE_R8:
8583 case MONO_TYPE_I8:
8584 case MONO_TYPE_U8:
8585 case MONO_TYPE_FNPTR:
8586 return emit_marshal_scalar (m, argnum, t, spec, conv_arg, conv_arg_type, action);
8587 case MONO_TYPE_GENERICINST:
8588 if (mono_type_generic_inst_is_valuetype (t))
8589 return emit_marshal_vtype (m, argnum, t, spec, conv_arg, conv_arg_type, action);
8590 else
8591 return emit_marshal_object (m, argnum, t, spec, conv_arg, conv_arg_type, action);
8592 }
8593
8594 return conv_arg;
8595 }
8596
8597 /**
8598 * mono_marshal_emit_native_wrapper:
8599 * @image: the image to use for looking up custom marshallers
8600 * @sig: The signature of the native function
8601 * @piinfo: Marshalling information
8602 * @mspecs: Marshalling information
8603 * @aot: whenever the created method will be compiled by the AOT compiler
8604 * @method: if non-NULL, the pinvoke method to call
8605 * @check_exceptions: Whenever to check for pending exceptions after the native call
8606 *
8607 * generates IL code for the pinvoke wrapper, the generated code calls @func.
8608 */
8609 static void
8610 mono_marshal_emit_native_wrapper (MonoImage *image, MonoMethodBuilder *mb, MonoMethodSignature *sig, MonoMethodPInvoke *piinfo, MonoMarshalSpec **mspecs, gpointer func, gboolean aot, gboolean check_exceptions)
8611 {
8612 EmitMarshalContext m;
8613 MonoMethodSignature *csig;
8614 MonoClass *klass;
8615 int i, argnum, *tmp_locals;
8616 int type;
8617 static MonoMethodSignature *get_last_error_sig = NULL;
8618
8619 m.mb = mb;
8620 m.piinfo = piinfo;
8621
8622 /* we copy the signature, so that we can set pinvoke to 0 */
8623 csig = signature_dup (mb->method->klass->image, sig);
8624 csig->pinvoke = 1;
8625 m.csig = csig;
8626 m.image = image;
8627
8628 /* we allocate local for use with emit_struct_conv() */
8629 /* allocate local 0 (pointer) src_ptr */
8630 mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
8631 /* allocate local 1 (pointer) dst_ptr */
8632 mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
8633 /* allocate local 2 (boolean) delete_old */
8634 mono_mb_add_local (mb, &mono_defaults.boolean_class->byval_arg);
8635
8636 /* delete_old = FALSE */
8637 mono_mb_emit_icon (mb, 0);
8638 mono_mb_emit_stloc (mb, 2);
8639
8640 if (!MONO_TYPE_IS_VOID(sig->ret)) {
8641 /* allocate local 3 to store the return value */
8642 mono_mb_add_local (mb, sig->ret);
8643 }
8644
8645 if (mspecs [0] && mspecs [0]->native == MONO_NATIVE_CUSTOM) {
8646 /* Return type custom marshaling */
8647 /*
8648 * Since we can't determine the return type of the unmanaged function,
8649 * we assume it returns a pointer, and pass that pointer to
8650 * MarshalNativeToManaged.
8651 */
8652 csig->ret = &mono_defaults.int_class->byval_arg;
8653 }
8654
8655 /* we first do all conversions */
8656 tmp_locals = alloca (sizeof (int) * sig->param_count);
8657 m.orig_conv_args = alloca (sizeof (int) * (sig->param_count + 1));
8658
8659 for (i = 0; i < sig->param_count; i ++) {
8660 tmp_locals [i] = emit_marshal (&m, i + sig->hasthis, sig->params [i], mspecs [i + 1], 0, &csig->params [i], MARSHAL_ACTION_CONV_IN);
8661 }
8662
8663 /* push all arguments */
8664
8665 if (sig->hasthis)
8666 mono_mb_emit_byte (mb, CEE_LDARG_0);
8667
8668 for (i = 0; i < sig->param_count; i++) {
8669 emit_marshal (&m, i + sig->hasthis, sig->params [i], mspecs [i + 1], tmp_locals [i], NULL, MARSHAL_ACTION_PUSH);
8670 }
8671
8672 /* call the native method */
8673 if (MONO_CLASS_IS_IMPORT (mb->method->klass)) {
8674 #ifndef DISABLE_COM
8675 mono_mb_emit_cominterop_call (mb, csig, &piinfo->method);
8676 #else
8677 g_assert_not_reached ();
8678 #endif
8679 }
8680 else {
8681 if (aot) {
8682 /* Reuse the ICALL_ADDR opcode for pinvokes too */
8683 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
8684 mono_mb_emit_op (mb, CEE_MONO_ICALL_ADDR, &piinfo->method);
8685 mono_mb_emit_calli (mb, csig);
8686 } else {
8687 mono_mb_emit_native_call (mb, csig, func);
8688 }
8689 }
8690
8691 /* Set LastError if needed */
8692 if (piinfo->piflags & PINVOKE_ATTRIBUTE_SUPPORTS_LAST_ERROR) {
8693 if (!get_last_error_sig) {
8694 get_last_error_sig = mono_metadata_signature_alloc (mono_defaults.corlib, 0);
8695 get_last_error_sig->ret = &mono_defaults.int_class->byval_arg;
8696 get_last_error_sig->pinvoke = 1;
8697 }
8698
8699 #ifdef PLATFORM_WIN32
8700 /*
8701 * Have to call GetLastError () early and without a wrapper, since various runtime components could
8702 * clobber its value.
8703 */
8704 mono_mb_emit_native_call (mb, get_last_error_sig, GetLastError);
8705 mono_mb_emit_icall (mb, mono_marshal_set_last_error_windows);
8706 #else
8707 mono_mb_emit_icall (mb, mono_marshal_set_last_error);
8708 #endif
8709 }
8710
8711 /* convert the result */
8712 if (!sig->ret->byref) {
8713 MonoMarshalSpec *spec = mspecs [0];
8714 type = sig->ret->type;
8715
8716 if (spec && spec->native == MONO_NATIVE_CUSTOM) {
8717 emit_marshal (&m, 0, sig->ret, spec, 0, NULL, MARSHAL_ACTION_CONV_RESULT);
8718 } else {
8719
8720 handle_enum:
8721 switch (type) {
8722 case MONO_TYPE_VOID:
8723 break;
8724 case MONO_TYPE_VALUETYPE:
8725 klass = sig->ret->data.klass;
8726 if (klass->enumtype) {
8727 type = sig->ret->data.klass->enum_basetype->type;
8728 goto handle_enum;
8729 }
8730 emit_marshal (&m, 0, sig->ret, spec, 0, NULL, MARSHAL_ACTION_CONV_RESULT);
8731 break;
8732 case MONO_TYPE_I1:
8733 case MONO_TYPE_U1:
8734 case MONO_TYPE_I2:
8735 case MONO_TYPE_U2:
8736 case MONO_TYPE_I4:
8737 case MONO_TYPE_U4:
8738 case MONO_TYPE_I:
8739 case MONO_TYPE_U:
8740 case MONO_TYPE_R4:
8741 case MONO_TYPE_R8:
8742 case MONO_TYPE_I8:
8743 case MONO_TYPE_U8:
8744 case MONO_TYPE_FNPTR:
8745 case MONO_TYPE_STRING:
8746 case MONO_TYPE_CLASS:
8747 case MONO_TYPE_OBJECT:
8748 case MONO_TYPE_BOOLEAN:
8749 case MONO_TYPE_ARRAY:
8750 case MONO_TYPE_SZARRAY:
8751 case MONO_TYPE_CHAR:
8752 case MONO_TYPE_PTR:
8753 case MONO_TYPE_GENERICINST:
8754 emit_marshal (&m, 0, sig->ret, spec, 0, NULL, MARSHAL_ACTION_CONV_RESULT);
8755 break;
8756 case MONO_TYPE_TYPEDBYREF:
8757 default:
8758 g_warning ("return type 0x%02x unknown", sig->ret->type);
8759 g_assert_not_reached ();
8760 }
8761 }
8762 } else {
8763 mono_mb_emit_stloc (mb, 3);
8764 }
8765
8766 /*
8767 * Need to call this after converting the result since MONO_VTADDR needs
8768 * to be adjacent to the call instruction.
8769 */
8770 if (check_exceptions)
8771 emit_thread_interrupt_checkpoint (mb);
8772
8773 /* we need to convert byref arguments back and free string arrays */
8774 for (i = 0; i < sig->param_count; i++) {
8775 MonoType *t = sig->params [i];
8776 MonoMarshalSpec *spec = mspecs [i + 1];
8777
8778 argnum = i + sig->hasthis;
8779
8780 if (spec && ((spec->native == MONO_NATIVE_CUSTOM) || (spec->native == MONO_NATIVE_ASANY))) {
8781 emit_marshal (&m, argnum, t, spec, tmp_locals [i], NULL, MARSHAL_ACTION_CONV_OUT);
8782 continue;
8783 }
8784
8785 switch (t->type) {
8786 case MONO_TYPE_STRING:
8787 case MONO_TYPE_VALUETYPE:
8788 case MONO_TYPE_CLASS:
8789 case MONO_TYPE_OBJECT:
8790 case MONO_TYPE_SZARRAY:
8791 case MONO_TYPE_BOOLEAN:
8792 emit_marshal (&m, argnum, t, spec, tmp_locals [i], NULL, MARSHAL_ACTION_CONV_OUT);
8793 break;
8794 }
8795 }
8796
8797 if (!MONO_TYPE_IS_VOID(sig->ret))
8798 mono_mb_emit_ldloc (mb, 3);
8799
8800 mono_mb_emit_byte (mb, CEE_RET);
8801 }
8802
8803 /**
8804 * mono_marshal_get_native_wrapper:
8805 * @method: The MonoMethod to wrap.
8806 * @check_exceptions: Whenever to check for pending exceptions
8807 *
8808 * generates IL code for the pinvoke wrapper (the generated method
8809 * calls the unmanaged code in piinfo->addr)
8810 */
8811 MonoMethod *
8812 mono_marshal_get_native_wrapper (MonoMethod *method, gboolean check_exceptions, gboolean aot)
8813 {
8814 MonoMethodSignature *sig, *csig;
8815 MonoMethodPInvoke *piinfo = (MonoMethodPInvoke *) method;
8816 MonoMethodBuilder *mb;
8817 MonoMarshalSpec **mspecs;
8818 MonoMethod *res;
8819 GHashTable *cache;
8820 gboolean pinvoke = FALSE;
8821 gpointer iter;
8822 int i;
8823 const char *exc_class = "MissingMethodException";
8824 const char *exc_arg = NULL;
8825
8826 g_assert (method != NULL);
8827 g_assert (mono_method_signature (method)->pinvoke);
8828
8829 cache = method->klass->image->native_wrapper_cache;
8830 if ((res = mono_marshal_find_in_cache (cache, method)))
8831 return res;
8832
8833 if (MONO_CLASS_IS_IMPORT (method->klass)) {
8834 #ifndef DISABLE_COM
8835 return cominterop_get_native_wrapper (method);
8836 #else
8837 g_assert_not_reached ();
8838 #endif
8839 }
8840
8841 sig = mono_method_signature (method);
8842
8843 if (!(method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) &&
8844 (method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL))
8845 pinvoke = TRUE;
8846
8847 if (!piinfo->addr) {
8848 if (pinvoke)
8849 if (method->iflags & METHOD_IMPL_ATTRIBUTE_NATIVE)
8850 exc_arg = "Method contains unsupported native code";
8851 else
8852 mono_lookup_pinvoke_call (method, &exc_class, &exc_arg);
8853 else
8854 piinfo->addr = mono_lookup_internal_call (method);
8855 }
8856
8857 /* hack - redirect certain string constructors to CreateString */
8858 if (piinfo->addr == ves_icall_System_String_ctor_RedirectToCreateString) {
8859 g_assert (!pinvoke);
8860 g_assert (method->string_ctor);
8861 g_assert (sig->hasthis);
8862
8863 /* CreateString returns a value */
8864 csig = signature_dup (method->klass->image, sig);
8865 csig->ret = &mono_defaults.string_class->byval_arg;
8866 csig->pinvoke = 0;
8867
8868 iter = NULL;
8869 while ((res = mono_class_get_methods (mono_defaults.string_class, &iter))) {
8870 if (!strcmp ("CreateString", res->name) &&
8871 mono_metadata_signature_equal (csig, mono_method_signature (res))) {
8872
8873 g_assert (!(res->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL));
8874 g_assert (!(res->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL));
8875
8876 /* create a wrapper to preserve .ctor in stack trace */
8877 mb = mono_mb_new (method->klass, method->name, MONO_WRAPPER_MANAGED_TO_MANAGED);
8878
8879 mono_mb_emit_byte (mb, CEE_LDARG_0);
8880 for (i = 1; i <= csig->param_count; i++)
8881 mono_mb_emit_ldarg (mb, i);
8882 mono_mb_emit_managed_call (mb, res, NULL);
8883 mono_mb_emit_byte (mb, CEE_RET);
8884
8885 /* use native_wrapper_cache because internal calls are looked up there */
8886 res = mono_mb_create_and_cache (cache, method,
8887 mb, csig, csig->param_count + 1);
8888
8889 mono_mb_free (mb);
8890
8891 return res;
8892 }
8893 }
8894
8895 /* exception will be thrown */
8896 piinfo->addr = NULL;
8897 g_warning ("cannot find CreateString for .ctor");
8898 }
8899
8900 mb = mono_mb_new (method->klass, method->name, MONO_WRAPPER_MANAGED_TO_NATIVE);
8901
8902 mb->method->save_lmf = 1;
8903
8904 /*
8905 * In AOT mode and embedding scenarios, it is possible that the icall is not
8906 * registered in the runtime doing the AOT compilation.
8907 */
8908 if (!piinfo->addr && !aot) {
8909 mono_mb_emit_exception (mb, exc_class, exc_arg);
8910 csig = signature_dup (method->klass->image, sig);
8911 csig->pinvoke = 0;
8912 res = mono_mb_create_and_cache (cache, method,
8913 mb, csig, csig->param_count + 16);
8914 mono_mb_free (mb);
8915 return res;
8916 }
8917
8918 /* internal calls: we simply push all arguments and call the method (no conversions) */
8919 if (method->iflags & (METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL | METHOD_IMPL_ATTRIBUTE_RUNTIME)) {
8920
8921 /* hack - string constructors returns a value */
8922 if (method->string_ctor) {
8923 csig = signature_dup (method->klass->image, sig);
8924 csig->ret = &mono_defaults.string_class->byval_arg;
8925 } else
8926 csig = sig;
8927
8928 if (sig->hasthis)
8929 mono_mb_emit_byte (mb, CEE_LDARG_0);
8930
8931 for (i = 0; i < sig->param_count; i++)
8932 mono_mb_emit_ldarg (mb, i + sig->hasthis);
8933
8934 if (aot) {
8935 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
8936 mono_mb_emit_op (mb, CEE_MONO_ICALL_ADDR, &piinfo->method);
8937 mono_mb_emit_calli (mb, csig);
8938 } else {
8939 g_assert (piinfo->addr);
8940 mono_mb_emit_native_call (mb, csig, piinfo->addr);
8941 }
8942 if (check_exceptions)
8943 emit_thread_interrupt_checkpoint (mb);
8944 mono_mb_emit_byte (mb, CEE_RET);
8945
8946 csig = signature_dup (method->klass->image, csig);
8947 csig->pinvoke = 0;
8948 res = mono_mb_create_and_cache (cache, method,
8949 mb, csig, csig->param_count + 16);
8950 mono_mb_free (mb);
8951 return res;
8952 }
8953
8954 g_assert (pinvoke);
8955 if (!aot)
8956 g_assert (piinfo->addr);
8957
8958 mspecs = g_new (MonoMarshalSpec*, sig->param_count + 1);
8959 mono_method_get_marshal_info (method, mspecs);
8960
8961 mono_marshal_emit_native_wrapper (mb->method->klass->image, mb, sig, piinfo, mspecs, piinfo->addr, aot, check_exceptions);
8962
8963 csig = signature_dup (method->klass->image, sig);
8964 csig->pinvoke = 0;
8965 res = mono_mb_create_and_cache (cache, method,
8966 mb, csig, csig->param_count + 16);
8967 mono_mb_free (mb);
8968
8969 for (i = sig->param_count; i >= 0; i--)
8970 if (mspecs [i])
8971 mono_metadata_free_marshal_spec (mspecs [i]);
8972 g_free (mspecs);
8973
8974 /* printf ("CODE FOR %s: \n%s.\n", mono_method_full_name (res, TRUE), mono_disasm_code (0, res, ((MonoMethodNormal*)res)->header->code, ((MonoMethodNormal*)res)->header->code + ((MonoMethodNormal*)res)->header->code_size)); */
8975
8976 return res;
8977 }
8978
8979 /**
8980 * mono_marshal_get_native_func_wrapper:
8981 * @image: The image to use for memory allocation and for looking up custom marshallers.
8982 * @sig: The signature of the function
8983 * @func: The native function to wrap
8984 *
8985 * Returns a wrapper method around native functions, similar to the pinvoke
8986 * wrapper.
8987 */
8988 MonoMethod *
8989 mono_marshal_get_native_func_wrapper (MonoImage *image, MonoMethodSignature *sig,
8990 MonoMethodPInvoke *piinfo, MonoMarshalSpec **mspecs, gpointer func)
8991 {
8992 MonoMethodSignature *csig;
8993
8994 MonoMethodBuilder *mb;
8995 MonoMethod *res;
8996 GHashTable *cache;
8997 char *name;
8998
8999 cache = image->native_wrapper_cache;
9000 if ((res = mono_marshal_find_in_cache (cache, func)))
9001 return res;
9002
9003 name = g_strdup_printf ("wrapper_native_%p", func);
9004 mb = mono_mb_new (mono_defaults.object_class, name, MONO_WRAPPER_MANAGED_TO_NATIVE);
9005 mb->method->save_lmf = 1;
9006
9007 mono_marshal_emit_native_wrapper (image, mb, sig, piinfo, mspecs, func, FALSE, TRUE);
9008
9009 csig = signature_dup (image, sig);
9010 csig->pinvoke = 0;
9011 res = mono_mb_create_and_cache (cache, func,
9012 mb, csig, csig->param_count + 16);
9013 mono_mb_free (mb);
9014
9015 /* printf ("CODE FOR %s: \n%s.\n", mono_method_full_name (res, TRUE), mono_disasm_code (0, res, ((MonoMethodNormal*)res)->header->code, ((MonoMethodNormal*)res)->header->code + ((MonoMethodNormal*)res)->header->code_size)); */
9016
9017 return res;
9018 }
9019
9020 /* FIXME: moving GC */
9021 static void
9022 mono_marshal_emit_managed_wrapper (MonoMethodBuilder *mb, MonoMethodSignature *invoke_sig, MonoMarshalSpec **mspecs, EmitMarshalContext* m, MonoMethod *method, MonoObject* this)
9023 {
9024 MonoMethodSignature *sig, *csig;
9025 int i, *tmp_locals;
9026
9027 sig = m->sig;
9028 csig = m->csig;
9029
9030 /* allocate local 0 (pointer) src_ptr */
9031 mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
9032 /* allocate local 1 (pointer) dst_ptr */
9033 mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
9034 /* allocate local 2 (boolean) delete_old */
9035 mono_mb_add_local (mb, &mono_defaults.boolean_class->byval_arg);
9036
9037 if (!MONO_TYPE_IS_VOID(sig->ret)) {
9038 /* allocate local 3 to store the return value */
9039 mono_mb_add_local (mb, sig->ret);
9040 }
9041
9042 mono_mb_emit_icon (mb, 0);
9043 mono_mb_emit_stloc (mb, 2);
9044
9045 /* we first do all conversions */
9046 tmp_locals = alloca (sizeof (int) * sig->param_count);
9047 for (i = 0; i < sig->param_count; i ++) {
9048 MonoType *t = sig->params [i];
9049
9050 switch (t->type) {
9051 case MONO_TYPE_OBJECT:
9052 case MONO_TYPE_CLASS:
9053 case MONO_TYPE_VALUETYPE:
9054 case MONO_TYPE_ARRAY:
9055 case MONO_TYPE_SZARRAY:
9056 case MONO_TYPE_STRING:
9057 tmp_locals [i] = emit_marshal (m, i, sig->params [i], mspecs [i + 1], 0, &csig->params [i], MARSHAL_ACTION_MANAGED_CONV_IN);
9058
9059 break;
9060 default:
9061 tmp_locals [i] = 0;
9062 break;
9063 }
9064 }
9065
9066 emit_thread_interrupt_checkpoint (mb);
9067
9068 /* fixme: howto handle this ? */
9069 if (sig->hasthis) {
9070 if (this) {
9071 /* FIXME: need a solution for the moving GC here */
9072 mono_mb_emit_ptr (mb, this);
9073 } else {
9074 /* fixme: */
9075 g_assert_not_reached ();
9076 }
9077 }
9078
9079 for (i = 0; i < sig->param_count; i++) {
9080 MonoType *t = sig->params [i];
9081
9082 if (tmp_locals [i]) {
9083 if (t->byref)
9084 mono_mb_emit_ldloc_addr (mb, tmp_locals [i]);
9085 else
9086 mono_mb_emit_ldloc (mb, tmp_locals [i]);
9087 }
9088 else
9089 mono_mb_emit_ldarg (mb, i);
9090 }
9091
9092 mono_mb_emit_managed_call (mb, method, NULL);
9093
9094 if (mspecs [0] && mspecs [0]->native == MONO_NATIVE_CUSTOM) {
9095 emit_marshal (m, 0, sig->ret, mspecs [0], 0, NULL, MARSHAL_ACTION_MANAGED_CONV_RESULT);
9096 }
9097 else
9098 if (!sig->ret->byref) {
9099 switch (sig->ret->type) {
9100 case MONO_TYPE_VOID:
9101 break;
9102 case MONO_TYPE_BOOLEAN:
9103 case MONO_TYPE_I1:
9104 case MONO_TYPE_U1:
9105 case MONO_TYPE_CHAR:
9106 case MONO_TYPE_I2:
9107 case MONO_TYPE_U2:
9108 case MONO_TYPE_I4:
9109 case MONO_TYPE_U4:
9110 case MONO_TYPE_I:
9111 case MONO_TYPE_U:
9112 case MONO_TYPE_PTR:
9113 case MONO_TYPE_R4:
9114 case MONO_TYPE_R8:
9115 case MONO_TYPE_I8:
9116 case MONO_TYPE_U8:
9117 case MONO_TYPE_OBJECT:
9118 mono_mb_emit_stloc (mb, 3);
9119 break;
9120 case MONO_TYPE_STRING:
9121 csig->ret = &mono_defaults.int_class->byval_arg;
9122 emit_marshal (m, 0, sig->ret, mspecs [0], 0, NULL, MARSHAL_ACTION_MANAGED_CONV_RESULT);
9123 break;
9124 case MONO_TYPE_VALUETYPE:
9125 case MONO_TYPE_CLASS:
9126 case MONO_TYPE_SZARRAY:
9127 emit_marshal (m, 0, sig->ret, mspecs [0], 0, NULL, MARSHAL_ACTION_MANAGED_CONV_RESULT);
9128 break;
9129 default:
9130 g_warning ("return type 0x%02x unknown", sig->ret->type);
9131 g_assert_not_reached ();
9132 }
9133 } else {
9134 mono_mb_emit_stloc (mb, 3);
9135 }
9136
9137 /* Convert byref arguments back */
9138 for (i = 0; i < sig->param_count; i ++) {
9139 MonoType *t = sig->params [i];
9140 MonoMarshalSpec *spec = mspecs [i + 1];
9141
9142 if (spec && spec->native == MONO_NATIVE_CUSTOM) {
9143 emit_marshal (m, i, t, mspecs [i + 1], tmp_locals [i], NULL, MARSHAL_ACTION_MANAGED_CONV_OUT);
9144 }
9145 else if (t->byref) {
9146 switch (t->type) {
9147 case MONO_TYPE_CLASS:
9148 case MONO_TYPE_VALUETYPE:
9149 case MONO_TYPE_OBJECT:
9150 case MONO_TYPE_STRING:
9151 emit_marshal (m, i, t, mspecs [i + 1], tmp_locals [i], NULL, MARSHAL_ACTION_MANAGED_CONV_OUT);
9152 break;
9153 }
9154 }
9155 else if (invoke_sig->params [i]->attrs & PARAM_ATTRIBUTE_OUT) {
9156 /* The [Out] information is encoded in the delegate signature */
9157 switch (t->type) {
9158 case MONO_TYPE_SZARRAY:
9159 case MONO_TYPE_CLASS:
9160 case MONO_TYPE_VALUETYPE:
9161 emit_marshal (m, i, invoke_sig->params [i], mspecs [i + 1], tmp_locals [i], NULL, MARSHAL_ACTION_MANAGED_CONV_OUT);
9162 break;
9163 default:
9164 g_assert_not_reached ();
9165 }
9166 }
9167 }
9168
9169 if (m->retobj_var) {
9170 mono_mb_emit_ldloc (mb, m->retobj_var);
9171 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
9172 mono_mb_emit_op (mb, CEE_MONO_RETOBJ, m->retobj_class);
9173 }
9174 else {
9175 if (!MONO_TYPE_IS_VOID(sig->ret))
9176 mono_mb_emit_ldloc (mb, 3);
9177 mono_mb_emit_byte (mb, CEE_RET);
9178 }
9179 }
9180
9181
9182 static void
9183 mono_marshal_set_callconv_from_modopt (MonoMethod *method, MonoMethodSignature *csig)
9184 {
9185 MonoMethodSignature *sig;
9186 int i;
9187
9188 #ifdef PLATFORM_WIN32
9189 /*
9190 * Under windows, delegates passed to native code must use the STDCALL
9191 * calling convention.
9192 */
9193 csig->call_convention = MONO_CALL_STDCALL;
9194 #endif
9195
9196 sig = mono_method_signature (method);
9197
9198 /* Change default calling convention if needed */
9199 /* Why is this a modopt ? */
9200 if (sig->ret && sig->ret->num_mods) {
9201 for (i = 0; i < sig->ret->num_mods; ++i) {
9202 MonoClass *cmod_class = mono_class_get (method->klass->image, sig->ret->modifiers [i].token);
9203 g_assert (cmod_class);
9204 if ((cmod_class->image == mono_defaults.corlib) && !strcmp (cmod_class->name_space, "System.Runtime.CompilerServices")) {
9205 if (!strcmp (cmod_class->name, "CallConvCdecl"))
9206 csig->call_convention = MONO_CALL_C;
9207 else if (!strcmp (cmod_class->name, "CallConvStdcall"))
9208 csig->call_convention = MONO_CALL_STDCALL;
9209 else if (!strcmp (cmod_class->name, "CallConvFastcall"))
9210 csig->call_convention = MONO_CALL_FASTCALL;
9211 else if (!strcmp (cmod_class->name, "CallConvThiscall"))
9212 csig->call_convention = MONO_CALL_THISCALL;
9213 }
9214 }
9215 }
9216 }
9217
9218 /*
9219 * generates IL code to call managed methods from unmanaged code
9220 */
9221 MonoMethod *
9222 mono_marshal_get_managed_wrapper (MonoMethod *method, MonoClass *delegate_klass, MonoObject *this)
9223 {
9224 static MonoClass *UnmanagedFunctionPointerAttribute;
9225 MonoMethodSignature *sig, *csig, *invoke_sig;
9226 MonoMethodBuilder *mb;
9227 MonoMethod *res, *invoke;
9228 MonoMarshalSpec **mspecs;
9229 MonoMethodPInvoke piinfo;
9230 GHashTable *cache;
9231 int i;
9232 EmitMarshalContext m;
9233
9234 g_assert (method != NULL);
9235 g_assert (!mono_method_signature (method)->pinvoke);
9236
9237 /*
9238 * FIXME: Should cache the method+delegate type pair, since the same method
9239 * could be called with different delegates, thus different marshalling
9240 * options.
9241 */
9242 cache = get_cache (&method->klass->image->managed_wrapper_cache, mono_aligned_addr_hash, NULL);
9243 if (!this && (res = mono_marshal_find_in_cache (cache, method)))
9244 return res;
9245
9246 invoke = mono_class_get_method_from_name (delegate_klass, "Invoke", mono_method_signature (method)->param_count);
9247 invoke_sig = mono_method_signature (invoke);
9248
9249 mspecs = g_new0 (MonoMarshalSpec*, mono_method_signature (invoke)->param_count + 1);
9250 mono_method_get_marshal_info (invoke, mspecs);
9251
9252 sig = mono_method_signature (method);
9253
9254 mb = mono_mb_new (method->klass, method->name, MONO_WRAPPER_NATIVE_TO_MANAGED);
9255
9256
9257 /* we copy the signature, so that we can modify it */
9258 if (this)
9259 /* Need to free this later */
9260 csig = mono_metadata_signature_dup (sig);
9261 else
9262 csig = signature_dup (method->klass->image, sig);
9263 csig->hasthis = 0;
9264 csig->pinvoke = 1;
9265
9266 m.mb = mb;
9267 m.sig = sig;
9268 m.piinfo = NULL;
9269 m.retobj_var = 0;
9270 m.csig = csig;
9271 m.image = method->klass->image;
9272
9273 mono_marshal_set_callconv_from_modopt (invoke, csig);
9274
9275 /* Handle the UnmanagedFunctionPointerAttribute */
9276 if (!UnmanagedFunctionPointerAttribute)
9277 UnmanagedFunctionPointerAttribute = mono_class_from_name (mono_defaults.corlib, "System.Runtime.InteropServices", "UnmanagedFunctionPointerAttribute");
9278
9279 /* The attribute is only available in Net 2.0 */
9280 if (UnmanagedFunctionPointerAttribute) {
9281 MonoReflectionUnmanagedFunctionPointerAttribute *attr;
9282 MonoCustomAttrInfo *cinfo;
9283
9284 /*
9285 * The pinvoke attributes are stored in a real custom attribute so we have to
9286 * construct it.
9287 */
9288 cinfo = mono_custom_attrs_from_class (delegate_klass);
9289 if (cinfo) {
9290 attr = (MonoReflectionUnmanagedFunctionPointerAttribute*)mono_custom_attrs_get_attr (cinfo, UnmanagedFunctionPointerAttribute);
9291 if (attr) {
9292 memset (&piinfo, 0, sizeof (piinfo));
9293 m.piinfo = &piinfo;
9294 piinfo.piflags = (attr->call_conv << 8) | (attr->charset ? (attr->charset - 1) * 2 : 1) | attr->set_last_error;
9295
9296 csig->call_convention = attr->call_conv - 1;
9297 }
9298 if (!cinfo->cached)
9299 mono_custom_attrs_free (cinfo);
9300 }
9301 }
9302
9303 mono_marshal_emit_managed_wrapper (mb, invoke_sig, mspecs, &m, method, this);
9304
9305 if (!this)
9306 res = mono_mb_create_and_cache (cache, method,
9307 mb, csig, sig->param_count + 16);
9308 else {
9309 mb->dynamic = 1;
9310 res = mono_mb_create_method (mb, csig, sig->param_count + 16);
9311 }
9312 mono_mb_free (mb);
9313
9314 for (i = mono_method_signature (invoke)->param_count; i >= 0; i--)
9315 if (mspecs [i])
9316 mono_metadata_free_marshal_spec (mspecs [i]);
9317 g_free (mspecs);
9318
9319 /* printf ("CODE FOR %s: \n%s.\n", mono_method_full_name (res, TRUE), mono_disasm_code (0, res, ((MonoMethodNormal*)res)->header->code, ((MonoMethodNormal*)res)->header->code + ((MonoMethodNormal*)res)->header->code_size)); */
9320
9321 return res;
9322 }
9323
9324 gpointer
9325 mono_marshal_get_vtfixup_ftnptr (MonoImage *image, guint32 token, guint16 type)
9326 {
9327 MonoMethod *method;
9328 MonoMethodSignature *sig;
9329 MonoMethodBuilder *mb;
9330 int i, param_count;
9331
9332 g_assert (token);
9333
9334 method = mono_get_method (image, token, NULL);
9335 g_assert (method);
9336
9337 if (type & (VTFIXUP_TYPE_FROM_UNMANAGED | VTFIXUP_TYPE_FROM_UNMANAGED_RETAIN_APPDOMAIN)) {
9338 MonoMethodSignature *csig;
9339 MonoMarshalSpec **mspecs;
9340 EmitMarshalContext m;
9341
9342 sig = mono_method_signature (method);
9343 g_assert (!sig->hasthis);
9344
9345 mspecs = g_new0 (MonoMarshalSpec*, sig->param_count + 1);
9346 mono_method_get_marshal_info (method, mspecs);
9347
9348 mb = mono_mb_new (method->klass, method->name, MONO_WRAPPER_NATIVE_TO_MANAGED);
9349 csig = signature_dup (image, sig);
9350 csig->hasthis = 0;
9351 csig->pinvoke = 1;
9352
9353 m.mb = mb;
9354 m.sig = sig;
9355 m.piinfo = NULL;
9356 m.retobj_var = 0;
9357 m.csig = csig;
9358 m.image = image;
9359
9360 mono_marshal_set_callconv_from_modopt (method, csig);
9361
9362 /* FIXME: Implement VTFIXUP_TYPE_FROM_UNMANAGED_RETAIN_APPDOMAIN. */
9363
9364 mono_marshal_emit_managed_wrapper (mb, sig, mspecs, &m, method, NULL);
9365
9366 mb->dynamic = 1;
9367 method = mono_mb_create_method (mb, csig, sig->param_count + 16);
9368 mono_mb_free (mb);
9369
9370 for (i = sig->param_count; i >= 0; i--)
9371 if (mspecs [i])
9372 mono_metadata_free_marshal_spec (mspecs [i]);
9373 g_free (mspecs);
9374
9375 return mono_compile_method (method);
9376 }
9377
9378 sig = mono_method_signature (method);
9379 mb = mono_mb_new (method->klass, method->name, MONO_WRAPPER_MANAGED_TO_MANAGED);
9380
9381 param_count = sig->param_count + sig->hasthis;
9382 for (i = 0; i < param_count; i++)
9383 mono_mb_emit_ldarg (mb, i);
9384
9385 if (type & VTFIXUP_TYPE_CALL_MOST_DERIVED)
9386 mono_mb_emit_op (mb, CEE_CALLVIRT, method);
9387 else
9388 mono_mb_emit_op (mb, CEE_CALL, method);
9389 mono_mb_emit_byte (mb, CEE_RET);
9390
9391 mb->dynamic = 1;
9392 method = mono_mb_create_method (mb, sig, param_count);
9393 mono_mb_free (mb);
9394
9395 return mono_compile_method (method);
9396 }
9397
9398 static MonoReflectionType *
9399 type_from_handle (MonoType *handle)
9400 {
9401 MonoDomain *domain = mono_domain_get ();
9402 MonoClass *klass = mono_class_from_mono_type (handle);
9403
9404 MONO_ARCH_SAVE_REGS;
9405
9406 mono_class_init (klass);
9407 return mono_type_get_object (domain, handle);
9408 }
9409
9410 /*
9411 * mono_marshal_get_isinst:
9412 * @klass: the type of the field
9413 *
9414 * This method generates a function which can be used to check if an object is
9415 * an instance of the given type, icluding the case where the object is a proxy.
9416 * The generated function has the following signature:
9417 * MonoObject* __isinst_wrapper_ (MonoObject *obj)
9418 */
9419 MonoMethod *
9420 mono_marshal_get_isinst (MonoClass *klass)
9421 {
9422 static MonoMethodSignature *isint_sig = NULL;
9423 GHashTable *cache;
9424 MonoMethod *res;
9425 int pos_was_ok, pos_failed, pos_end, pos_end2;
9426 char *name;
9427 MonoMethodBuilder *mb;
9428
9429 cache = get_cache (&klass->image->isinst_cache, mono_aligned_addr_hash, NULL);
9430 if ((res = mono_marshal_find_in_cache (cache, klass)))
9431 return res;
9432
9433 if (!isint_sig) {
9434 isint_sig = mono_metadata_signature_alloc (mono_defaults.corlib, 1);
9435 isint_sig->params [0] = &mono_defaults.object_class->byval_arg;
9436 isint_sig->ret = &mono_defaults.object_class->byval_arg;
9437 isint_sig->pinvoke = 0;
9438 }
9439
9440 name = g_strdup_printf ("__isinst_wrapper_%s", klass->name);
9441 mb = mono_mb_new (mono_defaults.object_class, name, MONO_WRAPPER_ISINST);
9442 g_free (name);
9443
9444 mb->method->save_lmf = 1;
9445
9446 /* check if the object is a proxy that needs special cast */
9447 mono_mb_emit_ldarg (mb, 0);
9448 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
9449 mono_mb_emit_op (mb, CEE_MONO_CISINST, klass);
9450
9451 /* The result of MONO_ISINST can be:
9452 0) the type check succeeded
9453 1) the type check did not succeed
9454 2) a CanCastTo call is needed */
9455
9456 mono_mb_emit_byte (mb, CEE_DUP);
9457 pos_was_ok = mono_mb_emit_branch (mb, CEE_BRFALSE);
9458
9459 mono_mb_emit_byte (mb, CEE_LDC_I4_2);
9460 pos_failed = mono_mb_emit_branch (mb, CEE_BNE_UN);
9461
9462 /* get the real proxy from the transparent proxy*/
9463
9464 mono_mb_emit_ldarg (mb, 0);
9465 mono_mb_emit_managed_call (mb, mono_marshal_get_proxy_cancast (klass), NULL);
9466 pos_end = mono_mb_emit_branch (mb, CEE_BR);
9467
9468 /* fail */
9469
9470 mono_mb_patch_branch (mb, pos_failed);
9471 mono_mb_emit_byte (mb, CEE_LDNULL);
9472 pos_end2 = mono_mb_emit_branch (mb, CEE_BR);
9473
9474 /* success */
9475
9476 mono_mb_patch_branch (mb, pos_was_ok);
9477 mono_mb_emit_byte (mb, CEE_POP);
9478 mono_mb_emit_ldarg (mb, 0);
9479
9480 /* the end */
9481
9482 mono_mb_patch_branch (mb, pos_end);
9483 mono_mb_patch_branch (mb, pos_end2);
9484 mono_mb_emit_byte (mb, CEE_RET);
9485
9486 res = mono_mb_create_and_cache (cache, klass, mb, isint_sig, isint_sig->param_count + 16);
9487 mono_mb_free (mb);
9488
9489 return res;
9490 }
9491
9492 /*
9493 * mono_marshal_get_castclass:
9494 * @klass: the type of the field
9495 *
9496 * This method generates a function which can be used to cast an object to
9497 * an instance of the given type, icluding the case where the object is a proxy.
9498 * The generated function has the following signature:
9499 * MonoObject* __castclass_wrapper_ (MonoObject *obj)
9500 */
9501 MonoMethod *
9502 mono_marshal_get_castclass (MonoClass *klass)
9503 {
9504 static MonoMethodSignature *castclass_sig = NULL;
9505 GHashTable *cache;
9506 MonoMethod *res;
9507 int pos_was_ok, pos_was_ok2;
9508 char *name;
9509 MonoMethodBuilder *mb;
9510
9511 cache = get_cache (&klass->image->castclass_cache, mono_aligned_addr_hash, NULL);
9512 if ((res = mono_marshal_find_in_cache (cache, klass)))
9513 return res;
9514
9515 if (!castclass_sig) {
9516 castclass_sig = mono_metadata_signature_alloc (mono_defaults.corlib, 1);
9517 castclass_sig->params [0] = &mono_defaults.object_class->byval_arg;
9518 castclass_sig->ret = &mono_defaults.object_class->byval_arg;
9519 castclass_sig->pinvoke = 0;
9520 }
9521
9522 name = g_strdup_printf ("__castclass_wrapper_%s", klass->name);
9523 mb = mono_mb_new (mono_defaults.object_class, name, MONO_WRAPPER_CASTCLASS);
9524 g_free (name);
9525
9526 mb->method->save_lmf = 1;
9527
9528 /* check if the object is a proxy that needs special cast */
9529 mono_mb_emit_ldarg (mb, 0);
9530 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
9531 mono_mb_emit_op (mb, CEE_MONO_CCASTCLASS, klass);
9532
9533 /* The result of MONO_ISINST can be:
9534 0) the cast is valid
9535 1) cast of unknown proxy type
9536 or an exception if the cast is is invalid
9537 */
9538
9539 pos_was_ok = mono_mb_emit_branch (mb, CEE_BRFALSE);
9540
9541 /* get the real proxy from the transparent proxy*/
9542
9543 mono_mb_emit_ldarg (mb, 0);
9544 mono_mb_emit_managed_call (mb, mono_marshal_get_proxy_cancast (klass), NULL);
9545 pos_was_ok2 = mono_mb_emit_branch (mb, CEE_BRTRUE);
9546
9547 /* fail */
9548 mono_mb_emit_exception (mb, "InvalidCastException", NULL);
9549
9550 /* success */
9551 mono_mb_patch_branch (mb, pos_was_ok);
9552 mono_mb_patch_branch (mb, pos_was_ok2);
9553 mono_mb_emit_ldarg (mb, 0);
9554
9555 /* the end */
9556 mono_mb_emit_byte (mb, CEE_RET);
9557
9558 res = mono_mb_create_and_cache (cache, klass, mb, castclass_sig, castclass_sig->param_count + 16);
9559 mono_mb_free (mb);
9560
9561 return res;
9562 }
9563
9564 MonoMethod *
9565 mono_marshal_get_proxy_cancast (MonoClass *klass)
9566 {
9567 static MonoMethodSignature *isint_sig = NULL;
9568 GHashTable *cache;
9569 MonoMethod *res;
9570 int pos_failed, pos_end;
9571 char *name;
9572 MonoMethod *can_cast_to;
9573 MonoMethodDesc *desc;
9574 MonoMethodBuilder *mb;
9575
9576 cache = get_cache (&klass->image->proxy_isinst_cache, mono_aligned_addr_hash, NULL);
9577 if ((res = mono_marshal_find_in_cache (cache, klass)))
9578 return res;
9579
9580 if (!isint_sig) {
9581 isint_sig = mono_metadata_signature_alloc (mono_defaults.corlib, 1);
9582 isint_sig->params [0] = &mono_defaults.object_class->byval_arg;
9583 isint_sig->ret = &mono_defaults.object_class->byval_arg;
9584 isint_sig->pinvoke = 0;
9585 }
9586
9587 name = g_strdup_printf ("__proxy_isinst_wrapper_%s", klass->name);
9588 mb = mono_mb_new (mono_defaults.object_class, name, MONO_WRAPPER_PROXY_ISINST);
9589 g_free (name);
9590
9591 mb->method->save_lmf = 1;
9592
9593 /* get the real proxy from the transparent proxy*/
9594 mono_mb_emit_ldarg (mb, 0);
9595 mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoTransparentProxy, rp));
9596 mono_mb_emit_byte (mb, CEE_LDIND_REF);
9597
9598 /* get the reflection type from the type handle */
9599 mono_mb_emit_ptr (mb, &klass->byval_arg);
9600 mono_mb_emit_icall (mb, type_from_handle);
9601
9602 mono_mb_emit_ldarg (mb, 0);
9603
9604 /* make the call to CanCastTo (type, ob) */
9605 desc = mono_method_desc_new ("IRemotingTypeInfo:CanCastTo", FALSE);
9606 can_cast_to = mono_method_desc_search_in_class (desc, mono_defaults.iremotingtypeinfo_class);
9607 g_assert (can_cast_to);
9608 mono_method_desc_free (desc);
9609 mono_mb_emit_op (mb, CEE_CALLVIRT, can_cast_to);
9610
9611 pos_failed = mono_mb_emit_branch (mb, CEE_BRFALSE);
9612
9613 /* Upgrade the proxy vtable by calling: mono_upgrade_remote_class_wrapper (type, ob)*/
9614 mono_mb_emit_ptr (mb, &klass->byval_arg);
9615 mono_mb_emit_icall (mb, type_from_handle);
9616 mono_mb_emit_ldarg (mb, 0);
9617
9618 mono_mb_emit_icall (mb, mono_upgrade_remote_class_wrapper);
9619 emit_thread_interrupt_checkpoint (mb);
9620
9621 mono_mb_emit_ldarg (mb, 0);
9622 pos_end = mono_mb_emit_branch (mb, CEE_BR);
9623
9624 /* fail */
9625
9626 mono_mb_patch_branch (mb, pos_failed);
9627 mono_mb_emit_byte (mb, CEE_LDNULL);
9628
9629 /* the end */
9630
9631 mono_mb_patch_branch (mb, pos_end);
9632 mono_mb_emit_byte (mb, CEE_RET);
9633
9634 res = mono_mb_create_and_cache (cache, klass, mb, isint_sig, isint_sig->param_count + 16);
9635 mono_mb_free (mb);
9636
9637 return res;
9638 }
9639
9640 void
9641 mono_upgrade_remote_class_wrapper (MonoReflectionType *rtype, MonoTransparentProxy *tproxy)
9642 {
9643 MonoClass *klass;
9644 MonoDomain *domain = ((MonoObject*)tproxy)->vtable->domain;
9645 klass = mono_class_from_mono_type (rtype->type);
9646 mono_upgrade_remote_class (domain, (MonoObject*)tproxy, klass);
9647 }
9648
9649 /**
9650 * mono_marshal_get_struct_to_ptr:
9651 * @klass:
9652 *
9653 * generates IL code for StructureToPtr (object structure, IntPtr ptr, bool fDeleteOld)
9654 */
9655 MonoMethod *
9656 mono_marshal_get_struct_to_ptr (MonoClass *klass)
9657 {
9658 MonoMethodBuilder *mb;
9659 static MonoMethod *stoptr = NULL;
9660 MonoMethod *res;
9661
9662 g_assert (klass != NULL);
9663
9664 mono_marshal_load_type_info (klass);
9665
9666 if (klass->marshal_info->str_to_ptr)
9667 return klass->marshal_info->str_to_ptr;
9668
9669 if (!stoptr)
9670 stoptr = mono_class_get_method_from_name (mono_defaults.marshal_class, "StructureToPtr", 3);
9671 g_assert (stoptr);
9672
9673 mb = mono_mb_new (klass, stoptr->name, MONO_WRAPPER_UNKNOWN);
9674
9675 if (klass->blittable) {
9676 mono_mb_emit_byte (mb, CEE_LDARG_1);
9677 mono_mb_emit_byte (mb, CEE_LDARG_0);
9678 mono_mb_emit_ldflda (mb, sizeof (MonoObject));
9679 mono_mb_emit_icon (mb, mono_class_value_size (klass, NULL));
9680 mono_mb_emit_byte (mb, CEE_PREFIX1);
9681 mono_mb_emit_byte (mb, CEE_CPBLK);
9682 } else {
9683
9684 /* allocate local 0 (pointer) src_ptr */
9685 mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
9686 /* allocate local 1 (pointer) dst_ptr */
9687 mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
9688 /* allocate local 2 (boolean) delete_old */
9689 mono_mb_add_local (mb, &mono_defaults.boolean_class->byval_arg);
9690 mono_mb_emit_byte (mb, CEE_LDARG_2);
9691 mono_mb_emit_stloc (mb, 2);
9692
9693 /* initialize src_ptr to point to the start of object data */
9694 mono_mb_emit_byte (mb, CEE_LDARG_0);
9695 mono_mb_emit_ldflda (mb, sizeof (MonoObject));
9696 mono_mb_emit_stloc (mb, 0);
9697
9698 /* initialize dst_ptr */
9699 mono_mb_emit_byte (mb, CEE_LDARG_1);
9700 mono_mb_emit_stloc (mb, 1);
9701
9702 emit_struct_conv (mb, klass, FALSE);
9703 }
9704
9705 mono_mb_emit_byte (mb, CEE_RET);
9706
9707 res = mono_mb_create_method (mb, mono_signature_no_pinvoke (stoptr), 0);
9708 mono_mb_free (mb);
9709
9710 klass->marshal_info->str_to_ptr = res;
9711 return res;
9712 }
9713
9714 /**
9715 * mono_marshal_get_ptr_to_struct:
9716 * @klass:
9717 *
9718 * generates IL code for PtrToStructure (IntPtr src, object structure)
9719 */
9720 MonoMethod *
9721 mono_marshal_get_ptr_to_struct (MonoClass *klass)
9722 {
9723 MonoMethodBuilder *mb;
9724 static MonoMethodSignature *ptostr = NULL;
9725 MonoMethod *res;
9726
9727 g_assert (klass != NULL);
9728
9729 mono_marshal_load_type_info (klass);
9730
9731 if (klass->marshal_info->ptr_to_str)
9732 return klass->marshal_info->ptr_to_str;
9733
9734 if (!ptostr) {
9735 MonoMethodSignature *sig;
9736
9737 /* Create the signature corresponding to
9738 static void PtrToStructure (IntPtr ptr, object structure);
9739 defined in class/corlib/System.Runtime.InteropServices/Marshal.cs */
9740 sig = mono_create_icall_signature ("void ptr object");
9741 sig = signature_dup (mono_defaults.corlib, sig);
9742 sig->pinvoke = 0;
9743 mono_memory_barrier ();
9744 ptostr = sig;
9745 }
9746
9747 mb = mono_mb_new (klass, "PtrToStructure", MONO_WRAPPER_UNKNOWN);
9748
9749 if (klass->blittable) {
9750 mono_mb_emit_byte (mb, CEE_LDARG_1);
9751 mono_mb_emit_ldflda (mb, sizeof (MonoObject));
9752 mono_mb_emit_byte (mb, CEE_LDARG_0);
9753 mono_mb_emit_icon (mb, mono_class_value_size (klass, NULL));
9754 mono_mb_emit_byte (mb, CEE_PREFIX1);
9755 mono_mb_emit_byte (mb, CEE_CPBLK);
9756 } else {
9757
9758 /* allocate local 0 (pointer) src_ptr */
9759 mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
9760 /* allocate local 1 (pointer) dst_ptr */
9761 mono_mb_add_local (mb, &klass->this_arg);
9762
9763 /* initialize src_ptr to point to the start of object data */
9764 mono_mb_emit_byte (mb, CEE_LDARG_0);
9765 mono_mb_emit_stloc (mb, 0);
9766
9767 /* initialize dst_ptr */
9768 mono_mb_emit_byte (mb, CEE_LDARG_1);
9769 mono_mb_emit_op (mb, CEE_UNBOX, klass);
9770 mono_mb_emit_stloc (mb, 1);
9771
9772 emit_struct_conv (mb, klass, TRUE);
9773 }
9774
9775 mono_mb_emit_byte (mb, CEE_RET);
9776
9777 res = mono_mb_create_method (mb, ptostr, 0);
9778 mono_mb_free (mb);
9779
9780 klass->marshal_info->ptr_to_str = res;
9781 return res;
9782 }
9783
9784 /*
9785 * generates IL code for the synchronized wrapper: the generated method
9786 * calls METHOD while locking 'this' or the parent type.
9787 */
9788 MonoMethod *
9789 mono_marshal_get_synchronized_wrapper (MonoMethod *method)
9790 {
9791 static MonoMethod *enter_method, *exit_method, *gettypefromhandle_method;
9792 MonoMethodSignature *sig;
9793 MonoExceptionClause *clause;
9794 MonoMethodHeader *header;
9795 MonoMethodBuilder *mb;
9796 MonoMethod *res;
9797 GHashTable *cache;
9798 int i, pos, this_local, ret_local = 0;
9799
9800 g_assert (method);
9801
9802 if (method->wrapper_type == MONO_WRAPPER_SYNCHRONIZED)
9803 return method;
9804
9805 cache = get_cache (&method->klass->image->synchronized_cache, mono_aligned_addr_hash, NULL);
9806 if ((res = mono_marshal_find_in_cache (cache, method)))
9807 return res;
9808
9809 sig = signature_dup (method->klass->image, mono_method_signature (method));
9810 sig->pinvoke = 0;
9811
9812 mb = mono_mb_new (method->klass, method->name, MONO_WRAPPER_SYNCHRONIZED);
9813
9814 /* result */
9815 if (!MONO_TYPE_IS_VOID (sig->ret))
9816 ret_local = mono_mb_add_local (mb, sig->ret);
9817
9818 if (method->klass->valuetype && !(method->flags & MONO_METHOD_ATTR_STATIC)) {
9819 mono_class_set_failure (method->klass, MONO_EXCEPTION_TYPE_LOAD, NULL);
9820 /* This will throw the type load exception when the wrapper is compiled */
9821 mono_mb_emit_byte (mb, CEE_LDNULL);
9822 mono_mb_emit_op (mb, CEE_ISINST, method->klass);
9823 mono_mb_emit_byte (mb, CEE_POP);
9824
9825 if (!MONO_TYPE_IS_VOID (sig->ret))
9826 mono_mb_emit_ldloc (mb, ret_local);
9827 mono_mb_emit_byte (mb, CEE_RET);
9828
9829 res = mono_mb_create_and_cache (cache, method,
9830 mb, sig, sig->param_count + 16);
9831 mono_mb_free (mb);
9832
9833 return res;
9834 }
9835
9836 /* this */
9837 this_local = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
9838
9839 mono_loader_lock ();
9840 clause = mono_image_alloc0 (method->klass->image, sizeof (MonoExceptionClause));
9841 mono_loader_unlock ();
9842 clause->flags = MONO_EXCEPTION_CLAUSE_FINALLY;
9843
9844 if (!enter_method) {
9845 MonoMethodDesc *desc;
9846
9847 desc = mono_method_desc_new ("Monitor:Enter", FALSE);
9848 enter_method = mono_method_desc_search_in_class (desc, mono_defaults.monitor_class);
9849 g_assert (enter_method);
9850 mono_method_desc_free (desc);
9851
9852 desc = mono_method_desc_new ("Monitor:Exit", FALSE);
9853 exit_method = mono_method_desc_search_in_class (desc, mono_defaults.monitor_class);
9854 g_assert (exit_method);
9855 mono_method_desc_free (desc);
9856
9857 desc = mono_method_desc_new ("Type:GetTypeFromHandle", FALSE);
9858 gettypefromhandle_method = mono_method_desc_search_in_class (desc, mono_defaults.monotype_class->parent);
9859 g_assert (gettypefromhandle_method);
9860 mono_method_desc_free (desc);
9861 }
9862
9863 /* Push this or the type object */
9864 if (method->flags & METHOD_ATTRIBUTE_STATIC) {
9865 /* We have special handling for this in the JIT */
9866 int index = mono_mb_add_data (mb, method->klass);
9867 mono_mb_add_data (mb, mono_defaults.typehandle_class);
9868 mono_mb_emit_byte (mb, CEE_LDTOKEN);
9869 mono_mb_emit_i4 (mb, index);
9870
9871 mono_mb_emit_managed_call (mb, gettypefromhandle_method, NULL);
9872 }
9873 else
9874 mono_mb_emit_ldarg (mb, 0);
9875 mono_mb_emit_stloc (mb, this_local);
9876
9877 /* Call Monitor::Enter() */
9878 mono_mb_emit_ldloc (mb, this_local);
9879 mono_mb_emit_managed_call (mb, enter_method, NULL);
9880
9881 clause->try_offset = mono_mb_get_label (mb);
9882
9883 /* Call the method */
9884 if (sig->hasthis)
9885 mono_mb_emit_ldarg (mb, 0);
9886 for (i = 0; i < sig->param_count; i++)
9887 mono_mb_emit_ldarg (mb, i + (sig->hasthis == TRUE));
9888
9889 mono_mb_emit_managed_call (mb, method, NULL);
9890
9891 if (!MONO_TYPE_IS_VOID (sig->ret))
9892 mono_mb_emit_stloc (mb, ret_local);
9893
9894 pos = mono_mb_emit_branch (mb, CEE_LEAVE);
9895
9896 clause->try_len = mono_mb_get_pos (mb) - clause->try_offset;
9897 clause->handler_offset = mono_mb_get_label (mb);
9898
9899 /* Call Monitor::Exit() */
9900 mono_mb_emit_ldloc (mb, this_local);
9901 mono_mb_emit_managed_call (mb, exit_method, NULL);
9902 mono_mb_emit_byte (mb, CEE_ENDFINALLY);
9903
9904 clause->handler_len = mono_mb_get_pos (mb) - clause->handler_offset;
9905
9906 mono_mb_patch_branch (mb, pos);
9907 if (!MONO_TYPE_IS_VOID (sig->ret))
9908 mono_mb_emit_ldloc (mb, ret_local);
9909 mono_mb_emit_byte (mb, CEE_RET);
9910
9911 res = mono_mb_create_and_cache (cache, method,
9912 mb, sig, sig->param_count + 16);
9913 mono_mb_free (mb);
9914
9915 header = ((MonoMethodNormal *)res)->header;
9916 header->num_clauses = 1;
9917 header->clauses = clause;
9918
9919 return res;
9920 }
9921
9922
9923 /*
9924 * the returned method calls 'method' unboxing the this argument
9925 */
9926 MonoMethod *
9927 mono_marshal_get_unbox_wrapper (MonoMethod *method)
9928 {
9929 MonoMethodSignature *sig = mono_method_signature (method);
9930 int i;
9931 MonoMethodBuilder *mb;
9932 MonoMethod *res;
9933 GHashTable *cache;
9934
9935 cache = get_cache (&method->klass->image->unbox_wrapper_cache, mono_aligned_addr_hash, NULL);
9936 if ((res = mono_marshal_find_in_cache (cache, method)))
9937 return res;
9938
9939 mb = mono_mb_new (method->klass, method->name, MONO_WRAPPER_UNBOX);
9940
9941 g_assert (sig->hasthis);
9942
9943 mono_mb_emit_ldarg (mb, 0);
9944 mono_mb_emit_icon (mb, sizeof (MonoObject));
9945 mono_mb_emit_byte (mb, CEE_ADD);
9946 for (i = 0; i < sig->param_count; ++i)
9947 mono_mb_emit_ldarg (mb, i + 1);
9948 mono_mb_emit_managed_call (mb, method, NULL);
9949 mono_mb_emit_byte (mb, CEE_RET);
9950
9951 res = mono_mb_create_and_cache (cache, method,
9952 mb, sig, sig->param_count + 16);
9953 mono_mb_free (mb);
9954
9955 /* printf ("CODE FOR %s: \n%s.\n", mono_method_full_name (res, TRUE), mono_disasm_code (0, res, ((MonoMethodNormal*)res)->header->code, ((MonoMethodNormal*)res)->header->code + ((MonoMethodNormal*)res)->header->code_size)); */
9956
9957 return res;
9958 }
9959
9960 MonoMethod*
9961 mono_marshal_get_stelemref ()
9962 {
9963 static MonoMethod* ret = NULL;
9964 MonoMethodSignature *sig;
9965 MonoMethodBuilder *mb;
9966
9967 guint32 b1, b2, b3, b4;
9968 guint32 copy_pos;
9969 int aklass, vklass;
9970 int array_slot_addr;
9971
9972 if (ret)
9973 return ret;
9974
9975 mb = mono_mb_new (mono_defaults.object_class, "stelemref", MONO_WRAPPER_STELEMREF);
9976
9977
9978 sig = mono_metadata_signature_alloc (mono_defaults.corlib, 3);
9979
9980 /* void stelemref (void* array, int idx, void* value) */
9981 sig->ret = &mono_defaults.void_class->byval_arg;
9982 sig->params [0] = &mono_defaults.object_class->byval_arg;
9983 sig->params [1] = &mono_defaults.int_class->byval_arg; /* this is a natural sized int */
9984 sig->params [2] = &mono_defaults.object_class->byval_arg;
9985
9986 aklass = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
9987 vklass = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
9988 array_slot_addr = mono_mb_add_local (mb, &mono_defaults.object_class->this_arg);
9989
9990 /*
9991 the method:
9992 <ldelema (bound check)>
9993 if (!value)
9994 goto store;
9995
9996 aklass = array->vtable->klass->element_class;
9997 vklass = value->vtable->klass;
9998
9999 if (vklass->idepth < aklass->idepth)
10000 goto long;
10001
10002 if (vklass->supertypes [aklass->idepth - 1] != aklass)
10003 goto long;
10004
10005 store:
10006 *array_slot_addr = value;
10007 return;
10008
10009 long:
10010 if (mono_object_isinst (value, aklass))
10011 goto store;
10012
10013 throw new ArrayTypeMismatchException ();
10014 */
10015
10016 /* ldelema (implicit bound check) */
10017 mono_mb_emit_ldarg (mb, 0);
10018 mono_mb_emit_ldarg (mb, 1);
10019 mono_mb_emit_op (mb, CEE_LDELEMA, mono_defaults.object_class);
10020 mono_mb_emit_stloc (mb, array_slot_addr);
10021
10022 /* if (!value) goto do_store */
10023 mono_mb_emit_ldarg (mb, 2);
10024 b1 = mono_mb_emit_branch (mb, CEE_BRFALSE);
10025
10026 /* aklass = array->vtable->klass->element_class */
10027 mono_mb_emit_ldarg (mb, 0);
10028 mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoObject, vtable));
10029 mono_mb_emit_byte (mb, CEE_LDIND_I);
10030 mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoVTable, klass));
10031 mono_mb_emit_byte (mb, CEE_LDIND_I);
10032 mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoClass, element_class));
10033 mono_mb_emit_byte (mb, CEE_LDIND_I);
10034 mono_mb_emit_stloc (mb, aklass);
10035
10036 /* vklass = value->vtable->klass */
10037 mono_mb_emit_ldarg (mb, 2);
10038 mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoObject, vtable));
10039 mono_mb_emit_byte (mb, CEE_LDIND_I);
10040 mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoVTable, klass));
10041 mono_mb_emit_byte (mb, CEE_LDIND_I);
10042 mono_mb_emit_stloc (mb, vklass);
10043
10044 /* if (vklass->idepth < aklass->idepth) goto failue */
10045 mono_mb_emit_ldloc (mb, vklass);
10046 mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoClass, idepth));
10047 mono_mb_emit_byte (mb, CEE_LDIND_U2);
10048
10049 mono_mb_emit_ldloc (mb, aklass);
10050 mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoClass, idepth));
10051 mono_mb_emit_byte (mb, CEE_LDIND_U2);
10052
10053 b2 = mono_mb_emit_branch (mb, CEE_BLT_UN);
10054
10055 /* if (vklass->supertypes [aklass->idepth - 1] != aklass) goto failure */
10056 mono_mb_emit_ldloc (mb, vklass);
10057 mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoClass, supertypes));
10058 mono_mb_emit_byte (mb, CEE_LDIND_I);
10059
10060 mono_mb_emit_ldloc (mb, aklass);
10061 mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoClass, idepth));
10062 mono_mb_emit_byte (mb, CEE_LDIND_U2);
10063 mono_mb_emit_icon (mb, 1);
10064 mono_mb_emit_byte (mb, CEE_SUB);
10065 mono_mb_emit_icon (mb, sizeof (void*));
10066 mono_mb_emit_byte (mb, CEE_MUL);
10067 mono_mb_emit_byte (mb, CEE_ADD);
10068 mono_mb_emit_byte (mb, CEE_LDIND_I);
10069
10070 mono_mb_emit_ldloc (mb, aklass);
10071
10072 b3 = mono_mb_emit_branch (mb, CEE_BNE_UN);
10073
10074 copy_pos = mono_mb_get_label (mb);
10075 /* do_store */
10076 mono_mb_patch_branch (mb, b1);
10077 mono_mb_emit_ldloc (mb, array_slot_addr);
10078 mono_mb_emit_ldarg (mb, 2);
10079 mono_mb_emit_byte (mb, CEE_STIND_REF);
10080
10081 mono_mb_emit_byte (mb, CEE_RET);
10082
10083 /* the hard way */
10084 mono_mb_patch_branch (mb, b2);
10085 mono_mb_patch_branch (mb, b3);
10086
10087 mono_mb_emit_ldarg (mb, 2);
10088 mono_mb_emit_ldloc (mb, aklass);
10089 mono_mb_emit_icall (mb, mono_object_isinst);
10090
10091 b4 = mono_mb_emit_branch (mb, CEE_BRTRUE);
10092 mono_mb_patch_addr (mb, b4, copy_pos - (b4 + 4));
10093 mono_mb_emit_exception (mb, "ArrayTypeMismatchException", NULL);
10094
10095 mono_mb_emit_byte (mb, CEE_RET);
10096 ret = mono_mb_create_method (mb, sig, 4);
10097 mono_mb_free (mb);
10098 return ret;
10099 }
10100
10101 typedef struct {
10102 int rank;
10103 int elem_size;
10104 MonoMethod *method;
10105 } ArrayElemAddr;
10106
10107 /* LOCKING: vars accessed under the marshal lock */
10108 static ArrayElemAddr *elem_addr_cache = NULL;
10109 static int elem_addr_cache_size = 0;
10110 static int elem_addr_cache_next = 0;
10111
10112 /**
10113 * mono_marshal_get_array_address:
10114 * @rank: rank of the array type
10115 * @elem_size: size in bytes of an element of an array.
10116 *
10117 * Returns a MonoMethd that implements the code to get the address
10118 * of an element in a multi-dimenasional array of @rank dimensions.
10119 * The returned method takes an array as the first argument and then
10120 * @rank indexes for the @rank dimensions.
10121 */
10122 MonoMethod*
10123 mono_marshal_get_array_address (int rank, int elem_size)
10124 {
10125 MonoMethod *ret;
10126 MonoMethodBuilder *mb;
10127 MonoMethodSignature *sig;
10128 int i, bounds, ind, realidx;
10129 int branch_pos, *branch_positions;
10130 int cached;
10131
10132 ret = NULL;
10133 mono_marshal_lock ();
10134 for (i = 0; i < elem_addr_cache_next; ++i) {
10135 if (elem_addr_cache [i].rank == rank && elem_addr_cache [i].elem_size == elem_size) {
10136 ret = elem_addr_cache [i].method;
10137 break;
10138 }
10139 }
10140 mono_marshal_unlock ();
10141 if (ret)
10142 return ret;
10143
10144 branch_positions = g_new0 (int, rank);
10145
10146 sig = mono_metadata_signature_alloc (mono_defaults.corlib, 1 + rank);
10147
10148 /* void* address (void* array, int idx0, int idx1, int idx2, ...) */
10149 sig->ret = &mono_defaults.int_class->byval_arg;
10150 sig->params [0] = &mono_defaults.object_class->byval_arg;
10151 for (i = 0; i < rank; ++i) {
10152 sig->params [i + 1] = &mono_defaults.int32_class->byval_arg;
10153 }
10154
10155 mb = mono_mb_new (mono_defaults.object_class, "ElementAddr", MONO_WRAPPER_MANAGED_TO_MANAGED);
10156
10157 bounds = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
10158 ind = mono_mb_add_local (mb, &mono_defaults.int32_class->byval_arg);
10159 realidx = mono_mb_add_local (mb, &mono_defaults.int32_class->byval_arg);
10160
10161 /* bounds = array->bounds; */
10162 mono_mb_emit_ldarg (mb, 0);
10163 mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoArray, bounds));
10164 mono_mb_emit_byte (mb, CEE_LDIND_I);
10165 mono_mb_emit_stloc (mb, bounds);
10166
10167 /* ind is the overall element index, realidx is the partial index in a single dimension */
10168 /* ind = idx0 - bounds [0].lower_bound */
10169 mono_mb_emit_ldarg (mb, 1);
10170 mono_mb_emit_ldloc (mb, bounds);
10171 mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoArrayBounds, lower_bound));
10172 mono_mb_emit_byte (mb, CEE_ADD);
10173 mono_mb_emit_byte (mb, CEE_LDIND_I4);
10174 mono_mb_emit_byte (mb, CEE_SUB);
10175 mono_mb_emit_stloc (mb, ind);
10176 /* if (ind >= bounds [0].length) goto exeception; */
10177 mono_mb_emit_ldloc (mb, ind);
10178 mono_mb_emit_ldloc (mb, bounds);
10179 mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoArrayBounds, length));
10180 mono_mb_emit_byte (mb, CEE_ADD);
10181 mono_mb_emit_byte (mb, CEE_LDIND_I4);
10182 /* note that we use unsigned comparison */
10183 branch_pos = mono_mb_emit_branch (mb, CEE_BGE_UN);
10184
10185 /* For large ranks (> 4?) use a loop n IL later to reduce code size.
10186 * We could also decide to ignore the passed elem_size and get it
10187 * from the array object, to reduce the number of methods we generate:
10188 * the additional cost is 3 memory loads and a non-immediate mul.
10189 */
10190 for (i = 1; i < rank; ++i) {
10191 /* realidx = idxi - bounds [i].lower_bound */
10192 mono_mb_emit_ldarg (mb, 1 + i);
10193 mono_mb_emit_ldloc (mb, bounds);
10194 mono_mb_emit_icon (mb, (i * sizeof (MonoArrayBounds)) + G_STRUCT_OFFSET (MonoArrayBounds, lower_bound));
10195 mono_mb_emit_byte (mb, CEE_ADD);
10196 mono_mb_emit_byte (mb, CEE_LDIND_I4);
10197 mono_mb_emit_byte (mb, CEE_SUB);
10198 mono_mb_emit_stloc (mb, realidx);
10199 /* if (realidx >= bounds [i].length) goto exeception; */
10200 mono_mb_emit_ldloc (mb, realidx);
10201 mono_mb_emit_ldloc (mb, bounds);
10202 mono_mb_emit_icon (mb, (i * sizeof (MonoArrayBounds)) + G_STRUCT_OFFSET (MonoArrayBounds, length));
10203 mono_mb_emit_byte (mb, CEE_ADD);
10204 mono_mb_emit_byte (mb, CEE_LDIND_I4);
10205 branch_positions [i] = mono_mb_emit_branch (mb, CEE_BGE_UN);
10206 /* ind = ind * bounds [i].length + realidx */
10207 mono_mb_emit_ldloc (mb, ind);
10208 mono_mb_emit_ldloc (mb, bounds);
10209 mono_mb_emit_icon (mb, (i * sizeof (MonoArrayBounds)) + G_STRUCT_OFFSET (MonoArrayBounds, length));
10210 mono_mb_emit_byte (mb, CEE_ADD);
10211 mono_mb_emit_byte (mb, CEE_LDIND_I4);
10212 mono_mb_emit_byte (mb, CEE_MUL);
10213 mono_mb_emit_ldloc (mb, realidx);
10214 mono_mb_emit_byte (mb, CEE_ADD);
10215 mono_mb_emit_stloc (mb, ind);
10216 }
10217
10218 /* return array->vector + ind * element_size */
10219 mono_mb_emit_ldarg (mb, 0);
10220 mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoArray, vector));
10221 mono_mb_emit_ldloc (mb, ind);
10222 mono_mb_emit_icon (mb, elem_size);
10223 mono_mb_emit_byte (mb, CEE_MUL);
10224 mono_mb_emit_byte (mb, CEE_ADD);
10225 mono_mb_emit_byte (mb, CEE_RET);
10226
10227 /* patch the branches to get here and throw */
10228 for (i = 1; i < rank; ++i) {
10229 mono_mb_patch_branch (mb, branch_positions [i]);
10230 }
10231 mono_mb_patch_branch (mb, branch_pos);
10232 /* throw exception */
10233 mono_mb_emit_exception (mb, "IndexOutOfRangeException", NULL);
10234
10235 g_free (branch_positions);
10236 ret = mono_mb_create_method (mb, sig, 4);
10237 mono_mb_free (mb);
10238
10239 /* cache the result */
10240 cached = 0;
10241 mono_marshal_lock ();
10242 for (i = 0; i < elem_addr_cache_next; ++i) {
10243 if (elem_addr_cache [i].rank == rank && elem_addr_cache [i].elem_size == elem_size) {
10244 /* FIXME: free ret */
10245 ret = elem_addr_cache [i].method;
10246 cached = TRUE;
10247 break;
10248 }
10249 }
10250 if (!cached) {
10251 if (elem_addr_cache_next >= elem_addr_cache_size) {
10252 int new_size = elem_addr_cache_size + 4;
10253 ArrayElemAddr *new_array = g_new0 (ArrayElemAddr, new_size);
10254 memcpy (new_array, elem_addr_cache, elem_addr_cache_size * sizeof (ArrayElemAddr));
10255 g_free (elem_addr_cache);
10256 elem_addr_cache = new_array;
10257 elem_addr_cache_size = new_size;
10258 }
10259 elem_addr_cache [elem_addr_cache_next].rank = rank;
10260 elem_addr_cache [elem_addr_cache_next].elem_size = elem_size;
10261 elem_addr_cache [elem_addr_cache_next].method = ret;
10262 }
10263 mono_marshal_unlock ();
10264 return ret;
10265 }
10266
10267 MonoMethod*
10268 mono_marshal_get_write_barrier (void)
10269 {
10270 static MonoMethod* ret = NULL;
10271 MonoMethodSignature *sig;
10272 MonoMethodBuilder *mb;
10273 int max_stack = 2;
10274
10275 if (ret)
10276 return ret;
10277
10278 mb = mono_mb_new (mono_defaults.object_class, "writebarrier", MONO_WRAPPER_WRITE_BARRIER);
10279
10280 sig = mono_metadata_signature_alloc (mono_defaults.corlib, 2);
10281
10282 /* void writebarrier (MonoObject** addr, MonoObject* obj) */
10283 sig->ret = &mono_defaults.void_class->byval_arg;
10284 sig->params [0] = &mono_defaults.object_class->this_arg;
10285 sig->params [1] = &mono_defaults.object_class->byval_arg;
10286
10287 /* just the store right now: add an hook for the GC to use, maybe something
10288 * that can be used for stelemref as well
10289 * We need a write barrier variant to be used with struct copies as well, though
10290 * there are also other approaches possible, like writing a wrapper specific to
10291 * the struct or to the reference pattern in the struct...
10292 * Depending on the GC, we may want variants that take the object we store to
10293 * when it is available.
10294 */
10295 mono_mb_emit_ldarg (mb, 0);
10296 mono_mb_emit_ldarg (mb, 1);
10297 mono_mb_emit_icall (mb, mono_gc_wbarrier_generic_store);
10298 /*mono_mb_emit_byte (mb, CEE_STIND_REF);*/
10299
10300 mono_mb_emit_byte (mb, CEE_RET);
10301
10302 ret = mono_mb_create_method (mb, sig, max_stack);
10303 mono_mb_free (mb);
10304 return ret;
10305 }
10306
10307 void*
10308 mono_marshal_alloc (gulong size)
10309 {
10310 gpointer res;
10311
10312 #ifdef PLATFORM_WIN32
10313 res = CoTaskMemAlloc (size);
10314 #else
10315 res = g_try_malloc ((gulong)size);
10316 if (!res)
10317 mono_gc_out_of_memory ((gulong)size);
10318 #endif
10319 return res;
10320 }
10321
10322 void
10323 mono_marshal_free (gpointer ptr)
10324 {
10325 #ifdef PLATFORM_WIN32
10326 CoTaskMemFree (ptr);
10327 #else
10328 g_free (ptr);
10329 #endif
10330 }
10331
10332 void
10333 mono_marshal_free_array (gpointer *ptr, int size)
10334 {
10335 int i;
10336
10337 if (!ptr)
10338 return;
10339
10340 for (i = 0; i < size; i++)
10341 if (ptr [i])
10342 g_free (ptr [i]);
10343 }
10344
10345 void *
10346 mono_marshal_string_to_utf16 (MonoString *s)
10347 {
10348 return s ? mono_string_chars (s) : NULL;
10349 }
10350
10351 static void *
10352 mono_marshal_string_to_utf16_copy (MonoString *s)
10353 {
10354 if (s == NULL) {
10355 return NULL;
10356 } else {
10357 gunichar2 *res = mono_marshal_alloc ((mono_string_length (s) * 2) + 2);
10358 memcpy (res, mono_string_chars (s), mono_string_length (s) * 2);
10359 res [mono_string_length (s)] = 0;
10360 return res;
10361 }
10362 }
10363
10364 /**
10365 * mono_marshal_set_last_error:
10366 *
10367 * This function is invoked to set the last error value from a P/Invoke call
10368 * which has SetLastError set.
10369 */
10370 void
10371 mono_marshal_set_last_error (void)
10372 {
10373 #ifdef WIN32
10374 TlsSetValue (last_error_tls_id, GINT_TO_POINTER (GetLastError ()));
10375 #else
10376 TlsSetValue (last_error_tls_id, GINT_TO_POINTER (errno));
10377 #endif
10378 }
10379
10380 static void
10381 mono_marshal_set_last_error_windows (int error)
10382 {
10383 #ifdef WIN32
10384 TlsSetValue (last_error_tls_id, GINT_TO_POINTER (error));
10385 #endif
10386 }
10387
10388 void
10389 ves_icall_System_Runtime_InteropServices_Marshal_copy_to_unmanaged (MonoArray *src, gint32 start_index,
10390 gpointer dest, gint32 length)
10391 {
10392 int element_size;
10393 void *source_addr;
10394
10395 MONO_ARCH_SAVE_REGS;
10396
10397 MONO_CHECK_ARG_NULL (src);
10398 MONO_CHECK_ARG_NULL (dest);
10399
10400 if (src->obj.vtable->klass->rank != 1)
10401 mono_raise_exception (mono_get_exception_argument ("array", "array is multi-dimensional"));
10402 if (start_index < 0)
10403 mono_raise_exception (mono_get_exception_argument ("startIndex", "Must be >= 0"));
10404 if (length < 0)
10405 mono_raise_exception (mono_get_exception_argument ("length", "Must be >= 0"));
10406 if (start_index + length > mono_array_length (src))
10407 mono_raise_exception (mono_get_exception_argument ("length", "start_index + length > array length"));
10408
10409 element_size = mono_array_element_size (src->obj.vtable->klass);
10410
10411 /* no references should be involved */
10412 source_addr = mono_array_addr_with_size (src, element_size, start_index);
10413
10414 memcpy (dest, source_addr, length * element_size);
10415 }
10416
10417 void
10418 ves_icall_System_Runtime_InteropServices_Marshal_copy_from_unmanaged (gpointer src, gint32 start_index,
10419 MonoArray *dest, gint32 length)
10420 {
10421 int element_size;
10422 void *dest_addr;
10423
10424 MONO_ARCH_SAVE_REGS;
10425
10426 MONO_CHECK_ARG_NULL (src);
10427 MONO_CHECK_ARG_NULL (dest);
10428
10429 if (dest->obj.vtable->klass->rank != 1)
10430 mono_raise_exception (mono_get_exception_argument ("array", "array is multi-dimensional"));
10431 if (start_index < 0)
10432 mono_raise_exception (mono_get_exception_argument ("startIndex", "Must be >= 0"));
10433 if (length < 0)
10434 mono_raise_exception (mono_get_exception_argument ("length", "Must be >= 0"));
10435 if (start_index + length > mono_array_length (dest))
10436 mono_raise_exception (mono_get_exception_argument ("length", "start_index + length > array length"));
10437
10438 element_size = mono_array_element_size (dest->obj.vtable->klass);
10439
10440 /* no references should be involved */
10441 dest_addr = mono_array_addr_with_size (dest, element_size, start_index);
10442
10443 memcpy (dest_addr, src, length * element_size);
10444 }
10445
10446 #if NO_UNALIGNED_ACCESS
10447 #define RETURN_UNALIGNED(type, addr) \
10448 { \
10449 type val; \
10450 memcpy(&val, p + offset, sizeof(val)); \
10451 return val; \
10452 }
10453 #define WRITE_UNALIGNED(type, addr, val) \
10454 memcpy(addr, &val, sizeof(type))
10455 #else
10456 #define RETURN_UNALIGNED(type, addr) \
10457 return *(type*)(p + offset);
10458 #define WRITE_UNALIGNED(type, addr, val) \
10459 (*(type *)(addr) = (val))
10460 #endif
10461
10462 gpointer
10463 ves_icall_System_Runtime_InteropServices_Marshal_ReadIntPtr (gpointer ptr, gint32 offset)
10464 {
10465 char *p = ptr;
10466
10467 MONO_ARCH_SAVE_REGS;
10468
10469 RETURN_UNALIGNED(gpointer, p + offset);
10470 }
10471
10472 unsigned char
10473 ves_icall_System_Runtime_InteropServices_Marshal_ReadByte (gpointer ptr, gint32 offset)
10474 {
10475 char *p = ptr;
10476
10477 MONO_ARCH_SAVE_REGS;
10478
10479 return *(unsigned char*)(p + offset);
10480 }
10481
10482 gint16
10483 ves_icall_System_Runtime_InteropServices_Marshal_ReadInt16 (gpointer ptr, gint32 offset)
10484 {
10485 char *p = ptr;
10486
10487 MONO_ARCH_SAVE_REGS;
10488
10489 RETURN_UNALIGNED(gint16, p + offset);
10490 }
10491
10492 gint32
10493 ves_icall_System_Runtime_InteropServices_Marshal_ReadInt32 (gpointer ptr, gint32 offset)
10494 {
10495 char *p = ptr;
10496
10497 MONO_ARCH_SAVE_REGS;
10498
10499 RETURN_UNALIGNED(gint32, p + offset);
10500 }
10501
10502 gint64
10503 ves_icall_System_Runtime_InteropServices_Marshal_ReadInt64 (gpointer ptr, gint32 offset)
10504 {
10505 char *p = ptr;
10506
10507 MONO_ARCH_SAVE_REGS;
10508
10509 RETURN_UNALIGNED(gint64, p + offset);
10510 }
10511
10512 void
10513 ves_icall_System_Runtime_InteropServices_Marshal_WriteByte (gpointer ptr, gint32 offset, unsigned char val)
10514 {
10515 char *p = ptr;
10516
10517 MONO_ARCH_SAVE_REGS;
10518
10519 *(unsigned char*)(p + offset) = val;
10520 }
10521
10522 void
10523 ves_icall_System_Runtime_InteropServices_Marshal_WriteIntPtr (gpointer ptr, gint32 offset, gpointer val)
10524 {
10525 char *p = ptr;
10526
10527 MONO_ARCH_SAVE_REGS;
10528
10529 WRITE_UNALIGNED(gpointer, p + offset, val);
10530 }
10531
10532 void
10533 ves_icall_System_Runtime_InteropServices_Marshal_WriteInt16 (gpointer ptr, gint32 offset, gint16 val)
10534 {
10535 char *p = ptr;
10536
10537 MONO_ARCH_SAVE_REGS;
10538
10539 WRITE_UNALIGNED(gint16, p + offset, val);
10540 }
10541
10542 void
10543 ves_icall_System_Runtime_InteropServices_Marshal_WriteInt32 (gpointer ptr, gint32 offset, gint32 val)
10544 {
10545 char *p = ptr;
10546
10547 MONO_ARCH_SAVE_REGS;
10548
10549 WRITE_UNALIGNED(gint32, p + offset, val);
10550 }
10551
10552 void
10553 ves_icall_System_Runtime_InteropServices_Marshal_WriteInt64 (gpointer ptr, gint32 offset, gint64 val)
10554 {
10555 char *p = ptr;
10556
10557 MONO_ARCH_SAVE_REGS;
10558
10559 WRITE_UNALIGNED(gint64, p + offset, val);
10560 }
10561
10562 MonoString *
10563 ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringAnsi (char *ptr)
10564 {
10565 MONO_ARCH_SAVE_REGS;
10566
10567 if (ptr == NULL)
10568 return NULL;
10569 else
10570 return mono_string_new (mono_domain_get (), ptr);
10571 }
10572
10573 MonoString *
10574 ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringAnsi_len (char *ptr, gint32 len)
10575 {
10576 MONO_ARCH_SAVE_REGS;
10577
10578 if (ptr == NULL) {
10579 mono_raise_exception (mono_get_exception_argument_null ("ptr"));
10580 g_assert_not_reached ();
10581 return NULL;
10582 } else {
10583 return mono_string_new_len (mono_domain_get (), ptr, len);
10584 }
10585 }
10586
10587 MonoString *
10588 ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringUni (guint16 *ptr)
10589 {
10590 MonoDomain *domain = mono_domain_get ();
10591 int len = 0;
10592 guint16 *t = ptr;
10593
10594 MONO_ARCH_SAVE_REGS;
10595
10596 if (ptr == NULL)
10597 return NULL;
10598
10599 while (*t++)
10600 len++;
10601
10602 return mono_string_new_utf16 (domain, ptr, len);
10603 }
10604
10605 MonoString *
10606 ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringUni_len (guint16 *ptr, gint32 len)
10607 {
10608 MonoDomain *domain = mono_domain_get ();
10609
10610 MONO_ARCH_SAVE_REGS;
10611
10612 if (ptr == NULL) {
10613 mono_raise_exception (mono_get_exception_argument_null ("ptr"));
10614 g_assert_not_reached ();
10615 return NULL;
10616 } else {
10617 return mono_string_new_utf16 (domain, ptr, len);
10618 }
10619 }
10620
10621 MonoString *
10622 ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringBSTR (gpointer ptr)
10623 {
10624 MONO_ARCH_SAVE_REGS;
10625
10626 return mono_string_from_bstr(ptr);
10627 }
10628
10629 gpointer
10630 ves_icall_System_Runtime_InteropServices_Marshal_StringToBSTR (MonoString* ptr)
10631 {
10632 MONO_ARCH_SAVE_REGS;
10633
10634 return mono_string_to_bstr(ptr);
10635 }
10636
10637 typedef struct
10638 {
10639 int (STDCALL *QueryInterface)(gpointer pUnk, gpointer riid, gpointer* ppv);
10640 int (STDCALL *AddRef)(gpointer pUnk);
10641 int (STDCALL *Release)(gpointer pUnk);
10642 } MonoIUnknown;
10643
10644 void
10645 ves_icall_System_Runtime_InteropServices_Marshal_FreeBSTR (gpointer ptr)
10646 {
10647 MONO_ARCH_SAVE_REGS;
10648
10649 mono_free_bstr (ptr);
10650 }
10651
10652 int
10653 ves_icall_System_Runtime_InteropServices_Marshal_AddRefInternal (gpointer pUnk)
10654 {
10655 g_assert (pUnk);
10656 return (*(MonoIUnknown**)pUnk)->AddRef(pUnk);
10657 }
10658
10659 int
10660 ves_icall_System_Runtime_InteropServices_Marshal_QueryInterfaceInternal (gpointer pUnk, gpointer riid, gpointer* ppv)
10661 {
10662 g_assert (pUnk);
10663 return (*(MonoIUnknown**)pUnk)->QueryInterface(pUnk, riid, ppv);
10664 }
10665
10666 int
10667 ves_icall_System_Runtime_InteropServices_Marshal_ReleaseInternal (gpointer pUnk)
10668 {
10669 g_assert (pUnk);
10670 return (*(MonoIUnknown**)pUnk)->Release(pUnk);
10671 }
10672
10673 #ifndef DISABLE_COM
10674
10675 static void*
10676 cominterop_get_idispatch_for_object (MonoObject* object)
10677 {
10678 if (!object)
10679 return NULL;
10680
10681 if (cominterop_object_is_rcw (object)) {
10682 return cominterop_get_interface (((MonoComInteropProxy*)((MonoTransparentProxy*)object)->rp)->com_object,
10683 mono_defaults.idispatch_class, TRUE);
10684 }
10685 else {
10686 return cominterop_get_ccw (object, mono_defaults.idispatch_class);
10687 }
10688 }
10689
10690 #endif
10691
10692 void*
10693 ves_icall_System_Runtime_InteropServices_Marshal_GetIUnknownForObjectInternal (MonoObject* object)
10694 {
10695 #ifndef DISABLE_COM
10696 if (!object)
10697 return NULL;
10698
10699 if (cominterop_object_is_rcw (object)) {
10700 MonoClass *klass = NULL;
10701 MonoRealProxy* real_proxy = NULL;
10702 if (!object)
10703 return NULL;
10704 klass = mono_object_class (object);
10705 if (klass != mono_defaults.transparent_proxy_class) {
10706 g_assert_not_reached ();
10707 return NULL;
10708 }
10709
10710 real_proxy = ((MonoTransparentProxy*)object)->rp;
10711 if (!real_proxy) {
10712 g_assert_not_reached ();
10713 return NULL;
10714 }
10715
10716 klass = mono_object_class (real_proxy);
10717 if (klass != mono_defaults.com_interop_proxy_class) {
10718 g_assert_not_reached ();
10719 return NULL;
10720 }
10721
10722 if (!((MonoComInteropProxy*)real_proxy)->com_object) {
10723 g_assert_not_reached ();
10724 return NULL;
10725 }
10726
10727 return ((MonoComInteropProxy*)real_proxy)->com_object->iunknown;
10728 }
10729 else {
10730 return cominterop_get_ccw (object, mono_defaults.iunknown_class);
10731 }
10732 #else
10733 g_assert_not_reached ();
10734 #endif
10735 }
10736
10737 MonoObject*
10738 ves_icall_System_Runtime_InteropServices_Marshal_GetObjectForCCW (void* pUnk)
10739 {
10740 #ifndef DISABLE_COM
10741 MonoObject* object = NULL;
10742
10743 if (!pUnk)
10744 return NULL;
10745
10746 /* see if it is a CCW */
10747 object = cominterop_get_ccw_object ((MonoCCWInterface*)pUnk, TRUE);
10748
10749 return object;
10750 #else
10751 g_assert_not_reached ();
10752 #endif
10753 }
10754
10755 void*
10756 ves_icall_System_Runtime_InteropServices_Marshal_GetIDispatchForObjectInternal (MonoObject* object)
10757 {
10758 #ifndef DISABLE_COM
10759 return cominterop_get_idispatch_for_object (object);
10760 #else
10761 g_assert_not_reached ();
10762 #endif
10763 }
10764
10765 void*
10766 ves_icall_System_Runtime_InteropServices_Marshal_GetCCW (MonoObject* object, MonoReflectionType* type)
10767 {
10768 #ifndef DISABLE_COM
10769 MonoClass* klass = NULL;
10770 void* itf = NULL;
10771 g_assert (type);
10772 g_assert (type->type);
10773 klass = mono_type_get_class (type->type);
10774 g_assert (klass);
10775 itf = cominterop_get_ccw (object, klass);
10776 g_assert (itf);
10777 return itf;
10778 #else
10779 g_assert_not_reached ();
10780 #endif
10781 }
10782
10783
10784 MonoBoolean
10785 ves_icall_System_Runtime_InteropServices_Marshal_IsComObject (MonoObject* object)
10786 {
10787 #ifndef DISABLE_COM
10788 return (MonoBoolean)cominterop_object_is_rcw (object);
10789 #else
10790 g_assert_not_reached ();
10791 #endif
10792 }
10793
10794 gint32
10795 ves_icall_System_Runtime_InteropServices_Marshal_ReleaseComObjectInternal (MonoObject* object)
10796 {
10797 #ifndef DISABLE_COM
10798 MonoComInteropProxy* proxy = NULL;
10799 gint32 ref_count = 0;
10800
10801 g_assert (object);
10802 g_assert (cominterop_object_is_rcw (object));
10803
10804 proxy = (MonoComInteropProxy*)((MonoTransparentProxy*)object)->rp;
10805 g_assert (proxy);
10806
10807 ref_count = InterlockedDecrement (&proxy->ref_count);
10808 g_assert (ref_count >= 0);
10809
10810 if (ref_count == 0)
10811 ves_icall_System_ComObject_ReleaseInterfaces (proxy->com_object);
10812
10813 return ref_count;
10814 #else
10815 g_assert_not_reached ();
10816 #endif
10817 }
10818
10819 guint32
10820 ves_icall_System_Runtime_InteropServices_Marshal_GetComSlotForMethodInfoInternal (MonoReflectionMethod *m)
10821 {
10822 MONO_ARCH_SAVE_REGS;
10823
10824 #ifndef DISABLE_COM
10825 return cominterop_get_com_slot_for_method (m->method);
10826 #else
10827 g_assert_not_reached ();
10828 #endif
10829 }
10830
10831 guint32
10832 ves_icall_System_Runtime_InteropServices_Marshal_GetLastWin32Error (void)
10833 {
10834 MONO_ARCH_SAVE_REGS;
10835
10836 return (GPOINTER_TO_INT (TlsGetValue (last_error_tls_id)));
10837 }
10838
10839 guint32
10840 ves_icall_System_Runtime_InteropServices_Marshal_SizeOf (MonoReflectionType *rtype)
10841 {
10842 MonoClass *klass;
10843 MonoType *type;
10844 guint32 layout;
10845
10846 MONO_ARCH_SAVE_REGS;
10847
10848 MONO_CHECK_ARG_NULL (rtype);
10849
10850 type = rtype->type;
10851 klass = mono_class_from_mono_type (type);
10852 layout = (klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK);
10853
10854 if (layout == TYPE_ATTRIBUTE_AUTO_LAYOUT) {
10855 gchar *msg;
10856 MonoException *exc;
10857
10858 msg = g_strdup_printf ("Type %s cannot be marshaled as an unmanaged structure.", klass->name);
10859 exc = mono_get_exception_argument ("t", msg);
10860 g_free (msg);
10861 mono_raise_exception (exc);
10862 }
10863
10864
10865 return mono_class_native_size (klass, NULL);
10866 }
10867
10868 void
10869 ves_icall_System_Runtime_InteropServices_Marshal_StructureToPtr (MonoObject *obj, gpointer dst, MonoBoolean delete_old)
10870 {
10871 MonoMethod *method;
10872 gpointer pa [3];
10873
10874 MONO_ARCH_SAVE_REGS;
10875
10876 MONO_CHECK_ARG_NULL (obj);
10877 MONO_CHECK_ARG_NULL (dst);
10878
10879 method = mono_marshal_get_struct_to_ptr (obj->vtable->klass);
10880
10881 pa [0] = obj;
10882 pa [1] = &dst;
10883 pa [2] = &delete_old;
10884
10885 mono_runtime_invoke (method, NULL, pa, NULL);
10886 }
10887
10888 static void
10889 ptr_to_structure (gpointer src, MonoObject *dst)
10890 {
10891 MonoMethod *method;
10892 gpointer pa [2];
10893
10894 method = mono_marshal_get_ptr_to_struct (dst->vtable->klass);
10895
10896 pa [0] = &src;
10897 pa [1] = dst;
10898
10899 mono_runtime_invoke (method, NULL, pa, NULL);
10900 }
10901
10902 void
10903 ves_icall_System_Runtime_InteropServices_Marshal_PtrToStructure (gpointer src, MonoObject *dst)
10904 {
10905 MonoType *t;
10906
10907 MONO_ARCH_SAVE_REGS;
10908
10909 MONO_CHECK_ARG_NULL (src);
10910 MONO_CHECK_ARG_NULL (dst);
10911
10912 t = mono_type_get_underlying_type (mono_class_get_type (dst->vtable->klass));
10913
10914 if (t->type == MONO_TYPE_VALUETYPE) {
10915 MonoException *exc;
10916 gchar *tmp;
10917
10918 tmp = g_strdup_printf ("Destination is a boxed value type.");
10919 exc = mono_get_exception_argument ("dst", tmp);
10920 g_free (tmp);
10921
10922 mono_raise_exception (exc);
10923 return;
10924 }
10925
10926 ptr_to_structure (src, dst);
10927 }
10928
10929 MonoObject *
10930 ves_icall_System_Runtime_InteropServices_Marshal_PtrToStructure_type (gpointer src, MonoReflectionType *type)
10931 {
10932 MonoDomain *domain = mono_domain_get ();
10933 MonoObject *res;
10934
10935 MONO_ARCH_SAVE_REGS;
10936
10937 MONO_CHECK_ARG_NULL (src);
10938 MONO_CHECK_ARG_NULL (type);
10939
10940 res = mono_object_new (domain, mono_class_from_mono_type (type->type));
10941
10942 ptr_to_structure (src, res);
10943
10944 return res;
10945 }
10946
10947 int
10948 ves_icall_System_Runtime_InteropServices_Marshal_OffsetOf (MonoReflectionType *type, MonoString *field_name)
10949 {
10950 MonoMarshalType *info;
10951 MonoClass *klass;
10952 char *fname;
10953 int match_index = -1;
10954
10955 MONO_ARCH_SAVE_REGS;
10956
10957 MONO_CHECK_ARG_NULL (type);
10958 MONO_CHECK_ARG_NULL (field_name);
10959
10960 fname = mono_string_to_utf8 (field_name);
10961 klass = mono_class_from_mono_type (type->type);
10962
10963 while (klass && match_index == -1) {
10964 MonoClassField* field;
10965 int i = 0;
10966 gpointer iter = NULL;
10967 while ((field = mono_class_get_fields (klass, &iter))) {
10968 if (field->type->attrs & FIELD_ATTRIBUTE_STATIC)
10969 continue;
10970 if (!strcmp (fname, mono_field_get_name (field))) {
10971 match_index = i;
10972 break;
10973 }
10974 i ++;
10975 }
10976
10977 if (match_index == -1)
10978 klass = klass->parent;
10979 }
10980
10981 g_free (fname);
10982
10983 if(match_index == -1) {
10984 MonoException* exc;
10985 gchar *tmp;
10986
10987 /* Get back original class instance */
10988 klass = mono_class_from_mono_type (type->type);
10989
10990 tmp = g_strdup_printf ("Field passed in is not a marshaled member of the type %s", klass->name);
10991 exc = mono_get_exception_argument ("fieldName", tmp);
10992 g_free (tmp);
10993
10994 mono_raise_exception ((MonoException*)exc);
10995 }
10996
10997 info = mono_marshal_load_type_info (klass);
10998 return info->fields [match_index].offset;
10999 }
11000
11001 gpointer
11002 ves_icall_System_Runtime_InteropServices_Marshal_StringToHGlobalAnsi (MonoString *string)
11003 {
11004 #ifdef PLATFORM_WIN32
11005 char* tres, *ret;
11006 size_t len;
11007 tres = mono_string_to_utf8 (string);
11008 if (!tres)
11009 return tres;
11010
11011 len = strlen (tres) + 1;
11012 ret = ves_icall_System_Runtime_InteropServices_Marshal_AllocHGlobal (len);
11013 memcpy (ret, tres, len);
11014 g_free (tres);
11015 return ret;
11016
11017 #else
11018 return mono_string_to_utf8 (string);
11019 #endif
11020 }
11021
11022 gpointer
11023 ves_icall_System_Runtime_InteropServices_Marshal_StringToHGlobalUni (MonoString *string)
11024 {
11025 MONO_ARCH_SAVE_REGS;
11026
11027 if (string == NULL)
11028 return NULL;
11029 else {
11030 #ifdef PLATFORM_WIN32
11031 gunichar2 *res = ves_icall_System_Runtime_InteropServices_Marshal_AllocHGlobal
11032 ((mono_string_length (string) + 1) * 2);
11033 #else
11034 gunichar2 *res = g_malloc ((mono_string_length (string) + 1) * 2);
11035 #endif
11036 memcpy (res, mono_string_chars (string), mono_string_length (string) * 2);
11037 res [mono_string_length (string)] = 0;
11038 return res;
11039 }
11040 }
11041
11042 static void
11043 mono_struct_delete_old (MonoClass *klass, char *ptr)
11044 {
11045 MonoMarshalType *info;
11046 int i;
11047
11048 info = mono_marshal_load_type_info (klass);
11049
11050 for (i = 0; i < info->num_fields; i++) {
11051 MonoMarshalNative ntype;
11052 MonoMarshalConv conv;
11053 MonoType *ftype = info->fields [i].field->type;
11054 char *cpos;
11055
11056 if (ftype->attrs & FIELD_ATTRIBUTE_STATIC)
11057 continue;
11058
11059 ntype = mono_type_to_unmanaged (ftype, info->fields [i].mspec, TRUE,
11060 klass->unicode, &conv);
11061
11062 cpos = ptr + info->fields [i].offset;
11063
11064 switch (conv) {
11065 case MONO_MARSHAL_CONV_NONE:
11066 if (MONO_TYPE_ISSTRUCT (ftype)) {
11067 mono_struct_delete_old (ftype->data.klass, cpos);
11068 continue;
11069 }
11070 break;
11071 case MONO_MARSHAL_CONV_STR_LPWSTR:
11072 /* We assume this field points inside a MonoString */
11073 break;
11074 case MONO_MARSHAL_CONV_STR_LPTSTR:
11075 #ifdef PLATFORM_WIN32
11076 /* We assume this field points inside a MonoString
11077 * on Win32 */
11078 break;
11079 #endif
11080 case MONO_MARSHAL_CONV_STR_LPSTR:
11081 case MONO_MARSHAL_CONV_STR_BSTR:
11082 case MONO_MARSHAL_CONV_STR_ANSIBSTR:
11083 case MONO_MARSHAL_CONV_STR_TBSTR:
11084 mono_marshal_free (*(gpointer *)cpos);
11085 break;
11086
11087 default:
11088 continue;
11089 }
11090 }
11091 }
11092
11093 void
11094 ves_icall_System_Runtime_InteropServices_Marshal_DestroyStructure (gpointer src, MonoReflectionType *type)
11095 {
11096 MonoClass *klass;
11097
11098 MONO_ARCH_SAVE_REGS;
11099
11100 MONO_CHECK_ARG_NULL (src);
11101 MONO_CHECK_ARG_NULL (type);
11102
11103 klass = mono_class_from_mono_type (type->type);
11104
11105 mono_struct_delete_old (klass, (char *)src);
11106 }
11107
11108 void*
11109 ves_icall_System_Runtime_InteropServices_Marshal_AllocHGlobal (int size)
11110 {
11111 gpointer res;
11112
11113 MONO_ARCH_SAVE_REGS;
11114
11115 if ((gulong)size == 0)
11116 /* This returns a valid pointer for size 0 on MS.NET */
11117 size = 4;
11118
11119 #ifdef PLATFORM_WIN32
11120 res = GlobalAlloc (GMEM_FIXED, (gulong)size);
11121 #else
11122 res = g_try_malloc ((gulong)size);
11123 #endif
11124 if (!res)
11125 mono_gc_out_of_memory ((gulong)size);
11126
11127 return res;
11128 }
11129
11130 gpointer
11131 ves_icall_System_Runtime_InteropServices_Marshal_ReAllocHGlobal (gpointer ptr, int size)
11132 {
11133 gpointer res;
11134
11135 if (ptr == NULL) {
11136 mono_gc_out_of_memory ((gulong)size);
11137 return NULL;
11138 }
11139
11140 #ifdef PLATFORM_WIN32
11141 res = GlobalReAlloc (ptr, (gulong)size, GMEM_MOVEABLE);
11142 #else
11143 res = g_try_realloc (ptr, (gulong)size);
11144 #endif
11145 if (!res)
11146 mono_gc_out_of_memory ((gulong)size);
11147
11148 return res;
11149 }
11150
11151 void
11152 ves_icall_System_Runtime_InteropServices_Marshal_FreeHGlobal (void *ptr)
11153 {
11154 MONO_ARCH_SAVE_REGS;
11155
11156 #ifdef PLATFORM_WIN32
11157 GlobalFree (ptr);
11158 #else
11159 g_free (ptr);
11160 #endif
11161 }
11162
11163 void*
11164 ves_icall_System_Runtime_InteropServices_Marshal_AllocCoTaskMem (int size)
11165 {
11166 MONO_ARCH_SAVE_REGS;
11167
11168 #ifdef PLATFORM_WIN32
11169 return CoTaskMemAlloc (size);
11170 #else
11171 return g_try_malloc ((gulong)size);
11172 #endif
11173 }
11174
11175 void
11176 ves_icall_System_Runtime_InteropServices_Marshal_FreeCoTaskMem (void *ptr)
11177 {
11178 MONO_ARCH_SAVE_REGS;
11179
11180 #ifdef PLATFORM_WIN32
11181 CoTaskMemFree (ptr);
11182 #else
11183 g_free (ptr);
11184 #endif
11185 }
11186
11187 gpointer
11188 ves_icall_System_Runtime_InteropServices_Marshal_ReAllocCoTaskMem (gpointer ptr, int size)
11189 {
11190 MONO_ARCH_SAVE_REGS;
11191
11192 #ifdef PLATFORM_WIN32
11193 return CoTaskMemRealloc (ptr, size);
11194 #else
11195 return g_try_realloc (ptr, (gulong)size);
11196 #endif
11197 }
11198
11199 void*
11200 ves_icall_System_Runtime_InteropServices_Marshal_UnsafeAddrOfPinnedArrayElement (MonoArray *arrayobj, int index)
11201 {
11202 return mono_array_addr_with_size (arrayobj, mono_array_element_size (arrayobj->obj.vtable->klass), index);
11203 }
11204
11205 MonoDelegate*
11206 ves_icall_System_Runtime_InteropServices_Marshal_GetDelegateForFunctionPointerInternal (void *ftn, MonoReflectionType *type)
11207 {
11208 return mono_ftnptr_to_delegate (mono_type_get_class (type->type), ftn);
11209 }
11210
11211 /* Only used for COM RCWs */
11212 MonoObject *
11213 ves_icall_System_ComObject_CreateRCW (MonoReflectionType *type)
11214 {
11215 MonoClass *klass;
11216 MonoDomain *domain;
11217 MonoObject *obj;
11218
11219 MONO_ARCH_SAVE_REGS;
11220
11221 domain = mono_object_domain (type);
11222 klass = mono_class_from_mono_type (type->type);
11223
11224 /* call mono_object_new_alloc_specific instead of mono_object_new
11225 * because we want to actually create object. mono_object_new checks
11226 * to see if type is import and creates transparent proxy. this method
11227 * is called by the corresponding real proxy to create the real RCW.
11228 * Constructor does not need to be called. Will be called later.
11229 */
11230 obj = mono_object_new_alloc_specific (mono_class_vtable (domain, klass));
11231 return obj;
11232 }
11233
11234 static gboolean
11235 cominterop_finalizer (gpointer key, gpointer value, gpointer user_data)
11236 {
11237 ves_icall_System_Runtime_InteropServices_Marshal_ReleaseInternal (value);
11238 return TRUE;
11239 }
11240
11241 void
11242 ves_icall_System_ComObject_ReleaseInterfaces (MonoComObject* obj)
11243 {
11244 g_assert(obj);
11245 if (obj->itf_hash) {
11246 guint32 gchandle = 0;
11247 mono_cominterop_lock ();
11248 gchandle = GPOINTER_TO_UINT (g_hash_table_lookup (rcw_hash, obj->iunknown));
11249 if (gchandle) {
11250 mono_gchandle_free (gchandle);
11251 g_hash_table_remove (rcw_hash, obj->iunknown);
11252 }
11253
11254 g_hash_table_foreach_remove (obj->itf_hash, cominterop_finalizer, NULL);
11255 ves_icall_System_Runtime_InteropServices_Marshal_ReleaseInternal (obj->iunknown);
11256 obj->itf_hash = obj->iunknown = NULL;
11257 mono_cominterop_unlock ();
11258 }
11259 }
11260
11261 gpointer
11262 ves_icall_System_ComObject_GetInterfaceInternal (MonoComObject* obj, MonoReflectionType* type, MonoBoolean throw_exception)
11263 {
11264 #ifndef DISABLE_COM
11265 return cominterop_get_interface (obj, mono_type_get_class (type->type), (gboolean)throw_exception);
11266 #else
11267 g_assert_not_reached ();
11268 #endif
11269 }
11270
11271 void
11272 ves_icall_Mono_Interop_ComInteropProxy_AddProxy (gpointer pUnk, MonoComInteropProxy* proxy)
11273 {
11274 #ifndef DISABLE_COM
11275 guint32 gchandle = 0;
11276 if (!rcw_hash) {
11277 mono_cominterop_lock ();
11278 rcw_hash = g_hash_table_new (mono_aligned_addr_hash, NULL);
11279 mono_cominterop_unlock ();
11280 }
11281
11282 gchandle = mono_gchandle_new_weakref ((MonoObject*)proxy, FALSE);
11283
11284 mono_cominterop_lock ();
11285 g_hash_table_insert (rcw_hash, pUnk, GUINT_TO_POINTER (gchandle));
11286 mono_cominterop_unlock ();
11287 #else
11288 g_assert_not_reached ();
11289 #endif
11290 }
11291
11292 MonoComInteropProxy*
11293 ves_icall_Mono_Interop_ComInteropProxy_FindProxy (gpointer pUnk)
11294 {
11295 #ifndef DISABLE_COM
11296 MonoComInteropProxy* proxy = NULL;
11297 guint32 gchandle = 0;
11298
11299 mono_cominterop_lock ();
11300 if (rcw_hash)
11301 gchandle = GPOINTER_TO_UINT (g_hash_table_lookup (rcw_hash, pUnk));
11302 mono_cominterop_unlock ();
11303 if (gchandle) {
11304 proxy = (MonoComInteropProxy*)mono_gchandle_get_target (gchandle);
11305 /* proxy is null means we need to free up old RCW */
11306 if (!proxy) {
11307 mono_gchandle_free (gchandle);
11308 g_hash_table_remove (rcw_hash, pUnk);
11309 }
11310 }
11311 return proxy;
11312 #else
11313 g_assert_not_reached ();
11314 #endif
11315 }
11316
11317 /**
11318 * mono_marshal_is_loading_type_info:
11319 *
11320 * Return whenever mono_marshal_load_type_info () is being executed for KLASS by this
11321 * thread.
11322 */
11323 static gboolean
11324 mono_marshal_is_loading_type_info (MonoClass *klass)
11325 {
11326 GSList *loads_list = TlsGetValue (load_type_info_tls_id);
11327
11328 return g_slist_find (loads_list, klass) != NULL;
11329 }
11330
11331 /**
11332 * mono_marshal_load_type_info:
11333 *
11334 * Initialize klass->marshal_info using information from metadata. This function can
11335 * recursively call itself, and the caller is responsible to avoid that by calling
11336 * mono_marshal_is_loading_type_info () beforehand.
11337 *
11338 * LOCKING: Acquires the loader lock.
11339 */
11340 MonoMarshalType *
11341 mono_marshal_load_type_info (MonoClass* klass)
11342 {
11343 int j, count = 0;
11344 guint32 native_size = 0, min_align = 1;
11345 MonoMarshalType *info;
11346 MonoClassField* field;
11347 gpointer iter;
11348 guint32 layout;
11349 GSList *loads_list;
11350
11351 g_assert (klass != NULL);
11352
11353 if (klass->marshal_info)
11354 return klass->marshal_info;
11355
11356 if (!klass->inited)
11357 mono_class_init (klass);
11358
11359 mono_loader_lock ();
11360
11361 if (klass->marshal_info) {
11362 mono_loader_unlock ();
11363 return klass->marshal_info;
11364 }
11365
11366 /*
11367 * This function can recursively call itself, so we keep the list of classes which are
11368 * under initialization in a TLS list.
11369 */
11370 g_assert (!mono_marshal_is_loading_type_info (klass));
11371 loads_list = TlsGetValue (load_type_info_tls_id);
11372 loads_list = g_slist_prepend (loads_list, klass);
11373 TlsSetValue (load_type_info_tls_id, loads_list);
11374
11375 iter = NULL;
11376 while ((field = mono_class_get_fields (klass, &iter))) {
11377 if (field->type->attrs & FIELD_ATTRIBUTE_STATIC)
11378 continue;
11379 if (mono_field_is_deleted (field))
11380 continue;
11381 count++;
11382 }
11383
11384 layout = klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK;
11385
11386 /* The mempool is protected by the loader lock */
11387 info = mono_image_alloc0 (klass->image, sizeof (MonoMarshalType) + sizeof (MonoMarshalField) * count);
11388 info->num_fields = count;
11389
11390 /* Try to find a size for this type in metadata */
11391 mono_metadata_packing_from_typedef (klass->image, klass->type_token, NULL, &native_size);
11392
11393 if (klass->parent) {
11394 int parent_size = mono_class_native_size (klass->parent, NULL);
11395
11396 /* Add parent size to real size */
11397 native_size += parent_size;
11398 info->native_size = parent_size;
11399 }
11400
11401 iter = NULL;
11402 j = 0;
11403 while ((field = mono_class_get_fields (klass, &iter))) {
11404 int size;
11405 guint32 align;
11406
11407 if (field->type->attrs & FIELD_ATTRIBUTE_STATIC)
11408 continue;
11409
11410 if (mono_field_is_deleted (field))
11411 continue;
11412 if (field->type->attrs & FIELD_ATTRIBUTE_HAS_FIELD_MARSHAL)
11413 mono_metadata_field_info_with_mempool (klass->image->mempool, klass->image, mono_metadata_token_index (mono_class_get_field_token (field)) - 1,
11414 NULL, NULL, &info->fields [j].mspec);
11415
11416 info->fields [j].field = field;
11417
11418 if ((mono_class_num_fields (klass) == 1) && (klass->instance_size == sizeof (MonoObject)) &&
11419 (strcmp (mono_field_get_name (field), "$PRIVATE$") == 0)) {
11420 /* This field is a hack inserted by MCS to empty structures */
11421 continue;
11422 }
11423
11424 switch (layout) {
11425 case TYPE_ATTRIBUTE_AUTO_LAYOUT:
11426 case TYPE_ATTRIBUTE_SEQUENTIAL_LAYOUT:
11427 size = mono_marshal_type_size (field->type, info->fields [j].mspec,
11428 &align, TRUE, klass->unicode);
11429 align = klass->packing_size ? MIN (klass->packing_size, align): align;
11430 min_align = MAX (align, min_align);
11431 info->fields [j].offset = info->native_size;
11432 info->fields [j].offset += align - 1;
11433 info->fields [j].offset &= ~(align - 1);
11434 info->native_size = info->fields [j].offset + size;
11435 break;
11436 case TYPE_ATTRIBUTE_EXPLICIT_LAYOUT:
11437 size = mono_marshal_type_size (field->type, info->fields [j].mspec,
11438 &align, TRUE, klass->unicode);
11439 align = klass->packing_size ? MIN (klass->packing_size, align): align;
11440 min_align = MAX (align, min_align);
11441 info->fields [j].offset = field->offset - sizeof (MonoObject);
11442 info->native_size = MAX (info->native_size, info->fields [j].offset + size);
11443 break;
11444 }
11445 j++;
11446 }
11447
11448 if(layout != TYPE_ATTRIBUTE_AUTO_LAYOUT) {
11449 info->native_size = MAX (native_size, info->native_size);
11450 }
11451
11452 if (info->native_size & (min_align - 1)) {
11453 info->native_size += min_align - 1;
11454 info->native_size &= ~(min_align - 1);
11455 }
11456
11457 /* Update the class's blittable info, if the layouts don't match */
11458 if (info->native_size != mono_class_value_size (klass, NULL))
11459 klass->blittable = FALSE;
11460
11461 /* If this is an array type, ensure that we have element info */
11462 if (klass->element_class && !mono_marshal_is_loading_type_info (klass->element_class)) {
11463 mono_marshal_load_type_info (klass->element_class);
11464 }
11465
11466 loads_list = TlsGetValue (load_type_info_tls_id);
11467 loads_list = g_slist_remove (loads_list, klass);
11468 TlsSetValue (load_type_info_tls_id, loads_list);
11469
11470 /*We do double-checking locking on marshal_info */
11471 mono_memory_barrier ();
11472
11473 klass->marshal_info = info;
11474
11475 mono_loader_unlock ();
11476
11477 return klass->marshal_info;
11478 }
11479
11480 /**
11481 * mono_class_native_size:
11482 * @klass: a class
11483 *
11484 * Returns: the native size of an object instance (when marshaled
11485 * to unmanaged code)
11486 */
11487 gint32
11488 mono_class_native_size (MonoClass *klass, guint32 *align)
11489 {
11490 if (!klass->marshal_info) {
11491 if (mono_marshal_is_loading_type_info (klass)) {
11492 if (align)
11493 *align = 0;
11494 return 0;
11495 } else {
11496 mono_marshal_load_type_info (klass);
11497 }
11498 }
11499
11500 if (align)
11501 *align = klass->min_align;
11502
11503 return klass->marshal_info->native_size;
11504 }
11505
11506 /*
11507 * mono_type_native_stack_size:
11508 * @t: the type to return the size it uses on the stack
11509 *
11510 * Returns: the number of bytes required to hold an instance of this
11511 * type on the native stack
11512 */
11513 int
11514 mono_type_native_stack_size (MonoType *t, guint32 *align)
11515 {
11516 guint32 tmp;
11517
11518 g_assert (t != NULL);
11519
11520 if (!align)
11521 align = &tmp;
11522
11523 if (t->byref) {
11524 *align = 4;
11525 return 4;
11526 }
11527
11528 switch (t->type){
11529 case MONO_TYPE_BOOLEAN:
11530 case MONO_TYPE_CHAR:
11531 case MONO_TYPE_I1:
11532 case MONO_TYPE_U1:
11533 case MONO_TYPE_I2:
11534 case MONO_TYPE_U2:
11535 case MONO_TYPE_I4:
11536 case MONO_TYPE_U4:
11537 case MONO_TYPE_I:
11538 case MONO_TYPE_U:
11539 case MONO_TYPE_STRING:
11540 case MONO_TYPE_OBJECT:
11541 case MONO_TYPE_CLASS:
11542 case MONO_TYPE_SZARRAY:
11543 case MONO_TYPE_PTR:
11544 case MONO_TYPE_FNPTR:
11545 case MONO_TYPE_ARRAY:
11546 *align = 4;
11547 return 4;
11548 case MONO_TYPE_R4:
11549 *align = 4;
11550 return 4;
11551 case MONO_TYPE_I8:
11552 case MONO_TYPE_U8:
11553 case MONO_TYPE_R8:
11554 *align = 4;
11555 return 8;
11556 case MONO_TYPE_GENERICINST:
11557 if (!mono_type_generic_inst_is_valuetype (t)) {
11558 *align = 4;
11559 return 4;
11560 }
11561 /* Fall through */
11562 case MONO_TYPE_TYPEDBYREF:
11563 case MONO_TYPE_VALUETYPE: {
11564 guint32 size;
11565 MonoClass *klass = mono_class_from_mono_type (t);
11566
11567 if (klass->enumtype)
11568 return mono_type_native_stack_size (klass->enum_basetype, align);
11569 else {
11570 size = mono_class_native_size (klass, align);
11571 *align = *align + 3;
11572 *align &= ~3;
11573
11574 size += 3;
11575 size &= ~3;
11576
11577 return size;
11578 }
11579 }
11580 default:
11581 g_error ("type 0x%02x unknown", t->type);
11582 }
11583 return 0;
11584 }
11585
11586 /* __alignof__ returns the preferred alignment of values not the actual alignment used by
11587 the compiler so is wrong e.g. for Linux where doubles are aligned on a 4 byte boundary
11588 but __alignof__ returns 8 - using G_STRUCT_OFFSET works better */
11589 #define ALIGNMENT(type) G_STRUCT_OFFSET(struct { char c; type x; }, x)
11590
11591 gint32
11592 mono_marshal_type_size (MonoType *type, MonoMarshalSpec *mspec, guint32 *align,
11593 gboolean as_field, gboolean unicode)
11594 {
11595 MonoMarshalNative native_type = mono_type_to_unmanaged (type, mspec, as_field, unicode, NULL);
11596 MonoClass *klass;
11597
11598 switch (native_type) {
11599 case MONO_NATIVE_BOOLEAN:
11600 *align = 4;
11601 return 4;
11602 case MONO_NATIVE_I1:
11603 case MONO_NATIVE_U1:
11604 *align = 1;
11605 return 1;
11606 case MONO_NATIVE_I2:
11607 case MONO_NATIVE_U2:
11608 case MONO_NATIVE_VARIANTBOOL:
11609 *align = 2;
11610 return 2;
11611 case MONO_NATIVE_I4:
11612 case MONO_NATIVE_U4:
11613 case MONO_NATIVE_ERROR:
11614 *align = 4;
11615 return 4;
11616 case MONO_NATIVE_I8:
11617 case MONO_NATIVE_U8:
11618 *align = ALIGNMENT(guint64);
11619 return 8;
11620 case MONO_NATIVE_R4:
11621 *align = 4;
11622 return 4;
11623 case MONO_NATIVE_R8:
11624 *align = ALIGNMENT(double);
11625 return 8;
11626 case MONO_NATIVE_INT:
11627 case MONO_NATIVE_UINT:
11628 case MONO_NATIVE_LPSTR:
11629 case MONO_NATIVE_LPWSTR:
11630 case MONO_NATIVE_LPTSTR:
11631 case MONO_NATIVE_BSTR:
11632 case MONO_NATIVE_ANSIBSTR:
11633 case MONO_NATIVE_TBSTR:
11634 case MONO_NATIVE_LPARRAY:
11635 case MONO_NATIVE_SAFEARRAY:
11636 case MONO_NATIVE_IUNKNOWN:
11637 case MONO_NATIVE_IDISPATCH:
11638 case MONO_NATIVE_INTERFACE:
11639 case MONO_NATIVE_ASANY:
11640 case MONO_NATIVE_FUNC:
11641 case MONO_NATIVE_LPSTRUCT:
11642 *align = ALIGNMENT(gpointer);
11643 return sizeof (gpointer);
11644 case MONO_NATIVE_STRUCT:
11645 klass = mono_class_from_mono_type (type);
11646 if (klass == mono_defaults.object_class &&
11647 (mspec && mspec->native == MONO_NATIVE_STRUCT)) {
11648 *align = 16;
11649 return 16;
11650 }
11651 return mono_class_native_size (klass, align);
11652 case MONO_NATIVE_BYVALTSTR: {
11653 int esize = unicode ? 2: 1;
11654 g_assert (mspec);
11655 *align = esize;
11656 return mspec->data.array_data.num_elem * esize;
11657 }
11658 case MONO_NATIVE_BYVALARRAY: {
11659 // FIXME: Have to consider ArraySubType
11660 int esize;
11661 klass = mono_class_from_mono_type (type);
11662 if (klass->element_class == mono_defaults.char_class) {
11663 esize = unicode ? 2 : 1;
11664 *align = esize;
11665 } else {
11666 esize = mono_class_native_size (klass->element_class, align);
11667 }
11668 g_assert (mspec);
11669 return mspec->data.array_data.num_elem * esize;
11670 }
11671 case MONO_NATIVE_CUSTOM:
11672 *align = sizeof (gpointer);
11673 return sizeof (gpointer);
11674 break;
11675 case MONO_NATIVE_CURRENCY:
11676 case MONO_NATIVE_VBBYREFSTR:
11677 default:
11678 g_error ("native type %02x not implemented", native_type);
11679 break;
11680 }
11681 g_assert_not_reached ();
11682 return 0;
11683 }
11684
11685 gpointer
11686 mono_marshal_asany (MonoObject *o, MonoMarshalNative string_encoding, int param_attrs)
11687 {
11688 MonoType *t;
11689 MonoClass *klass;
11690
11691 if (o == NULL)
11692 return NULL;
11693
11694 t = &o->vtable->klass->byval_arg;
11695 switch (t->type) {
11696 case MONO_TYPE_I4:
11697 case MONO_TYPE_U4:
11698 case MONO_TYPE_PTR:
11699 case MONO_TYPE_I1:
11700 case MONO_TYPE_U1:
11701 case MONO_TYPE_BOOLEAN:
11702 case MONO_TYPE_I2:
11703 case MONO_TYPE_U2:
11704 case MONO_TYPE_CHAR:
11705 case MONO_TYPE_I8:
11706 case MONO_TYPE_U8:
11707 case MONO_TYPE_R4:
11708 case MONO_TYPE_R8:
11709 return mono_object_unbox (o);
11710 break;
11711 case MONO_TYPE_STRING:
11712 switch (string_encoding) {
11713 case MONO_NATIVE_LPWSTR:
11714 return mono_string_to_utf16 ((MonoString*)o);
11715 break;
11716 case MONO_NATIVE_LPSTR:
11717 return mono_string_to_lpstr ((MonoString*)o);
11718 break;
11719 default:
11720 g_warning ("marshaling conversion %d not implemented", string_encoding);
11721 g_assert_not_reached ();
11722 }
11723 break;
11724 case MONO_TYPE_CLASS:
11725 case MONO_TYPE_VALUETYPE: {
11726 MonoMethod *method;
11727 gpointer pa [3];
11728 gpointer res;
11729 MonoBoolean delete_old = FALSE;
11730
11731 klass = t->data.klass;
11732
11733 if ((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_AUTO_LAYOUT)
11734 break;
11735
11736 if (klass->valuetype && (((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) ||
11737 klass->blittable || klass->enumtype))
11738 return mono_object_unbox (o);
11739
11740 res = mono_marshal_alloc (mono_class_native_size (klass, NULL));
11741
11742 if (!((param_attrs & PARAM_ATTRIBUTE_OUT) && !(param_attrs & PARAM_ATTRIBUTE_IN))) {
11743 method = mono_marshal_get_struct_to_ptr (o->vtable->klass);
11744
11745 pa [0] = o;
11746 pa [1] = &res;
11747 pa [2] = &delete_old;
11748
11749 mono_runtime_invoke (method, NULL, pa, NULL);
11750 }
11751
11752 return res;
11753 }
11754 }
11755
11756 mono_raise_exception (mono_get_exception_argument ("", "No PInvoke conversion exists for value passed to Object-typed parameter."));
11757
11758 return NULL;
11759 }
11760
11761 void
11762 mono_marshal_free_asany (MonoObject *o, gpointer ptr, MonoMarshalNative string_encoding, int param_attrs)
11763 {
11764 MonoType *t;
11765 MonoClass *klass;
11766
11767 if (o == NULL)
11768 return;
11769
11770 t = &o->vtable->klass->byval_arg;
11771 switch (t->type) {
11772 case MONO_TYPE_STRING:
11773 switch (string_encoding) {
11774 case MONO_NATIVE_LPWSTR:
11775 case MONO_NATIVE_LPSTR:
11776 mono_marshal_free (ptr);
11777 break;
11778 default:
11779 g_warning ("marshaling conversion %d not implemented", string_encoding);
11780 g_assert_not_reached ();
11781 }
11782 break;
11783 case MONO_TYPE_CLASS:
11784 case MONO_TYPE_VALUETYPE: {
11785 klass = t->data.klass;
11786
11787 if (klass->valuetype && (((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) ||
11788 klass->blittable || klass->enumtype))
11789 break;
11790
11791 if (param_attrs & PARAM_ATTRIBUTE_OUT) {
11792 MonoMethod *method = mono_marshal_get_ptr_to_struct (o->vtable->klass);
11793 gpointer pa [2];
11794
11795 pa [0] = &ptr;
11796 pa [1] = o;
11797
11798 mono_runtime_invoke (method, NULL, pa, NULL);
11799 }
11800
11801 if (!((param_attrs & PARAM_ATTRIBUTE_OUT) && !(param_attrs & PARAM_ATTRIBUTE_IN))) {
11802 mono_struct_delete_old (klass, ptr);
11803 }
11804
11805 mono_marshal_free (ptr);
11806 break;
11807 }
11808 default:
11809 break;
11810 }
11811 }
11812
11813 MonoMethod *
11814 mono_marshal_get_generic_array_helper (MonoClass *class, MonoClass *iface, gchar *name, MonoMethod *method)
11815 {
11816 MonoMethodSignature *sig, *csig;
11817 MonoMethodBuilder *mb;
11818 MonoMethod *res;
11819 int i;
11820
11821 mb = mono_mb_new_no_dup_name (class, name, MONO_WRAPPER_MANAGED_TO_MANAGED);
11822 mb->method->slot = -1;
11823
11824 mb->method->flags = METHOD_ATTRIBUTE_PRIVATE | METHOD_ATTRIBUTE_VIRTUAL |
11825 METHOD_ATTRIBUTE_NEW_SLOT | METHOD_ATTRIBUTE_HIDE_BY_SIG | METHOD_ATTRIBUTE_FINAL;
11826
11827 sig = mono_method_signature (method);
11828 csig = signature_dup (method->klass->image, sig);
11829 csig->generic_param_count = 0;
11830
11831 mono_mb_emit_ldarg (mb, 0);
11832 for (i = 0; i < csig->param_count; i++)
11833 mono_mb_emit_ldarg (mb, i + 1);
11834 mono_mb_emit_managed_call (mb, method, NULL);
11835 mono_mb_emit_byte (mb, CEE_RET);
11836
11837 res = mono_mb_create_method (mb, csig, csig->param_count + 16);
11838
11839 /* We can corlib internal methods */
11840 res->skip_visibility = TRUE;
11841
11842 mono_mb_free (mb);
11843
11844 return res;
11845 }
11846
11847 /*
11848 * The mono_win32_compat_* functions are implementations of inline
11849 * Windows kernel32 APIs, which are DllImport-able under MS.NET,
11850 * although not exported by kernel32.
11851 *
11852 * We map the appropiate kernel32 entries to these functions using
11853 * dllmaps declared in the global etc/mono/config.
11854 */
11855
11856 void
11857 mono_win32_compat_CopyMemory (gpointer dest, gconstpointer source, gsize length)
11858 {
11859 if (!dest || !source)
11860 return;
11861
11862 memcpy (dest, source, length);
11863 }
11864
11865 void
11866 mono_win32_compat_FillMemory (gpointer dest, gsize length, guchar fill)
11867 {
11868 memset (dest, fill, length);
11869 }
11870
11871 void
11872 mono_win32_compat_MoveMemory (gpointer dest, gconstpointer source, gsize length)
11873 {
11874 if (!dest || !source)
11875 return;
11876
11877 memmove (dest, source, length);
11878 }
11879
11880 void
11881 mono_win32_compat_ZeroMemory (gpointer dest, gsize length)
11882 {
11883 memset (dest, 0, length);
11884 }
11885
11886 /* Put COM Interop related stuff here */
11887
11888 #ifndef DISABLE_COM
11889
11890 /**
11891 * cominterop_get_ccw_object:
11892 * @ccw_entry: a pointer to the CCWEntry
11893 * @verify: verify ccw_entry is in fact a ccw
11894 *
11895 * Returns: the corresponding object for the CCW
11896 */
11897 static MonoObject*
11898 cominterop_get_ccw_object (MonoCCWInterface* ccw_entry, gboolean verify)
11899 {
11900 MonoCCW *ccw = NULL;
11901
11902 /* no CCW's exist yet */
11903 if (!ccw_interface_hash)
11904 return NULL;
11905
11906 if (verify) {
11907 ccw = g_hash_table_lookup (ccw_interface_hash, ccw_entry);
11908 }
11909 else {
11910 ccw = ccw_entry->ccw;
11911 g_assert (ccw);
11912 }
11913 if (ccw)
11914 return mono_gchandle_get_target (ccw->gc_handle);
11915 else
11916 return NULL;
11917 }
11918
11919 static void
11920 cominterop_setup_marshal_context (EmitMarshalContext *m, MonoMethod *method)
11921 {
11922 MonoMethodSignature *sig, *csig;
11923 sig = mono_method_signature (method);
11924 /* we copy the signature, so that we can modify it */
11925 /* FIXME: which to use? */
11926 csig = signature_dup (method->klass->image, sig);
11927 /* csig = mono_metadata_signature_dup (sig); */
11928
11929 /* STDCALL on windows, CDECL everywhere else to work with XPCOM and MainWin COM */
11930 #ifdef PLATFORM_WIN32
11931 csig->call_convention = MONO_CALL_STDCALL;
11932 #else
11933 csig->call_convention = MONO_CALL_C;
11934 #endif
11935 csig->hasthis = 0;
11936 csig->pinvoke = 1;
11937
11938 m->image = method->klass->image;
11939 m->piinfo = NULL;
11940 m->retobj_var = 0;
11941 m->sig = sig;
11942 m->csig = csig;
11943 }
11944
11945 /**
11946 * cominterop_get_ccw:
11947 * @object: a pointer to the object
11948 * @itf: interface type needed
11949 *
11950 * Returns: a value indicating if the object is a
11951 * Runtime Callable Wrapper (RCW) for a COM object
11952 */
11953 static gpointer
11954 cominterop_get_ccw (MonoObject* object, MonoClass* itf)
11955 {
11956 int i;
11957 MonoCCW *ccw = NULL;
11958 MonoCCWInterface* ccw_entry = NULL;
11959 gpointer *vtable = NULL;
11960 static gpointer iunknown[3] = {NULL, NULL, NULL};
11961 static gpointer idispatch[4] = {NULL, NULL, NULL, NULL};
11962 MonoClass* iface = NULL;
11963 MonoClass* klass = NULL;
11964 EmitMarshalContext m;
11965 int start_slot = 3;
11966 int method_count = 0;
11967 GList *ccw_list, *ccw_list_item;
11968 MonoCustomAttrInfo *cinfo = NULL;
11969
11970 if (!object)
11971 return NULL;
11972
11973 klass = mono_object_get_class (object);
11974
11975 if (!ccw_hash)
11976 ccw_hash = g_hash_table_new (mono_aligned_addr_hash, NULL);
11977 if (!ccw_interface_hash)
11978 ccw_interface_hash = g_hash_table_new (mono_aligned_addr_hash, NULL);
11979
11980 ccw_list = g_hash_table_lookup (ccw_hash, GINT_TO_POINTER (mono_object_hash (object)));
11981
11982 ccw_list_item = ccw_list;
11983 while (ccw_list_item) {
11984 MonoCCW* ccw_iter = ccw_list_item->data;
11985 if (mono_gchandle_get_target (ccw_iter->gc_handle) == object) {
11986 ccw = ccw_iter;
11987 break;
11988 }
11989 ccw_list_item = g_list_next(ccw_list_item);
11990 }
11991
11992 if (!iunknown [0]) {
11993 iunknown [0] = cominterop_ccw_queryinterface;
11994 iunknown [1] = cominterop_ccw_addref;
11995 iunknown [2] = cominterop_ccw_release;
11996 }
11997
11998 if (!idispatch [0]) {
11999 idispatch [0] = cominterop_ccw_get_type_info_count;
12000 idispatch [1] = cominterop_ccw_get_type_info;
12001 idispatch [2] = cominterop_ccw_get_ids_of_names;
12002 idispatch [3] = cominterop_ccw_invoke;
12003 }
12004
12005 if (!ccw) {
12006 ccw = g_new0 (MonoCCW, 1);
12007 #ifdef PLATFORM_WIN32
12008 ccw->free_marshaler = 0;
12009 #endif
12010 ccw->vtable_hash = g_hash_table_new (mono_aligned_addr_hash, NULL);
12011 ccw->ref_count = 0;
12012 /* just alloc a weak handle until we are addref'd*/
12013 ccw->gc_handle = mono_gchandle_new_weakref (object, FALSE);
12014
12015 if (!ccw_list) {
12016 ccw_list = g_list_alloc ();
12017 ccw_list->data = ccw;
12018 }
12019 else
12020 ccw_list = g_list_append (ccw_list, ccw);
12021 g_hash_table_insert (ccw_hash, GINT_TO_POINTER (mono_object_hash (object)), ccw_list);
12022 /* register for finalization to clean up ccw */
12023 mono_object_register_finalizer (object);
12024 }
12025
12026 cinfo = mono_custom_attrs_from_class (itf);
12027 if (cinfo) {
12028 static MonoClass* coclass_attribute = NULL;
12029 if (!coclass_attribute)
12030 coclass_attribute = mono_class_from_name (mono_defaults.corlib, "System.Runtime.InteropServices", "CoClassAttribute");
12031 if (mono_custom_attrs_has_attr (cinfo, coclass_attribute)) {
12032 g_assert(itf->interface_count && itf->interfaces[0]);
12033 itf = itf->interfaces[0];
12034 }
12035 if (!cinfo->cached)
12036 mono_custom_attrs_free (cinfo);
12037 }
12038
12039 iface = itf;
12040 if (iface == mono_defaults.iunknown_class) {
12041 start_slot = 3;
12042 }
12043 else if (iface == mono_defaults.idispatch_class) {
12044 start_slot = 7;
12045 }
12046 else {
12047 method_count += iface->method.count;
12048 start_slot = cominterop_get_com_slot_begin (iface);
12049 iface = NULL;
12050 }
12051
12052 ccw_entry = g_hash_table_lookup (ccw->vtable_hash, itf);
12053
12054 if (!ccw_entry) {
12055 int vtable_index = method_count-1+start_slot;
12056 mono_loader_lock ();
12057 vtable = mono_image_alloc0 (klass->image, sizeof (gpointer)*(method_count+start_slot));
12058 mono_loader_unlock ();
12059 memcpy (vtable, iunknown, sizeof (iunknown));
12060 if (start_slot == 7)
12061 memcpy (vtable+3, idispatch, sizeof (idispatch));
12062
12063 iface = itf;
12064 for (i = iface->method.count-1; i >= 0;i--) {
12065 int param_index = 0;
12066 MonoMethodBuilder *mb;
12067 MonoMarshalSpec ** mspecs;
12068 MonoMethod *wrapper_method, *adjust_method;
12069 MonoMethod *method = iface->methods [i];
12070 MonoMethodSignature* sig_adjusted;
12071 MonoMethodSignature* sig = mono_method_signature (method);
12072 gboolean preserve_sig = method->iflags & METHOD_IMPL_ATTRIBUTE_PRESERVE_SIG;
12073
12074
12075 mb = mono_mb_new (iface, method->name, MONO_WRAPPER_NATIVE_TO_MANAGED);
12076 adjust_method = cominterop_get_managed_wrapper_adjusted (method);
12077 sig_adjusted = mono_method_signature (adjust_method);
12078
12079 mspecs = g_new (MonoMarshalSpec*, sig_adjusted->param_count + 1);
12080 mono_method_get_marshal_info (method, mspecs);
12081
12082
12083 /* move managed args up one */
12084 for (param_index = sig->param_count; param_index >= 1; param_index--) {
12085 int mspec_index = param_index+1;
12086 mspecs [mspec_index] = mspecs [param_index];
12087
12088 if (mspecs[mspec_index] == NULL) {
12089 if (sig_adjusted->params[param_index]->type == MONO_TYPE_OBJECT) {
12090 mspecs[mspec_index] = g_new0 (MonoMarshalSpec, 1);
12091 mspecs[mspec_index]->native = MONO_NATIVE_STRUCT;
12092 }
12093 else if (sig_adjusted->params[param_index]->type == MONO_TYPE_STRING) {
12094 mspecs[mspec_index] = g_new0 (MonoMarshalSpec, 1);
12095 mspecs[mspec_index]->native = MONO_NATIVE_BSTR;
12096 }
12097 else if (sig_adjusted->params[param_index]->type == MONO_TYPE_CLASS) {
12098 mspecs[mspec_index] = g_new0 (MonoMarshalSpec, 1);
12099 mspecs[mspec_index]->native = MONO_NATIVE_INTERFACE;
12100 }
12101 }
12102 }
12103
12104 /* first arg is IntPtr for interface */
12105 mspecs [1] = NULL;
12106
12107 /* move return spec to last param */
12108 if (!preserve_sig && !MONO_TYPE_IS_VOID (sig->ret)) {
12109 if (mspecs [0] == NULL) {
12110 if (sig_adjusted->params[sig_adjusted->param_count-1]->type == MONO_TYPE_OBJECT) {
12111 mspecs[0] = g_new0 (MonoMarshalSpec, 1);
12112 mspecs[0]->native = MONO_NATIVE_STRUCT;
12113 }
12114 else if (sig_adjusted->params[sig_adjusted->param_count-1]->type == MONO_TYPE_STRING) {
12115 mspecs[0] = g_new0 (MonoMarshalSpec, 1);
12116 mspecs[0]->native = MONO_NATIVE_BSTR;
12117 }
12118 else if (sig_adjusted->params[sig_adjusted->param_count-1]->type == MONO_TYPE_CLASS) {
12119 mspecs[0] = g_new0 (MonoMarshalSpec, 1);
12120 mspecs[0]->native = MONO_NATIVE_INTERFACE;
12121 }
12122 }
12123
12124 mspecs [sig_adjusted->param_count] = mspecs [0];
12125 mspecs [0] = NULL;
12126 }
12127
12128 cominterop_setup_marshal_context (&m, adjust_method);
12129 m.mb = mb;
12130 mono_marshal_emit_managed_wrapper (mb, sig_adjusted, mspecs, &m, adjust_method, NULL);
12131 mono_loader_lock ();
12132 mono_marshal_lock ();
12133 wrapper_method = mono_mb_create_method (mb, m.csig, m.csig->param_count + 16);
12134 mono_marshal_unlock ();
12135 mono_loader_unlock ();
12136
12137 /* skip visiblity since we call internal methods */
12138 wrapper_method->skip_visibility = TRUE;
12139
12140 vtable [vtable_index--] = mono_compile_method (wrapper_method);
12141
12142
12143 for (param_index = sig_adjusted->param_count; param_index >= 0; param_index--)
12144 if (mspecs [param_index])
12145 mono_metadata_free_marshal_spec (mspecs [param_index]);
12146 g_free (mspecs);
12147 }
12148
12149 ccw_entry = g_new0 (MonoCCWInterface, 1);
12150 ccw_entry->ccw = ccw;
12151 ccw_entry->vtable = vtable;
12152 g_hash_table_insert (ccw->vtable_hash, itf, ccw_entry);
12153 g_hash_table_insert (ccw_interface_hash, ccw_entry, ccw);
12154 }
12155
12156 return ccw_entry;
12157 }
12158
12159 static gboolean
12160 mono_marshal_free_ccw_entry (gpointer key, gpointer value, gpointer user_data)
12161 {
12162 g_assert (value);
12163 g_free (value);
12164 return TRUE;
12165 }
12166
12167 /**
12168 * mono_marshal_free_ccw:
12169 * @object: the mono object
12170 *
12171 * Returns: whether the object had a CCW
12172 */
12173 gboolean
12174 mono_marshal_free_ccw (MonoObject* object)
12175 {
12176 GList *ccw_list, *ccw_list_orig, *ccw_list_item;
12177 /* no ccw's were created */
12178 if (!ccw_hash || g_hash_table_size (ccw_hash) == 0)
12179 return FALSE;
12180
12181 /* need to cache orig list address to remove from hash_table if empty */
12182 mono_cominterop_lock ();
12183 ccw_list = ccw_list_orig = g_hash_table_lookup (ccw_hash, GINT_TO_POINTER (mono_object_hash (object)));
12184 mono_cominterop_unlock ();
12185
12186 if (!ccw_list)
12187 return FALSE;
12188
12189 ccw_list_item = ccw_list;
12190 while (ccw_list_item) {
12191 MonoCCW* ccw_iter = ccw_list_item->data;
12192 MonoObject* handle_target = mono_gchandle_get_target (ccw_iter->gc_handle);
12193
12194 /* Looks like the GC NULLs the weakref handle target before running the
12195 * finalizer. So if we get a NULL target, destroy the CCW as well. */
12196 if (!handle_target || handle_target == object) {
12197 /* remove all interfaces */
12198 g_hash_table_foreach_remove (ccw_iter->vtable_hash, mono_marshal_free_ccw_entry, NULL);
12199 g_hash_table_destroy (ccw_iter->vtable_hash);
12200
12201 /* get next before we delete */
12202 ccw_list_item = g_list_next(ccw_list_item);
12203
12204 /* remove ccw from list */
12205 ccw_list = g_list_remove (ccw_list, ccw_iter);
12206 g_free (ccw_iter);
12207 }
12208 else
12209 ccw_list_item = g_list_next(ccw_list_item);
12210 }
12211
12212 /* if list is empty remove original address from hash */
12213 if (g_list_length (ccw_list) == 0)
12214 g_hash_table_remove (ccw_hash, GINT_TO_POINTER (mono_object_hash (object)));
12215
12216
12217 return TRUE;
12218 }
12219
12220 /**
12221 * cominterop_get_managed_wrapper_adjusted:
12222 * @method: managed COM Interop method
12223 *
12224 * Returns: the generated method to call with signature matching
12225 * the unmanaged COM Method signature
12226 */
12227 static MonoMethod *
12228 cominterop_get_managed_wrapper_adjusted (MonoMethod *method)
12229 {
12230 static MonoMethod *get_hr_for_exception = NULL;
12231 MonoMethod *res = NULL;
12232 MonoMethodBuilder *mb;
12233 MonoMarshalSpec **mspecs;
12234 MonoMethodSignature *sig, *sig_native;
12235 MonoExceptionClause *main_clause = NULL;
12236 MonoMethodHeader *header;
12237 int pos_leave;
12238 int hr = 0;
12239 int i;
12240 gboolean preserve_sig = method->iflags & METHOD_IMPL_ATTRIBUTE_PRESERVE_SIG;
12241
12242 if (!get_hr_for_exception)
12243 get_hr_for_exception = mono_class_get_method_from_name (mono_defaults.marshal_class, "GetHRForException", -1);
12244
12245 sig = mono_method_signature (method);
12246
12247 /* create unmanaged wrapper */
12248 mb = mono_mb_new (method->klass, method->name, MONO_WRAPPER_COMINTEROP);
12249
12250 sig_native = cominterop_method_signature (method);
12251
12252 mspecs = g_new0 (MonoMarshalSpec*, sig_native->param_count+1);
12253
12254 mono_method_get_marshal_info (method, mspecs);
12255
12256 /* move managed args up one */
12257 for (i = sig->param_count; i >= 1; i--)
12258 mspecs [i+1] = mspecs [i];
12259
12260 /* first arg is IntPtr for interface */
12261 mspecs [1] = NULL;
12262
12263 /* move return spec to last param */
12264 if (!preserve_sig && !MONO_TYPE_IS_VOID (sig->ret))
12265 mspecs [sig_native->param_count] = mspecs [0];
12266
12267 mspecs [0] = NULL;
12268
12269 if (!preserve_sig) {
12270 hr = mono_mb_add_local (mb, &mono_defaults.int32_class->byval_arg);
12271
12272 /* try */
12273 main_clause = g_new0 (MonoExceptionClause, 1);
12274 main_clause->try_offset = mono_mb_get_label (mb);
12275 }
12276
12277 /* load last param to store result if not preserve_sig and not void */
12278 if (!preserve_sig && !MONO_TYPE_IS_VOID (sig->ret))
12279 mono_mb_emit_ldarg (mb, sig_native->param_count-1);
12280
12281 /* the CCW -> object conversion */
12282 mono_mb_emit_ldarg (mb, 0);
12283 mono_mb_emit_icon (mb, FALSE);
12284 mono_mb_emit_icall (mb, cominterop_get_ccw_object);
12285
12286 for (i = 0; i < sig->param_count; i++)
12287 mono_mb_emit_ldarg (mb, i+1);
12288
12289 mono_mb_emit_managed_call (mb, method, NULL);
12290
12291 if (!preserve_sig) {
12292 /* store result if not preserve_sig and we have one */
12293 if (!MONO_TYPE_IS_VOID (sig->ret))
12294 mono_mb_emit_byte (mb, mono_type_to_stind (sig->ret));
12295
12296 pos_leave = mono_mb_emit_branch (mb, CEE_LEAVE);
12297
12298 /* Main exception catch */
12299 main_clause->flags = MONO_EXCEPTION_CLAUSE_NONE;
12300 main_clause->try_len = mono_mb_get_pos (mb) - main_clause->try_offset;
12301 main_clause->data.catch_class = mono_defaults.object_class;
12302
12303 /* handler code */
12304 main_clause->handler_offset = mono_mb_get_label (mb);
12305 mono_mb_emit_managed_call (mb, get_hr_for_exception, NULL);
12306 mono_mb_emit_stloc (mb, hr);
12307 mono_mb_emit_branch (mb, CEE_LEAVE);
12308 main_clause->handler_len = mono_mb_get_pos (mb) - main_clause->handler_offset;
12309 /* end catch */
12310
12311 mono_mb_patch_branch (mb, pos_leave);
12312
12313 mono_mb_emit_ldloc (mb, hr);
12314 }
12315
12316 mono_mb_emit_byte (mb, CEE_RET);
12317
12318 mono_loader_lock ();
12319 mono_marshal_lock ();
12320 res = mono_mb_create_method (mb, sig_native, sig_native->param_count + 16);
12321 mono_marshal_unlock ();
12322 mono_loader_unlock ();
12323
12324 mono_mb_free (mb);
12325
12326 for (i = sig_native->param_count; i >= 0; i--)
12327 if (mspecs [i])
12328 mono_metadata_free_marshal_spec (mspecs [i]);
12329 g_free (mspecs);
12330
12331 if (!preserve_sig) {
12332 header = ((MonoMethodNormal *)res)->header;
12333 header->num_clauses = 1;
12334 header->clauses = main_clause;
12335 }
12336
12337 return res;
12338 }
12339
12340 /**
12341 * cominterop_mono_string_to_guid:
12342 *
12343 * Converts the standard string representation of a GUID
12344 * to a 16 byte Microsoft GUID.
12345 */
12346 static void
12347 cominterop_mono_string_to_guid (const MonoString* string, guint8 *guid) {
12348 gunichar2 * chars = mono_string_chars (string);
12349 int i = 0;
12350 static guint8 indexes[16] = {7, 5, 3, 1, 12, 10, 17, 15, 20, 22, 25, 27, 29, 31, 33, 35};
12351
12352 for (i = 0; i < sizeof(indexes); i++)
12353 guid [i] = g_unichar_xdigit_value (chars [indexes [i]]) + (g_unichar_xdigit_value (chars [indexes [i] - 1]) << 4);
12354 }
12355
12356 static gboolean
12357 cominterop_class_guid_equal (guint8* guid, MonoClass* klass)
12358 {
12359 guint8 klass_guid [16];
12360 if (cominterop_class_guid (klass, klass_guid))
12361 return !memcmp (guid, klass_guid, sizeof (klass_guid));
12362 return FALSE;
12363 }
12364
12365 static int STDCALL
12366 cominterop_ccw_addref (MonoCCWInterface* ccwe)
12367 {
12368 gint32 ref_count = 0;
12369 MonoCCW* ccw = ccwe->ccw;
12370 g_assert (ccw);
12371 g_assert (ccw->gc_handle);
12372 g_assert (ccw->ref_count >= 0);
12373 ref_count = InterlockedIncrement ((gint32*)&ccw->ref_count);
12374 if (ref_count == 1) {
12375 guint32 oldhandle = ccw->gc_handle;
12376 g_assert (oldhandle);
12377 /* since we now have a ref count, alloc a strong handle*/
12378 ccw->gc_handle = mono_gchandle_new (mono_gchandle_get_target (oldhandle), FALSE);
12379 mono_gchandle_free (oldhandle);
12380 }
12381 return ref_count;
12382 }
12383
12384 static int STDCALL
12385 cominterop_ccw_release (MonoCCWInterface* ccwe)
12386 {
12387 gint32 ref_count = 0;
12388 MonoCCW* ccw = ccwe->ccw;
12389 g_assert (ccw);
12390 g_assert (ccw->ref_count > 0);
12391 ref_count = InterlockedDecrement ((gint32*)&ccw->ref_count);
12392 if (ref_count == 0) {
12393 /* allow gc of object */
12394 guint32 oldhandle = ccw->gc_handle;
12395 g_assert (oldhandle);
12396 #ifdef PLATFORM_WIN32
12397 if (ccw->free_marshaler)
12398 ves_icall_System_Runtime_InteropServices_Marshal_ReleaseInternal (ccw->free_marshaler);
12399 #endif
12400 ccw->gc_handle = mono_gchandle_new_weakref (mono_gchandle_get_target (oldhandle), FALSE);
12401 mono_gchandle_free (oldhandle);
12402 }
12403 return ref_count;
12404 }
12405
12406 #define MONO_S_OK 0x00000000L
12407 #define MONO_E_NOINTERFACE 0x80004002L
12408 #define MONO_E_NOTIMPL 0x80004001L
12409
12410 #ifdef PLATFORM_WIN32
12411 static const IID MONO_IID_IMarshal = {0x3, 0x0, 0x0, {0xC0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x46}};
12412 #endif
12413
12414 #ifdef PLATFORM_WIN32
12415 /* All ccw objects are free threaded */
12416 static int
12417 cominterop_ccw_getfreethreadedmarshaler (MonoCCW* ccw, MonoObject* object, gpointer* ppv)
12418 {
12419 #ifdef PLATFORM_WIN32
12420 if (!ccw->free_marshaler) {
12421 int ret = 0;
12422 gpointer tunk;
12423 tunk = cominterop_get_ccw (object, mono_defaults.iunknown_class);
12424 /* remember to addref on QI */
12425 cominterop_ccw_addref (tunk);
12426 ret = CoCreateFreeThreadedMarshaler (tunk, (LPUNKNOWN*)&ccw->free_marshaler);
12427 cominterop_ccw_release(tunk);
12428 }
12429
12430 if (!ccw->free_marshaler)
12431 return MONO_E_NOINTERFACE;
12432
12433 return ves_icall_System_Runtime_InteropServices_Marshal_QueryInterfaceInternal (ccw->free_marshaler, (IID*)&MONO_IID_IMarshal, ppv);
12434 #else
12435 return MONO_E_NOINTERFACE;
12436 #endif
12437 }
12438 #endif
12439
12440 static int STDCALL
12441 cominterop_ccw_queryinterface (MonoCCWInterface* ccwe, guint8* riid, gpointer* ppv)
12442 {
12443 GPtrArray *ifaces;
12444 MonoClass *itf = NULL;
12445 int i;
12446 MonoCCW* ccw = ccwe->ccw;
12447 MonoClass* klass = NULL;
12448 MonoObject* object = mono_gchandle_get_target (ccw->gc_handle);
12449
12450 g_assert (object);
12451 klass = mono_object_class (object);
12452
12453 if (ppv)
12454 *ppv = NULL;
12455
12456 if (!mono_domain_get ())
12457 mono_thread_attach (mono_get_root_domain ());
12458
12459 /* handle IUnknown special */
12460 if (cominterop_class_guid_equal (riid, mono_defaults.iunknown_class)) {
12461 *ppv = cominterop_get_ccw (object, mono_defaults.iunknown_class);
12462 /* remember to addref on QI */
12463 cominterop_ccw_addref (*ppv);
12464 return MONO_S_OK;
12465 }
12466
12467 /* handle IDispatch special */
12468 if (cominterop_class_guid_equal (riid, mono_defaults.idispatch_class)) {
12469 *ppv = cominterop_get_ccw (object, mono_defaults.idispatch_class);
12470 /* remember to addref on QI */
12471 cominterop_ccw_addref (*ppv);
12472 return MONO_S_OK;
12473 }
12474
12475 #ifdef PLATFORM_WIN32
12476 /* handle IMarshal special */
12477 if (0 == memcmp (riid, &MONO_IID_IMarshal, sizeof (IID))) {
12478 return cominterop_ccw_getfreethreadedmarshaler (ccw, object, ppv);
12479 }
12480 #endif
12481
12482 ifaces = mono_class_get_implemented_interfaces (klass);
12483 if (ifaces) {
12484 for (i = 0; i < ifaces->len; ++i) {
12485 MonoClass *ic = NULL;
12486 ic = g_ptr_array_index (ifaces, i);
12487 if (cominterop_class_guid_equal (riid, ic)) {
12488 itf = ic;
12489 break;
12490 }
12491 }
12492 g_ptr_array_free (ifaces, TRUE);
12493 }
12494 if (itf) {
12495 *ppv = cominterop_get_ccw (object, itf);
12496 /* remember to addref on QI */
12497 cominterop_ccw_addref (*ppv);
12498 return MONO_S_OK;
12499 }
12500
12501 return MONO_E_NOINTERFACE;
12502 }
12503
12504 static int STDCALL
12505 cominterop_ccw_get_type_info_count (MonoCCWInterface* ccwe, guint32 *pctinfo)
12506 {
12507 return MONO_E_NOTIMPL;
12508 }
12509
12510 static int STDCALL
12511 cominterop_ccw_get_type_info (MonoCCWInterface* ccwe, guint32 iTInfo, guint32 lcid, gpointer *ppTInfo)
12512 {
12513 return MONO_E_NOTIMPL;
12514 }
12515
12516 static int STDCALL
12517 cominterop_ccw_get_ids_of_names (MonoCCWInterface* ccwe, gpointer riid,
12518 gunichar2** rgszNames, guint32 cNames,
12519 guint32 lcid, gint32 *rgDispId)
12520 {
12521 return MONO_E_NOTIMPL;
12522 }
12523
12524 static int STDCALL
12525 cominterop_ccw_invoke (MonoCCWInterface* ccwe, guint32 dispIdMember,
12526 gpointer riid, guint32 lcid,
12527 guint16 wFlags, gpointer pDispParams,
12528 gpointer pVarResult, gpointer pExcepInfo,
12529 guint32 *puArgErr)
12530 {
12531 return MONO_E_NOTIMPL;
12532 }
12533
12534 #else /* DISABLE_COM */
12535
12536 gboolean
12537 mono_marshal_free_ccw (MonoObject* object)
12538 {
12539 return FALSE;
12540 }
12541
12542 #endif /* DISABLE_COM */
12543
12544 void
12545 mono_marshal_find_nonzero_bit_offset (guint8 *buf, int len, int *byte_offset, guint8 *bitmask)
12546 {
12547 int i;
12548 guint8 byte;
12549
12550 for (i = 0; i < len; ++i)
12551 if (buf [i])
12552 break;
12553
12554 g_assert (i < len);
12555
12556 byte = buf [i];
12557 while (byte && !(byte & 1))
12558 byte >>= 1;
12559 g_assert (byte == 1);
12560
12561 *byte_offset = i;
12562 *bitmask = buf [i];
12563 }
12564
12565 MonoMethod *
12566 mono_marshal_get_thunk_invoke_wrapper (MonoMethod *method)
12567 {
12568 MonoMethodBuilder *mb;
12569 MonoMethodSignature *sig, *csig;
12570 MonoExceptionClause *clause;
12571 MonoMethodHeader *header;
12572 MonoImage *image;
12573 MonoClass *klass;
12574 GHashTable *cache;
12575 MonoMethod *res;
12576 int i, param_count, sig_size, pos_leave;
12577
12578 g_assert (method);
12579
12580 klass = method->klass;
12581 image = method->klass->image;
12582 cache = get_cache (&image->thunk_invoke_cache, mono_aligned_addr_hash, NULL);
12583
12584 if ((res = mono_marshal_find_in_cache (cache, method)))
12585 return res;
12586
12587 sig = mono_method_signature (method);
12588 mb = mono_mb_new (klass, method->name, MONO_WRAPPER_NATIVE_TO_MANAGED);
12589
12590 /* add "this" and exception param */
12591 param_count = sig->param_count + sig->hasthis + 1;
12592
12593 /* dup & extend signature */
12594 csig = mono_metadata_signature_alloc (image, param_count);
12595 sig_size = sizeof (MonoMethodSignature) + ((sig->param_count - MONO_ZERO_LEN_ARRAY) * sizeof (MonoType *));
12596 memcpy (csig, sig, sig_size);
12597 csig->param_count = param_count;
12598 csig->hasthis = 0;
12599 csig->pinvoke = 1;
12600 csig->call_convention = MONO_CALL_DEFAULT;
12601
12602 if (sig->hasthis) {
12603 /* add "this" */
12604 csig->params [0] = &klass->byval_arg;
12605 /* move params up by one */
12606 for (i = 0; i < sig->param_count; i++)
12607 csig->params [i + 1] = sig->params [i];
12608 }
12609
12610 /* setup exception param as byref+[out] */
12611 csig->params [param_count - 1] = mono_metadata_type_dup (image->mempool,
12612 &mono_defaults.exception_class->byval_arg);
12613 csig->params [param_count - 1]->byref = 1;
12614 csig->params [param_count - 1]->attrs = PARAM_ATTRIBUTE_OUT;
12615
12616 /* convert struct return to object */
12617 if (MONO_TYPE_ISSTRUCT (sig->ret))
12618 csig->ret = &mono_defaults.object_class->byval_arg;
12619
12620 /* local 0 (temp for exception object) */
12621 mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
12622
12623 /* local 1 (temp for result) */
12624 if (!MONO_TYPE_IS_VOID (sig->ret))
12625 mono_mb_add_local (mb, sig->ret);
12626
12627 /* clear exception arg */
12628 mono_mb_emit_ldarg (mb, param_count - 1);
12629 mono_mb_emit_byte (mb, CEE_LDNULL);
12630 mono_mb_emit_byte (mb, CEE_STIND_REF);
12631
12632 /* try */
12633 mono_loader_lock ();
12634 clause = mono_image_alloc0 (image, sizeof (MonoExceptionClause));
12635 mono_loader_unlock ();
12636 clause->try_offset = mono_mb_get_label (mb);
12637
12638 /* push method's args */
12639 for (i = 0; i < param_count - 1; i++) {
12640 MonoType *type;
12641 MonoClass *klass;
12642
12643 mono_mb_emit_ldarg (mb, i);
12644
12645 /* get the byval type of the param */
12646 klass = mono_class_from_mono_type (csig->params [i]);
12647 type = &klass->byval_arg;
12648
12649 /* unbox struct args */
12650 if (MONO_TYPE_ISSTRUCT (type)) {
12651 mono_mb_emit_op (mb, CEE_UNBOX, klass);
12652
12653 /* byref args & and the "this" arg must remain a ptr.
12654 Otherwise make a copy of the value type */
12655 if (!(csig->params [i]->byref || (i == 0 && sig->hasthis)))
12656 mono_mb_emit_op (mb, CEE_LDOBJ, klass);
12657
12658 csig->params [i] = &mono_defaults.object_class->byval_arg;
12659 }
12660 }
12661
12662 /* call */
12663 if (method->flags & METHOD_ATTRIBUTE_VIRTUAL)
12664 mono_mb_emit_op (mb, CEE_CALLVIRT, method);
12665 else
12666 mono_mb_emit_op (mb, CEE_CALL, method);
12667
12668 /* save result at local 1 */
12669 if (!MONO_TYPE_IS_VOID (sig->ret))
12670 mono_mb_emit_stloc (mb, 1);
12671
12672 pos_leave = mono_mb_emit_branch (mb, CEE_LEAVE);
12673
12674 /* catch */
12675 clause->flags = MONO_EXCEPTION_CLAUSE_NONE;
12676 clause->try_len = mono_mb_get_pos (mb) - clause->try_offset;
12677 clause->data.catch_class = mono_defaults.object_class;
12678
12679 clause->handler_offset = mono_mb_get_label (mb);
12680
12681 /* store exception at local 0 */
12682 mono_mb_emit_stloc (mb, 0);
12683 mono_mb_emit_ldarg (mb, param_count - 1);
12684 mono_mb_emit_ldloc (mb, 0);
12685 mono_mb_emit_byte (mb, CEE_STIND_REF);
12686 mono_mb_emit_branch (mb, CEE_LEAVE);
12687
12688 clause->handler_len = mono_mb_get_pos (mb) - clause->handler_offset;
12689
12690 mono_mb_patch_branch (mb, pos_leave);
12691 /* end-try */
12692
12693 if (!MONO_TYPE_IS_VOID (sig->ret)) {
12694 mono_mb_emit_ldloc (mb, 1);
12695
12696 /* box the return value */
12697 if (MONO_TYPE_ISSTRUCT (sig->ret))
12698 mono_mb_emit_op (mb, CEE_BOX, mono_class_from_mono_type (sig->ret));
12699 }
12700
12701 mono_mb_emit_byte (mb, CEE_RET);
12702
12703 res = mono_mb_create_and_cache (cache, method, mb, csig, param_count + 16);
12704 mono_mb_free (mb);
12705
12706 header = ((MonoMethodNormal *)res)->header;
12707 header->num_clauses = 1;
12708 header->clauses = clause;
12709
12710 return res;
12711 }
Mirror of the official Mono project git repository