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