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