2 * marshal.c: Routines for marshaling complex types in P/Invoke methods.
5 * Paolo Molaro (lupus@ximian.com)
7 * (C) 2002 Ximian, Inc. http://www.ximian.com
14 #include "metadata/marshal.h"
15 #include "metadata/tabledefs.h"
16 #include "metadata/exception.h"
17 #include "metadata/appdomain.h"
18 #include "mono/metadata/debug-helpers.h"
19 #include "mono/metadata/threadpool.h"
20 #include "mono/metadata/threads.h"
21 #include "mono/metadata/monitor.h"
22 #include "mono/metadata/metadata-internals.h"
23 #include "mono/metadata/domain-internals.h"
24 #include "mono/metadata/gc-internal.h"
25 #include "mono/metadata/threads-types.h"
26 #include <mono/os/gc_wrapper.h>
30 /* #define DEBUG_RUNTIME_CODE */
32 #define OPDEF(a,b,c,d,e,f,g,h,i,j) \
36 MONO_MARSHAL_NONE
, /* No marshalling needed */
37 MONO_MARSHAL_COPY
, /* Can be copied by value to the new domain */
38 MONO_MARSHAL_COPY_OUT
, /* out parameter that needs to be copied back to the original instance */
39 MONO_MARSHAL_SERIALIZE
/* Value needs to be serialized into the new domain */
40 } MonoXDomainMarshalType
;
43 #include "mono/cil/opcode.def"
48 struct _MonoMethodBuilder
{
52 guint32 code_size
, pos
;
56 struct _MonoRemotingMethods
{
58 MonoMethod
*invoke_with_check
;
59 MonoMethod
*xdomain_invoke
;
60 MonoMethod
*xdomain_dispatch
;
63 typedef struct _MonoRemotingMethods MonoRemotingMethods
;
66 delegate_hash_table_add (MonoDelegate
*d
);
69 emit_struct_conv (MonoMethodBuilder
*mb
, MonoClass
*klass
, gboolean to_object
);
71 #ifdef DEBUG_RUNTIME_CODE
73 indenter (MonoDisHelper
*dh
, MonoMethod
*method
, guint32 ip_offset
)
75 return g_strdup (" ");
78 static MonoDisHelper marshal_dh
= {
88 /* This mutex protects the various marshalling related caches in MonoImage */
89 static CRITICAL_SECTION marshal_mutex
;
91 /* Maps wrapper methods to the methods they wrap */
92 static GHashTable
*wrapper_hash
;
94 static guint32 last_error_tls_id
;
96 static void mono_struct_delete_old (MonoClass
*klass
, char *ptr
);
97 void * mono_marshal_string_to_utf16 (MonoString
*s
);
99 static gpointer
mono_string_to_lpstr (MonoString
*string_obj
);
102 register_icall (gpointer func
, const char *name
, const char *sigstr
, gboolean save
)
104 MonoMethodSignature
*sig
= mono_create_icall_signature (sigstr
);
106 mono_register_jit_icall (func
, name
, sig
, save
);
109 static MonoMethodSignature
*
110 signature_no_pinvoke (MonoMethodSignature
* sig
)
113 sig
= mono_metadata_signature_dup (sig
);
114 sig
->pinvoke
= FALSE
;
121 mono_marshal_init (void)
123 static gboolean module_initialized
= FALSE
;
125 if (!module_initialized
) {
126 module_initialized
= TRUE
;
127 InitializeCriticalSection (&marshal_mutex
);
128 wrapper_hash
= g_hash_table_new (NULL
, NULL
);
129 last_error_tls_id
= TlsAlloc ();
131 register_icall (mono_marshal_string_to_utf16
, "mono_marshal_string_to_utf16", "ptr obj", FALSE
);
132 register_icall (mono_string_to_utf16
, "mono_string_to_utf16", "ptr obj", FALSE
);
133 register_icall (mono_string_from_utf16
, "mono_string_from_utf16", "obj ptr", FALSE
);
134 register_icall (mono_string_new_wrapper
, "mono_string_new_wrapper", "obj ptr", FALSE
);
135 register_icall (mono_string_to_utf8
, "mono_string_to_utf8", "ptr obj", FALSE
);
136 register_icall (mono_string_to_lpstr
, "mono_string_to_lpstr", "ptr obj", FALSE
);
137 register_icall (mono_string_to_bstr
, "mono_string_to_bstr", "ptr obj", FALSE
);
138 register_icall (mono_string_to_ansibstr
, "mono_string_to_ansibstr", "ptr object", FALSE
);
139 register_icall (mono_string_builder_to_utf8
, "mono_string_builder_to_utf8", "ptr object", FALSE
);
140 register_icall (mono_string_builder_to_utf16
, "mono_string_builder_to_utf16", "ptr object", FALSE
);
141 register_icall (mono_array_to_savearray
, "mono_array_to_savearray", "ptr object", FALSE
);
142 register_icall (mono_array_to_lparray
, "mono_array_to_lparray", "ptr object", FALSE
);
143 register_icall (mono_delegate_to_ftnptr
, "mono_delegate_to_ftnptr", "ptr object", FALSE
);
144 register_icall (mono_ftnptr_to_delegate
, "mono_ftnptr_to_delegate", "object ptr ptr", FALSE
);
145 register_icall (mono_marshal_asany
, "mono_marshal_asany", "ptr object int32", FALSE
);
146 register_icall (mono_marshal_free_asany
, "mono_marshal_free_asany", "void object ptr int32", FALSE
);
147 register_icall (mono_marshal_alloc
, "mono_marshal_alloc", "ptr int32", FALSE
);
148 register_icall (mono_marshal_free
, "mono_marshal_free", "void ptr", FALSE
);
149 register_icall (mono_string_utf8_to_builder
, "mono_string_utf8_to_builder", "void ptr ptr", FALSE
);
150 register_icall (mono_string_utf16_to_builder
, "mono_string_utf16_to_builder", "void ptr ptr", FALSE
);
151 register_icall (mono_marshal_free_array
, "mono_marshal_free_array", "void ptr int32", FALSE
);
152 register_icall (mono_string_to_byvalstr
, "mono_string_to_byvalstr", "void ptr ptr int32", FALSE
);
153 register_icall (mono_string_to_byvalwstr
, "mono_string_to_byvalwstr", "void ptr ptr int32", FALSE
);
154 register_icall (g_free
, "g_free", "void ptr", FALSE
);
155 register_icall (mono_object_isinst
, "mono_object_isinst", "object object ptr", FALSE
);
156 register_icall (mono_struct_delete_old
, "mono_struct_delete_old", "void ptr ptr", FALSE
);
161 MonoClass
*byte_array_class
;
162 static MonoMethod
*method_rs_serialize
, *method_rs_deserialize
, *method_exc_fixexc
, *method_rs_appdomain_target
;
163 static MonoMethod
*method_set_context
, *method_get_context
, *method_reset_datastore
, *method_restore_datastore
;
164 static MonoMethod
*method_set_call_context
, *method_needs_context_sink
, *method_rs_serialize_exc
;
167 mono_remoting_marshal_init (void)
171 static gboolean module_initialized
= FALSE
;
173 if (!module_initialized
) {
174 klass
= mono_class_from_name (mono_defaults
.corlib
, "System.Runtime.Remoting", "RemotingServices");
175 method_rs_serialize
= mono_class_get_method_from_name (klass
, "SerializeCallData", -1);
176 method_rs_deserialize
= mono_class_get_method_from_name (klass
, "DeserializeCallData", -1);
177 method_rs_serialize_exc
= mono_class_get_method_from_name (klass
, "SerializeExceptionData", -1);
179 klass
= mono_defaults
.real_proxy_class
;
180 method_rs_appdomain_target
= mono_class_get_method_from_name (klass
, "GetAppDomainTarget", -1);
182 klass
= mono_defaults
.exception_class
;
183 method_exc_fixexc
= mono_class_get_method_from_name (klass
, "FixRemotingException", -1);
185 klass
= mono_defaults
.thread_class
;
186 method_reset_datastore
= mono_class_get_method_from_name (klass
, "ResetDataStoreStatus", -1);
187 method_restore_datastore
= mono_class_get_method_from_name (klass
, "RestoreDataStoreStatus", -1);
188 method_get_context
= mono_class_get_method_from_name (klass
, "get_CurrentContext", -1);
190 klass
= mono_defaults
.appdomain_class
;
191 method_set_context
= mono_class_get_method_from_name (klass
, "InternalSetContext", -1);
192 byte_array_class
= mono_array_class_get (mono_defaults
.byte_class
, 1);
194 klass
= mono_class_from_name (mono_defaults
.corlib
, "System.Runtime.Remoting.Messaging", "CallContext");
195 method_set_call_context
= mono_class_get_method_from_name (klass
, "SetCurrentCallContext", -1);
197 klass
= mono_class_from_name (mono_defaults
.corlib
, "System.Runtime.Remoting.Contexts", "Context");
198 method_needs_context_sink
= mono_class_get_method_from_name (klass
, "get_NeedsContextSink", -1);
203 mono_delegate_to_ftnptr (MonoDelegate
*delegate
)
205 MonoMethod
*method
, *wrapper
, *invoke
;
206 MonoMarshalSpec
**mspecs
;
213 if (delegate
->delegate_trampoline
)
214 return delegate
->delegate_trampoline
;
216 klass
= ((MonoObject
*)delegate
)->vtable
->klass
;
217 g_assert (klass
->delegate
);
219 method
= delegate
->method_info
->method
;
220 invoke
= mono_class_get_method_from_name (klass
, "Invoke", method
->signature
->param_count
);
222 mspecs
= g_new (MonoMarshalSpec
*, invoke
->signature
->param_count
+ 1);
223 mono_method_get_marshal_info (invoke
, mspecs
);
225 wrapper
= mono_marshal_get_managed_wrapper (method
, delegate
->target
, mspecs
);
227 for (i
= invoke
->signature
->param_count
; i
>= 0; i
--)
229 mono_metadata_free_marshal_spec (mspecs
[i
]);
232 delegate
->delegate_trampoline
= mono_compile_method (wrapper
);
234 // Add the delegate to the delegate hash table
235 delegate_hash_table_add (delegate
);
237 return delegate
->delegate_trampoline
;
240 static GHashTable
*delegate_hash_table
;
243 delegate_hash_table_new (void) {
244 return g_hash_table_new (NULL
, NULL
);
248 delegate_hash_table_remove (MonoDelegate
*d
)
250 EnterCriticalSection (&marshal_mutex
);
251 if (delegate_hash_table
== NULL
)
252 delegate_hash_table
= delegate_hash_table_new ();
253 g_hash_table_remove (delegate_hash_table
, d
->delegate_trampoline
);
254 LeaveCriticalSection (&marshal_mutex
);
258 delegate_hash_table_add (MonoDelegate
*d
)
260 EnterCriticalSection (&marshal_mutex
);
261 if (delegate_hash_table
== NULL
)
262 delegate_hash_table
= delegate_hash_table_new ();
263 g_hash_table_insert (delegate_hash_table
, d
->delegate_trampoline
, d
);
264 LeaveCriticalSection (&marshal_mutex
);
268 mono_ftnptr_to_delegate (MonoClass
*klass
, gpointer ftn
)
272 EnterCriticalSection (&marshal_mutex
);
273 if (delegate_hash_table
== NULL
)
274 delegate_hash_table
= delegate_hash_table_new ();
276 d
= g_hash_table_lookup (delegate_hash_table
, ftn
);
277 LeaveCriticalSection (&marshal_mutex
);
279 mono_raise_exception (mono_get_exception_argument (NULL
, "Additional information: Function pointer was not created by a delegate."));
284 mono_delegate_free_ftnptr (MonoDelegate
*delegate
)
289 delegate_hash_table_remove (delegate
);
290 ptr2
= delegate
->delegate_trampoline
;
292 ptr
= InterlockedExchangePointer (&delegate
->delegate_trampoline
, NULL
);
293 ji
= mono_jit_info_table_find (mono_domain_get (), ptr
);
296 if (!delegate
->target
) {
297 /* The wrapper method is shared between delegates -> no need to free it */
301 mono_runtime_free_method (mono_object_domain (delegate
), ji
->method
);
305 mono_array_to_savearray (MonoArray
*array
)
310 g_assert_not_reached ();
315 mono_array_to_lparray (MonoArray
*array
)
320 /* fixme: maybe we need to make a copy */
321 return array
->vector
;
325 mono_string_utf8_to_builder (MonoStringBuilder
*sb
, char *text
)
327 GError
*error
= NULL
;
337 ut
= g_utf8_to_utf16 (text
, l
, NULL
, &items_written
, &error
);
339 if (items_written
> mono_stringbuilder_capacity (sb
))
340 items_written
= mono_stringbuilder_capacity (sb
);
343 if (! sb
->str
|| sb
->str
== sb
->cached_str
) {
344 sb
->str
= mono_string_new_size (mono_domain_get (), items_written
);
345 sb
->cached_str
= NULL
;
348 memcpy (mono_string_chars (sb
->str
), ut
, items_written
* 2);
349 sb
->length
= items_written
;
351 g_error_free (error
);
357 mono_string_utf16_to_builder (MonoStringBuilder
*sb
, gunichar2
*text
)
364 g_assert (mono_string_chars (sb
->str
) == text
);
366 for (len
= 0; text
[len
] != 0; ++len
)
373 mono_string_builder_to_utf8 (MonoStringBuilder
*sb
)
375 GError
*error
= NULL
;
382 res
= mono_marshal_alloc (mono_stringbuilder_capacity (sb
) + 1);
384 tmp
= g_utf16_to_utf8 (mono_string_chars (sb
->str
), sb
->length
, NULL
, res
, &error
);
386 g_error_free (error
);
387 mono_raise_exception (mono_get_exception_execution_engine ("Failed to convert StringBuilder from utf16 to utf8"));
390 memcpy (res
, tmp
, sb
->length
+ 1);
398 mono_string_builder_to_utf16 (MonoStringBuilder
*sb
)
404 * The sb could have been allocated with the default capacity and be empty.
405 * we need to alloc a buffer of the default capacity in this case.
408 sb
->str
= mono_string_new_size (mono_domain_get (), mono_stringbuilder_capacity (sb
));
410 * The stringbuilder might not have ownership of this string. If this is
411 * the case, we must duplicate the string, so that we don't munge immutable
414 else if (sb
->str
== sb
->cached_str
) {
415 sb
->str
= mono_string_new_utf16 (mono_domain_get (), mono_string_chars (sb
->str
), mono_stringbuilder_capacity (sb
));
416 sb
->cached_str
= NULL
;
419 return mono_string_chars (sb
->str
);
423 mono_string_to_lpstr (MonoString
*s
)
425 #ifdef PLATFORM_WIN32
428 GError
*error
= NULL
;
434 as
= CoTaskMemAlloc (1);
439 tmp
= g_utf16_to_utf8 (mono_string_chars (s
), s
->length
, NULL
, &len
, &error
);
441 g_warning (error
->message
);
442 g_error_free (error
);
446 as
= CoTaskMemAlloc (len
+ 1);
447 memcpy (as
, tmp
, len
+ 1);
451 return mono_string_to_utf8 (s
);
456 mono_string_to_ansibstr (MonoString
*string_obj
)
458 g_error ("UnmanagedMarshal.BStr is not implemented.");
463 mono_string_to_bstr (MonoString
*string_obj
)
465 g_error ("UnmanagedMarshal.AnsiBStr is not implemented.");
470 mono_string_to_byvalstr (gpointer dst
, MonoString
*src
, int size
)
475 g_assert (dst
!= NULL
);
478 memset (dst
, 0, size
);
483 s
= mono_string_to_utf8 (src
);
484 len
= MIN (size
, strlen (s
));
485 memcpy (dst
, s
, len
);
488 *((char *)dst
+ size
- 1) = 0;
492 mono_string_to_byvalwstr (gpointer dst
, MonoString
*src
, int size
)
496 g_assert (dst
!= NULL
);
500 memset (dst
, 0, size
);
504 len
= MIN (size
, (mono_string_length (src
) * 2));
505 memcpy (dst
, mono_string_chars (src
), len
);
507 *((char *)dst
+ size
- 1) = 0;
508 *((char *)dst
+ size
- 2) = 0;
512 mono_mb_free (MonoMethodBuilder
*mb
)
514 g_list_free (mb
->locals_list
);
519 mono_mb_new (MonoClass
*klass
, const char *name
, MonoWrapperType type
)
521 MonoMethodBuilder
*mb
;
524 g_assert (klass
!= NULL
);
525 g_assert (name
!= NULL
);
527 mb
= g_new0 (MonoMethodBuilder
, 1);
529 mb
->method
= m
= (MonoMethod
*)g_new0 (MonoMethodWrapper
, 1);
532 m
->name
= g_strdup (name
);
534 m
->wrapper_type
= type
;
537 mb
->code
= g_malloc (mb
->code_size
);
543 mono_mb_add_local (MonoMethodBuilder
*mb
, MonoType
*type
)
545 int res
= mb
->locals
;
547 g_assert (mb
!= NULL
);
548 g_assert (type
!= NULL
);
550 mb
->locals_list
= g_list_append (mb
->locals_list
, type
);
557 mono_mb_create_method (MonoMethodBuilder
*mb
, MonoMethodSignature
*signature
, int max_stack
)
559 MonoMethodHeader
*header
;
560 MonoMethodWrapper
*mw
;
564 g_assert (mb
!= NULL
);
566 ((MonoMethodNormal
*)mb
->method
)->header
= header
= (MonoMethodHeader
*)
567 g_malloc0 (sizeof (MonoMethodHeader
) + mb
->locals
* sizeof (MonoType
*));
572 header
->max_stack
= max_stack
;
574 for (i
= 0, l
= mb
->locals_list
; l
; l
= l
->next
, i
++) {
575 header
->locals
[i
] = (MonoType
*)l
->data
;
578 mb
->method
->signature
= signature
;
579 header
->code
= mb
->code
;
580 header
->code_size
= mb
->pos
;
581 header
->num_locals
= mb
->locals
;
583 mw
= (MonoMethodWrapper
*) mb
->method
;
584 i
= g_list_length (mw
->method_data
);
588 l
= g_list_reverse (mw
->method_data
);
589 data
= mw
->method_data
= g_new (gpointer
, i
+ 1);
590 /* store the size in the first element */
591 data
[0] = GUINT_TO_POINTER (i
);
593 for (tmp
= l
; tmp
; tmp
= tmp
->next
) {
594 data
[i
++] = tmp
->data
;
599 static int total_code = 0;
600 static int total_alloc = 0;
601 total_code += mb->pos;
602 total_alloc += mb->code_size;
603 g_print ("code size: %d of %d (allocated: %d)\n", mb->pos, total_code, total_alloc);
606 #ifdef DEBUG_RUNTIME_CODE
607 printf ("RUNTIME CODE FOR %s\n", mono_method_full_name (mb
->method
, TRUE
));
608 printf ("%s\n", mono_disasm_code (&marshal_dh
, mb
->method
, mb
->code
, mb
->code
+ mb
->pos
));
615 mono_mb_add_data (MonoMethodBuilder
*mb
, gpointer data
)
617 MonoMethodWrapper
*mw
;
619 g_assert (mb
!= NULL
);
621 mw
= (MonoMethodWrapper
*)mb
->method
;
623 /* one O(n) is enough */
624 mw
->method_data
= g_list_prepend (mw
->method_data
, data
);
626 return g_list_length (mw
->method_data
);
630 mono_mb_patch_addr (MonoMethodBuilder
*mb
, int pos
, int value
)
632 mb
->code
[pos
] = value
& 0xff;
633 mb
->code
[pos
+ 1] = (value
>> 8) & 0xff;
634 mb
->code
[pos
+ 2] = (value
>> 16) & 0xff;
635 mb
->code
[pos
+ 3] = (value
>> 24) & 0xff;
639 mono_mb_patch_addr_s (MonoMethodBuilder
*mb
, int pos
, gint8 value
)
641 *((gint8
*)(&mb
->code
[pos
])) = value
;
645 mono_mb_emit_byte (MonoMethodBuilder
*mb
, guint8 op
)
647 if (mb
->pos
>= mb
->code_size
) {
648 mb
->code_size
+= mb
->code_size
>> 1;
649 mb
->code
= g_realloc (mb
->code
, mb
->code_size
);
652 mb
->code
[mb
->pos
++] = op
;
656 mono_mb_emit_ldflda (MonoMethodBuilder
*mb
, gint32 offset
)
658 mono_mb_emit_byte (mb
, MONO_CUSTOM_PREFIX
);
659 mono_mb_emit_byte (mb
, CEE_MONO_OBJADDR
);
662 mono_mb_emit_icon (mb
, offset
);
663 mono_mb_emit_byte (mb
, CEE_ADD
);
668 mono_mb_emit_proxy_check (MonoMethodBuilder
*mb
, int branch_code
)
671 mono_mb_emit_ldflda (mb
, G_STRUCT_OFFSET (MonoObject
, vtable
));
672 mono_mb_emit_byte (mb
, CEE_LDIND_I
);
673 mono_mb_emit_icon (mb
, G_STRUCT_OFFSET (MonoVTable
, klass
));
674 mono_mb_emit_byte (mb
, CEE_ADD
);
675 mono_mb_emit_byte (mb
, CEE_LDIND_I
);
676 mono_mb_emit_byte (mb
, MONO_CUSTOM_PREFIX
);
677 mono_mb_emit_byte (mb
, CEE_MONO_CLASSCONST
);
678 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, mono_defaults
.transparent_proxy_class
));
679 mono_mb_emit_byte (mb
, branch_code
);
681 mono_mb_emit_i4 (mb
, 0);
686 mono_mb_emit_xdomain_check (MonoMethodBuilder
*mb
, int branch_code
)
689 mono_mb_emit_ldflda (mb
, G_STRUCT_OFFSET (MonoTransparentProxy
, rp
));
690 mono_mb_emit_byte (mb
, CEE_LDIND_REF
);
691 mono_mb_emit_ldflda (mb
, G_STRUCT_OFFSET (MonoRealProxy
, target_domain_id
));
692 mono_mb_emit_byte (mb
, CEE_LDIND_I4
);
693 mono_mb_emit_icon (mb
, -1);
694 mono_mb_emit_byte (mb
, branch_code
);
696 mono_mb_emit_i4 (mb
, 0);
701 mono_mb_emit_i4 (MonoMethodBuilder
*mb
, gint32 data
)
703 if ((mb
->pos
+ 4) >= mb
->code_size
) {
704 mb
->code_size
+= mb
->code_size
>> 1;
705 mb
->code
= g_realloc (mb
->code
, mb
->code_size
);
708 mono_mb_patch_addr (mb
, mb
->pos
, data
);
713 mono_mb_emit_i2 (MonoMethodBuilder
*mb
, gint16 data
)
715 if ((mb
->pos
+ 2) >= mb
->code_size
) {
716 mb
->code_size
+= mb
->code_size
>> 1;
717 mb
->code
= g_realloc (mb
->code
, mb
->code_size
);
720 mb
->code
[mb
->pos
] = data
& 0xff;
721 mb
->code
[mb
->pos
+ 1] = (data
>> 8) & 0xff;
726 mono_mb_emit_ldstr (MonoMethodBuilder
*mb
, char *str
)
728 mono_mb_emit_byte (mb
, CEE_LDSTR
);
729 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, str
));
734 mono_mb_emit_ldarg (MonoMethodBuilder
*mb
, guint argnum
)
737 mono_mb_emit_byte (mb
, CEE_LDARG_0
+ argnum
);
738 } else if (argnum
< 256) {
739 mono_mb_emit_byte (mb
, CEE_LDARG_S
);
740 mono_mb_emit_byte (mb
, argnum
);
742 mono_mb_emit_byte (mb
, CEE_PREFIX1
);
743 mono_mb_emit_byte (mb
, CEE_LDARG
);
744 mono_mb_emit_i2 (mb
, argnum
);
749 mono_mb_emit_ldarg_addr (MonoMethodBuilder
*mb
, guint argnum
)
752 mono_mb_emit_byte (mb
, CEE_LDARGA_S
);
753 mono_mb_emit_byte (mb
, argnum
);
755 mono_mb_emit_byte (mb
, CEE_PREFIX1
);
756 mono_mb_emit_byte (mb
, CEE_LDARGA
);
757 mono_mb_emit_i2 (mb
, argnum
);
762 mono_mb_emit_ldloc_addr (MonoMethodBuilder
*mb
, guint locnum
)
765 mono_mb_emit_byte (mb
, CEE_LDLOCA_S
);
766 mono_mb_emit_byte (mb
, locnum
);
768 mono_mb_emit_byte (mb
, CEE_PREFIX1
);
769 mono_mb_emit_byte (mb
, CEE_LDLOCA
);
770 mono_mb_emit_i2 (mb
, locnum
);
775 mono_mb_emit_ldloc (MonoMethodBuilder
*mb
, guint num
)
778 mono_mb_emit_byte (mb
, CEE_LDLOC_0
+ num
);
779 } else if (num
< 256) {
780 mono_mb_emit_byte (mb
, CEE_LDLOC_S
);
781 mono_mb_emit_byte (mb
, num
);
783 mono_mb_emit_byte (mb
, CEE_PREFIX1
);
784 mono_mb_emit_byte (mb
, CEE_LDLOC
);
785 mono_mb_emit_i2 (mb
, num
);
790 mono_mb_emit_stloc (MonoMethodBuilder
*mb
, guint num
)
793 mono_mb_emit_byte (mb
, CEE_STLOC_0
+ num
);
794 } else if (num
< 256) {
795 mono_mb_emit_byte (mb
, CEE_STLOC_S
);
796 mono_mb_emit_byte (mb
, num
);
798 mono_mb_emit_byte (mb
, CEE_PREFIX1
);
799 mono_mb_emit_byte (mb
, CEE_STLOC
);
800 mono_mb_emit_i2 (mb
, num
);
805 mono_mb_emit_icon (MonoMethodBuilder
*mb
, gint32 value
)
807 if (value
>= -1 && value
< 8) {
808 mono_mb_emit_byte (mb
, CEE_LDC_I4_0
+ value
);
809 } else if (value
>= -128 && value
<= 127) {
810 mono_mb_emit_byte (mb
, CEE_LDC_I4_S
);
811 mono_mb_emit_byte (mb
, value
);
813 mono_mb_emit_byte (mb
, CEE_LDC_I4
);
814 mono_mb_emit_i4 (mb
, value
);
819 mono_mb_emit_branch (MonoMethodBuilder
*mb
, guint8 op
)
822 mono_mb_emit_byte (mb
, op
);
824 mono_mb_emit_i4 (mb
, 0);
829 mono_mb_emit_calli (MonoMethodBuilder
*mb
, MonoMethodSignature
*sig
)
831 mono_mb_emit_byte (mb
, CEE_CALLI
);
832 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, sig
));
836 mono_mb_emit_managed_call (MonoMethodBuilder
*mb
, MonoMethod
*method
, MonoMethodSignature
*opt_sig
)
838 mono_mb_emit_byte (mb
, CEE_CALL
);
839 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, method
));
843 mono_mb_emit_native_call (MonoMethodBuilder
*mb
, MonoMethodSignature
*sig
, gpointer func
)
845 mono_mb_emit_byte (mb
, MONO_CUSTOM_PREFIX
);
846 mono_mb_emit_byte (mb
, CEE_MONO_SAVE_LMF
);
847 mono_mb_emit_byte (mb
, MONO_CUSTOM_PREFIX
);
848 mono_mb_emit_byte (mb
, CEE_MONO_LDPTR
);
849 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, func
));
850 mono_mb_emit_calli (mb
, sig
);
851 mono_mb_emit_byte (mb
, MONO_CUSTOM_PREFIX
);
852 mono_mb_emit_byte (mb
, CEE_MONO_RESTORE_LMF
);
856 mono_mb_emit_icall (MonoMethodBuilder
*mb
, gpointer func
)
858 mono_mb_emit_byte (mb
, MONO_CUSTOM_PREFIX
);
859 mono_mb_emit_byte (mb
, CEE_MONO_ICALL
);
860 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, func
));
864 mono_mb_emit_exception (MonoMethodBuilder
*mb
, const char *exc_name
, const char *msg
)
866 /* fixme: we need a better way to throw exception,
867 * supporting several exception types and messages */
868 MonoMethod
*ctor
= NULL
;
870 MonoClass
*mme
= mono_class_from_name (mono_defaults
.corlib
, "System", exc_name
);
872 mono_class_init (mme
);
873 for (i
= 0; i
< mme
->method
.count
; ++i
) {
874 if (strcmp (mme
->methods
[i
]->name
, ".ctor") == 0 && mme
->methods
[i
]->signature
->param_count
== 0) {
875 ctor
= mme
->methods
[i
];
880 mono_mb_emit_byte (mb
, CEE_NEWOBJ
);
881 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, ctor
));
883 mono_mb_emit_byte (mb
, CEE_DUP
);
884 mono_mb_emit_ldflda (mb
, G_STRUCT_OFFSET (MonoException
, message
));
885 mono_mb_emit_ldstr (mb
, (char*)msg
);
886 mono_mb_emit_byte (mb
, CEE_STIND_I
);
888 mono_mb_emit_byte (mb
, CEE_THROW
);
892 mono_mb_emit_add_to_local (MonoMethodBuilder
*mb
, guint16 local
, gint32 incr
)
894 mono_mb_emit_ldloc (mb
, local
);
895 mono_mb_emit_icon (mb
, incr
);
896 mono_mb_emit_byte (mb
, CEE_ADD
);
897 mono_mb_emit_stloc (mb
, local
);
901 emit_ptr_to_object_conv (MonoMethodBuilder
*mb
, MonoType
*type
, MonoMarshalConv conv
,
902 int usize
, int msize
, MonoMarshalSpec
*mspec
)
905 case MONO_MARSHAL_CONV_BOOL_I4
:
906 mono_mb_emit_byte (mb
, CEE_LDLOC_1
);
907 mono_mb_emit_byte (mb
, CEE_LDLOC_0
);
908 mono_mb_emit_byte (mb
, CEE_LDIND_I4
);
909 mono_mb_emit_byte (mb
, CEE_BRFALSE_S
);
910 mono_mb_emit_byte (mb
, 3);
911 mono_mb_emit_byte (mb
, CEE_LDC_I4_1
);
912 mono_mb_emit_byte (mb
, CEE_BR_S
);
913 mono_mb_emit_byte (mb
, 1);
914 mono_mb_emit_byte (mb
, CEE_LDC_I4_0
);
915 mono_mb_emit_byte (mb
, CEE_STIND_I1
);
917 case MONO_MARSHAL_CONV_BOOL_VARIANTBOOL
:
918 mono_mb_emit_byte (mb
, CEE_LDLOC_1
);
919 mono_mb_emit_byte (mb
, CEE_LDLOC_0
);
920 mono_mb_emit_byte (mb
, CEE_LDIND_I2
);
921 mono_mb_emit_byte (mb
, CEE_BRFALSE_S
);
922 mono_mb_emit_byte (mb
, 3);
923 mono_mb_emit_byte (mb
, CEE_LDC_I4_1
);
924 mono_mb_emit_byte (mb
, CEE_BR_S
);
925 mono_mb_emit_byte (mb
, 1);
926 mono_mb_emit_byte (mb
, CEE_LDC_I4_0
);
927 mono_mb_emit_byte (mb
, CEE_STIND_I1
);
929 case MONO_MARSHAL_CONV_ARRAY_BYVALARRAY
: {
930 MonoClass
*eclass
= NULL
;
933 if (type
->type
== MONO_TYPE_SZARRAY
) {
934 eclass
= type
->data
.klass
;
936 g_assert_not_reached ();
939 if (eclass
->valuetype
)
940 esize
= mono_class_instance_size (eclass
) - sizeof (MonoObject
);
942 esize
= sizeof (gpointer
);
944 /* create a new array */
945 mono_mb_emit_byte (mb
, CEE_LDLOC_1
);
946 mono_mb_emit_icon (mb
, mspec
->data
.array_data
.num_elem
);
947 mono_mb_emit_byte (mb
, CEE_NEWARR
);
948 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, eclass
));
949 mono_mb_emit_byte (mb
, CEE_STIND_I
);
951 /* copy the elements */
952 mono_mb_emit_byte (mb
, CEE_LDLOC_1
);
953 mono_mb_emit_byte (mb
, CEE_LDIND_I
);
954 mono_mb_emit_icon (mb
, G_STRUCT_OFFSET (MonoArray
, vector
));
955 mono_mb_emit_byte (mb
, CEE_ADD
);
956 mono_mb_emit_byte (mb
, CEE_LDLOC_0
);
957 mono_mb_emit_icon (mb
, mspec
->data
.array_data
.num_elem
* esize
);
958 mono_mb_emit_byte (mb
, CEE_PREFIX1
);
959 mono_mb_emit_byte (mb
, CEE_CPBLK
);
963 case MONO_MARSHAL_CONV_STR_BYVALSTR
:
964 mono_mb_emit_byte (mb
, CEE_LDLOC_1
);
965 mono_mb_emit_byte (mb
, CEE_LDLOC_0
);
966 mono_mb_emit_icall (mb
, mono_string_new_wrapper
);
967 mono_mb_emit_byte (mb
, CEE_STIND_I
);
969 case MONO_MARSHAL_CONV_STR_BYVALWSTR
:
970 mono_mb_emit_byte (mb
, CEE_LDLOC_1
);
971 mono_mb_emit_byte (mb
, CEE_LDLOC_0
);
972 mono_mb_emit_icall (mb
, mono_string_from_utf16
);
973 mono_mb_emit_byte (mb
, CEE_STIND_I
);
975 case MONO_MARSHAL_CONV_STR_LPTSTR
:
976 case MONO_MARSHAL_CONV_STR_LPSTR
:
977 mono_mb_emit_byte (mb
, CEE_LDLOC_1
);
978 mono_mb_emit_byte (mb
, CEE_LDLOC_0
);
979 mono_mb_emit_byte (mb
, CEE_LDIND_I
);
980 mono_mb_emit_icall (mb
, mono_string_new_wrapper
);
981 mono_mb_emit_byte (mb
, CEE_STIND_I
);
983 case MONO_MARSHAL_CONV_STR_LPWSTR
:
984 mono_mb_emit_byte (mb
, CEE_LDLOC_1
);
985 mono_mb_emit_byte (mb
, CEE_LDLOC_0
);
986 mono_mb_emit_byte (mb
, CEE_LDIND_I
);
987 mono_mb_emit_icall (mb
, mono_string_from_utf16
);
988 mono_mb_emit_byte (mb
, CEE_STIND_I
);
990 case MONO_MARSHAL_CONV_OBJECT_STRUCT
: {
991 MonoClass
*klass
= mono_class_from_mono_type (type
);
992 int src_var
, dst_var
;
994 src_var
= mono_mb_add_local (mb
, &mono_defaults
.int_class
->byval_arg
);
995 dst_var
= mono_mb_add_local (mb
, &mono_defaults
.int_class
->byval_arg
);
997 /* *dst = new object */
998 mono_mb_emit_byte (mb
, CEE_LDLOC_1
);
999 mono_mb_emit_byte (mb
, MONO_CUSTOM_PREFIX
);
1000 mono_mb_emit_byte (mb
, CEE_MONO_NEWOBJ
);
1001 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, klass
));
1002 mono_mb_emit_byte (mb
, CEE_STIND_I
);
1004 /* save the old src pointer */
1005 mono_mb_emit_byte (mb
, CEE_LDLOC_0
);
1006 mono_mb_emit_stloc (mb
, src_var
);
1007 /* save the old dst pointer */
1008 mono_mb_emit_byte (mb
, CEE_LDLOC_1
);
1009 mono_mb_emit_stloc (mb
, dst_var
);
1011 /* dst = pointer to newly created object data */
1012 mono_mb_emit_byte (mb
, CEE_LDLOC_1
);
1013 mono_mb_emit_byte (mb
, CEE_LDIND_I
);
1014 mono_mb_emit_icon (mb
, sizeof (MonoObject
));
1015 mono_mb_emit_byte (mb
, CEE_ADD
);
1016 mono_mb_emit_byte (mb
, CEE_STLOC_1
);
1018 emit_struct_conv (mb
, klass
, TRUE
);
1020 /* restore the old src pointer */
1021 mono_mb_emit_ldloc (mb
, src_var
);
1022 mono_mb_emit_byte (mb
, CEE_STLOC_0
);
1023 /* restore the old dst pointer */
1024 mono_mb_emit_ldloc (mb
, dst_var
);
1025 mono_mb_emit_byte (mb
, CEE_STLOC_1
);
1028 case MONO_MARSHAL_CONV_DEL_FTN
: {
1029 /* fixme: we never convert functions back to delegates, dont
1030 // know if thats the correct behaviour
1034 case MONO_MARSHAL_CONV_ARRAY_LPARRAY
:
1035 g_error ("Structure field of type %s can't be marshalled as LPArray", mono_class_from_mono_type (type
)->name
);
1037 case MONO_MARSHAL_CONV_STR_BSTR
:
1038 case MONO_MARSHAL_CONV_STR_ANSIBSTR
:
1039 case MONO_MARSHAL_CONV_STR_TBSTR
:
1040 case MONO_MARSHAL_CONV_ARRAY_SAVEARRAY
:
1042 g_warning ("marshaling conversion %d not implemented", conv
);
1043 g_assert_not_reached ();
1048 conv_to_icall (MonoMarshalConv conv
)
1051 case MONO_MARSHAL_CONV_STR_LPWSTR
:
1052 return mono_marshal_string_to_utf16
;
1053 case MONO_MARSHAL_CONV_LPWSTR_STR
:
1054 return mono_string_from_utf16
;
1055 case MONO_MARSHAL_CONV_LPSTR_STR
:
1056 return mono_string_new_wrapper
;
1057 case MONO_MARSHAL_CONV_STR_LPTSTR
:
1058 case MONO_MARSHAL_CONV_STR_LPSTR
:
1059 return mono_string_to_lpstr
;
1060 case MONO_MARSHAL_CONV_STR_BSTR
:
1061 return mono_string_to_bstr
;
1062 case MONO_MARSHAL_CONV_STR_TBSTR
:
1063 case MONO_MARSHAL_CONV_STR_ANSIBSTR
:
1064 return mono_string_to_ansibstr
;
1065 case MONO_MARSHAL_CONV_SB_LPSTR
:
1066 case MONO_MARSHAL_CONV_SB_LPTSTR
:
1067 return mono_string_builder_to_utf8
;
1068 case MONO_MARSHAL_CONV_SB_LPWSTR
:
1069 return mono_string_builder_to_utf16
;
1070 case MONO_MARSHAL_CONV_ARRAY_SAVEARRAY
:
1071 return mono_array_to_savearray
;
1072 case MONO_MARSHAL_CONV_ARRAY_LPARRAY
:
1073 return mono_array_to_lparray
;
1074 case MONO_MARSHAL_CONV_DEL_FTN
:
1075 return mono_delegate_to_ftnptr
;
1076 case MONO_MARSHAL_CONV_FTN_DEL
:
1077 return mono_ftnptr_to_delegate
;
1078 case MONO_MARSHAL_CONV_LPSTR_SB
:
1079 case MONO_MARSHAL_CONV_LPTSTR_SB
:
1080 return mono_string_utf8_to_builder
;
1081 case MONO_MARSHAL_CONV_LPWSTR_SB
:
1082 return mono_string_utf16_to_builder
;
1083 case MONO_MARSHAL_FREE_ARRAY
:
1084 return mono_marshal_free_array
;
1085 case MONO_MARSHAL_CONV_STR_BYVALSTR
:
1086 return mono_string_to_byvalstr
;
1087 case MONO_MARSHAL_CONV_STR_BYVALWSTR
:
1088 return mono_string_to_byvalwstr
;
1090 g_assert_not_reached ();
1097 emit_object_to_ptr_conv (MonoMethodBuilder
*mb
, MonoType
*type
, MonoMarshalConv conv
, int usize
, int msize
,
1098 MonoMarshalSpec
*mspec
)
1103 case MONO_MARSHAL_CONV_BOOL_I4
:
1104 mono_mb_emit_byte (mb
, CEE_LDLOC_1
);
1105 mono_mb_emit_byte (mb
, CEE_LDLOC_0
);
1106 mono_mb_emit_byte (mb
, CEE_LDIND_U1
);
1107 mono_mb_emit_byte (mb
, CEE_STIND_I4
);
1109 case MONO_MARSHAL_CONV_BOOL_VARIANTBOOL
:
1110 mono_mb_emit_byte (mb
, CEE_LDLOC_1
);
1111 mono_mb_emit_byte (mb
, CEE_LDLOC_0
);
1112 mono_mb_emit_byte (mb
, CEE_LDIND_U1
);
1113 mono_mb_emit_byte (mb
, CEE_NEG
);
1114 mono_mb_emit_byte (mb
, CEE_STIND_I2
);
1116 case MONO_MARSHAL_CONV_STR_LPWSTR
:
1117 case MONO_MARSHAL_CONV_STR_LPSTR
:
1118 case MONO_MARSHAL_CONV_STR_LPTSTR
:
1119 case MONO_MARSHAL_CONV_STR_BSTR
:
1120 case MONO_MARSHAL_CONV_STR_ANSIBSTR
:
1121 case MONO_MARSHAL_CONV_STR_TBSTR
: {
1124 /* free space if free == true */
1125 mono_mb_emit_byte (mb
, CEE_LDLOC_2
);
1126 mono_mb_emit_byte (mb
, CEE_BRFALSE_S
);
1128 mono_mb_emit_byte (mb
, 0);
1129 mono_mb_emit_byte (mb
, CEE_LDLOC_1
);
1130 mono_mb_emit_byte (mb
, CEE_LDIND_I
);
1131 mono_mb_emit_icall (mb
, g_free
);
1132 mono_mb_patch_addr_s (mb
, pos
, mb
->pos
- pos
- 1);
1134 mono_mb_emit_byte (mb
, CEE_LDLOC_1
);
1135 mono_mb_emit_byte (mb
, CEE_LDLOC_0
);
1136 mono_mb_emit_byte (mb
, CEE_LDIND_I
);
1137 mono_mb_emit_icall (mb
, conv_to_icall (conv
));
1138 mono_mb_emit_byte (mb
, CEE_STIND_I
);
1141 case MONO_MARSHAL_CONV_ARRAY_SAVEARRAY
:
1142 case MONO_MARSHAL_CONV_ARRAY_LPARRAY
:
1143 case MONO_MARSHAL_CONV_DEL_FTN
:
1144 mono_mb_emit_byte (mb
, CEE_LDLOC_1
);
1145 mono_mb_emit_byte (mb
, CEE_LDLOC_0
);
1146 mono_mb_emit_byte (mb
, CEE_LDIND_I
);
1147 mono_mb_emit_icall (mb
, conv_to_icall (conv
));
1148 mono_mb_emit_byte (mb
, CEE_STIND_I
);
1150 case MONO_MARSHAL_CONV_STR_BYVALSTR
:
1151 case MONO_MARSHAL_CONV_STR_BYVALWSTR
: {
1155 mono_mb_emit_byte (mb
, CEE_LDLOC_1
); /* dst */
1156 mono_mb_emit_byte (mb
, CEE_LDLOC_0
);
1157 mono_mb_emit_byte (mb
, CEE_LDIND_I
); /* src String */
1158 mono_mb_emit_icon (mb
, usize
);
1159 mono_mb_emit_icall (mb
, conv_to_icall (conv
));
1162 case MONO_MARSHAL_CONV_ARRAY_BYVALARRAY
: {
1163 MonoClass
*eclass
= NULL
;
1166 if (type
->type
== MONO_TYPE_SZARRAY
) {
1167 eclass
= type
->data
.klass
;
1169 g_assert_not_reached ();
1172 if (eclass
->valuetype
)
1173 esize
= mono_class_native_size (eclass
, NULL
);
1175 esize
= sizeof (gpointer
);
1180 mono_mb_emit_byte (mb
, CEE_LDLOC_0
);
1181 mono_mb_emit_byte (mb
, CEE_LDIND_I
);
1182 mono_mb_emit_byte (mb
, CEE_BRFALSE_S
);
1184 mono_mb_emit_byte (mb
, 0);
1186 mono_mb_emit_byte (mb
, CEE_LDLOC_1
);
1187 mono_mb_emit_byte (mb
, CEE_LDLOC_0
);
1188 mono_mb_emit_byte (mb
, CEE_LDIND_I
);
1189 mono_mb_emit_byte (mb
, MONO_CUSTOM_PREFIX
);
1190 mono_mb_emit_byte (mb
, CEE_MONO_OBJADDR
);
1191 mono_mb_emit_icon (mb
, G_STRUCT_OFFSET (MonoArray
, vector
));
1192 mono_mb_emit_byte (mb
, CEE_ADD
);
1193 mono_mb_emit_icon (mb
, mspec
->data
.array_data
.num_elem
* esize
);
1194 mono_mb_emit_byte (mb
, CEE_PREFIX1
);
1195 mono_mb_emit_byte (mb
, CEE_CPBLK
);
1196 mono_mb_patch_addr_s (mb
, pos
, mb
->pos
- pos
- 1);
1199 case MONO_MARSHAL_CONV_OBJECT_STRUCT
: {
1200 int src_var
, dst_var
;
1202 src_var
= mono_mb_add_local (mb
, &mono_defaults
.int_class
->byval_arg
);
1203 dst_var
= mono_mb_add_local (mb
, &mono_defaults
.int_class
->byval_arg
);
1205 mono_mb_emit_byte (mb
, CEE_LDLOC_0
);
1206 mono_mb_emit_byte (mb
, CEE_LDIND_I
);
1207 mono_mb_emit_byte (mb
, CEE_BRFALSE_S
);
1209 mono_mb_emit_byte (mb
, 0);
1211 /* save the old src pointer */
1212 mono_mb_emit_byte (mb
, CEE_LDLOC_0
);
1213 mono_mb_emit_stloc (mb
, src_var
);
1214 /* save the old dst pointer */
1215 mono_mb_emit_byte (mb
, CEE_LDLOC_1
);
1216 mono_mb_emit_stloc (mb
, dst_var
);
1218 /* src = pointer to object data */
1219 mono_mb_emit_byte (mb
, CEE_LDLOC_0
);
1220 mono_mb_emit_byte (mb
, CEE_LDIND_I
);
1221 mono_mb_emit_icon (mb
, sizeof (MonoObject
));
1222 mono_mb_emit_byte (mb
, CEE_ADD
);
1223 mono_mb_emit_byte (mb
, CEE_STLOC_0
);
1225 emit_struct_conv (mb
, mono_class_from_mono_type (type
), FALSE
);
1227 /* restore the old src pointer */
1228 mono_mb_emit_ldloc (mb
, src_var
);
1229 mono_mb_emit_byte (mb
, CEE_STLOC_0
);
1230 /* restore the old dst pointer */
1231 mono_mb_emit_ldloc (mb
, dst_var
);
1232 mono_mb_emit_byte (mb
, CEE_STLOC_1
);
1234 mono_mb_patch_addr_s (mb
, pos
, mb
->pos
- pos
- 1);
1238 char *msg
= g_strdup_printf ("marshalling conversion %d not implemented", conv
);
1239 MonoException
*exc
= mono_get_exception_not_implemented (msg
);
1242 mono_raise_exception (exc
);
1248 emit_struct_conv (MonoMethodBuilder
*mb
, MonoClass
*klass
, gboolean to_object
)
1250 MonoMarshalType
*info
;
1254 emit_struct_conv(mb
, klass
->parent
, to_object
);
1256 info
= mono_marshal_load_type_info (klass
);
1258 if (info
->native_size
== 0)
1261 if (klass
->blittable
) {
1262 int msize
= mono_class_value_size (klass
, NULL
);
1263 g_assert (msize
== info
->native_size
);
1264 mono_mb_emit_byte (mb
, CEE_LDLOC_1
);
1265 mono_mb_emit_byte (mb
, CEE_LDLOC_0
);
1266 mono_mb_emit_icon (mb
, msize
);
1267 mono_mb_emit_byte (mb
, CEE_PREFIX1
);
1268 mono_mb_emit_byte (mb
, CEE_CPBLK
);
1270 mono_mb_emit_add_to_local (mb
, 0, msize
);
1271 mono_mb_emit_add_to_local (mb
, 1, msize
);
1275 for (i
= 0; i
< info
->num_fields
; i
++) {
1276 MonoMarshalNative ntype
;
1277 MonoMarshalConv conv
;
1278 MonoType
*ftype
= info
->fields
[i
].field
->type
;
1281 gboolean last_field
= i
< (info
->num_fields
-1) ? 0 : 1;
1283 if (ftype
->attrs
& FIELD_ATTRIBUTE_STATIC
)
1286 ntype
= mono_type_to_unmanaged (ftype
, info
->fields
[i
].mspec
, TRUE
, klass
->unicode
, &conv
);
1289 msize
= klass
->instance_size
- info
->fields
[i
].field
->offset
;
1290 usize
= info
->native_size
- info
->fields
[i
].offset
;
1292 msize
= info
->fields
[i
+ 1].field
->offset
- info
->fields
[i
].field
->offset
;
1293 usize
= info
->fields
[i
+ 1].offset
- info
->fields
[i
].offset
;
1295 if ((msize
< 0) || (usize
< 0))
1296 /* This happens with GC aware auto layout */
1297 g_error ("Type %s which is passed to unmanaged code must have a StructLayout attribute", mono_type_full_name (&klass
->byval_arg
));
1299 g_assert ((msize
>= 0) && (usize
>= 0));
1302 case MONO_MARSHAL_CONV_NONE
: {
1305 if (ftype
->byref
|| ftype
->type
== MONO_TYPE_I
||
1306 ftype
->type
== MONO_TYPE_U
) {
1307 mono_mb_emit_byte (mb
, CEE_LDLOC_1
);
1308 mono_mb_emit_byte (mb
, CEE_LDLOC_0
);
1309 mono_mb_emit_byte (mb
, CEE_LDIND_I
);
1310 mono_mb_emit_byte (mb
, CEE_STIND_I
);
1319 #if SIZEOF_VOID_P == 4
1322 mono_mb_emit_byte (mb
, CEE_LDLOC_1
);
1323 mono_mb_emit_byte (mb
, CEE_LDLOC_0
);
1324 mono_mb_emit_byte (mb
, CEE_LDIND_I4
);
1325 mono_mb_emit_byte (mb
, CEE_STIND_I4
);
1329 case MONO_TYPE_BOOLEAN
:
1330 mono_mb_emit_byte (mb
, CEE_LDLOC_1
);
1331 mono_mb_emit_byte (mb
, CEE_LDLOC_0
);
1332 mono_mb_emit_byte (mb
, CEE_LDIND_I1
);
1333 mono_mb_emit_byte (mb
, CEE_STIND_I1
);
1337 case MONO_TYPE_CHAR
:
1338 mono_mb_emit_byte (mb
, CEE_LDLOC_1
);
1339 mono_mb_emit_byte (mb
, CEE_LDLOC_0
);
1340 mono_mb_emit_byte (mb
, CEE_LDIND_I2
);
1341 mono_mb_emit_byte (mb
, CEE_STIND_I2
);
1345 #if SIZEOF_VOID_P == 8
1348 mono_mb_emit_byte (mb
, CEE_LDLOC_1
);
1349 mono_mb_emit_byte (mb
, CEE_LDLOC_0
);
1350 mono_mb_emit_byte (mb
, CEE_LDIND_I8
);
1351 mono_mb_emit_byte (mb
, CEE_STIND_I8
);
1354 mono_mb_emit_byte (mb
, CEE_LDLOC_1
);
1355 mono_mb_emit_byte (mb
, CEE_LDLOC_0
);
1356 mono_mb_emit_byte (mb
, CEE_LDIND_R4
);
1357 mono_mb_emit_byte (mb
, CEE_STIND_R4
);
1360 mono_mb_emit_byte (mb
, CEE_LDLOC_1
);
1361 mono_mb_emit_byte (mb
, CEE_LDLOC_0
);
1362 mono_mb_emit_byte (mb
, CEE_LDIND_R8
);
1363 mono_mb_emit_byte (mb
, CEE_STIND_R8
);
1365 case MONO_TYPE_VALUETYPE
:
1366 if (ftype
->data
.klass
->enumtype
) {
1367 t
= ftype
->data
.klass
->enum_basetype
->type
;
1370 emit_struct_conv (mb
, ftype
->data
.klass
, to_object
);
1373 g_warning ("marshaling type %02x not implemented", ftype
->type
);
1374 g_assert_not_reached ();
1380 emit_ptr_to_object_conv (mb
, ftype
, conv
, usize
, msize
, info
->fields
[i
].mspec
);
1382 emit_object_to_ptr_conv (mb
, ftype
, conv
, usize
, msize
, info
->fields
[i
].mspec
);
1386 mono_mb_emit_add_to_local (mb
, 0, usize
);
1387 mono_mb_emit_add_to_local (mb
, 1, msize
);
1389 mono_mb_emit_add_to_local (mb
, 0, msize
);
1390 mono_mb_emit_add_to_local (mb
, 1, usize
);
1396 emit_struct_free (MonoMethodBuilder
*mb
, MonoClass
*klass
, int struct_var
)
1398 /* Call DestroyStructure */
1399 /* FIXME: Only do this if needed */
1400 mono_mb_emit_byte (mb
, MONO_CUSTOM_PREFIX
);
1401 mono_mb_emit_byte (mb
, CEE_MONO_CLASSCONST
);
1402 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, klass
));
1403 mono_mb_emit_ldloc (mb
, struct_var
);
1404 mono_mb_emit_icall (mb
, mono_struct_delete_old
);
1408 emit_thread_interrupt_checkpoint_call (MonoMethodBuilder
*mb
, gpointer checkpoint_func
)
1412 mono_mb_emit_byte (mb
, MONO_CUSTOM_PREFIX
);
1413 mono_mb_emit_byte (mb
, CEE_MONO_LDPTR
);
1414 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, (gpointer
) mono_thread_interruption_request_flag ()));
1415 mono_mb_emit_byte (mb
, CEE_LDIND_I4
);
1416 pos_noabort
= mono_mb_emit_branch (mb
, CEE_BRFALSE
);
1418 mono_mb_emit_icall (mb
, checkpoint_func
);
1420 mono_mb_patch_addr (mb
, pos_noabort
, mb
->pos
- (pos_noabort
+ 4));
1424 emit_thread_interrupt_checkpoint (MonoMethodBuilder
*mb
)
1426 if (strstr (mb
->method
->name
, "mono_thread_interruption_checkpoint"))
1429 emit_thread_interrupt_checkpoint_call (mb
, mono_thread_interruption_checkpoint
);
1433 emit_thread_force_interrupt_checkpoint (MonoMethodBuilder
*mb
)
1435 emit_thread_interrupt_checkpoint_call (mb
, mono_thread_force_interruption_checkpoint
);
1438 static MonoAsyncResult
*
1439 mono_delegate_begin_invoke (MonoDelegate
*delegate
, gpointer
*params
)
1441 MonoMethodMessage
*msg
;
1442 MonoDelegate
*async_callback
;
1446 MonoMethod
*method
= NULL
;
1449 g_assert (delegate
);
1451 if (delegate
->target
&& mono_object_class (delegate
->target
) == mono_defaults
.transparent_proxy_class
) {
1453 MonoTransparentProxy
* tp
= (MonoTransparentProxy
*)delegate
->target
;
1454 if (!tp
->remote_class
->proxy_class
->contextbound
|| tp
->rp
->context
!= (MonoObject
*) mono_context_get ()) {
1456 /* If the target is a proxy, make a direct call. Is proxy's work
1457 // to make the call asynchronous.
1459 MonoAsyncResult
*ares
;
1461 MonoArray
*out_args
;
1463 method
= delegate
->method_info
->method
;
1465 msg
= mono_method_call_message_new (mono_marshal_method_from_wrapper (method
), params
, NULL
, &async_callback
, &state
);
1466 handle
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
1467 ares
= mono_async_result_new (mono_domain_get (), handle
, state
, handle
);
1468 ares
->async_delegate
= (MonoObject
*)delegate
;
1469 ares
->async_callback
= (MonoObject
*)async_callback
;
1470 msg
->async_result
= ares
;
1471 msg
->call_type
= CallType_BeginInvoke
;
1473 mono_remoting_invoke ((MonoObject
*)tp
->rp
, msg
, &exc
, &out_args
);
1478 klass
= delegate
->object
.vtable
->klass
;
1480 method
= mono_get_delegate_invoke (klass
);
1481 for (i
= 0; i
< klass
->method
.count
; ++i
) {
1482 if (klass
->methods
[i
]->name
[0] == 'B' &&
1483 !strcmp ("BeginInvoke", klass
->methods
[i
]->name
)) {
1484 method
= klass
->methods
[i
];
1489 g_assert (method
!= NULL
);
1491 im
= mono_get_delegate_invoke (method
->klass
);
1492 msg
= mono_method_call_message_new (method
, params
, im
, &async_callback
, &state
);
1494 return mono_thread_pool_add ((MonoObject
*)delegate
, msg
, async_callback
, state
);
1498 mono_mb_emit_save_args (MonoMethodBuilder
*mb
, MonoMethodSignature
*sig
, gboolean save_this
)
1500 int i
, params_var
, tmp_var
;
1502 /* allocate local (pointer) *params[] */
1503 params_var
= mono_mb_add_local (mb
, &mono_defaults
.int_class
->byval_arg
);
1504 /* allocate local (pointer) tmp */
1505 tmp_var
= mono_mb_add_local (mb
, &mono_defaults
.int_class
->byval_arg
);
1507 /* alloate space on stack to store an array of pointers to the arguments */
1508 mono_mb_emit_icon (mb
, sizeof (gpointer
) * (sig
->param_count
+ 1));
1509 mono_mb_emit_byte (mb
, CEE_PREFIX1
);
1510 mono_mb_emit_byte (mb
, CEE_LOCALLOC
);
1511 mono_mb_emit_stloc (mb
, params_var
);
1514 mono_mb_emit_ldloc (mb
, params_var
);
1515 mono_mb_emit_stloc (mb
, tmp_var
);
1517 if (save_this
&& sig
->hasthis
) {
1518 mono_mb_emit_ldloc (mb
, tmp_var
);
1519 mono_mb_emit_ldarg_addr (mb
, 0);
1520 mono_mb_emit_byte (mb
, CEE_STIND_I
);
1521 /* tmp = tmp + sizeof (gpointer) */
1522 if (sig
->param_count
)
1523 mono_mb_emit_add_to_local (mb
, tmp_var
, sizeof (gpointer
));
1527 for (i
= 0; i
< sig
->param_count
; i
++) {
1528 mono_mb_emit_ldloc (mb
, tmp_var
);
1529 mono_mb_emit_ldarg_addr (mb
, i
+ sig
->hasthis
);
1530 mono_mb_emit_byte (mb
, CEE_STIND_I
);
1531 /* tmp = tmp + sizeof (gpointer) */
1532 if (i
< (sig
->param_count
- 1))
1533 mono_mb_emit_add_to_local (mb
, tmp_var
, sizeof (gpointer
));
1540 mono_signature_to_name (MonoMethodSignature
*sig
, const char *prefix
)
1544 GString
*res
= g_string_new ("");
1547 g_string_append (res
, prefix
);
1548 g_string_append_c (res
, '_');
1551 mono_type_get_desc (res
, sig
->ret
, FALSE
);
1553 for (i
= 0; i
< sig
->param_count
; ++i
) {
1554 g_string_append_c (res
, '_');
1555 mono_type_get_desc (res
, sig
->params
[i
], FALSE
);
1558 g_string_free (res
, FALSE
);
1563 * mono_marshal_get_string_encoding:
1565 * Return the string encoding which should be used for a given parameter.
1567 static MonoMarshalNative
1568 mono_marshal_get_string_encoding (MonoMethodPInvoke
*piinfo
, MonoMarshalSpec
*spec
)
1570 /* First try the parameter marshal info */
1572 if (spec
->native
== MONO_NATIVE_LPARRAY
) {
1573 if (spec
->data
.array_data
.elem_type
!= 0)
1574 return spec
->data
.array_data
.elem_type
;
1577 return spec
->native
;
1581 return MONO_NATIVE_LPSTR
;
1583 /* Then try the method level marshal info */
1584 switch (piinfo
->piflags
& PINVOKE_ATTRIBUTE_CHAR_SET_MASK
) {
1585 case PINVOKE_ATTRIBUTE_CHAR_SET_ANSI
:
1586 return MONO_NATIVE_LPSTR
;
1587 case PINVOKE_ATTRIBUTE_CHAR_SET_UNICODE
:
1588 return MONO_NATIVE_LPWSTR
;
1589 case PINVOKE_ATTRIBUTE_CHAR_SET_AUTO
:
1590 return MONO_NATIVE_LPTSTR
;
1592 return MONO_NATIVE_LPSTR
;
1596 static MonoMarshalConv
1597 mono_marshal_get_string_to_ptr_conv (MonoMethodPInvoke
*piinfo
, MonoMarshalSpec
*spec
)
1599 MonoMarshalNative encoding
= mono_marshal_get_string_encoding (piinfo
, spec
);
1602 case MONO_NATIVE_LPWSTR
:
1603 return MONO_MARSHAL_CONV_STR_LPWSTR
;
1604 case MONO_NATIVE_LPSTR
:
1605 return MONO_MARSHAL_CONV_STR_LPSTR
;
1606 case MONO_NATIVE_LPTSTR
:
1607 return MONO_MARSHAL_CONV_STR_LPTSTR
;
1613 static MonoMarshalConv
1614 mono_marshal_get_stringbuilder_to_ptr_conv (MonoMethodPInvoke
*piinfo
, MonoMarshalSpec
*spec
)
1616 MonoMarshalNative encoding
= mono_marshal_get_string_encoding (piinfo
, spec
);
1619 case MONO_NATIVE_LPWSTR
:
1620 return MONO_MARSHAL_CONV_SB_LPWSTR
;
1622 case MONO_NATIVE_LPSTR
:
1623 return MONO_MARSHAL_CONV_SB_LPSTR
;
1625 case MONO_NATIVE_LPTSTR
:
1626 return MONO_MARSHAL_CONV_SB_LPTSTR
;
1633 static MonoMarshalConv
1634 mono_marshal_get_ptr_to_stringbuilder_conv (MonoMethodPInvoke
*piinfo
, MonoMarshalSpec
*spec
, gboolean
*need_free
)
1636 MonoMarshalNative encoding
= mono_marshal_get_string_encoding (piinfo
, spec
);
1641 case MONO_NATIVE_LPWSTR
:
1643 * mono_string_builder_to_utf16 does not allocate a
1644 * new buffer, so no need to free it.
1647 return MONO_MARSHAL_CONV_LPWSTR_SB
;
1648 case MONO_NATIVE_LPSTR
:
1649 return MONO_MARSHAL_CONV_LPSTR_SB
;
1651 case MONO_NATIVE_LPTSTR
:
1652 return MONO_MARSHAL_CONV_LPTSTR_SB
;
1660 * Return whenever a field of a native structure or an array member needs to
1664 mono_marshal_need_free (MonoType
*t
, MonoMethodPInvoke
*piinfo
, MonoMarshalSpec
*spec
)
1666 MonoMarshalNative encoding
;
1667 MonoMarshalConv conv
;
1670 case MONO_TYPE_VALUETYPE
:
1671 /* FIXME: Optimize this */
1673 case MONO_TYPE_OBJECT
:
1674 case MONO_TYPE_CLASS
:
1675 if (t
->data
.klass
== mono_defaults
.stringbuilder_class
) {
1677 conv
= mono_marshal_get_ptr_to_stringbuilder_conv (piinfo
, spec
, &need_free
);
1681 case MONO_TYPE_STRING
:
1682 encoding
= mono_marshal_get_string_encoding (piinfo
, spec
);
1683 return (encoding
== MONO_NATIVE_LPWSTR
) ? FALSE
: TRUE
;
1689 static inline MonoMethod
*
1690 mono_marshal_find_in_cache (GHashTable
*cache
, gpointer key
)
1694 EnterCriticalSection (&marshal_mutex
);
1695 res
= g_hash_table_lookup (cache
, key
);
1696 LeaveCriticalSection (&marshal_mutex
);
1700 /* Create the method from the builder and place it in the cache */
1701 static inline MonoMethod
*
1702 mono_mb_create_and_cache (GHashTable
*cache
, gpointer key
,
1703 MonoMethodBuilder
*mb
, MonoMethodSignature
*sig
,
1708 EnterCriticalSection (&marshal_mutex
);
1709 res
= g_hash_table_lookup (cache
, key
);
1711 /* This does not acquire any locks */
1712 res
= mono_mb_create_method (mb
, sig
, max_stack
);
1713 g_hash_table_insert (cache
, key
, res
);
1714 g_hash_table_insert (wrapper_hash
, res
, key
);
1716 LeaveCriticalSection (&marshal_mutex
);
1722 static inline MonoMethod
*
1723 mono_marshal_remoting_find_in_cache (MonoMethod
*method
, int wrapper_type
)
1725 MonoMethod
*res
= NULL
;
1726 MonoRemotingMethods
*wrps
;
1728 EnterCriticalSection (&marshal_mutex
);
1729 wrps
= g_hash_table_lookup (method
->klass
->image
->remoting_invoke_cache
, method
);
1732 switch (wrapper_type
) {
1733 case MONO_WRAPPER_REMOTING_INVOKE
: res
= wrps
->invoke
; break;
1734 case MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK
: res
= wrps
->invoke_with_check
; break;
1735 case MONO_WRAPPER_XDOMAIN_INVOKE
: res
= wrps
->xdomain_invoke
; break;
1736 case MONO_WRAPPER_XDOMAIN_DISPATCH
: res
= wrps
->xdomain_dispatch
; break;
1740 LeaveCriticalSection (&marshal_mutex
);
1744 /* Create the method from the builder and place it in the cache */
1745 static inline MonoMethod
*
1746 mono_remoting_mb_create_and_cache (MonoMethod
*key
, MonoMethodBuilder
*mb
,
1747 MonoMethodSignature
*sig
, int max_stack
)
1749 MonoMethod
**res
= NULL
;
1750 MonoRemotingMethods
*wrps
;
1751 GHashTable
*cache
= key
->klass
->image
->remoting_invoke_cache
;
1753 EnterCriticalSection (&marshal_mutex
);
1754 wrps
= g_hash_table_lookup (cache
, key
);
1756 wrps
= g_new0 (MonoRemotingMethods
, 1);
1757 g_hash_table_insert (cache
, key
, wrps
);
1760 switch (mb
->method
->wrapper_type
) {
1761 case MONO_WRAPPER_REMOTING_INVOKE
: res
= &wrps
->invoke
; break;
1762 case MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK
: res
= &wrps
->invoke_with_check
; break;
1763 case MONO_WRAPPER_XDOMAIN_INVOKE
: res
= &wrps
->xdomain_invoke
; break;
1764 case MONO_WRAPPER_XDOMAIN_DISPATCH
: res
= &wrps
->xdomain_dispatch
; break;
1765 default: g_assert_not_reached (); break;
1769 /* This does not acquire any locks */
1770 *res
= mono_mb_create_method (mb
, sig
, max_stack
);
1771 g_hash_table_insert (wrapper_hash
, *res
, key
);
1774 LeaveCriticalSection (&marshal_mutex
);
1780 mono_marshal_method_from_wrapper (MonoMethod
*wrapper
)
1784 if (wrapper
->wrapper_type
== MONO_WRAPPER_NONE
)
1787 EnterCriticalSection (&marshal_mutex
);
1788 res
= g_hash_table_lookup (wrapper_hash
, wrapper
);
1789 LeaveCriticalSection (&marshal_mutex
);
1794 mono_marshal_get_delegate_begin_invoke (MonoMethod
*method
)
1796 MonoMethodSignature
*sig
;
1797 static MonoMethodSignature
*csig
= NULL
;
1798 MonoMethodBuilder
*mb
;
1804 g_assert (method
&& method
->klass
->parent
== mono_defaults
.multicastdelegate_class
&&
1805 !strcmp (method
->name
, "BeginInvoke"));
1807 sig
= signature_no_pinvoke (method
->signature
);
1809 cache
= method
->klass
->image
->delegate_begin_invoke_cache
;
1810 if ((res
= mono_marshal_find_in_cache (cache
, sig
)))
1813 g_assert (sig
->hasthis
);
1816 csig
= mono_metadata_signature_alloc (method
->klass
->image
, 2);
1818 /* MonoAsyncResult * begin_invoke (MonoDelegate *delegate, gpointer params[]) */
1819 csig
->ret
= &mono_defaults
.object_class
->byval_arg
;
1820 csig
->params
[0] = &mono_defaults
.object_class
->byval_arg
;
1821 csig
->params
[1] = &mono_defaults
.int_class
->byval_arg
;
1824 name
= mono_signature_to_name (sig
, "begin_invoke");
1825 mb
= mono_mb_new (mono_defaults
.multicastdelegate_class
, name
, MONO_WRAPPER_DELEGATE_BEGIN_INVOKE
);
1828 mb
->method
->save_lmf
= 1;
1830 params_var
= mono_mb_emit_save_args (mb
, sig
, FALSE
);
1832 mono_mb_emit_ldarg (mb
, 0);
1833 mono_mb_emit_ldloc (mb
, params_var
);
1834 mono_mb_emit_native_call (mb
, csig
, mono_delegate_begin_invoke
);
1835 emit_thread_interrupt_checkpoint (mb
);
1836 mono_mb_emit_byte (mb
, CEE_RET
);
1838 res
= mono_mb_create_and_cache (cache
, sig
, mb
, sig
, sig
->param_count
+ 16);
1844 mono_delegate_end_invoke (MonoDelegate
*delegate
, gpointer
*params
)
1846 MonoDomain
*domain
= mono_domain_get ();
1847 MonoAsyncResult
*ares
;
1848 MonoMethod
*method
= NULL
;
1849 MonoMethodSignature
*sig
;
1850 MonoMethodMessage
*msg
;
1851 MonoObject
*res
, *exc
;
1852 MonoArray
*out_args
;
1856 g_assert (delegate
);
1858 if (!delegate
->method_info
|| !delegate
->method_info
->method
)
1859 g_assert_not_reached ();
1861 klass
= delegate
->object
.vtable
->klass
;
1863 for (i
= 0; i
< klass
->method
.count
; ++i
) {
1864 if (klass
->methods
[i
]->name
[0] == 'E' &&
1865 !strcmp ("EndInvoke", klass
->methods
[i
]->name
)) {
1866 method
= klass
->methods
[i
];
1871 g_assert (method
!= NULL
);
1873 sig
= signature_no_pinvoke (method
->signature
);
1875 msg
= mono_method_call_message_new (method
, params
, NULL
, NULL
, NULL
);
1877 ares
= mono_array_get (msg
->args
, gpointer
, sig
->param_count
- 1);
1880 if (delegate
->target
&& mono_object_class (delegate
->target
) == mono_defaults
.transparent_proxy_class
) {
1881 MonoTransparentProxy
* tp
= (MonoTransparentProxy
*)delegate
->target
;
1882 msg
= (MonoMethodMessage
*)mono_object_new (domain
, mono_defaults
.mono_method_message_class
);
1883 mono_message_init (domain
, msg
, delegate
->method_info
, NULL
);
1884 msg
->call_type
= CallType_EndInvoke
;
1885 msg
->async_result
= ares
;
1886 res
= mono_remoting_invoke ((MonoObject
*)tp
->rp
, msg
, &exc
, &out_args
);
1889 res
= mono_thread_pool_finish (ares
, &out_args
, &exc
);
1892 if (((MonoException
*)exc
)->stack_trace
) {
1893 char *strace
= mono_string_to_utf8 (((MonoException
*)exc
)->stack_trace
);
1895 tmp
= g_strdup_printf ("%s\nException Rethrown at:\n", strace
);
1897 ((MonoException
*)exc
)->stack_trace
= mono_string_new (domain
, tmp
);
1900 mono_raise_exception ((MonoException
*)exc
);
1903 mono_method_return_message_restore (method
, params
, out_args
);
1908 mono_mb_emit_restore_result (MonoMethodBuilder
*mb
, MonoType
*return_type
)
1910 if (return_type
->byref
)
1911 return_type
= &mono_defaults
.int_class
->byval_arg
;
1912 else if (return_type
->type
== MONO_TYPE_VALUETYPE
&& return_type
->data
.klass
->enumtype
)
1913 return_type
= return_type
->data
.klass
->enum_basetype
;
1915 switch (return_type
->type
) {
1916 case MONO_TYPE_VOID
:
1917 g_assert_not_reached ();
1920 case MONO_TYPE_STRING
:
1921 case MONO_TYPE_CLASS
:
1922 case MONO_TYPE_OBJECT
:
1923 case MONO_TYPE_ARRAY
:
1924 case MONO_TYPE_SZARRAY
:
1928 case MONO_TYPE_BOOLEAN
:
1929 mono_mb_emit_byte (mb
, CEE_UNBOX
);
1930 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, mono_class_from_mono_type (return_type
)));
1931 mono_mb_emit_byte (mb
, CEE_LDIND_U1
);
1934 mono_mb_emit_byte (mb
, CEE_UNBOX
);
1935 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, mono_class_from_mono_type (return_type
)));
1936 mono_mb_emit_byte (mb
, CEE_LDIND_I1
);
1939 case MONO_TYPE_CHAR
:
1940 mono_mb_emit_byte (mb
, CEE_UNBOX
);
1941 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, mono_class_from_mono_type (return_type
)));
1942 mono_mb_emit_byte (mb
, CEE_LDIND_U2
);
1945 mono_mb_emit_byte (mb
, CEE_UNBOX
);
1946 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, mono_class_from_mono_type (return_type
)));
1947 mono_mb_emit_byte (mb
, CEE_LDIND_I2
);
1951 mono_mb_emit_byte (mb
, CEE_UNBOX
);
1952 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, mono_class_from_mono_type (return_type
)));
1953 mono_mb_emit_byte (mb
, CEE_LDIND_I
);
1956 mono_mb_emit_byte (mb
, CEE_UNBOX
);
1957 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, mono_class_from_mono_type (return_type
)));
1958 mono_mb_emit_byte (mb
, CEE_LDIND_I4
);
1961 mono_mb_emit_byte (mb
, CEE_UNBOX
);
1962 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, mono_class_from_mono_type (return_type
)));
1963 mono_mb_emit_byte (mb
, CEE_LDIND_U4
);
1967 mono_mb_emit_byte (mb
, CEE_UNBOX
);
1968 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, mono_class_from_mono_type (return_type
)));
1969 mono_mb_emit_byte (mb
, CEE_LDIND_I8
);
1972 mono_mb_emit_byte (mb
, CEE_UNBOX
);
1973 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, mono_class_from_mono_type (return_type
)));
1974 mono_mb_emit_byte (mb
, CEE_LDIND_R4
);
1977 mono_mb_emit_byte (mb
, CEE_UNBOX
);
1978 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, mono_class_from_mono_type (return_type
)));
1979 mono_mb_emit_byte (mb
, CEE_LDIND_R8
);
1981 case MONO_TYPE_VALUETYPE
: {
1983 mono_mb_emit_byte (mb
, CEE_UNBOX
);
1984 class = mono_mb_add_data (mb
, mono_class_from_mono_type (return_type
));
1985 mono_mb_emit_i4 (mb
, class);
1986 mono_mb_emit_byte (mb
, CEE_LDOBJ
);
1987 mono_mb_emit_i4 (mb
, class);
1991 g_warning ("type 0x%x not handled", return_type
->type
);
1992 g_assert_not_reached ();
1995 mono_mb_emit_byte (mb
, CEE_RET
);
1999 mono_marshal_get_delegate_end_invoke (MonoMethod
*method
)
2001 MonoMethodSignature
*sig
;
2002 static MonoMethodSignature
*csig
= NULL
;
2003 MonoMethodBuilder
*mb
;
2009 g_assert (method
&& method
->klass
->parent
== mono_defaults
.multicastdelegate_class
&&
2010 !strcmp (method
->name
, "EndInvoke"));
2012 sig
= signature_no_pinvoke (method
->signature
);
2014 cache
= method
->klass
->image
->delegate_end_invoke_cache
;
2015 if ((res
= mono_marshal_find_in_cache (cache
, sig
)))
2018 g_assert (sig
->hasthis
);
2021 csig
= mono_metadata_signature_alloc (method
->klass
->image
, 2);
2023 /* MonoObject *end_invoke (MonoDelegate *delegate, gpointer params[]) */
2024 csig
->ret
= &mono_defaults
.object_class
->byval_arg
;
2025 csig
->params
[0] = &mono_defaults
.object_class
->byval_arg
;
2026 csig
->params
[1] = &mono_defaults
.int_class
->byval_arg
;
2029 name
= mono_signature_to_name (sig
, "end_invoke");
2030 mb
= mono_mb_new (mono_defaults
.multicastdelegate_class
, name
, MONO_WRAPPER_DELEGATE_END_INVOKE
);
2033 mb
->method
->save_lmf
= 1;
2035 params_var
= mono_mb_emit_save_args (mb
, sig
, FALSE
);
2037 mono_mb_emit_ldarg (mb
, 0);
2038 mono_mb_emit_ldloc (mb
, params_var
);
2039 mono_mb_emit_native_call (mb
, csig
, mono_delegate_end_invoke
);
2040 emit_thread_interrupt_checkpoint (mb
);
2042 if (sig
->ret
->type
== MONO_TYPE_VOID
) {
2043 mono_mb_emit_byte (mb
, CEE_POP
);
2044 mono_mb_emit_byte (mb
, CEE_RET
);
2046 mono_mb_emit_restore_result (mb
, sig
->ret
);
2048 res
= mono_mb_create_and_cache (cache
, sig
,
2049 mb
, sig
, sig
->param_count
+ 16);
2056 mono_remoting_wrapper (MonoMethod
*method
, gpointer
*params
)
2058 MonoMethodMessage
*msg
;
2059 MonoTransparentProxy
*this;
2060 MonoObject
*res
, *exc
;
2061 MonoArray
*out_args
;
2063 this = *((MonoTransparentProxy
**)params
[0]);
2066 g_assert (((MonoObject
*)this)->vtable
->klass
== mono_defaults
.transparent_proxy_class
);
2068 /* skip the this pointer */
2071 if (this->remote_class
->proxy_class
->contextbound
&& this->rp
->context
== (MonoObject
*) mono_context_get ())
2074 MonoMethodSignature
*sig
= method
->signature
;
2075 int count
= sig
->param_count
;
2076 gpointer
* mparams
= (gpointer
*) alloca(count
*sizeof(gpointer
));
2078 for (i
=0; i
<count
; i
++) {
2079 MonoClass
*class = mono_class_from_mono_type (sig
->params
[i
]);
2080 if (class->valuetype
) {
2081 if (sig
->params
[i
]->byref
)
2082 mparams
[i
] = *((gpointer
*)params
[i
]);
2084 mparams
[i
] = params
[i
];
2086 mparams
[i
] = *((gpointer
**)params
[i
]);
2090 return mono_runtime_invoke (method
, method
->klass
->valuetype
? mono_object_unbox ((MonoObject
*)this): this, mparams
, NULL
);
2093 msg
= mono_method_call_message_new (method
, params
, NULL
, NULL
, NULL
);
2095 res
= mono_remoting_invoke ((MonoObject
*)this->rp
, msg
, &exc
, &out_args
);
2098 mono_raise_exception ((MonoException
*)exc
);
2100 mono_method_return_message_restore (method
, params
, out_args
);
2106 mono_marshal_get_remoting_invoke (MonoMethod
*method
)
2108 MonoMethodSignature
*sig
;
2109 static MonoMethodSignature
*csig
= NULL
;
2110 MonoMethodBuilder
*mb
;
2116 if (method
->wrapper_type
== MONO_WRAPPER_REMOTING_INVOKE
|| method
->wrapper_type
== MONO_WRAPPER_XDOMAIN_INVOKE
)
2119 sig
= signature_no_pinvoke (method
->signature
);
2121 /* we cant remote methods without this pointer */
2125 if ((res
= mono_marshal_remoting_find_in_cache (method
, MONO_WRAPPER_REMOTING_INVOKE
)))
2129 csig
= mono_metadata_signature_alloc (mono_defaults
.corlib
, 2);
2130 csig
->params
[0] = &mono_defaults
.int_class
->byval_arg
;
2131 csig
->params
[1] = &mono_defaults
.int_class
->byval_arg
;
2132 csig
->ret
= &mono_defaults
.object_class
->byval_arg
;
2136 mb
= mono_mb_new (method
->klass
, method
->name
, MONO_WRAPPER_REMOTING_INVOKE
);
2137 mb
->method
->save_lmf
= 1;
2139 params_var
= mono_mb_emit_save_args (mb
, sig
, TRUE
);
2141 mono_mb_emit_byte (mb
, MONO_CUSTOM_PREFIX
);
2142 mono_mb_emit_byte (mb
, CEE_MONO_LDPTR
);
2143 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, method
));
2144 mono_mb_emit_ldloc (mb
, params_var
);
2145 mono_mb_emit_native_call (mb
, csig
, mono_remoting_wrapper
);
2146 emit_thread_interrupt_checkpoint (mb
);
2148 if (sig
->ret
->type
== MONO_TYPE_VOID
) {
2149 mono_mb_emit_byte (mb
, CEE_POP
);
2150 mono_mb_emit_byte (mb
, CEE_RET
);
2152 mono_mb_emit_restore_result (mb
, sig
->ret
);
2155 res
= mono_remoting_mb_create_and_cache (method
, mb
, sig
, sig
->param_count
+ 16);
2161 /* mono_get_xdomain_marshal_type()
2162 * Returns the kind of marshalling that a type needs for cross domain calls.
2164 static MonoXDomainMarshalType
2165 mono_get_xdomain_marshal_type (MonoType
*t
)
2168 case MONO_TYPE_VOID
:
2169 g_assert_not_reached ();
2173 case MONO_TYPE_BOOLEAN
:
2176 case MONO_TYPE_CHAR
:
2183 return MONO_MARSHAL_NONE
;
2184 case MONO_TYPE_STRING
:
2185 return MONO_MARSHAL_COPY
;
2186 case MONO_TYPE_ARRAY
:
2187 case MONO_TYPE_SZARRAY
: {
2188 MonoClass
*elem_class
= mono_class_from_mono_type (t
)->element_class
;
2189 if (mono_get_xdomain_marshal_type (&(elem_class
->byval_arg
)) != MONO_MARSHAL_SERIALIZE
)
2190 return MONO_MARSHAL_COPY
;
2195 if (mono_class_from_mono_type (t
) == mono_defaults
.stringbuilder_class
)
2196 return MONO_MARSHAL_COPY
;
2198 return MONO_MARSHAL_SERIALIZE
;
2202 /* mono_marshal_xdomain_copy_value
2203 * Makes a copy of "val" suitable for the current domain.
2206 mono_marshal_xdomain_copy_value (MonoObject
*val
)
2209 if (val
== NULL
) return NULL
;
2211 domain
= mono_domain_get ();
2213 switch (mono_object_class (val
)->byval_arg
.type
) {
2214 case MONO_TYPE_VOID
:
2215 g_assert_not_reached ();
2219 case MONO_TYPE_BOOLEAN
:
2222 case MONO_TYPE_CHAR
:
2228 case MONO_TYPE_R8
: {
2229 return mono_value_box (domain
, mono_object_class (val
), ((char*)val
) + sizeof(MonoObject
));
2231 case MONO_TYPE_STRING
: {
2232 MonoString
*str
= (MonoString
*) val
;
2233 return (MonoObject
*) mono_string_new_utf16 (domain
, mono_string_chars (str
), mono_string_length (str
));
2235 case MONO_TYPE_ARRAY
:
2236 case MONO_TYPE_SZARRAY
: {
2238 MonoXDomainMarshalType mt
= mono_get_xdomain_marshal_type (&(mono_object_class (val
)->element_class
->byval_arg
));
2239 if (mt
== MONO_MARSHAL_SERIALIZE
) return NULL
;
2240 acopy
= mono_array_clone_in_domain (domain
, (MonoArray
*) val
);
2241 if (mt
== MONO_MARSHAL_COPY
) {
2242 int i
, len
= mono_array_length (acopy
);
2243 for (i
= 0; i
< len
; i
++) {
2244 MonoObject
*item
= mono_array_get (acopy
, gpointer
, i
);
2245 mono_array_set (acopy
, gpointer
, i
, mono_marshal_xdomain_copy_value (item
));
2248 return (MonoObject
*) acopy
;
2252 if (mono_object_class (val
) == mono_defaults
.stringbuilder_class
) {
2253 MonoStringBuilder
*oldsb
= (MonoStringBuilder
*) val
;
2254 MonoStringBuilder
*newsb
= (MonoStringBuilder
*) mono_object_new (domain
, mono_defaults
.stringbuilder_class
);
2255 newsb
->str
= mono_string_new_utf16 (domain
, mono_string_chars (oldsb
->str
), mono_string_length (oldsb
->str
));
2256 newsb
->length
= oldsb
->length
;
2257 newsb
->max_capacity
= (gint32
)0x7fffffff;
2258 return (MonoObject
*) newsb
;
2263 /* mono_marshal_xdomain_copy_out_value()
2264 * Copies the contents of the src instance into the dst instance. src and dst
2265 * must have the same type, and if they are arrays, the same size.
2268 mono_marshal_xdomain_copy_out_value (MonoObject
*src
, MonoObject
*dst
)
2270 if (src
== NULL
|| dst
== NULL
) return;
2272 g_assert (mono_object_class (src
) == mono_object_class (dst
));
2274 switch (mono_object_class (src
)->byval_arg
.type
) {
2275 case MONO_TYPE_ARRAY
:
2276 case MONO_TYPE_SZARRAY
: {
2277 int mt
= mono_get_xdomain_marshal_type (&(mono_object_class (src
)->element_class
->byval_arg
));
2278 if (mt
== MONO_MARSHAL_SERIALIZE
) return;
2279 if (mt
== MONO_MARSHAL_COPY
) {
2280 int i
, len
= mono_array_length ((MonoArray
*)dst
);
2281 for (i
= 0; i
< len
; i
++) {
2282 MonoObject
*item
= mono_array_get ((MonoArray
*)src
, gpointer
, i
);
2283 mono_array_set ((MonoArray
*)dst
, gpointer
, i
, mono_marshal_xdomain_copy_value (item
));
2286 mono_array_full_copy ((MonoArray
*)src
, (MonoArray
*)dst
);
2292 if (mono_object_class (src
) == mono_defaults
.stringbuilder_class
) {
2293 MonoStringBuilder
*src_sb
= (MonoStringBuilder
*) src
;
2294 MonoStringBuilder
*dst_sb
= (MonoStringBuilder
*) dst
;
2296 dst_sb
->str
= mono_string_new_utf16 (mono_object_domain (dst
), mono_string_chars (src_sb
->str
), mono_string_length (src_sb
->str
));
2297 dst_sb
->length
= src_sb
->length
;
2302 mono_marshal_emit_xdomain_copy_value (MonoMethodBuilder
*mb
, MonoClass
*pclass
)
2304 static MonoMethodSignature
*csig
= NULL
;
2306 csig
= mono_metadata_signature_alloc (mono_defaults
.corlib
, 1);
2307 csig
->params
[0] = &mono_defaults
.object_class
->byval_arg
;
2308 csig
->ret
= &mono_defaults
.object_class
->byval_arg
;
2312 mono_mb_emit_native_call (mb
, csig
, mono_marshal_xdomain_copy_value
);
2313 mono_mb_emit_byte (mb
, CEE_CASTCLASS
);
2314 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, pclass
));
2318 mono_marshal_emit_xdomain_copy_out_value (MonoMethodBuilder
*mb
, MonoClass
*pclass
)
2320 static MonoMethodSignature
*csig
= NULL
;
2322 csig
= mono_metadata_signature_alloc (mono_defaults
.corlib
, 2);
2323 csig
->params
[0] = &mono_defaults
.object_class
->byval_arg
;
2324 csig
->params
[1] = &mono_defaults
.object_class
->byval_arg
;
2325 csig
->ret
= &mono_defaults
.void_class
->byval_arg
;
2329 mono_mb_emit_native_call (mb
, csig
, mono_marshal_xdomain_copy_out_value
);
2332 /* mono_marshal_supports_fast_xdomain()
2333 * Returns TRUE if the method can use the fast xdomain wrapper.
2336 mono_marshal_supports_fast_xdomain (MonoMethod
*method
)
2338 return !method
->klass
->contextbound
&&
2339 !((method
->flags
& METHOD_ATTRIBUTE_SPECIAL_NAME
) && (strcmp (".ctor", method
->name
) == 0));
2343 mono_marshal_set_domain_by_id (gint32 id
, MonoBoolean push
)
2345 MonoDomain
*current_domain
= mono_domain_get ();
2346 MonoDomain
*domain
= mono_domain_get_by_id (id
);
2348 if (!domain
|| !mono_domain_set (domain
, FALSE
))
2349 mono_raise_exception (mono_get_exception_appdomain_unloaded ());
2352 mono_thread_push_appdomain_ref (domain
);
2354 mono_thread_pop_appdomain_ref ();
2356 return current_domain
->domain_id
;
2360 mono_marshal_emit_switch_domain (MonoMethodBuilder
*mb
)
2362 static MonoMethodSignature
*csig
= NULL
;
2364 csig
= mono_metadata_signature_alloc (mono_defaults
.corlib
, 2);
2365 csig
->params
[0] = &mono_defaults
.int32_class
->byval_arg
;
2366 csig
->params
[1] = &mono_defaults
.int32_class
->byval_arg
;
2367 csig
->ret
= &mono_defaults
.int32_class
->byval_arg
;
2371 mono_mb_emit_native_call (mb
, csig
, mono_marshal_set_domain_by_id
);
2374 /* mono_marshal_emit_load_domain_method ()
2375 * Loads into the stack a pointer to the code of the provided method for
2376 * the current domain.
2379 mono_marshal_emit_load_domain_method (MonoMethodBuilder
*mb
, MonoMethod
*method
)
2381 static MonoMethodSignature
*csig
= NULL
;
2383 csig
= mono_metadata_signature_alloc (mono_defaults
.corlib
, 1);
2384 csig
->params
[0] = &mono_defaults
.int_class
->byval_arg
;
2385 csig
->ret
= &mono_defaults
.int_class
->byval_arg
;
2389 /* We need a pointer to the method for the running domain (not the domain
2390 * that compiles the method).
2392 mono_mb_emit_byte (mb
, MONO_CUSTOM_PREFIX
);
2393 mono_mb_emit_byte (mb
, CEE_MONO_LDPTR
);
2394 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, method
));
2395 mono_mb_emit_native_call (mb
, csig
, mono_compile_method
);
2398 /* mono_marshal_get_xappdomain_dispatch ()
2399 * Generates a method that dispatches a method call from another domain into
2400 * the current domain.
2403 mono_marshal_get_xappdomain_dispatch (MonoMethod
*method
, int *marshal_types
, int complex_count
, int complex_out_count
, int ret_marshal_type
)
2405 MonoMethodSignature
*sig
, *csig
;
2406 MonoMethodBuilder
*mb
;
2408 int i
, j
, param_index
, copy_locals_base
;
2409 MonoClass
*ret_class
= NULL
;
2410 int loc_array
=0, loc_return
=0, loc_serialized_exc
=0;
2411 MonoExceptionClause
*main_clause
;
2412 MonoMethodHeader
*header
;
2414 gboolean copy_return
;
2416 if ((res
= mono_marshal_remoting_find_in_cache (method
, MONO_WRAPPER_XDOMAIN_DISPATCH
)))
2419 sig
= method
->signature
;
2420 copy_return
= (sig
->ret
->type
!= MONO_TYPE_VOID
&& ret_marshal_type
!= MONO_MARSHAL_SERIALIZE
);
2423 csig
= mono_metadata_signature_alloc (mono_defaults
.corlib
, 3 + sig
->param_count
- complex_count
);
2424 csig
->params
[j
++] = &mono_defaults
.object_class
->byval_arg
;
2425 csig
->params
[j
++] = &byte_array_class
->this_arg
;
2426 csig
->params
[j
++] = &byte_array_class
->this_arg
;
2427 for (i
= 0; i
< sig
->param_count
; i
++) {
2428 if (marshal_types
[i
] != MONO_MARSHAL_SERIALIZE
)
2429 csig
->params
[j
++] = sig
->params
[i
];
2432 csig
->ret
= sig
->ret
;
2434 csig
->ret
= &mono_defaults
.void_class
->byval_arg
;
2436 csig
->hasthis
= FALSE
;
2438 mb
= mono_mb_new (method
->klass
, method
->name
, MONO_WRAPPER_XDOMAIN_DISPATCH
);
2439 mb
->method
->save_lmf
= 1;
2443 loc_serialized_exc
= mono_mb_add_local (mb
, &byte_array_class
->byval_arg
);
2444 if (complex_count
> 0)
2445 loc_array
= mono_mb_add_local (mb
, &mono_defaults
.object_class
->byval_arg
);
2446 if (sig
->ret
->type
!= MONO_TYPE_VOID
) {
2447 loc_return
= mono_mb_add_local (mb
, sig
->ret
);
2448 ret_class
= mono_class_from_mono_type (sig
->ret
);
2453 main_clause
= g_new0 (MonoExceptionClause
, 1);
2454 main_clause
->try_offset
= mb
->pos
;
2456 /* Clean the call context */
2458 mono_mb_emit_byte (mb
, CEE_LDNULL
);
2459 mono_mb_emit_managed_call (mb
, method_set_call_context
, NULL
);
2460 mono_mb_emit_byte (mb
, CEE_POP
);
2462 /* Deserialize call data */
2464 mono_mb_emit_ldarg (mb
, 1);
2465 mono_mb_emit_byte (mb
, CEE_LDIND_REF
);
2466 mono_mb_emit_byte (mb
, CEE_DUP
);
2467 mono_mb_emit_byte (mb
, CEE_BRFALSE_S
);
2469 mono_mb_emit_byte (mb
, 0);
2471 mono_marshal_emit_xdomain_copy_value (mb
, byte_array_class
);
2472 mono_mb_emit_managed_call (mb
, method_rs_deserialize
, NULL
);
2474 if (complex_count
> 0)
2475 mono_mb_emit_stloc (mb
, loc_array
);
2477 mono_mb_emit_byte (mb
, CEE_POP
);
2479 mono_mb_patch_addr_s (mb
, pos
, mb
->pos
- (pos
+ 1));
2481 /* Get the target object */
2483 mono_mb_emit_ldarg (mb
, 0);
2484 mono_mb_emit_managed_call (mb
, method_rs_appdomain_target
, NULL
);
2486 /* Load the arguments */
2488 copy_locals_base
= mb
->locals
;
2489 param_index
= 3; // Index of the first non-serialized parameter of this wrapper
2491 for (i
= 0; i
< sig
->param_count
; i
++) {
2492 MonoType
*pt
= sig
->params
[i
];
2493 MonoClass
*pclass
= mono_class_from_mono_type (pt
);
2494 switch (marshal_types
[i
]) {
2495 case MONO_MARSHAL_SERIALIZE
: {
2496 /* take the value from the serialized array */
2497 mono_mb_emit_ldloc (mb
, loc_array
);
2498 mono_mb_emit_icon (mb
, j
++);
2500 if (pclass
->valuetype
) {
2501 mono_mb_emit_byte (mb
, CEE_LDELEM_REF
);
2502 mono_mb_emit_byte (mb
, CEE_UNBOX
);
2503 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, pclass
));
2505 mono_mb_emit_byte (mb
, CEE_LDELEMA
);
2506 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, pclass
));
2509 if (pclass
->valuetype
) {
2510 mono_mb_emit_byte (mb
, CEE_LDELEM_REF
);
2511 mono_mb_emit_byte (mb
, CEE_UNBOX
);
2512 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, pclass
));
2513 mono_mb_emit_byte (mb
, CEE_LDOBJ
);
2514 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, pclass
));
2516 mono_mb_emit_byte (mb
, CEE_LDELEM_REF
);
2517 if (pclass
!= mono_defaults
.object_class
) {
2518 mono_mb_emit_byte (mb
, CEE_CASTCLASS
);
2519 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, pclass
));
2525 case MONO_MARSHAL_COPY_OUT
: {
2526 /* Keep a local copy of the value since we need to copy it back after the call */
2527 int copy_local
= mono_mb_add_local (mb
, &(pclass
->byval_arg
));
2528 mono_mb_emit_ldarg (mb
, param_index
++);
2529 mono_marshal_emit_xdomain_copy_value (mb
, pclass
);
2530 mono_mb_emit_byte (mb
, CEE_DUP
);
2531 mono_mb_emit_stloc (mb
, copy_local
);
2534 case MONO_MARSHAL_COPY
: {
2535 mono_mb_emit_ldarg (mb
, param_index
);
2537 mono_mb_emit_byte (mb
, CEE_DUP
);
2538 mono_mb_emit_byte (mb
, CEE_DUP
);
2539 mono_mb_emit_byte (mb
, CEE_LDIND_REF
);
2540 mono_marshal_emit_xdomain_copy_value (mb
, pclass
);
2541 mono_mb_emit_byte (mb
, CEE_STIND_REF
);
2543 mono_marshal_emit_xdomain_copy_value (mb
, pclass
);
2548 case MONO_MARSHAL_NONE
:
2549 mono_mb_emit_ldarg (mb
, param_index
++);
2554 /* Make the call to the real object */
2556 emit_thread_force_interrupt_checkpoint (mb
);
2557 mono_mb_emit_managed_call (mb
, method
, NULL
);
2559 if (sig
->ret
->type
!= MONO_TYPE_VOID
)
2560 mono_mb_emit_stloc (mb
, loc_return
);
2562 /* copy back MONO_MARSHAL_COPY_OUT parameters */
2566 for (i
= 0; i
< sig
->param_count
; i
++) {
2567 if (marshal_types
[i
] == MONO_MARSHAL_SERIALIZE
) continue;
2568 if (marshal_types
[i
] == MONO_MARSHAL_COPY_OUT
) {
2569 mono_mb_emit_ldloc (mb
, copy_locals_base
+ (j
++));
2570 mono_mb_emit_ldarg (mb
, param_index
);
2571 mono_marshal_emit_xdomain_copy_out_value (mb
, mono_class_from_mono_type (sig
->params
[i
]));
2576 /* Serialize the return values */
2578 if (complex_out_count
> 0) {
2579 /* Reset parameters in the array that don't need to be serialized back */
2581 for (i
= 0; i
< sig
->param_count
; i
++) {
2582 if (marshal_types
[i
] != MONO_MARSHAL_SERIALIZE
) continue;
2583 if (!sig
->params
[i
]->byref
) {
2584 mono_mb_emit_ldloc (mb
, loc_array
);
2585 mono_mb_emit_icon (mb
, j
);
2586 mono_mb_emit_byte (mb
, CEE_LDNULL
);
2587 mono_mb_emit_byte (mb
, CEE_STELEM_REF
);
2592 /* Add the return value to the array */
2594 if (ret_marshal_type
== MONO_MARSHAL_SERIALIZE
) {
2595 mono_mb_emit_ldloc (mb
, loc_array
);
2596 mono_mb_emit_icon (mb
, complex_count
); /* The array has an additional slot to hold the ret value */
2597 mono_mb_emit_ldloc (mb
, loc_return
);
2598 if (ret_class
->valuetype
) {
2599 mono_mb_emit_byte (mb
, CEE_BOX
);
2600 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, ret_class
));
2602 mono_mb_emit_byte (mb
, CEE_STELEM_REF
);
2607 mono_mb_emit_ldarg (mb
, 1);
2608 mono_mb_emit_ldloc (mb
, loc_array
);
2609 mono_mb_emit_managed_call (mb
, method_rs_serialize
, NULL
);
2610 mono_mb_emit_byte (mb
, CEE_STIND_REF
);
2611 } else if (ret_marshal_type
== MONO_MARSHAL_SERIALIZE
) {
2612 mono_mb_emit_ldarg (mb
, 1);
2613 mono_mb_emit_ldloc (mb
, loc_return
);
2614 if (ret_class
->valuetype
) {
2615 mono_mb_emit_byte (mb
, CEE_BOX
);
2616 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, ret_class
));
2618 mono_mb_emit_managed_call (mb
, method_rs_serialize
, NULL
);
2619 mono_mb_emit_byte (mb
, CEE_STIND_REF
);
2621 mono_mb_emit_ldarg (mb
, 1);
2622 mono_mb_emit_byte (mb
, CEE_LDNULL
);
2623 mono_mb_emit_managed_call (mb
, method_rs_serialize
, NULL
);
2624 mono_mb_emit_byte (mb
, CEE_STIND_REF
);
2627 mono_mb_emit_ldarg (mb
, 2);
2628 mono_mb_emit_byte (mb
, CEE_LDNULL
);
2629 mono_mb_emit_byte (mb
, CEE_STIND_REF
);
2630 mono_mb_emit_byte (mb
, CEE_LEAVE
);
2631 pos_leave
= mb
->pos
;
2632 mono_mb_emit_i4 (mb
, 0);
2634 /* Main exception catch */
2635 main_clause
->flags
= MONO_EXCEPTION_CLAUSE_NONE
;
2636 main_clause
->try_len
= mb
->pos
- main_clause
->try_offset
;
2637 main_clause
->data
.catch_class
= mono_defaults
.object_class
;
2640 main_clause
->handler_offset
= mb
->pos
;
2641 mono_mb_emit_managed_call (mb
, method_rs_serialize_exc
, NULL
);
2642 mono_mb_emit_stloc (mb
, loc_serialized_exc
);
2643 mono_mb_emit_ldarg (mb
, 2);
2644 mono_mb_emit_ldloc (mb
, loc_serialized_exc
);
2645 mono_mb_emit_byte (mb
, CEE_STIND_REF
);
2646 mono_mb_emit_byte (mb
, CEE_LEAVE
);
2647 mono_mb_emit_i4 (mb
, 0);
2648 main_clause
->handler_len
= mb
->pos
- main_clause
->handler_offset
;
2651 mono_mb_patch_addr (mb
, pos_leave
, mb
->pos
- (pos_leave
+ 4));
2654 mono_mb_emit_ldloc (mb
, loc_return
);
2656 mono_mb_emit_byte (mb
, CEE_RET
);
2658 res
= mono_remoting_mb_create_and_cache (method
, mb
, csig
, csig
->param_count
+ 16);
2661 header
= ((MonoMethodNormal
*)res
)->header
;
2662 header
->num_clauses
= 1;
2663 header
->clauses
= main_clause
;
2668 /* mono_marshal_get_xappdomain_invoke ()
2669 * Generates a fast remoting wrapper for cross app domain calls.
2672 mono_marshal_get_xappdomain_invoke (MonoMethod
*method
)
2674 MonoMethodSignature
*sig
;
2675 static MonoMethodSignature
*sig_context_get
;
2676 static MonoMethodSignature
*sig_context_set
;
2677 MonoMethodBuilder
*mb
;
2679 int i
, j
, complex_count
, complex_out_count
, copy_locals_base
;
2681 MonoClass
*ret_class
= NULL
;
2682 MonoMethod
*xdomain_method
;
2683 int ret_marshal_type
= MONO_MARSHAL_NONE
;
2684 int loc_array
=0, loc_serialized_data
=-1, loc_real_proxy
;
2685 int loc_old_domainid
, loc_return
=0, loc_serialized_exc
=0, loc_context
, loc_datastore
;
2687 gboolean copy_return
= FALSE
;
2691 if (method
->wrapper_type
== MONO_WRAPPER_REMOTING_INVOKE
|| method
->wrapper_type
== MONO_WRAPPER_XDOMAIN_INVOKE
)
2694 /* we cant remote methods without this pointer */
2695 if (!method
->signature
->hasthis
)
2698 if (!mono_marshal_supports_fast_xdomain (method
))
2699 return mono_marshal_get_remoting_invoke (method
);
2701 mono_remoting_marshal_init ();
2703 if ((res
= mono_marshal_remoting_find_in_cache (method
, MONO_WRAPPER_XDOMAIN_INVOKE
)))
2706 sig
= signature_no_pinvoke (method
->signature
);
2708 if (sig_context_set
== NULL
) {
2709 sig_context_set
= mono_metadata_signature_alloc (mono_defaults
.corlib
, 1);
2710 sig_context_set
->params
[0] = &mono_defaults
.object_class
->byval_arg
;
2711 sig_context_set
->ret
= &mono_defaults
.void_class
->byval_arg
;
2712 sig_context_set
->pinvoke
= 1;
2714 sig_context_get
= mono_metadata_signature_alloc (mono_defaults
.corlib
, 0);
2715 sig_context_get
->ret
= &mono_defaults
.object_class
->byval_arg
;
2716 sig_context_get
->pinvoke
= 1;
2719 mb
= mono_mb_new (method
->klass
, method
->name
, MONO_WRAPPER_XDOMAIN_INVOKE
);
2720 mb
->method
->save_lmf
= 1;
2722 /* Count the number of parameters that need to be serialized */
2724 marshal_types
= alloca (sizeof (int) * sig
->param_count
);
2725 complex_count
= complex_out_count
= 0;
2726 for (i
= 0; i
< sig
->param_count
; i
++) {
2727 MonoType
*ptype
= sig
->params
[i
];
2728 int mt
= mono_get_xdomain_marshal_type (ptype
);
2730 /* If the [Out] attribute is applied to a parameter that can be internally copied,
2731 * the copy will be made by reusing the original object instance
2733 if ((ptype
->attrs
& PARAM_ATTRIBUTE_OUT
) != 0 && mt
== MONO_MARSHAL_COPY
&& !ptype
->byref
)
2734 mt
= MONO_MARSHAL_COPY_OUT
;
2735 else if (mt
== MONO_MARSHAL_SERIALIZE
) {
2737 if (ptype
->byref
) complex_out_count
++;
2739 marshal_types
[i
] = mt
;
2742 if (sig
->ret
->type
!= MONO_TYPE_VOID
) {
2743 ret_marshal_type
= mono_get_xdomain_marshal_type (sig
->ret
);
2744 ret_class
= mono_class_from_mono_type (sig
->ret
);
2745 copy_return
= ret_marshal_type
!= MONO_MARSHAL_SERIALIZE
;
2750 if (complex_count
> 0)
2751 loc_array
= mono_mb_add_local (mb
, &mono_defaults
.object_class
->byval_arg
);
2752 loc_serialized_data
= mono_mb_add_local (mb
, &byte_array_class
->byval_arg
);
2753 loc_real_proxy
= mono_mb_add_local (mb
, &mono_defaults
.object_class
->byval_arg
);
2755 loc_return
= mono_mb_add_local (mb
, sig
->ret
);
2756 loc_old_domainid
= mono_mb_add_local (mb
, &mono_defaults
.int32_class
->byval_arg
);
2757 loc_serialized_exc
= mono_mb_add_local (mb
, &byte_array_class
->byval_arg
);
2758 loc_context
= mono_mb_add_local (mb
, &mono_defaults
.object_class
->byval_arg
);
2759 loc_datastore
= mono_mb_add_local (mb
, &mono_defaults
.object_class
->byval_arg
);
2761 /* Save thread domain data */
2763 mono_mb_emit_native_call (mb
, sig_context_get
, mono_context_get
);
2764 mono_mb_emit_byte (mb
, CEE_DUP
);
2765 mono_mb_emit_stloc (mb
, loc_context
);
2767 /* If the thread is not running in the default context, it needs to go
2768 * through the whole remoting sink, since the context is going to change
2770 mono_mb_emit_managed_call (mb
, method_needs_context_sink
, NULL
);
2771 mono_mb_emit_byte (mb
, CEE_BRFALSE_S
);
2773 mono_mb_emit_byte (mb
, 0);
2775 mono_mb_emit_ldarg (mb
, 0);
2776 for (i
= 0; i
< sig
->param_count
; i
++)
2777 mono_mb_emit_ldarg (mb
, i
+ 1);
2779 mono_mb_emit_managed_call (mb
, mono_marshal_get_remoting_invoke (method
), NULL
);
2780 mono_mb_emit_byte (mb
, CEE_RET
);
2781 mono_mb_patch_addr_s (mb
, pos
, mb
->pos
- pos
- 1);
2783 mono_mb_emit_managed_call (mb
, method_reset_datastore
, NULL
);
2784 mono_mb_emit_stloc (mb
, loc_datastore
);
2786 /* Create the array that will hold the parameters to be serialized */
2788 if (complex_count
> 0) {
2789 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 */
2790 mono_mb_emit_byte (mb
, CEE_NEWARR
);
2791 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, mono_defaults
.object_class
));
2794 for (i
= 0; i
< sig
->param_count
; i
++) {
2795 if (marshal_types
[i
] != MONO_MARSHAL_SERIALIZE
) continue;
2796 MonoClass
*pclass
= mono_class_from_mono_type (sig
->params
[i
]);
2797 mono_mb_emit_byte (mb
, CEE_DUP
);
2798 mono_mb_emit_icon (mb
, j
);
2799 mono_mb_emit_ldarg (mb
, i
+ 1); /* 0=this */
2800 if (sig
->params
[i
]->byref
) {
2801 if (pclass
->valuetype
) {
2802 mono_mb_emit_byte (mb
, CEE_LDOBJ
);
2803 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, pclass
));
2805 mono_mb_emit_byte (mb
, CEE_LDIND_REF
);
2808 if (pclass
->valuetype
) {
2809 mono_mb_emit_byte (mb
, CEE_BOX
);
2810 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, pclass
));
2812 mono_mb_emit_byte (mb
, CEE_STELEM_REF
);
2815 mono_mb_emit_stloc (mb
, loc_array
);
2817 /* Serialize parameters */
2819 mono_mb_emit_ldloc (mb
, loc_array
);
2820 mono_mb_emit_managed_call (mb
, method_rs_serialize
, NULL
);
2821 mono_mb_emit_stloc (mb
, loc_serialized_data
);
2823 mono_mb_emit_byte (mb
, CEE_LDNULL
);
2824 mono_mb_emit_managed_call (mb
, method_rs_serialize
, NULL
);
2825 mono_mb_emit_stloc (mb
, loc_serialized_data
);
2828 /* Get the target domain id */
2830 mono_mb_emit_ldarg (mb
, 0);
2831 mono_mb_emit_ldflda (mb
, G_STRUCT_OFFSET (MonoTransparentProxy
, rp
));
2832 mono_mb_emit_byte (mb
, CEE_LDIND_REF
);
2833 mono_mb_emit_byte (mb
, CEE_DUP
);
2834 mono_mb_emit_stloc (mb
, loc_real_proxy
);
2836 mono_mb_emit_ldflda (mb
, G_STRUCT_OFFSET (MonoRealProxy
, target_domain_id
));
2837 mono_mb_emit_byte (mb
, CEE_LDIND_I4
);
2838 mono_mb_emit_byte (mb
, CEE_LDC_I4_1
);
2842 mono_marshal_emit_switch_domain (mb
);
2843 mono_mb_emit_stloc (mb
, loc_old_domainid
);
2845 /* Load the arguments */
2847 mono_mb_emit_ldloc (mb
, loc_real_proxy
);
2848 mono_mb_emit_ldloc_addr (mb
, loc_serialized_data
);
2849 mono_mb_emit_ldloc_addr (mb
, loc_serialized_exc
);
2851 copy_locals_base
= mb
->locals
;
2852 for (i
= 0; i
< sig
->param_count
; i
++) {
2853 switch (marshal_types
[i
]) {
2854 case MONO_MARSHAL_SERIALIZE
:
2856 case MONO_MARSHAL_COPY
: {
2857 mono_mb_emit_ldarg (mb
, i
+1);
2858 if (sig
->params
[i
]->byref
) {
2859 /* make a local copy of the byref parameter. The real parameter
2860 * will be updated after the xdomain call
2862 MonoClass
*pclass
= mono_class_from_mono_type (sig
->params
[i
]);
2863 int copy_local
= mono_mb_add_local (mb
, &(pclass
->byval_arg
));
2864 mono_mb_emit_byte (mb
, CEE_LDIND_REF
);
2865 mono_mb_emit_stloc (mb
, copy_local
);
2866 mono_mb_emit_ldloc_addr (mb
, copy_local
);
2870 case MONO_MARSHAL_COPY_OUT
:
2871 case MONO_MARSHAL_NONE
:
2872 mono_mb_emit_ldarg (mb
, i
+1);
2877 /* Make the call to the invoke wrapper in the target domain */
2879 xdomain_method
= mono_marshal_get_xappdomain_dispatch (method
, marshal_types
, complex_count
, complex_out_count
, ret_marshal_type
);
2880 mono_marshal_emit_load_domain_method (mb
, xdomain_method
);
2881 mono_mb_emit_calli (mb
, xdomain_method
->signature
);
2884 mono_mb_emit_stloc (mb
, loc_return
);
2888 mono_mb_emit_ldloc (mb
, loc_old_domainid
);
2889 mono_mb_emit_byte (mb
, CEE_LDC_I4_0
);
2890 mono_marshal_emit_switch_domain (mb
);
2891 mono_mb_emit_byte (mb
, CEE_POP
);
2893 /* Restore thread domain data */
2895 mono_mb_emit_ldloc (mb
, loc_context
);
2896 mono_mb_emit_native_call (mb
, sig_context_set
, mono_context_set
);
2897 mono_mb_emit_ldloc (mb
, loc_datastore
);
2898 mono_mb_emit_managed_call (mb
, method_restore_datastore
, NULL
);
2900 /* if (loc_serialized_exc != null) ... */
2902 mono_mb_emit_ldloc (mb
, loc_serialized_exc
);
2903 mono_mb_emit_byte (mb
, CEE_BRFALSE_S
);
2905 mono_mb_emit_byte (mb
, 0);
2907 mono_mb_emit_ldloc (mb
, loc_serialized_exc
);
2908 mono_marshal_emit_xdomain_copy_value (mb
, byte_array_class
);
2909 mono_mb_emit_managed_call (mb
, method_rs_deserialize
, NULL
);
2910 mono_mb_emit_byte (mb
, CEE_CASTCLASS
);
2911 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, mono_defaults
.exception_class
));
2912 mono_mb_emit_managed_call (mb
, method_exc_fixexc
, NULL
);
2913 mono_mb_emit_byte (mb
, CEE_THROW
);
2914 mono_mb_patch_addr_s (mb
, pos_noex
, mb
->pos
- pos_noex
- 1);
2916 /* copy back non-serialized output parameters */
2919 for (i
= 0; i
< sig
->param_count
; i
++) {
2920 if (!sig
->params
[i
]->byref
|| marshal_types
[i
] != MONO_MARSHAL_COPY
) continue;
2921 mono_mb_emit_ldarg (mb
, i
+ 1);
2922 mono_mb_emit_ldloc (mb
, copy_locals_base
+ (j
++));
2923 mono_marshal_emit_xdomain_copy_value (mb
, mono_class_from_mono_type (sig
->params
[i
]));
2924 mono_mb_emit_byte (mb
, CEE_STIND_REF
);
2927 /* Deserialize out parameters */
2929 if (complex_out_count
> 0) {
2930 mono_mb_emit_ldloc (mb
, loc_serialized_data
);
2931 mono_marshal_emit_xdomain_copy_value (mb
, byte_array_class
);
2932 mono_mb_emit_managed_call (mb
, method_rs_deserialize
, NULL
);
2933 mono_mb_emit_stloc (mb
, loc_array
);
2935 /* Copy back output parameters and return type */
2938 for (i
= 0; i
< sig
->param_count
; i
++) {
2939 if (marshal_types
[i
] != MONO_MARSHAL_SERIALIZE
) continue;
2940 if (sig
->params
[i
]->byref
) {
2941 MonoClass
*pclass
= mono_class_from_mono_type (sig
->params
[i
]);
2942 mono_mb_emit_ldarg (mb
, i
+ 1);
2943 mono_mb_emit_ldloc (mb
, loc_array
);
2944 mono_mb_emit_icon (mb
, j
);
2945 mono_mb_emit_byte (mb
, CEE_LDELEM_REF
);
2946 if (pclass
->valuetype
) {
2947 mono_mb_emit_byte (mb
, CEE_UNBOX
);
2948 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, pclass
));
2949 mono_mb_emit_byte (mb
, CEE_LDOBJ
);
2950 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, pclass
));
2951 mono_mb_emit_byte (mb
, CEE_STOBJ
);
2952 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, pclass
));
2954 if (pclass
!= mono_defaults
.object_class
) {
2955 mono_mb_emit_byte (mb
, CEE_CASTCLASS
);
2956 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, pclass
));
2958 mono_mb_emit_byte (mb
, CEE_STIND_REF
);
2964 if (ret_marshal_type
== MONO_MARSHAL_SERIALIZE
) {
2965 mono_mb_emit_ldloc (mb
, loc_array
);
2966 mono_mb_emit_icon (mb
, complex_count
);
2967 mono_mb_emit_byte (mb
, CEE_LDELEM_REF
);
2968 if (ret_class
->valuetype
) {
2969 mono_mb_emit_byte (mb
, CEE_UNBOX
);
2970 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, ret_class
));
2971 mono_mb_emit_byte (mb
, CEE_LDOBJ
);
2972 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, ret_class
));
2975 } else if (ret_marshal_type
== MONO_MARSHAL_SERIALIZE
) {
2976 mono_mb_emit_ldloc (mb
, loc_serialized_data
);
2977 mono_marshal_emit_xdomain_copy_value (mb
, byte_array_class
);
2978 mono_mb_emit_managed_call (mb
, method_rs_deserialize
, NULL
);
2979 if (ret_class
->valuetype
) {
2980 mono_mb_emit_byte (mb
, CEE_UNBOX
);
2981 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, ret_class
));
2982 mono_mb_emit_byte (mb
, CEE_LDOBJ
);
2983 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, ret_class
));
2984 } else if (ret_class
!= mono_defaults
.object_class
) {
2985 mono_mb_emit_byte (mb
, CEE_CASTCLASS
);
2986 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, ret_class
));
2989 mono_mb_emit_ldloc (mb
, loc_serialized_data
);
2990 mono_mb_emit_byte (mb
, CEE_DUP
);
2991 mono_mb_emit_byte (mb
, CEE_BRFALSE_S
);
2993 mono_mb_emit_byte (mb
, 0);
2994 mono_marshal_emit_xdomain_copy_value (mb
, byte_array_class
);
2996 mono_mb_patch_addr_s (mb
, pos
, mb
->pos
- (pos
+ 1));
2997 mono_mb_emit_managed_call (mb
, method_rs_deserialize
, NULL
);
2998 mono_mb_emit_byte (mb
, CEE_POP
);
3002 mono_mb_emit_ldloc (mb
, loc_return
);
3003 if (ret_marshal_type
== MONO_MARSHAL_COPY
)
3004 mono_marshal_emit_xdomain_copy_value (mb
, ret_class
);
3007 mono_mb_emit_byte (mb
, CEE_RET
);
3009 res
= mono_remoting_mb_create_and_cache (method
, mb
, sig
, sig
->param_count
+ 16);
3016 mono_marshal_get_remoting_invoke_for_target (MonoMethod
*method
, MonoRemotingTarget target_type
)
3018 if (target_type
== MONO_REMOTING_TARGET_APPDOMAIN
)
3019 return mono_marshal_get_xappdomain_invoke (method
);
3021 return mono_marshal_get_remoting_invoke (method
);
3024 G_GNUC_UNUSED
static gpointer
3025 mono_marshal_load_remoting_wrapper (MonoRealProxy
*rp
, MonoMethod
*method
)
3027 if (rp
->target_domain_id
!= -1)
3028 return mono_compile_method (mono_marshal_get_xappdomain_invoke (method
));
3030 return mono_compile_method (mono_marshal_get_remoting_invoke (method
));
3034 mono_marshal_get_remoting_invoke_with_check (MonoMethod
*method
)
3036 MonoMethodSignature
*sig
;
3037 MonoMethodBuilder
*mb
;
3038 MonoMethod
*res
, *native
;
3039 int i
, pos
, pos_rem
;
3043 if (method
->wrapper_type
== MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK
)
3046 sig
= signature_no_pinvoke (method
->signature
);
3048 /* we cant remote methods without this pointer */
3049 g_assert (sig
->hasthis
);
3051 if ((res
= mono_marshal_remoting_find_in_cache (method
, MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK
)))
3054 mb
= mono_mb_new (method
->klass
, method
->name
, MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK
);
3056 for (i
= 0; i
<= sig
->param_count
; i
++)
3057 mono_mb_emit_ldarg (mb
, i
);
3059 mono_mb_emit_ldarg (mb
, 0);
3060 pos
= mono_mb_emit_proxy_check (mb
, CEE_BNE_UN
);
3062 if (mono_marshal_supports_fast_xdomain (method
)) {
3063 mono_mb_emit_ldarg (mb
, 0);
3064 pos_rem
= mono_mb_emit_xdomain_check (mb
, CEE_BEQ
);
3066 /* wrapper for cross app domain calls */
3067 native
= mono_marshal_get_xappdomain_invoke (method
);
3068 mono_mb_emit_managed_call (mb
, native
, native
->signature
);
3069 mono_mb_emit_byte (mb
, CEE_RET
);
3071 mono_mb_patch_addr (mb
, pos_rem
, mb
->pos
- (pos_rem
+ 4));
3073 /* wrapper for normal remote calls */
3074 native
= mono_marshal_get_remoting_invoke (method
);
3075 mono_mb_emit_managed_call (mb
, native
, native
->signature
);
3076 mono_mb_emit_byte (mb
, CEE_RET
);
3079 mono_mb_patch_addr (mb
, pos
, mb
->pos
- (pos
+ 4));
3080 mono_mb_emit_managed_call (mb
, method
, method
->signature
);
3081 mono_mb_emit_byte (mb
, CEE_RET
);
3083 res
= mono_remoting_mb_create_and_cache (method
, mb
, sig
, sig
->param_count
+ 16);
3090 * the returned method invokes all methods in a multicast delegate
3093 mono_marshal_get_delegate_invoke (MonoMethod
*method
)
3095 MonoMethodSignature
*sig
, *static_sig
;
3097 MonoMethodBuilder
*mb
;
3103 g_assert (method
&& method
->klass
->parent
== mono_defaults
.multicastdelegate_class
&&
3104 !strcmp (method
->name
, "Invoke"));
3106 sig
= signature_no_pinvoke (method
->signature
);
3108 cache
= method
->klass
->image
->delegate_invoke_cache
;
3109 if ((res
= mono_marshal_find_in_cache (cache
, sig
)))
3112 static_sig
= mono_metadata_signature_dup (sig
);
3113 static_sig
->hasthis
= 0;
3115 name
= mono_signature_to_name (sig
, "invoke");
3116 mb
= mono_mb_new (mono_defaults
.multicastdelegate_class
, name
, MONO_WRAPPER_DELEGATE_INVOKE
);
3119 /* allocate local 0 (object) */
3120 mono_mb_add_local (mb
, &mono_defaults
.object_class
->byval_arg
);
3122 g_assert (sig
->hasthis
);
3126 * prev.Invoke( args .. );
3127 * return this.<target>( args .. );
3130 /* this wrapper can be used in unmanaged-managed transitions */
3131 emit_thread_interrupt_checkpoint (mb
);
3133 /* get this->prev */
3134 mono_mb_emit_ldarg (mb
, 0);
3135 mono_mb_emit_ldflda (mb
, G_STRUCT_OFFSET (MonoMulticastDelegate
, prev
));
3136 mono_mb_emit_byte (mb
, CEE_LDIND_I
);
3137 mono_mb_emit_stloc (mb
, 0);
3139 /* if prev != null */
3140 mono_mb_emit_ldloc (mb
, 0);
3141 mono_mb_emit_byte (mb
, CEE_BRFALSE
);
3144 mono_mb_emit_i4 (mb
, 0);
3147 mono_mb_emit_ldloc (mb
, 0);
3148 for (i
= 0; i
< sig
->param_count
; i
++)
3149 mono_mb_emit_ldarg (mb
, i
+ 1);
3150 mono_mb_emit_managed_call (mb
, method
, method
->signature
);
3151 if (sig
->ret
->type
!= MONO_TYPE_VOID
)
3152 mono_mb_emit_byte (mb
, CEE_POP
);
3154 /* continued or prev == null */
3155 mono_mb_patch_addr (mb
, pos0
, mb
->pos
- (pos0
+ 4));
3157 /* get this->target */
3158 mono_mb_emit_ldarg (mb
, 0);
3159 mono_mb_emit_ldflda (mb
, G_STRUCT_OFFSET (MonoDelegate
, target
));
3160 mono_mb_emit_byte (mb
, CEE_LDIND_I
);
3161 mono_mb_emit_stloc (mb
, 0);
3163 /* if target != null */
3164 mono_mb_emit_ldloc (mb
, 0);
3165 mono_mb_emit_byte (mb
, CEE_BRFALSE
);
3167 mono_mb_emit_i4 (mb
, 0);
3169 /* then call this->method_ptr nonstatic */
3170 mono_mb_emit_ldloc (mb
, 0);
3171 for (i
= 0; i
< sig
->param_count
; ++i
)
3172 mono_mb_emit_ldarg (mb
, i
+ 1);
3173 mono_mb_emit_ldarg (mb
, 0);
3174 mono_mb_emit_ldflda (mb
, G_STRUCT_OFFSET (MonoDelegate
, method_ptr
));
3175 mono_mb_emit_byte (mb
, CEE_LDIND_I
);
3176 mono_mb_emit_byte (mb
, CEE_CALLI
);
3177 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, sig
));
3179 mono_mb_emit_byte (mb
, CEE_BR
);
3181 mono_mb_emit_i4 (mb
, 0);
3183 /* else [target == null] call this->method_ptr static */
3184 mono_mb_patch_addr (mb
, pos0
, mb
->pos
- (pos0
+ 4));
3186 for (i
= 0; i
< sig
->param_count
; ++i
)
3187 mono_mb_emit_ldarg (mb
, i
+ 1);
3188 mono_mb_emit_ldarg (mb
, 0);
3189 mono_mb_emit_ldflda (mb
, G_STRUCT_OFFSET (MonoDelegate
, method_ptr
));
3190 mono_mb_emit_byte (mb
, CEE_LDIND_I
);
3191 mono_mb_emit_byte (mb
, CEE_CALLI
);
3192 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, static_sig
));
3195 mono_mb_patch_addr (mb
, pos1
, mb
->pos
- (pos1
+ 4));
3196 mono_mb_emit_byte (mb
, CEE_RET
);
3198 res
= mono_mb_create_and_cache (cache
, sig
,
3199 mb
, sig
, sig
->param_count
+ 16);
3206 * signature_dup_add_this:
3208 * Make a copy of @sig, adding an explicit this argument.
3210 static MonoMethodSignature
*
3211 signature_dup_add_this (MonoMethodSignature
*sig
, MonoClass
*klass
)
3213 MonoMethodSignature
*res
;
3216 res
= mono_metadata_signature_alloc (klass
->image
, sig
->param_count
+ 1);
3217 memcpy (res
, sig
, sizeof (MonoMethodSignature
));
3218 res
->param_count
= sig
->param_count
+ 1;
3219 res
->hasthis
= FALSE
;
3220 for (i
= sig
->param_count
- 1; i
>= 0; i
--)
3221 res
->params
[i
+ 1] = sig
->params
[i
];
3222 res
->params
[0] = &mono_ptr_class_get (&klass
->byval_arg
)->byval_arg
;
3229 MonoMethodSignature
*sig
;
3235 * generates IL code for the runtime invoke function
3236 * MonoObject *runtime_invoke (MonoObject *this, void **params, MonoObject **exc, void* method)
3238 * we also catch exceptions if exc != null
3241 mono_marshal_get_runtime_invoke (MonoMethod
*method
)
3243 MonoMethodSignature
*sig
, *csig
, *callsig
;
3244 MonoExceptionClause
*clause
;
3245 MonoMethodHeader
*header
;
3246 MonoMethodBuilder
*mb
;
3247 GHashTable
*cache
= NULL
;
3248 MonoClass
*target_klass
;
3249 MonoMethod
*res
= NULL
;
3251 static MonoString
*string_dummy
= NULL
;
3252 static MonoMethodSignature
*dealy_abort_sig
= NULL
;
3258 target_klass
= method
->klass
;
3260 EnterCriticalSection (&marshal_mutex
);
3262 if (method
->string_ctor
) {
3263 static GSList
*strsig_list
= NULL
;
3267 for (item
= strsig_list
; item
; item
= item
->next
) {
3269 if (mono_metadata_signature_equal (method
->signature
, cs
->ctor
->signature
)) {
3275 callsig
= mono_metadata_signature_dup (method
->signature
);
3276 callsig
->ret
= &mono_defaults
.string_class
->byval_arg
;
3277 cs
= g_new (CtorSigPair
, 1);
3280 strsig_list
= g_slist_prepend (strsig_list
, cs
);
3283 if (method
->klass
->valuetype
&& method
->signature
->hasthis
) {
3285 * Valuetype methods receive a managed pointer as the this argument.
3286 * Create a new signature to reflect this.
3288 callsig
= signature_dup_add_this (method
->signature
, method
->klass
);
3291 callsig
= method
->signature
;
3294 cache
= method
->klass
->image
->runtime_invoke_cache
;
3296 /* from mono_marshal_find_in_cache */
3297 res
= g_hash_table_lookup (cache
, callsig
);
3298 LeaveCriticalSection (&marshal_mutex
);
3304 if (!dealy_abort_sig
) {
3305 dealy_abort_sig
= mono_metadata_signature_alloc (mono_defaults
.corlib
, 0);
3306 dealy_abort_sig
->ret
= &mono_defaults
.void_class
->byval_arg
;
3307 dealy_abort_sig
->pinvoke
= 0;
3310 target_klass
= mono_defaults
.object_class
;
3312 /* to make it work with our special string constructors */
3313 if (!string_dummy
) {
3314 MONO_GC_REGISTER_ROOT (string_dummy
);
3315 string_dummy
= mono_string_new_wrapper ("dummy");
3318 sig
= method
->signature
;
3320 csig
= mono_metadata_signature_alloc (method
->klass
->image
, 4);
3322 csig
->ret
= &mono_defaults
.object_class
->byval_arg
;
3323 if (method
->klass
->valuetype
&& method
->signature
->hasthis
)
3324 csig
->params
[0] = callsig
->params
[0];
3326 csig
->params
[0] = &mono_defaults
.object_class
->byval_arg
;
3327 csig
->params
[1] = &mono_defaults
.int_class
->byval_arg
;
3328 csig
->params
[2] = &mono_defaults
.int_class
->byval_arg
;
3329 csig
->params
[3] = &mono_defaults
.int_class
->byval_arg
;
3331 name
= mono_signature_to_name (callsig
, "runtime_invoke");
3332 mb
= mono_mb_new (target_klass
, name
, MONO_WRAPPER_RUNTIME_INVOKE
);
3335 /* allocate local 0 (object) tmp */
3336 mono_mb_add_local (mb
, &mono_defaults
.object_class
->byval_arg
);
3337 /* allocate local 1 (object) exc */
3338 mono_mb_add_local (mb
, &mono_defaults
.object_class
->byval_arg
);
3340 /* cond set *exc to null */
3341 mono_mb_emit_byte (mb
, CEE_LDARG_2
);
3342 mono_mb_emit_byte (mb
, CEE_BRFALSE_S
);
3343 mono_mb_emit_byte (mb
, 3);
3344 mono_mb_emit_byte (mb
, CEE_LDARG_2
);
3345 mono_mb_emit_byte (mb
, CEE_LDNULL
);
3346 mono_mb_emit_byte (mb
, CEE_STIND_I
);
3349 if (method
->string_ctor
) {
3350 mono_mb_emit_byte (mb
, MONO_CUSTOM_PREFIX
);
3351 mono_mb_emit_byte (mb
, CEE_MONO_LDPTR
);
3352 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, string_dummy
));
3354 mono_mb_emit_ldarg (mb
, 0);
3358 for (i
= 0; i
< sig
->param_count
; i
++) {
3359 MonoType
*t
= sig
->params
[i
];
3362 mono_mb_emit_ldarg (mb
, 1);
3364 mono_mb_emit_icon (mb
, sizeof (gpointer
) * i
);
3365 mono_mb_emit_byte (mb
, CEE_ADD
);
3367 mono_mb_emit_byte (mb
, CEE_LDIND_I
);
3372 type
= sig
->params
[i
]->type
;
3376 mono_mb_emit_byte (mb
, CEE_LDIND_I1
);
3378 case MONO_TYPE_BOOLEAN
:
3380 mono_mb_emit_byte (mb
, CEE_LDIND_U1
);
3383 mono_mb_emit_byte (mb
, CEE_LDIND_I2
);
3386 case MONO_TYPE_CHAR
:
3387 mono_mb_emit_byte (mb
, CEE_LDIND_U2
);
3391 mono_mb_emit_byte (mb
, CEE_LDIND_I
);
3394 mono_mb_emit_byte (mb
, CEE_LDIND_I4
);
3397 mono_mb_emit_byte (mb
, CEE_LDIND_U4
);
3400 mono_mb_emit_byte (mb
, CEE_LDIND_R4
);
3403 mono_mb_emit_byte (mb
, CEE_LDIND_R8
);
3407 mono_mb_emit_byte (mb
, CEE_LDIND_I8
);
3409 case MONO_TYPE_STRING
:
3410 case MONO_TYPE_CLASS
:
3411 case MONO_TYPE_ARRAY
:
3413 case MONO_TYPE_SZARRAY
:
3414 case MONO_TYPE_OBJECT
:
3417 case MONO_TYPE_VALUETYPE
:
3418 if (t
->data
.klass
->enumtype
) {
3419 type
= t
->data
.klass
->enum_basetype
->type
;
3422 mono_mb_emit_byte (mb
, CEE_LDOBJ
);
3423 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, t
->data
.klass
));
3426 g_assert_not_reached ();
3430 mono_mb_emit_ldarg (mb
, 3);
3431 emit_thread_force_interrupt_checkpoint (mb
);
3432 mono_mb_emit_calli (mb
, callsig
);
3434 if (sig
->ret
->byref
) {
3436 g_assert_not_reached ();
3440 switch (sig
->ret
->type
) {
3441 case MONO_TYPE_VOID
:
3442 if (!method
->string_ctor
)
3443 mono_mb_emit_byte (mb
, CEE_LDNULL
);
3445 case MONO_TYPE_BOOLEAN
:
3446 case MONO_TYPE_CHAR
:
3459 case MONO_TYPE_VALUETYPE
:
3460 /* box value types */
3461 mono_mb_emit_byte (mb
, CEE_BOX
);
3462 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, mono_class_from_mono_type (sig
->ret
)));
3464 case MONO_TYPE_STRING
:
3465 case MONO_TYPE_CLASS
:
3466 case MONO_TYPE_ARRAY
:
3467 case MONO_TYPE_SZARRAY
:
3468 case MONO_TYPE_OBJECT
:
3473 g_assert_not_reached ();
3476 mono_mb_emit_stloc (mb
, 0);
3478 mono_mb_emit_byte (mb
, CEE_LEAVE
);
3480 mono_mb_emit_i4 (mb
, 0);
3482 clause
= g_new0 (MonoExceptionClause
, 1);
3483 clause
->flags
= MONO_EXCEPTION_CLAUSE_FILTER
;
3484 clause
->try_len
= mb
->pos
;
3487 clause
->data
.filter_offset
= mb
->pos
;
3489 mono_mb_emit_byte (mb
, CEE_POP
);
3490 mono_mb_emit_byte (mb
, CEE_LDARG_2
);
3491 mono_mb_emit_byte (mb
, CEE_LDC_I4_0
);
3492 mono_mb_emit_byte (mb
, CEE_PREFIX1
);
3493 mono_mb_emit_byte (mb
, CEE_CGT_UN
);
3494 mono_mb_emit_byte (mb
, CEE_PREFIX1
);
3495 mono_mb_emit_byte (mb
, CEE_ENDFILTER
);
3497 clause
->handler_offset
= mb
->pos
;
3500 /* store exception */
3501 mono_mb_emit_stloc (mb
, 1);
3503 mono_mb_emit_byte (mb
, CEE_LDARG_2
);
3504 mono_mb_emit_ldloc (mb
, 1);
3505 mono_mb_emit_byte (mb
, CEE_STIND_I
);
3507 mono_mb_emit_byte (mb
, CEE_LDC_I4_0
);
3508 mono_mb_emit_stloc (mb
, 0);
3510 /* Check for the abort exception */
3511 mono_mb_emit_ldloc (mb
, 1);
3512 mono_mb_emit_byte (mb
, CEE_ISINST
);
3513 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, mono_defaults
.threadabortexception_class
));
3514 mono_mb_emit_byte (mb
, CEE_BRFALSE_S
);
3516 mono_mb_emit_byte (mb
, 0);
3518 /* Delay the abort exception */
3519 mono_mb_emit_native_call (mb
, dealy_abort_sig
, ves_icall_System_Threading_Thread_ResetAbort
);
3521 mono_mb_patch_addr_s (mb
, posna
, mb
->pos
- posna
- 1);
3522 mono_mb_emit_byte (mb
, CEE_LEAVE
);
3523 mono_mb_emit_i4 (mb
, 0);
3525 clause
->handler_len
= mb
->pos
- clause
->handler_offset
;
3528 mono_mb_patch_addr (mb
, pos
, mb
->pos
- (pos
+ 4));
3529 mono_mb_emit_ldloc (mb
, 0);
3530 mono_mb_emit_byte (mb
, CEE_RET
);
3532 /* taken from mono_mb_create_and_cache */
3533 EnterCriticalSection (&marshal_mutex
);
3535 res
= g_hash_table_lookup (cache
, callsig
);
3536 /* Somebody may have created it before us */
3538 res
= mono_mb_create_method (mb
, csig
, sig
->param_count
+ 16);
3539 g_hash_table_insert (cache
, callsig
, res
);
3540 g_hash_table_insert (wrapper_hash
, res
, callsig
);
3543 LeaveCriticalSection (&marshal_mutex
);
3544 /* end mono_mb_create_and_cache */
3548 header
= ((MonoMethodNormal
*)res
)->header
;
3549 header
->num_clauses
= 1;
3550 header
->clauses
= clause
;
3556 raise_auto_layout_exception (MonoClass
*klass
)
3558 char *msg
= g_strdup_printf ("The type `%s.%s' layout needs to be Sequential or Explicit",
3559 klass
->name_space
, klass
->name
);
3561 MonoException
*e
= mono_exception_from_name_msg (
3562 mono_get_corlib (), "System.Runtime.InteropServices",
3563 "MarshalDirectiveException", msg
);
3565 mono_raise_exception (e
);
3569 * generates IL code to call managed methods from unmanaged code
3572 mono_marshal_get_managed_wrapper (MonoMethod
*method
, MonoObject
*this, MonoMarshalSpec
**mspecs
)
3574 MonoMethodSignature
*sig
, *csig
;
3575 MonoMethodBuilder
*mb
;
3576 MonoClass
*klass
= NULL
;
3579 int i
, pos
= 0, *tmp_locals
;
3580 static MonoMethodSignature
*alloc_sig
= NULL
;
3583 g_assert (method
!= NULL
);
3584 g_assert (!method
->signature
->pinvoke
);
3586 cache
= method
->klass
->image
->managed_wrapper_cache
;
3587 if (!this && (res
= mono_marshal_find_in_cache (cache
, method
)))
3590 /* Under MS, the allocation should be done using CoTaskMemAlloc */
3592 alloc_sig
= mono_metadata_signature_alloc (mono_defaults
.corlib
, 1);
3593 alloc_sig
->params
[0] = &mono_defaults
.int_class
->byval_arg
;
3594 alloc_sig
->ret
= &mono_defaults
.int_class
->byval_arg
;
3595 alloc_sig
->pinvoke
= 1;
3598 sig
= method
->signature
;
3600 mb
= mono_mb_new (method
->klass
, method
->name
, MONO_WRAPPER_NATIVE_TO_MANAGED
);
3602 /* allocate local 0 (pointer) src_ptr */
3603 mono_mb_add_local (mb
, &mono_defaults
.int_class
->byval_arg
);
3604 /* allocate local 1 (pointer) dst_ptr */
3605 mono_mb_add_local (mb
, &mono_defaults
.int_class
->byval_arg
);
3606 /* allocate local 2 (boolean) delete_old */
3607 mono_mb_add_local (mb
, &mono_defaults
.boolean_class
->byval_arg
);
3609 if (!MONO_TYPE_IS_VOID(sig
->ret
)) {
3610 /* allocate local 3 to store the return value */
3611 mono_mb_add_local (mb
, sig
->ret
);
3614 mono_mb_emit_icon (mb
, 0);
3615 mono_mb_emit_byte (mb
, CEE_STLOC_2
);
3617 /* we copy the signature, so that we can modify it */
3618 csig
= mono_metadata_signature_dup (sig
);
3622 #ifdef PLATFORM_WIN32
3624 * Under windows, delegates passed to native code must use the STDCALL
3625 * calling convention.
3627 csig
->call_convention
= MONO_CALL_STDCALL
;
3630 /* fixme: howto handle this ? */
3634 mono_mb_emit_byte (mb
, MONO_CUSTOM_PREFIX
);
3635 mono_mb_emit_byte (mb
, CEE_MONO_LDPTR
);
3636 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, this));
3641 g_assert_not_reached ();
3646 /* we first do all conversions */
3647 tmp_locals
= alloca (sizeof (int) * sig
->param_count
);
3648 for (i
= 0; i
< sig
->param_count
; i
++) {
3649 MonoType
*t
= sig
->params
[i
];
3650 MonoMarshalSpec
*spec
= mspecs
[i
+ 1];
3654 /* Ensure that we have marshalling info for this param */
3655 mono_marshal_load_type_info (mono_class_from_mono_type (t
));
3657 if (spec
&& spec
->native
== MONO_NATIVE_CUSTOM
) {
3660 MonoMethod
*marshal_native_to_managed
;
3661 MonoMethod
*get_instance
;
3663 mtype
= mono_reflection_type_from_name (spec
->data
.custom_data
.custom_name
, method
->klass
->image
);
3664 g_assert (mtype
!= NULL
);
3665 mklass
= mono_class_from_mono_type (mtype
);
3666 g_assert (mklass
!= NULL
);
3668 marshal_native_to_managed
= mono_class_get_method_from_name (mklass
, "MarshalNativeToManaged", 1);
3669 g_assert (marshal_native_to_managed
);
3670 get_instance
= mono_class_get_method_from_name (mklass
, "GetInstance", 1);
3671 g_assert (get_instance
);
3674 case MONO_TYPE_CLASS
:
3675 case MONO_TYPE_OBJECT
:
3676 case MONO_TYPE_STRING
:
3677 case MONO_TYPE_ARRAY
:
3678 case MONO_TYPE_SZARRAY
:
3682 tmp_locals
[i
] = mono_mb_add_local (mb
, &mono_defaults
.object_class
->byval_arg
);
3684 mono_mb_emit_ldstr (mb
, g_strdup (spec
->data
.custom_data
.cookie
));
3686 mono_mb_emit_byte (mb
, CEE_CALL
);
3687 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, get_instance
));
3689 mono_mb_emit_ldarg (mb
, i
);
3691 mono_mb_emit_byte (mb
, CEE_CALLVIRT
);
3692 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, marshal_native_to_managed
));
3694 mono_mb_emit_stloc (mb
, tmp_locals
[i
]);
3697 g_warning ("custom marshalling of type %x is currently not supported", t
->type
);
3698 g_assert_not_reached ();
3705 case MONO_TYPE_CLASS
: {
3706 klass
= t
->data
.klass
;
3708 tmp_locals
[i
] = mono_mb_add_local (mb
, &klass
->byval_arg
);
3710 if (klass
->delegate
) {
3711 g_assert (!t
->byref
);
3712 mono_mb_emit_byte (mb
, MONO_CUSTOM_PREFIX
);
3713 mono_mb_emit_byte (mb
, CEE_MONO_CLASSCONST
);
3714 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, klass
));
3715 mono_mb_emit_ldarg (mb
, i
);
3716 mono_mb_emit_icall (mb
, conv_to_icall (MONO_MARSHAL_CONV_FTN_DEL
));
3717 mono_mb_emit_stloc (mb
, tmp_locals
[i
]);
3721 /* The class can not have an automatic layout */
3722 if ((klass
->flags
& TYPE_ATTRIBUTE_LAYOUT_MASK
) == TYPE_ATTRIBUTE_AUTO_LAYOUT
)
3723 raise_auto_layout_exception (klass
);
3725 if (t
->attrs
& PARAM_ATTRIBUTE_OUT
) {
3726 mono_mb_emit_byte (mb
, CEE_LDNULL
);
3727 mono_mb_emit_stloc (mb
, tmp_locals
[i
]);
3732 mono_mb_emit_ldarg (mb
, i
);
3736 /* Check for NULL and raise an exception */
3737 mono_mb_emit_byte (mb
, CEE_BRTRUE
);
3739 mono_mb_emit_i4 (mb
, 0);
3741 mono_mb_emit_exception (mb
, "ArgumentNullException", NULL
);
3743 mono_mb_patch_addr (mb
, pos2
, mb
->pos
- (pos2
+ 4));
3744 mono_mb_emit_ldarg (mb
, i
);
3745 mono_mb_emit_byte (mb
, CEE_LDIND_I
);
3748 mono_mb_emit_byte (mb
, CEE_STLOC_0
);
3750 mono_mb_emit_byte (mb
, CEE_LDC_I4_0
);
3751 mono_mb_emit_stloc (mb
, tmp_locals
[i
]);
3753 mono_mb_emit_byte (mb
, CEE_LDLOC_0
);
3754 mono_mb_emit_byte (mb
, CEE_BRFALSE
);
3756 mono_mb_emit_i4 (mb
, 0);
3758 /* Create and set dst */
3759 mono_mb_emit_byte (mb
, MONO_CUSTOM_PREFIX
);
3760 mono_mb_emit_byte (mb
, CEE_MONO_NEWOBJ
);
3761 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, klass
));
3762 mono_mb_emit_stloc (mb
, tmp_locals
[i
]);
3763 mono_mb_emit_ldloc (mb
, tmp_locals
[i
]);
3764 mono_mb_emit_byte (mb
, MONO_CUSTOM_PREFIX
);
3765 mono_mb_emit_byte (mb
, CEE_MONO_OBJADDR
);
3766 mono_mb_emit_icon (mb
, sizeof (MonoObject
));
3767 mono_mb_emit_byte (mb
, CEE_ADD
);
3768 mono_mb_emit_byte (mb
, CEE_STLOC_1
);
3770 /* emit valuetype conversion code */
3771 emit_struct_conv (mb
, klass
, TRUE
);
3773 mono_mb_patch_addr (mb
, pos
, mb
->pos
- (pos
+ 4));
3776 case MONO_TYPE_VALUETYPE
:
3778 klass
= sig
->params
[i
]->data
.klass
;
3779 if (((klass
->flags
& TYPE_ATTRIBUTE_LAYOUT_MASK
) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT
) ||
3780 klass
->blittable
|| klass
->enumtype
)
3783 tmp_locals
[i
] = mono_mb_add_local (mb
, &klass
->byval_arg
);
3785 if (t
->attrs
& PARAM_ATTRIBUTE_OUT
)
3789 mono_mb_emit_ldarg (mb
, i
);
3791 mono_mb_emit_ldarg_addr (mb
, i
);
3792 mono_mb_emit_byte (mb
, CEE_STLOC_0
);
3795 mono_mb_emit_byte (mb
, CEE_LDLOC_0
);
3796 mono_mb_emit_byte (mb
, CEE_BRFALSE
);
3798 mono_mb_emit_i4 (mb
, 0);
3801 mono_mb_emit_ldloc_addr (mb
, tmp_locals
[i
]);
3802 mono_mb_emit_byte (mb
, CEE_STLOC_1
);
3804 /* emit valuetype conversion code */
3805 emit_struct_conv (mb
, klass
, TRUE
);
3808 mono_mb_patch_addr (mb
, pos
, mb
->pos
- (pos
+ 4));
3810 case MONO_TYPE_STRING
: {
3811 MonoMarshalNative encoding
= mono_marshal_get_string_encoding (NULL
, spec
);
3816 tmp_locals
[i
] = mono_mb_add_local (mb
, &mono_defaults
.object_class
->byval_arg
);
3817 csig
->params
[i
] = &mono_defaults
.int_class
->byval_arg
;
3819 mono_mb_emit_ldarg (mb
, i
);
3822 case MONO_NATIVE_LPWSTR
:
3823 mono_mb_emit_icall (mb
, conv_to_icall (MONO_MARSHAL_CONV_LPWSTR_STR
));
3825 case MONO_NATIVE_LPSTR
:
3826 mono_mb_emit_icall (mb
, conv_to_icall (MONO_MARSHAL_CONV_LPSTR_STR
));
3829 char *msg
= g_strdup_printf ("string marshalling conversion %d not implemented", encoding
);
3830 MonoException
*exc
= mono_get_exception_not_implemented (msg
);
3833 mono_raise_exception (exc
);
3837 mono_mb_emit_stloc (mb
, tmp_locals
[i
]);
3840 case MONO_TYPE_ARRAY
:
3841 case MONO_TYPE_SZARRAY
:
3845 klass
= mono_class_from_mono_type (t
);
3847 tmp_locals
[i
] = mono_mb_add_local (mb
, &mono_defaults
.object_class
->byval_arg
);
3848 csig
->params
[i
] = &mono_defaults
.int_class
->byval_arg
;
3850 g_warning ("array marshaling not implemented");
3851 g_assert_not_reached ();
3856 for (i
= 0; i
< sig
->param_count
; i
++) {
3857 MonoType
*t
= sig
->params
[i
];
3860 case MONO_TYPE_BOOLEAN
:
3874 mono_mb_emit_ldarg (mb
, i
);
3876 case MONO_TYPE_STRING
:
3878 mono_mb_emit_ldarg (mb
, i
);
3880 g_assert (tmp_locals
[i
]);
3881 mono_mb_emit_ldloc (mb
, tmp_locals
[i
]);
3884 case MONO_TYPE_CLASS
:
3886 mono_mb_emit_ldloc_addr (mb
, tmp_locals
[i
]);
3888 mono_mb_emit_ldloc (mb
, tmp_locals
[i
]);
3890 case MONO_TYPE_ARRAY
:
3891 case MONO_TYPE_SZARRAY
:
3892 case MONO_TYPE_OBJECT
:
3894 mono_mb_emit_ldloc (mb
, tmp_locals
[i
]);
3896 mono_mb_emit_ldarg (mb
, i
);
3898 case MONO_TYPE_VALUETYPE
:
3899 klass
= sig
->params
[i
]->data
.klass
;
3900 if (((klass
->flags
& TYPE_ATTRIBUTE_LAYOUT_MASK
) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT
) ||
3901 klass
->blittable
|| klass
->enumtype
) {
3902 mono_mb_emit_ldarg (mb
, i
);
3906 g_assert (tmp_locals
[i
]);
3908 mono_mb_emit_ldloc_addr (mb
, tmp_locals
[i
]);
3910 mono_mb_emit_ldloc (mb
, tmp_locals
[i
]);
3913 g_warning ("type 0x%02x unknown", t
->type
);
3914 g_assert_not_reached ();
3918 emit_thread_interrupt_checkpoint (mb
);
3919 mono_mb_emit_managed_call (mb
, method
, NULL
);
3921 /* Ensure that we have marshalling info for the return */
3922 mono_marshal_load_type_info (mono_class_from_mono_type (sig
->ret
));
3924 if (mspecs
[0] && mspecs
[0]->native
== MONO_NATIVE_CUSTOM
) {
3925 MonoMarshalSpec
*spec
= mspecs
[0];
3930 g_assert (!sig
->ret
->byref
);
3932 mtype
= mono_reflection_type_from_name (spec
->data
.custom_data
.custom_name
, method
->klass
->image
);
3934 mklass
= mono_class_from_mono_type (mtype
);
3937 loc1
= mono_mb_add_local (mb
, &mono_defaults
.object_class
->byval_arg
);
3939 switch (sig
->ret
->type
) {
3940 case MONO_TYPE_CLASS
:
3941 case MONO_TYPE_OBJECT
:
3942 case MONO_TYPE_STRING
:
3943 case MONO_TYPE_ARRAY
:
3944 case MONO_TYPE_SZARRAY
:
3945 mono_mb_emit_byte (mb
, CEE_STLOC_3
);
3947 mono_mb_emit_byte (mb
, CEE_LDLOC_3
);
3948 mono_mb_emit_stloc (mb
, loc1
);
3950 mono_mb_emit_ldstr (mb
, g_strdup (spec
->data
.custom_data
.cookie
));
3951 mono_mb_emit_byte (mb
, CEE_CALL
);
3952 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, mono_class_get_method_from_name (mklass
, "GetInstance", 1)));
3953 mono_mb_emit_byte (mb
, CEE_DUP
);
3955 mono_mb_emit_byte (mb
, CEE_LDLOC_3
);
3956 mono_mb_emit_byte (mb
, CEE_CALLVIRT
);
3957 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, mono_class_get_method_from_name (mklass
, "MarshalManagedToNative", 1)));
3958 mono_mb_emit_byte (mb
, CEE_STLOC_3
);
3960 mono_mb_emit_ldloc (mb
, loc1
);
3961 mono_mb_emit_byte (mb
, CEE_CALLVIRT
);
3962 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, mono_class_get_method_from_name (mklass
, "CleanUpManagedData", 1)));
3966 g_warning ("custom marshalling of type %x is currently not supported", sig
->ret
->type
);
3967 g_assert_not_reached ();
3972 if (!sig
->ret
->byref
) {
3973 switch (sig
->ret
->type
) {
3974 case MONO_TYPE_VOID
:
3976 case MONO_TYPE_BOOLEAN
:
3990 case MONO_TYPE_OBJECT
:
3991 mono_mb_emit_byte (mb
, CEE_STLOC_3
);
3993 case MONO_TYPE_STRING
:
3994 csig
->ret
= &mono_defaults
.int_class
->byval_arg
;
3996 mono_mb_emit_icall (mb
, conv_to_icall (MONO_MARSHAL_CONV_STR_LPSTR
));
3997 mono_mb_emit_byte (mb
, CEE_STLOC_3
);
3999 case MONO_TYPE_VALUETYPE
:
4000 klass
= sig
->ret
->data
.klass
;
4001 if (((klass
->flags
& TYPE_ATTRIBUTE_LAYOUT_MASK
) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT
) ||
4002 klass
->blittable
|| klass
->enumtype
) {
4003 mono_mb_emit_byte (mb
, CEE_STLOC_3
);
4007 /* load pointer to returned value type */
4008 mono_mb_emit_byte (mb
, MONO_CUSTOM_PREFIX
);
4009 mono_mb_emit_byte (mb
, CEE_MONO_VTADDR
);
4011 /* store the address of the source into local variable 0 */
4012 mono_mb_emit_byte (mb
, CEE_STLOC_0
);
4013 /* allocate space for the native struct and
4014 * store the address into dst_ptr */
4015 retobj_var
= mono_mb_add_local (mb
, &mono_defaults
.int_class
->byval_arg
);
4016 g_assert (retobj_var
);
4017 mono_mb_emit_icon (mb
, mono_class_native_size (klass
, NULL
));
4018 mono_mb_emit_byte (mb
, CEE_CONV_I
);
4019 mono_mb_emit_native_call (mb
, alloc_sig
, mono_marshal_alloc
);
4020 emit_thread_interrupt_checkpoint (mb
);
4021 mono_mb_emit_byte (mb
, CEE_STLOC_1
);
4022 mono_mb_emit_byte (mb
, CEE_LDLOC_1
);
4023 mono_mb_emit_stloc (mb
, retobj_var
);
4025 /* emit valuetype conversion code */
4026 emit_struct_conv (mb
, klass
, FALSE
);
4028 case MONO_TYPE_CLASS
: {
4031 klass
= sig
->ret
->data
.klass
;
4033 if (klass
->delegate
) {
4034 mono_mb_emit_icall (mb
, conv_to_icall (MONO_MARSHAL_CONV_DEL_FTN
));
4035 mono_mb_emit_byte (mb
, CEE_STLOC_3
);
4039 /* The class can not have an automatic layout */
4040 if ((klass
->flags
& TYPE_ATTRIBUTE_LAYOUT_MASK
) == TYPE_ATTRIBUTE_AUTO_LAYOUT
)
4041 raise_auto_layout_exception (klass
);
4043 mono_mb_emit_byte (mb
, CEE_STLOC_0
);
4044 /* Check for null */
4045 mono_mb_emit_byte (mb
, CEE_LDLOC_0
);
4046 pos
= mono_mb_emit_branch (mb
, CEE_BRTRUE
);
4047 mono_mb_emit_byte (mb
, CEE_LDNULL
);
4048 mono_mb_emit_byte (mb
, CEE_STLOC_3
);
4049 pos2
= mono_mb_emit_branch (mb
, CEE_BR
);
4051 mono_mb_patch_addr (mb
, pos
, mb
->pos
- (pos
+ 4));
4054 mono_mb_emit_byte (mb
, CEE_LDLOC_0
);
4055 mono_mb_emit_byte (mb
, MONO_CUSTOM_PREFIX
);
4056 mono_mb_emit_byte (mb
, CEE_MONO_OBJADDR
);
4057 mono_mb_emit_icon (mb
, sizeof (MonoObject
));
4058 mono_mb_emit_byte (mb
, CEE_ADD
);
4059 mono_mb_emit_byte (mb
, CEE_STLOC_0
);
4061 /* Allocate and set dest */
4062 mono_mb_emit_icon (mb
, mono_class_native_size (klass
, NULL
));
4063 mono_mb_emit_byte (mb
, CEE_CONV_I
);
4064 mono_mb_emit_native_call (mb
, alloc_sig
, mono_marshal_alloc
);
4065 emit_thread_interrupt_checkpoint (mb
);
4066 mono_mb_emit_byte (mb
, CEE_DUP
);
4067 mono_mb_emit_byte (mb
, CEE_STLOC_1
);
4068 mono_mb_emit_byte (mb
, CEE_STLOC_3
);
4070 emit_struct_conv (mb
, klass
, FALSE
);
4072 mono_mb_patch_addr (mb
, pos2
, mb
->pos
- (pos2
+ 4));
4076 g_warning ("return type 0x%02x unknown", sig
->ret
->type
);
4077 g_assert_not_reached ();
4080 mono_mb_emit_byte (mb
, CEE_STLOC_3
);
4083 /* Convert byref arguments back */
4084 for (i
= 0; i
< sig
->param_count
; i
++) {
4085 MonoType
*t
= sig
->params
[i
];
4086 MonoMarshalSpec
*spec
= mspecs
[i
+ 1];
4088 if (spec
&& spec
->native
== MONO_NATIVE_CUSTOM
) {
4091 MonoMethod
*cleanup_managed
;
4092 MonoMethod
*get_instance
;
4094 mtype
= mono_reflection_type_from_name (spec
->data
.custom_data
.custom_name
, method
->klass
->image
);
4095 g_assert (mtype
!= NULL
);
4096 mklass
= mono_class_from_mono_type (mtype
);
4097 g_assert (mklass
!= NULL
);
4099 get_instance
= mono_class_get_method_from_name (mklass
, "GetInstance", 1);
4100 g_assert (get_instance
);
4101 cleanup_managed
= mono_class_get_method_from_name (mklass
, "CleanUpManagedData", 1);
4102 g_assert (cleanup_managed
);
4105 case MONO_TYPE_CLASS
:
4106 case MONO_TYPE_OBJECT
:
4107 case MONO_TYPE_STRING
:
4108 case MONO_TYPE_ARRAY
:
4109 case MONO_TYPE_SZARRAY
:
4111 g_assert_not_reached ();
4113 /* Call CleanUpManagedData */
4115 mono_mb_emit_ldstr (mb
, g_strdup (spec
->data
.custom_data
.cookie
));
4117 mono_mb_emit_byte (mb
, CEE_CALL
);
4118 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, get_instance
));
4120 mono_mb_emit_ldloc (mb
, tmp_locals
[i
]);
4121 mono_mb_emit_byte (mb
, CEE_CALLVIRT
);
4122 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, cleanup_managed
));
4126 g_warning ("custom marshalling of type %x is currently not supported", t
->type
);
4127 g_assert_not_reached ();
4137 case MONO_TYPE_CLASS
: {
4140 klass
= t
->data
.klass
;
4142 /* Check for null */
4143 mono_mb_emit_ldloc (mb
, tmp_locals
[i
]);
4144 pos
= mono_mb_emit_branch (mb
, CEE_BRTRUE
);
4145 mono_mb_emit_ldarg (mb
, i
);
4146 mono_mb_emit_byte (mb
, CEE_LDC_I4_0
);
4147 mono_mb_emit_byte (mb
, CEE_STIND_I
);
4148 pos2
= mono_mb_emit_branch (mb
, CEE_BR
);
4150 mono_mb_patch_addr (mb
, pos
, mb
->pos
- (pos
+ 4));
4153 mono_mb_emit_ldloc (mb
, tmp_locals
[i
]);
4154 mono_mb_emit_byte (mb
, MONO_CUSTOM_PREFIX
);
4155 mono_mb_emit_byte (mb
, CEE_MONO_OBJADDR
);
4156 mono_mb_emit_icon (mb
, sizeof (MonoObject
));
4157 mono_mb_emit_byte (mb
, CEE_ADD
);
4158 mono_mb_emit_byte (mb
, CEE_STLOC_0
);
4160 /* Allocate and set dest */
4161 mono_mb_emit_icon (mb
, mono_class_native_size (klass
, NULL
));
4162 mono_mb_emit_byte (mb
, CEE_CONV_I
);
4163 mono_mb_emit_native_call (mb
, alloc_sig
, mono_marshal_alloc
);
4164 emit_thread_interrupt_checkpoint (mb
);
4165 mono_mb_emit_byte (mb
, CEE_STLOC_1
);
4167 /* Update argument pointer */
4168 mono_mb_emit_ldarg (mb
, i
);
4169 mono_mb_emit_byte (mb
, CEE_LDLOC_1
);
4170 mono_mb_emit_byte (mb
, CEE_STIND_I
);
4172 /* emit valuetype conversion code */
4173 emit_struct_conv (mb
, klass
, FALSE
);
4175 mono_mb_patch_addr (mb
, pos2
, mb
->pos
- (pos2
+ 4));
4178 case MONO_TYPE_VALUETYPE
: {
4181 klass
= t
->data
.klass
;
4183 if (((klass
->flags
& TYPE_ATTRIBUTE_LAYOUT_MASK
) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT
) ||
4184 klass
->blittable
|| klass
->enumtype
) {
4188 /* Check for null */
4189 mono_mb_emit_ldarg (mb
, i
);
4190 pos2
= mono_mb_emit_branch (mb
, CEE_BRFALSE
);
4193 mono_mb_emit_ldloc_addr (mb
, tmp_locals
[i
]);
4194 mono_mb_emit_byte (mb
, CEE_STLOC_0
);
4197 mono_mb_emit_ldarg (mb
, i
);
4198 mono_mb_emit_byte (mb
, CEE_STLOC_1
);
4200 /* emit valuetype conversion code */
4201 emit_struct_conv (mb
, klass
, FALSE
);
4203 mono_mb_patch_addr (mb
, pos2
, mb
->pos
- (pos2
+ 4));
4210 mono_mb_emit_ldloc (mb
, retobj_var
);
4211 mono_mb_emit_byte (mb
, MONO_CUSTOM_PREFIX
);
4212 mono_mb_emit_byte (mb
, CEE_MONO_RETOBJ
);
4213 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, klass
));
4216 if (!MONO_TYPE_IS_VOID(sig
->ret
))
4217 mono_mb_emit_byte (mb
, CEE_LDLOC_3
);
4218 mono_mb_emit_byte (mb
, CEE_RET
);
4222 res
= mono_mb_create_and_cache (cache
, method
,
4223 mb
, csig
, sig
->param_count
+ 16);
4225 res
= mono_mb_create_method (mb
, csig
, sig
->param_count
+ 16);
4230 /* printf ("CODE FOR %s: \n%s.\n", mono_method_full_name (res, TRUE), mono_disasm_code (0, res, ((MonoMethodNormal*)res)->header->code, ((MonoMethodNormal*)res)->header->code + ((MonoMethodNormal*)res)->header->code_size)); */
4236 * mono_marshal_get_ldfld_wrapper:
4237 * @type: the type of the field
4239 * This method generates a function which can be use to load a field with type
4240 * @type from an object. The generated function has the following signature:
4241 * <@type> ldfld_wrapper (MonoObject *this, MonoClass *class, MonoClassField *field, int offset)
4244 mono_marshal_get_ldfld_wrapper (MonoType
*type
)
4246 MonoMethodSignature
*sig
, *csig
;
4247 MonoMethodBuilder
*mb
;
4250 static GHashTable
*ldfld_hash
= NULL
;
4252 int t
, pos0
, pos1
= 0;
4257 if (type
->type
== MONO_TYPE_SZARRAY
) {
4258 klass
= mono_defaults
.array_class
;
4259 } else if (type
->type
== MONO_TYPE_VALUETYPE
) {
4260 klass
= type
->data
.klass
;
4261 if (klass
->enumtype
) {
4262 t
= klass
->enum_basetype
->type
;
4263 klass
= mono_class_from_mono_type (klass
->enum_basetype
);
4265 } else if (t
== MONO_TYPE_OBJECT
|| t
== MONO_TYPE_CLASS
|| t
== MONO_TYPE_STRING
||
4266 t
== MONO_TYPE_CLASS
) {
4267 klass
= mono_defaults
.object_class
;
4268 } else if (t
== MONO_TYPE_PTR
|| t
== MONO_TYPE_FNPTR
) {
4269 klass
= mono_defaults
.int_class
;
4271 klass
= mono_class_from_mono_type (type
);
4274 klass
= mono_defaults
.int_class
;
4277 EnterCriticalSection (&marshal_mutex
);
4279 ldfld_hash
= g_hash_table_new (NULL
, NULL
);
4280 res
= g_hash_table_lookup (ldfld_hash
, klass
);
4281 LeaveCriticalSection (&marshal_mutex
);
4285 name
= g_strdup_printf ("__ldfld_wrapper_%s.%s", klass
->name_space
, klass
->name
);
4286 mb
= mono_mb_new (mono_defaults
.object_class
, name
, MONO_WRAPPER_LDFLD
);
4289 mb
->method
->save_lmf
= 1;
4291 sig
= mono_metadata_signature_alloc (mono_defaults
.corlib
, 4);
4292 sig
->params
[0] = &mono_defaults
.object_class
->byval_arg
;
4293 sig
->params
[1] = &mono_defaults
.int_class
->byval_arg
;
4294 sig
->params
[2] = &mono_defaults
.int_class
->byval_arg
;
4295 sig
->params
[3] = &mono_defaults
.int_class
->byval_arg
;
4296 sig
->ret
= &klass
->byval_arg
;
4298 mono_mb_emit_ldarg (mb
, 0);
4299 pos0
= mono_mb_emit_proxy_check (mb
, CEE_BNE_UN
);
4301 mono_mb_emit_ldarg (mb
, 0);
4302 mono_mb_emit_ldarg (mb
, 1);
4303 mono_mb_emit_ldarg (mb
, 2);
4305 csig
= mono_metadata_signature_alloc (mono_defaults
.corlib
, 3);
4306 csig
->params
[0] = &mono_defaults
.object_class
->byval_arg
;
4307 csig
->params
[1] = &mono_defaults
.int_class
->byval_arg
;
4308 csig
->params
[2] = &mono_defaults
.int_class
->byval_arg
;
4309 csig
->ret
= &klass
->this_arg
;
4312 mono_mb_emit_native_call (mb
, csig
, mono_load_remote_field_new
);
4313 emit_thread_interrupt_checkpoint (mb
);
4315 if (klass
->valuetype
) {
4316 mono_mb_emit_byte (mb
, CEE_UNBOX
);
4317 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, klass
));
4318 mono_mb_emit_byte (mb
, CEE_BR
);
4320 mono_mb_emit_i4 (mb
, 0);
4322 mono_mb_emit_byte (mb
, CEE_RET
);
4326 mono_mb_patch_addr (mb
, pos0
, mb
->pos
- (pos0
+ 4));
4328 mono_mb_emit_ldarg (mb
, 0);
4329 mono_mb_emit_byte (mb
, MONO_CUSTOM_PREFIX
);
4330 mono_mb_emit_byte (mb
, CEE_MONO_OBJADDR
);
4331 mono_mb_emit_ldarg (mb
, 3);
4332 mono_mb_emit_byte (mb
, CEE_ADD
);
4334 if (klass
->valuetype
)
4335 mono_mb_patch_addr (mb
, pos1
, mb
->pos
- (pos1
+ 4));
4340 case MONO_TYPE_BOOLEAN
:
4341 mono_mb_emit_byte (mb
, CEE_LDIND_I1
);
4343 case MONO_TYPE_CHAR
:
4346 mono_mb_emit_byte (mb
, CEE_LDIND_I2
);
4350 mono_mb_emit_byte (mb
, CEE_LDIND_I4
);
4354 mono_mb_emit_byte (mb
, CEE_LDIND_I8
);
4357 mono_mb_emit_byte (mb
, CEE_LDIND_R4
);
4360 mono_mb_emit_byte (mb
, CEE_LDIND_R8
);
4362 case MONO_TYPE_ARRAY
:
4364 case MONO_TYPE_FNPTR
:
4365 case MONO_TYPE_SZARRAY
:
4366 case MONO_TYPE_OBJECT
:
4367 case MONO_TYPE_CLASS
:
4368 case MONO_TYPE_STRING
:
4371 mono_mb_emit_byte (mb
, CEE_LDIND_I
);
4373 case MONO_TYPE_VALUETYPE
:
4374 g_assert (!klass
->enumtype
);
4375 mono_mb_emit_byte (mb
, CEE_LDOBJ
);
4376 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, klass
));
4379 g_warning ("type %x not implemented", type
->type
);
4380 g_assert_not_reached ();
4383 mono_mb_emit_byte (mb
, CEE_RET
);
4385 res
= mono_mb_create_and_cache (ldfld_hash
, klass
,
4386 mb
, sig
, sig
->param_count
+ 16);
4393 * mono_marshal_get_stfld_wrapper:
4394 * @type: the type of the field
4396 * This method generates a function which can be use to store a field with type
4397 * @type. The generated function has the following signature:
4398 * void stfld_wrapper (MonoObject *this, MonoClass *class, MonoClassField *field, int offset, <@type> val)
4401 mono_marshal_get_stfld_wrapper (MonoType
*type
)
4403 MonoMethodSignature
*sig
, *csig
;
4404 MonoMethodBuilder
*mb
;
4407 static GHashTable
*stfld_hash
= NULL
;
4414 if (type
->type
== MONO_TYPE_SZARRAY
) {
4415 klass
= mono_defaults
.array_class
;
4416 } else if (type
->type
== MONO_TYPE_VALUETYPE
) {
4417 klass
= type
->data
.klass
;
4418 if (klass
->enumtype
) {
4419 t
= klass
->enum_basetype
->type
;
4420 klass
= mono_class_from_mono_type (klass
->enum_basetype
);
4422 } else if (t
== MONO_TYPE_OBJECT
|| t
== MONO_TYPE_CLASS
|| t
== MONO_TYPE_STRING
||
4423 t
== MONO_TYPE_CLASS
) {
4424 klass
= mono_defaults
.object_class
;
4425 } else if (t
== MONO_TYPE_PTR
|| t
== MONO_TYPE_FNPTR
) {
4426 klass
= mono_defaults
.int_class
;
4428 klass
= mono_class_from_mono_type (type
);
4431 klass
= mono_defaults
.int_class
;
4434 EnterCriticalSection (&marshal_mutex
);
4436 stfld_hash
= g_hash_table_new (NULL
, NULL
);
4437 res
= g_hash_table_lookup (stfld_hash
, klass
);
4438 LeaveCriticalSection (&marshal_mutex
);
4442 name
= g_strdup_printf ("__stfld_wrapper_%s.%s", klass
->name_space
, klass
->name
);
4443 mb
= mono_mb_new (mono_defaults
.object_class
, name
, MONO_WRAPPER_STFLD
);
4446 mb
->method
->save_lmf
= 1;
4448 sig
= mono_metadata_signature_alloc (mono_defaults
.corlib
, 5);
4449 sig
->params
[0] = &mono_defaults
.object_class
->byval_arg
;
4450 sig
->params
[1] = &mono_defaults
.int_class
->byval_arg
;
4451 sig
->params
[2] = &mono_defaults
.int_class
->byval_arg
;
4452 sig
->params
[3] = &mono_defaults
.int_class
->byval_arg
;
4453 sig
->params
[4] = &klass
->byval_arg
;
4454 sig
->ret
= &mono_defaults
.void_class
->byval_arg
;
4456 mono_mb_emit_ldarg (mb
, 0);
4457 pos
= mono_mb_emit_proxy_check (mb
, CEE_BNE_UN
);
4459 mono_mb_emit_ldarg (mb
, 0);
4460 mono_mb_emit_ldarg (mb
, 1);
4461 mono_mb_emit_ldarg (mb
, 2);
4462 mono_mb_emit_ldarg (mb
, 4);
4464 if (klass
->valuetype
) {
4465 mono_mb_emit_byte (mb
, CEE_BOX
);
4466 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, klass
));
4469 csig
= mono_metadata_signature_alloc (mono_defaults
.corlib
, 4);
4470 csig
->params
[0] = &mono_defaults
.object_class
->byval_arg
;
4471 csig
->params
[1] = &mono_defaults
.int_class
->byval_arg
;
4472 csig
->params
[2] = &mono_defaults
.int_class
->byval_arg
;
4473 csig
->params
[3] = &klass
->this_arg
;
4474 csig
->ret
= &mono_defaults
.void_class
->byval_arg
;
4477 mono_mb_emit_native_call (mb
, csig
, mono_store_remote_field_new
);
4478 emit_thread_interrupt_checkpoint (mb
);
4480 mono_mb_emit_byte (mb
, CEE_RET
);
4482 mono_mb_patch_addr (mb
, pos
, mb
->pos
- (pos
+ 4));
4484 mono_mb_emit_ldarg (mb
, 0);
4485 mono_mb_emit_byte (mb
, MONO_CUSTOM_PREFIX
);
4486 mono_mb_emit_byte (mb
, CEE_MONO_OBJADDR
);
4487 mono_mb_emit_ldarg (mb
, 3);
4488 mono_mb_emit_byte (mb
, CEE_ADD
);
4489 mono_mb_emit_ldarg (mb
, 4);
4494 case MONO_TYPE_BOOLEAN
:
4495 mono_mb_emit_byte (mb
, CEE_STIND_I1
);
4497 case MONO_TYPE_CHAR
:
4500 mono_mb_emit_byte (mb
, CEE_STIND_I2
);
4504 mono_mb_emit_byte (mb
, CEE_STIND_I4
);
4508 mono_mb_emit_byte (mb
, CEE_STIND_I8
);
4511 mono_mb_emit_byte (mb
, CEE_STIND_R4
);
4514 mono_mb_emit_byte (mb
, CEE_STIND_R8
);
4516 case MONO_TYPE_ARRAY
:
4518 case MONO_TYPE_FNPTR
:
4519 case MONO_TYPE_SZARRAY
:
4520 case MONO_TYPE_OBJECT
:
4521 case MONO_TYPE_CLASS
:
4522 case MONO_TYPE_STRING
:
4525 mono_mb_emit_byte (mb
, CEE_STIND_I
);
4527 case MONO_TYPE_VALUETYPE
:
4528 g_assert (!klass
->enumtype
);
4529 mono_mb_emit_byte (mb
, CEE_STOBJ
);
4530 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, klass
));
4533 g_warning ("type %x not implemented", type
->type
);
4534 g_assert_not_reached ();
4537 mono_mb_emit_byte (mb
, CEE_RET
);
4539 res
= mono_mb_create_and_cache (stfld_hash
, klass
,
4540 mb
, sig
, sig
->param_count
+ 16);
4547 * generates IL code for the icall wrapper (the generated method
4548 * calls the unmanaged code in func)
4551 mono_marshal_get_icall_wrapper (MonoMethodSignature
*sig
, const char *name
, gconstpointer func
)
4553 MonoMethodSignature
*csig
;
4554 MonoMethodBuilder
*mb
;
4558 g_assert (sig
->pinvoke
);
4560 mb
= mono_mb_new (mono_defaults
.object_class
, name
, MONO_WRAPPER_MANAGED_TO_NATIVE
);
4562 mb
->method
->save_lmf
= 1;
4564 /* we copy the signature, so that we can modify it */
4567 mono_mb_emit_byte (mb
, CEE_LDARG_0
);
4569 for (i
= 0; i
< sig
->param_count
; i
++)
4570 mono_mb_emit_ldarg (mb
, i
+ sig
->hasthis
);
4572 mono_mb_emit_native_call (mb
, sig
, (gpointer
) func
);
4573 emit_thread_interrupt_checkpoint (mb
);
4574 mono_mb_emit_byte (mb
, CEE_RET
);
4576 csig
= mono_metadata_signature_dup (sig
);
4578 if (csig
->call_convention
== MONO_CALL_VARARG
)
4579 csig
->call_convention
= 0;
4581 res
= mono_mb_create_method (mb
, csig
, csig
->param_count
+ 16);
4588 MonoMethodBuilder
*mb
;
4589 MonoMethodPInvoke
*piinfo
;
4590 int *orig_conv_args
; /* Locals containing the original values of byref args */
4591 } EmitMarshalContext
;
4594 MARSHAL_ACTION_CONV_IN
,
4595 MARSHAL_ACTION_PUSH
,
4596 MARSHAL_ACTION_CONV_OUT
,
4597 MARSHAL_ACTION_CONV_RESULT
4601 emit_marshal_custom (EmitMarshalContext
*m
, int argnum
, MonoType
*t
,
4602 MonoMarshalSpec
*spec
,
4603 int conv_arg
, MonoType
**conv_arg_type
,
4604 MarshalAction action
)
4608 MonoMethod
*get_instance
, *cleanup_native
;
4609 MonoMethod
*marshal_managed_to_native
, *marshal_native_to_managed
;
4610 MonoMethodBuilder
*mb
= m
->mb
;
4613 mtype
= mono_reflection_type_from_name (spec
->data
.custom_data
.custom_name
, mb
->method
->klass
->image
);
4614 g_assert (mtype
!= NULL
);
4615 mklass
= mono_class_from_mono_type (mtype
);
4616 g_assert (mklass
!= NULL
);
4618 get_instance
= mono_class_get_method_from_name (mklass
, "GetInstance", 1);
4619 g_assert (get_instance
);
4620 cleanup_native
= mono_class_get_method_from_name (mklass
, "CleanUpNativeData", 1);
4621 g_assert (cleanup_native
);
4622 marshal_managed_to_native
= mono_class_get_method_from_name (mklass
, "MarshalManagedToNative", 1);
4623 g_assert (marshal_managed_to_native
);
4624 marshal_native_to_managed
= mono_class_get_method_from_name (mklass
, "MarshalNativeToManaged", 1);
4625 g_assert (marshal_native_to_managed
);
4628 case MARSHAL_ACTION_CONV_IN
:
4630 case MONO_TYPE_CLASS
:
4631 case MONO_TYPE_OBJECT
:
4632 case MONO_TYPE_STRING
:
4633 case MONO_TYPE_ARRAY
:
4634 case MONO_TYPE_SZARRAY
:
4635 case MONO_TYPE_VALUETYPE
:
4639 conv_arg
= mono_mb_add_local (mb
, &mono_defaults
.int_class
->byval_arg
);
4641 mono_mb_emit_ldstr (mb
, g_strdup (spec
->data
.custom_data
.cookie
));
4643 mono_mb_emit_byte (mb
, CEE_CALL
);
4644 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, get_instance
));
4646 mono_mb_emit_ldarg (mb
, argnum
);
4648 if (t
->type
== MONO_TYPE_VALUETYPE
) {
4650 * Since we can't determine the type of the argument, we
4651 * will assume the unmanaged function takes a pointer.
4653 *conv_arg_type
= &mono_defaults
.int_class
->byval_arg
;
4655 mono_mb_emit_byte (mb
, CEE_BOX
);
4656 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, mono_class_from_mono_type (t
)));
4659 mono_mb_emit_byte (mb
, CEE_CALLVIRT
);
4660 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, marshal_managed_to_native
));
4661 mono_mb_emit_stloc (mb
, conv_arg
);
4665 g_warning ("custom marshalling of type %x is currently not supported", t
->type
);
4666 g_assert_not_reached ();
4672 case MARSHAL_ACTION_CONV_OUT
:
4674 case MONO_TYPE_CLASS
:
4675 case MONO_TYPE_OBJECT
:
4676 case MONO_TYPE_STRING
:
4677 case MONO_TYPE_ARRAY
:
4678 case MONO_TYPE_SZARRAY
:
4679 case MONO_TYPE_VALUETYPE
:
4680 mono_mb_emit_ldstr (mb
, g_strdup (spec
->data
.custom_data
.cookie
));
4682 mono_mb_emit_byte (mb
, CEE_CALL
);
4683 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, get_instance
));
4685 mono_mb_emit_ldloc (mb
, conv_arg
);
4687 mono_mb_emit_byte (mb
, CEE_CALLVIRT
);
4688 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, cleanup_native
));
4693 g_warning ("custom marshalling of type %x is currently not supported", t
->type
);
4694 g_assert_not_reached ();
4699 case MARSHAL_ACTION_PUSH
:
4700 mono_mb_emit_ldloc (mb
, conv_arg
);
4703 case MARSHAL_ACTION_CONV_RESULT
:
4704 loc1
= mono_mb_add_local (mb
, &mono_defaults
.int_class
->byval_arg
);
4707 case MONO_TYPE_CLASS
:
4708 case MONO_TYPE_OBJECT
:
4709 case MONO_TYPE_STRING
:
4710 case MONO_TYPE_ARRAY
:
4711 case MONO_TYPE_SZARRAY
:
4712 mono_mb_emit_byte (mb
, CEE_STLOC_3
);
4714 mono_mb_emit_byte (mb
, CEE_LDLOC_3
);
4715 mono_mb_emit_stloc (mb
, loc1
);
4717 mono_mb_emit_ldstr (mb
, g_strdup (spec
->data
.custom_data
.cookie
));
4719 mono_mb_emit_byte (mb
, CEE_CALL
);
4720 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, get_instance
));
4721 mono_mb_emit_byte (mb
, CEE_DUP
);
4723 mono_mb_emit_byte (mb
, CEE_LDLOC_3
);
4724 mono_mb_emit_byte (mb
, CEE_CALLVIRT
);
4725 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, marshal_native_to_managed
));
4726 mono_mb_emit_byte (mb
, CEE_STLOC_3
);
4728 mono_mb_emit_ldloc (mb
, loc1
);
4729 mono_mb_emit_byte (mb
, CEE_CALLVIRT
);
4730 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, cleanup_native
));
4734 g_assert_not_reached ();
4740 g_assert_not_reached ();
4747 emit_marshal_asany (EmitMarshalContext
*m
, int argnum
, MonoType
*t
,
4748 MonoMarshalSpec
*spec
,
4749 int conv_arg
, MonoType
**conv_arg_type
,
4750 MarshalAction action
)
4752 MonoMethodBuilder
*mb
= m
->mb
;
4755 case MARSHAL_ACTION_CONV_IN
: {
4756 MonoMarshalNative encoding
= mono_marshal_get_string_encoding (m
->piinfo
, NULL
);
4758 g_assert (t
->type
== MONO_TYPE_OBJECT
);
4759 g_assert (!t
->byref
);
4761 conv_arg
= mono_mb_add_local (mb
, &mono_defaults
.int_class
->byval_arg
);
4762 mono_mb_emit_ldarg (mb
, argnum
);
4763 mono_mb_emit_icon (mb
, encoding
);
4764 mono_mb_emit_icall (mb
, mono_marshal_asany
);
4765 mono_mb_emit_stloc (mb
, conv_arg
);
4769 case MARSHAL_ACTION_PUSH
:
4770 mono_mb_emit_ldloc (mb
, conv_arg
);
4773 case MARSHAL_ACTION_CONV_OUT
: {
4774 MonoMarshalNative encoding
= mono_marshal_get_string_encoding (m
->piinfo
, NULL
);
4776 mono_mb_emit_ldarg (mb
, argnum
);
4777 mono_mb_emit_ldloc (mb
, conv_arg
);
4778 mono_mb_emit_icon (mb
, encoding
);
4779 mono_mb_emit_icall (mb
, mono_marshal_free_asany
);
4784 g_assert_not_reached ();
4791 emit_marshal_vtype (EmitMarshalContext
*m
, int argnum
, MonoType
*t
,
4792 MonoMarshalSpec
*spec
,
4793 int conv_arg
, MonoType
**conv_arg_type
,
4794 MarshalAction action
)
4796 MonoMethodBuilder
*mb
= m
->mb
;
4800 klass
= t
->data
.klass
;
4803 case MARSHAL_ACTION_CONV_IN
:
4804 if (((klass
->flags
& TYPE_ATTRIBUTE_LAYOUT_MASK
) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT
) ||
4805 klass
->blittable
|| klass
->enumtype
)
4808 conv_arg
= mono_mb_add_local (mb
, &mono_defaults
.int_class
->byval_arg
);
4810 /* store the address of the source into local variable 0 */
4812 mono_mb_emit_ldarg (mb
, argnum
);
4814 mono_mb_emit_ldarg_addr (mb
, argnum
);
4816 mono_mb_emit_byte (mb
, CEE_STLOC_0
);
4818 /* allocate space for the native struct and
4819 * store the address into local variable 1 (dest) */
4820 mono_mb_emit_icon (mb
, mono_class_native_size (klass
, NULL
));
4821 mono_mb_emit_byte (mb
, CEE_PREFIX1
);
4822 mono_mb_emit_byte (mb
, CEE_LOCALLOC
);
4823 mono_mb_emit_stloc (mb
, conv_arg
);
4826 mono_mb_emit_byte (mb
, CEE_LDLOC_0
);
4827 mono_mb_emit_byte (mb
, CEE_BRFALSE
);
4829 mono_mb_emit_i4 (mb
, 0);
4833 mono_mb_emit_ldloc (mb
, conv_arg
);
4834 mono_mb_emit_byte (mb
, CEE_STLOC_1
);
4836 /* emit valuetype conversion code */
4837 emit_struct_conv (mb
, klass
, FALSE
);
4840 mono_mb_patch_addr (mb
, pos
, mb
->pos
- (pos
+ 4));
4843 case MARSHAL_ACTION_PUSH
:
4844 if (((klass
->flags
& TYPE_ATTRIBUTE_LAYOUT_MASK
) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT
) ||
4845 klass
->blittable
|| klass
->enumtype
) {
4846 mono_mb_emit_ldarg (mb
, argnum
);
4849 mono_mb_emit_ldloc (mb
, conv_arg
);
4851 mono_mb_emit_byte (mb
, MONO_CUSTOM_PREFIX
);
4852 mono_mb_emit_byte (mb
, CEE_MONO_LDNATIVEOBJ
);
4853 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, klass
));
4857 case MARSHAL_ACTION_CONV_OUT
:
4858 if (((klass
->flags
& TYPE_ATTRIBUTE_LAYOUT_MASK
) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT
) ||
4859 klass
->blittable
|| klass
->enumtype
)
4863 /* dst = argument */
4864 mono_mb_emit_ldarg (mb
, argnum
);
4865 mono_mb_emit_byte (mb
, CEE_STLOC_1
);
4867 mono_mb_emit_byte (mb
, CEE_LDLOC_1
);
4868 mono_mb_emit_byte (mb
, CEE_BRFALSE
);
4870 mono_mb_emit_i4 (mb
, 0);
4872 /* src = tmp_locals [i] */
4873 mono_mb_emit_ldloc (mb
, conv_arg
);
4874 mono_mb_emit_byte (mb
, CEE_STLOC_0
);
4876 /* emit valuetype conversion code */
4877 emit_struct_conv (mb
, klass
, TRUE
);
4880 emit_struct_free (mb
, klass
, conv_arg
);
4883 mono_mb_patch_addr (mb
, pos
, mb
->pos
- (pos
+ 4));
4886 case MARSHAL_ACTION_CONV_RESULT
:
4887 if (((klass
->flags
& TYPE_ATTRIBUTE_LAYOUT_MASK
) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT
) ||
4889 mono_mb_emit_byte (mb
, CEE_STLOC_3
);
4892 /* load pointer to returned value type */
4893 mono_mb_emit_byte (mb
, MONO_CUSTOM_PREFIX
);
4894 mono_mb_emit_byte (mb
, CEE_MONO_VTADDR
);
4895 /* store the address of the source into local variable 0 */
4896 mono_mb_emit_byte (mb
, CEE_STLOC_0
);
4898 mono_mb_emit_ldloc_addr (mb
, 3);
4899 mono_mb_emit_byte (mb
, CEE_STLOC_1
);
4901 /* emit valuetype conversion code */
4902 emit_struct_conv (mb
, klass
, TRUE
);
4906 g_assert_not_reached ();
4913 emit_marshal_string (EmitMarshalContext
*m
, int argnum
, MonoType
*t
,
4914 MonoMarshalSpec
*spec
,
4915 int conv_arg
, MonoType
**conv_arg_type
,
4916 MarshalAction action
)
4918 MonoMethodBuilder
*mb
= m
->mb
;
4919 MonoMarshalNative encoding
= mono_marshal_get_string_encoding (m
->piinfo
, spec
);
4920 MonoMarshalConv conv
= mono_marshal_get_string_to_ptr_conv (m
->piinfo
, spec
);
4923 case MARSHAL_ACTION_CONV_IN
:
4924 *conv_arg_type
= &mono_defaults
.int_class
->byval_arg
;
4925 conv_arg
= mono_mb_add_local (mb
, &mono_defaults
.int_class
->byval_arg
);
4928 if (t
->attrs
& PARAM_ATTRIBUTE_OUT
)
4931 mono_mb_emit_ldarg (mb
, argnum
);
4932 mono_mb_emit_byte (mb
, CEE_LDIND_I
);
4934 mono_mb_emit_ldarg (mb
, argnum
);
4938 char *msg
= g_strdup_printf ("string marshalling conversion %d not implemented", encoding
);
4939 MonoException
*exc
= mono_get_exception_not_implemented (msg
);
4942 mono_raise_exception (exc
);
4945 mono_mb_emit_icall (mb
, conv_to_icall (conv
));
4947 mono_mb_emit_stloc (mb
, conv_arg
);
4950 case MARSHAL_ACTION_CONV_OUT
:
4951 if (t
->byref
&& (t
->attrs
& PARAM_ATTRIBUTE_OUT
)) {
4952 mono_mb_emit_ldarg (mb
, argnum
);
4953 mono_mb_emit_ldloc (mb
, conv_arg
);
4954 mono_mb_emit_icall (mb
, conv_to_icall (MONO_MARSHAL_CONV_LPSTR_STR
));
4955 mono_mb_emit_byte (mb
, CEE_STIND_I
);
4957 if (mono_marshal_need_free (t
, m
->piinfo
, spec
)) {
4958 mono_mb_emit_ldloc (mb
, conv_arg
);
4959 mono_mb_emit_icall (mb
, mono_marshal_free
);
4964 case MARSHAL_ACTION_CONV_RESULT
:
4965 mono_mb_emit_byte (mb
, CEE_STLOC_0
);
4966 mono_mb_emit_byte (mb
, CEE_LDLOC_0
);
4969 switch (spec
->native
) {
4970 case MONO_NATIVE_LPWSTR
:
4971 mono_mb_emit_icall (mb
, conv_to_icall (MONO_MARSHAL_CONV_LPWSTR_STR
));
4974 g_warning ("marshalling conversion not implemented");
4975 g_assert_not_reached ();
4978 mono_mb_emit_icall (mb
, conv_to_icall (MONO_MARSHAL_CONV_LPSTR_STR
));
4980 mono_mb_emit_byte (mb
, CEE_STLOC_3
);
4982 /* free the string */
4983 mono_mb_emit_byte (mb
, CEE_LDLOC_0
);
4984 mono_mb_emit_icall (mb
, g_free
);
4988 g_assert_not_reached ();
4995 emit_marshal_object (EmitMarshalContext
*m
, int argnum
, MonoType
*t
,
4996 MonoMarshalSpec
*spec
,
4997 int conv_arg
, MonoType
**conv_arg_type
,
4998 MarshalAction action
)
5000 MonoMethodBuilder
*mb
= m
->mb
;
5001 MonoClass
*klass
= t
->data
.klass
;
5005 case MARSHAL_ACTION_CONV_IN
:
5006 *conv_arg_type
= &mono_defaults
.int_class
->byval_arg
;
5007 conv_arg
= mono_mb_add_local (mb
, &mono_defaults
.int_class
->byval_arg
);
5009 m
->orig_conv_args
[argnum
] = 0;
5011 if (klass
->delegate
) {
5012 g_assert (!t
->byref
);
5013 mono_mb_emit_ldarg (mb
, argnum
);
5014 mono_mb_emit_icall (mb
, conv_to_icall (MONO_MARSHAL_CONV_DEL_FTN
));
5015 mono_mb_emit_stloc (mb
, conv_arg
);
5016 } else if (klass
== mono_defaults
.stringbuilder_class
) {
5017 MonoMarshalNative encoding
= mono_marshal_get_string_encoding (m
->piinfo
, spec
);
5018 MonoMarshalConv conv
= mono_marshal_get_stringbuilder_to_ptr_conv (m
->piinfo
, spec
);
5020 g_assert (!t
->byref
);
5021 mono_mb_emit_ldarg (mb
, argnum
);
5024 mono_mb_emit_icall (mb
, conv_to_icall (conv
));
5026 char *msg
= g_strdup_printf ("stringbuilder marshalling conversion %d not implemented", encoding
);
5027 MonoException
*exc
= mono_get_exception_not_implemented (msg
);
5030 mono_raise_exception (exc
);
5033 mono_mb_emit_stloc (mb
, conv_arg
);
5034 } else if (klass
->blittable
) {
5035 mono_mb_emit_ldarg (mb
, argnum
);
5036 mono_mb_emit_byte (mb
, MONO_CUSTOM_PREFIX
);
5037 mono_mb_emit_byte (mb
, CEE_MONO_OBJADDR
);
5038 mono_mb_emit_icon (mb
, sizeof (MonoObject
));
5039 mono_mb_emit_byte (mb
, CEE_ADD
);
5040 mono_mb_emit_stloc (mb
, conv_arg
);
5043 mono_mb_emit_byte (mb
, CEE_LDNULL
);
5044 mono_mb_emit_stloc (mb
, conv_arg
);
5047 /* we dont need any conversions for out parameters */
5048 if (t
->attrs
& PARAM_ATTRIBUTE_OUT
)
5051 mono_mb_emit_ldarg (mb
, argnum
);
5052 mono_mb_emit_byte (mb
, CEE_LDIND_I
);
5055 mono_mb_emit_ldarg (mb
, argnum
);
5056 mono_mb_emit_byte (mb
, MONO_CUSTOM_PREFIX
);
5057 mono_mb_emit_byte (mb
, CEE_MONO_OBJADDR
);
5060 /* store the address of the source into local variable 0 */
5061 mono_mb_emit_byte (mb
, CEE_STLOC_0
);
5062 mono_mb_emit_byte (mb
, CEE_LDLOC_0
);
5063 mono_mb_emit_byte (mb
, CEE_BRFALSE
);
5065 mono_mb_emit_i4 (mb
, 0);
5067 /* allocate space for the native struct and store the address */
5068 mono_mb_emit_icon (mb
, mono_class_native_size (klass
, NULL
));
5069 mono_mb_emit_byte (mb
, CEE_PREFIX1
);
5070 mono_mb_emit_byte (mb
, CEE_LOCALLOC
);
5071 mono_mb_emit_stloc (mb
, conv_arg
);
5074 /* Need to store the original buffer so we can free it later */
5075 m
->orig_conv_args
[argnum
] = mono_mb_add_local (mb
, &mono_defaults
.int_class
->byval_arg
);
5076 mono_mb_emit_ldloc (mb
, conv_arg
);
5077 mono_mb_emit_stloc (mb
, m
->orig_conv_args
[argnum
]);
5080 /* set the src_ptr */
5081 mono_mb_emit_byte (mb
, CEE_LDLOC_0
);
5082 mono_mb_emit_byte (mb
, MONO_CUSTOM_PREFIX
);
5083 mono_mb_emit_byte (mb
, CEE_MONO_OBJADDR
);
5084 mono_mb_emit_icon (mb
, sizeof (MonoObject
));
5085 mono_mb_emit_byte (mb
, CEE_ADD
);
5086 mono_mb_emit_byte (mb
, CEE_STLOC_0
);
5089 mono_mb_emit_ldloc (mb
, conv_arg
);
5090 mono_mb_emit_byte (mb
, CEE_STLOC_1
);
5092 /* emit valuetype conversion code */
5093 emit_struct_conv (mb
, klass
, FALSE
);
5095 mono_mb_patch_addr (mb
, pos
, mb
->pos
- (pos
+ 4));
5099 case MARSHAL_ACTION_CONV_OUT
:
5100 if (klass
== mono_defaults
.stringbuilder_class
) {
5102 MonoMarshalNative encoding
;
5103 MonoMarshalConv conv
;
5105 encoding
= mono_marshal_get_string_encoding (m
->piinfo
, spec
);
5106 conv
= mono_marshal_get_ptr_to_stringbuilder_conv (m
->piinfo
, spec
, &need_free
);
5108 g_assert (!t
->byref
);
5109 g_assert (encoding
!= -1);
5111 mono_mb_emit_ldarg (mb
, argnum
);
5112 mono_mb_emit_ldloc (mb
, conv_arg
);
5114 mono_mb_emit_icall (mb
, conv_to_icall (conv
));
5117 mono_mb_emit_ldloc (mb
, conv_arg
);
5118 mono_mb_emit_icall (mb
, mono_marshal_free
);
5123 if (klass
->delegate
)
5126 if (t
->byref
&& (t
->attrs
& PARAM_ATTRIBUTE_OUT
)) {
5127 /* allocate a new object */
5128 mono_mb_emit_ldarg (mb
, argnum
);
5129 mono_mb_emit_byte (mb
, MONO_CUSTOM_PREFIX
);
5130 mono_mb_emit_byte (mb
, CEE_MONO_NEWOBJ
);
5131 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, t
->data
.klass
));
5132 mono_mb_emit_byte (mb
, CEE_STIND_I
);
5135 /* dst = *argument */
5136 mono_mb_emit_ldarg (mb
, argnum
);
5139 mono_mb_emit_byte (mb
, CEE_LDIND_I
);
5141 mono_mb_emit_byte (mb
, CEE_STLOC_1
);
5143 mono_mb_emit_byte (mb
, CEE_LDLOC_1
);
5144 mono_mb_emit_byte (mb
, CEE_BRFALSE
);
5146 mono_mb_emit_i4 (mb
, 0);
5148 if (t
->byref
|| (t
->attrs
& PARAM_ATTRIBUTE_OUT
)) {
5149 mono_mb_emit_byte (mb
, CEE_LDLOC_1
);
5150 mono_mb_emit_icon (mb
, sizeof (MonoObject
));
5151 mono_mb_emit_byte (mb
, CEE_ADD
);
5152 mono_mb_emit_byte (mb
, CEE_STLOC_1
);
5154 /* src = tmp_locals [i] */
5155 mono_mb_emit_ldloc (mb
, conv_arg
);
5156 mono_mb_emit_byte (mb
, CEE_STLOC_0
);
5158 /* emit valuetype conversion code */
5159 emit_struct_conv (mb
, t
->data
.klass
, TRUE
);
5161 /* Free the structure returned by the native code */
5162 emit_struct_free (mb
, klass
, conv_arg
);
5164 if (m
->orig_conv_args
[argnum
]) {
5166 * If the native function changed the pointer, then free
5167 * the original structure plus the new pointer.
5169 mono_mb_emit_ldloc (mb
, m
->orig_conv_args
[argnum
]);
5170 mono_mb_emit_ldloc (mb
, conv_arg
);
5171 mono_mb_emit_byte (mb
, CEE_BEQ
);
5173 mono_mb_emit_i4 (mb
, 0);
5175 if (!(t
->attrs
& PARAM_ATTRIBUTE_OUT
)) {
5176 g_assert (m
->orig_conv_args
[argnum
]);
5178 emit_struct_free (mb
, klass
, m
->orig_conv_args
[argnum
]);
5181 mono_mb_emit_ldloc (mb
, conv_arg
);
5182 mono_mb_emit_icall (mb
, g_free
);
5184 mono_mb_patch_addr (mb
, pos2
, mb
->pos
- (pos2
+ 4));
5188 /* Free the original structure passed to native code */
5189 emit_struct_free (mb
, klass
, conv_arg
);
5191 mono_mb_patch_addr (mb
, pos
, mb
->pos
- (pos
+ 4));
5194 case MARSHAL_ACTION_CONV_RESULT
:
5195 if (klass
->delegate
) {
5196 g_assert (!t
->byref
);
5197 mono_mb_emit_byte (mb
, CEE_STLOC_0
);
5198 mono_mb_emit_byte (mb
, MONO_CUSTOM_PREFIX
);
5199 mono_mb_emit_byte (mb
, CEE_MONO_CLASSCONST
);
5200 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, klass
));
5201 mono_mb_emit_byte (mb
, CEE_LDLOC_0
);
5202 mono_mb_emit_icall (mb
, conv_to_icall (MONO_MARSHAL_CONV_FTN_DEL
));
5203 mono_mb_emit_byte (mb
, CEE_STLOC_3
);
5206 mono_mb_emit_byte (mb
, CEE_STLOC_0
);
5208 /* Make a copy since emit_conv modifies local 0 */
5209 loc
= mono_mb_add_local (mb
, &mono_defaults
.int_class
->byval_arg
);
5210 mono_mb_emit_byte (mb
, CEE_LDLOC_0
);
5211 mono_mb_emit_stloc (mb
, loc
);
5213 mono_mb_emit_byte (mb
, CEE_LDNULL
);
5214 mono_mb_emit_byte (mb
, CEE_STLOC_3
);
5216 mono_mb_emit_byte (mb
, CEE_LDLOC_0
);
5217 mono_mb_emit_byte (mb
, CEE_BRFALSE
);
5219 mono_mb_emit_i4 (mb
, 0);
5221 /* allocate result object */
5223 mono_mb_emit_byte (mb
, MONO_CUSTOM_PREFIX
);
5224 mono_mb_emit_byte (mb
, CEE_MONO_NEWOBJ
);
5225 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, klass
));
5226 mono_mb_emit_byte (mb
, CEE_STLOC_3
);
5230 mono_mb_emit_byte (mb
, CEE_LDLOC_3
);
5231 mono_mb_emit_byte (mb
, MONO_CUSTOM_PREFIX
);
5232 mono_mb_emit_byte (mb
, CEE_MONO_OBJADDR
);
5233 mono_mb_emit_icon (mb
, sizeof (MonoObject
));
5234 mono_mb_emit_byte (mb
, CEE_ADD
);
5235 mono_mb_emit_byte (mb
, CEE_STLOC_1
);
5237 /* emit conversion code */
5238 emit_struct_conv (mb
, klass
, TRUE
);
5240 emit_struct_free (mb
, klass
, loc
);
5242 /* Free the pointer allocated by unmanaged code */
5243 mono_mb_emit_ldloc (mb
, loc
);
5244 mono_mb_emit_icall (mb
, g_free
);
5245 mono_mb_patch_addr (mb
, pos
, mb
->pos
- (pos
+ 4));
5250 g_assert_not_reached ();
5257 emit_marshal_array (EmitMarshalContext
*m
, int argnum
, MonoType
*t
,
5258 MonoMarshalSpec
*spec
,
5259 int conv_arg
, MonoType
**conv_arg_type
,
5260 MarshalAction action
)
5262 MonoMethodBuilder
*mb
= m
->mb
;
5263 MonoClass
*klass
= mono_class_from_mono_type (t
);
5264 gboolean need_convert
, need_free
;
5267 case MARSHAL_ACTION_CONV_IN
:
5268 *conv_arg_type
= &mono_defaults
.int_class
->byval_arg
;
5269 conv_arg
= mono_mb_add_local (mb
, &mono_defaults
.int_class
->byval_arg
);
5271 if (klass
->element_class
->blittable
) {
5272 mono_mb_emit_ldarg (mb
, argnum
);
5274 mono_mb_emit_byte (mb
, CEE_LDIND_I
);
5275 mono_mb_emit_icall (mb
, conv_to_icall (MONO_MARSHAL_CONV_ARRAY_LPARRAY
));
5276 mono_mb_emit_stloc (mb
, conv_arg
);
5280 guint32 label1
, label2
, label3
;
5281 int index_var
, src_var
, dest_ptr
, esize
;
5282 MonoMarshalNative encoding
;
5283 MonoMarshalConv conv
;
5284 gboolean is_string
= FALSE
;
5286 dest_ptr
= mono_mb_add_local (mb
, &mono_defaults
.int_class
->byval_arg
);
5288 eklass
= klass
->element_class
;
5290 encoding
= mono_marshal_get_string_encoding (m
->piinfo
, spec
);
5291 if (eklass
== mono_defaults
.string_class
) {
5293 conv
= mono_marshal_get_string_to_ptr_conv (m
->piinfo
, spec
);
5295 else if (eklass
== mono_defaults
.stringbuilder_class
) {
5297 conv
= mono_marshal_get_stringbuilder_to_ptr_conv (m
->piinfo
, spec
);
5302 src_var
= mono_mb_add_local (mb
, &mono_defaults
.int_class
->byval_arg
);
5303 mono_mb_emit_ldarg (mb
, argnum
);
5305 mono_mb_emit_byte (mb
, CEE_LDIND_I
);
5306 mono_mb_emit_stloc (mb
, src_var
);
5309 mono_mb_emit_ldloc (mb
, src_var
);
5310 mono_mb_emit_stloc (mb
, conv_arg
);
5311 mono_mb_emit_ldloc (mb
, src_var
);
5312 mono_mb_emit_byte (mb
, CEE_BRFALSE
);
5314 mono_mb_emit_i4 (mb
, 0);
5318 char *msg
= g_strdup_printf ("string/stringbuilder marshalling conversion %d not implemented", encoding
);
5319 MonoException
*exc
= mono_get_exception_not_implemented (msg
);
5322 mono_raise_exception (exc
);
5327 esize
= sizeof (gpointer
);
5329 esize
= mono_class_native_size (eklass
, NULL
);
5331 /* allocate space for the native struct and store the address */
5332 mono_mb_emit_icon (mb
, esize
);
5333 mono_mb_emit_ldloc (mb
, src_var
);
5334 mono_mb_emit_byte (mb
, CEE_LDLEN
);
5336 if (eklass
== mono_defaults
.string_class
) {
5337 /* Make the array bigger for the terminating null */
5338 mono_mb_emit_byte (mb
, CEE_LDC_I4_1
);
5339 mono_mb_emit_byte (mb
, CEE_ADD
);
5341 mono_mb_emit_byte (mb
, CEE_MUL
);
5342 mono_mb_emit_byte (mb
, CEE_PREFIX1
);
5343 mono_mb_emit_byte (mb
, CEE_LOCALLOC
);
5344 mono_mb_emit_stloc (mb
, conv_arg
);
5346 mono_mb_emit_ldloc (mb
, conv_arg
);
5347 mono_mb_emit_stloc (mb
, dest_ptr
);
5349 /* Emit marshalling loop */
5350 index_var
= mono_mb_add_local (mb
, &mono_defaults
.int_class
->byval_arg
);
5351 mono_mb_emit_byte (mb
, CEE_LDC_I4_0
);
5352 mono_mb_emit_stloc (mb
, index_var
);
5354 mono_mb_emit_ldloc (mb
, index_var
);
5355 mono_mb_emit_ldloc (mb
, src_var
);
5356 mono_mb_emit_byte (mb
, CEE_LDLEN
);
5357 mono_mb_emit_byte (mb
, CEE_BGE
);
5359 mono_mb_emit_i4 (mb
, 0);
5361 /* Emit marshalling code */
5364 mono_mb_emit_ldloc (mb
, dest_ptr
);
5365 mono_mb_emit_ldloc (mb
, src_var
);
5366 mono_mb_emit_ldloc (mb
, index_var
);
5367 mono_mb_emit_byte (mb
, CEE_LDELEM_REF
);
5368 mono_mb_emit_icall (mb
, conv_to_icall (conv
));
5369 mono_mb_emit_byte (mb
, CEE_STIND_I
);
5372 /* set the src_ptr */
5373 mono_mb_emit_ldloc (mb
, src_var
);
5374 mono_mb_emit_ldloc (mb
, index_var
);
5375 mono_mb_emit_byte (mb
, CEE_LDELEMA
);
5376 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, eklass
));
5377 mono_mb_emit_byte (mb
, CEE_STLOC_0
);
5380 mono_mb_emit_ldloc (mb
, dest_ptr
);
5381 mono_mb_emit_byte (mb
, CEE_STLOC_1
);
5383 /* emit valuetype conversion code */
5384 emit_struct_conv (mb
, eklass
, FALSE
);
5387 mono_mb_emit_add_to_local (mb
, index_var
, 1);
5388 mono_mb_emit_add_to_local (mb
, dest_ptr
, esize
);
5390 mono_mb_emit_byte (mb
, CEE_BR
);
5391 mono_mb_emit_i4 (mb
, label2
- (mb
->pos
+ 4));
5393 mono_mb_patch_addr (mb
, label3
, mb
->pos
- (label3
+ 4));
5395 if (eklass
== mono_defaults
.string_class
) {
5396 /* Null terminate */
5397 mono_mb_emit_ldloc (mb
, dest_ptr
);
5398 mono_mb_emit_byte (mb
, CEE_LDC_I4_0
);
5399 mono_mb_emit_byte (mb
, CEE_STIND_REF
);
5402 mono_mb_patch_addr (mb
, label1
, mb
->pos
- (label1
+ 4));
5407 case MARSHAL_ACTION_CONV_OUT
:
5408 /* Character arrays are implicitly marshalled as [Out] */
5409 need_convert
= (klass
->element_class
== mono_defaults
.char_class
) || (klass
->element_class
== mono_defaults
.stringbuilder_class
) || (t
->attrs
& PARAM_ATTRIBUTE_OUT
);
5410 need_free
= mono_marshal_need_free (&klass
->element_class
->byval_arg
,
5413 if (need_convert
|| need_free
) {
5414 /* FIXME: Optimize blittable case */
5416 guint32 label1
, label2
, label3
;
5417 int index_var
, src_ptr
, loc
, esize
;
5419 eklass
= klass
->element_class
;
5420 if ((eklass
== mono_defaults
.stringbuilder_class
) || (eklass
== mono_defaults
.string_class
))
5421 esize
= sizeof (gpointer
);
5423 esize
= mono_class_native_size (eklass
, NULL
);
5424 src_ptr
= mono_mb_add_local (mb
, &mono_defaults
.int_class
->byval_arg
);
5425 loc
= mono_mb_add_local (mb
, &mono_defaults
.int_class
->byval_arg
);
5428 mono_mb_emit_ldarg (mb
, argnum
);
5430 mono_mb_emit_byte (mb
, CEE_LDIND_I
);
5431 mono_mb_emit_byte (mb
, CEE_BRFALSE
);
5433 mono_mb_emit_i4 (mb
, 0);
5435 mono_mb_emit_ldloc (mb
, conv_arg
);
5436 mono_mb_emit_stloc (mb
, src_ptr
);
5438 /* Emit marshalling loop */
5439 index_var
= mono_mb_add_local (mb
, &mono_defaults
.int_class
->byval_arg
);
5440 mono_mb_emit_byte (mb
, CEE_LDC_I4_0
);
5441 mono_mb_emit_stloc (mb
, index_var
);
5443 mono_mb_emit_ldloc (mb
, index_var
);
5444 mono_mb_emit_ldarg (mb
, argnum
);
5446 mono_mb_emit_byte (mb
, CEE_LDIND_I
);
5447 mono_mb_emit_byte (mb
, CEE_LDLEN
);
5448 mono_mb_emit_byte (mb
, CEE_BGE
);
5450 mono_mb_emit_i4 (mb
, 0);
5452 /* Emit marshalling code */
5454 if (eklass
== mono_defaults
.stringbuilder_class
) {
5455 gboolean need_free2
;
5456 MonoMarshalConv conv
= mono_marshal_get_ptr_to_stringbuilder_conv (m
->piinfo
, spec
, &need_free2
);
5458 g_assert (conv
!= -1);
5461 mono_mb_emit_ldarg (mb
, argnum
);
5463 mono_mb_emit_byte (mb
, CEE_LDIND_I
);
5464 mono_mb_emit_ldloc (mb
, index_var
);
5465 mono_mb_emit_byte (mb
, CEE_LDELEM_REF
);
5468 mono_mb_emit_ldloc (mb
, src_ptr
);
5469 mono_mb_emit_byte (mb
, CEE_LDIND_I
);
5471 mono_mb_emit_icall (mb
, conv_to_icall (conv
));
5475 mono_mb_emit_ldloc (mb
, src_ptr
);
5476 mono_mb_emit_byte (mb
, CEE_LDIND_I
);
5478 mono_mb_emit_icall (mb
, mono_marshal_free
);
5481 else if (eklass
== mono_defaults
.string_class
) {
5484 mono_mb_emit_ldloc (mb
, src_ptr
);
5485 mono_mb_emit_byte (mb
, CEE_LDIND_I
);
5487 mono_mb_emit_icall (mb
, mono_marshal_free
);
5492 /* set the src_ptr */
5493 mono_mb_emit_ldloc (mb
, src_ptr
);
5494 mono_mb_emit_byte (mb
, CEE_STLOC_0
);
5497 mono_mb_emit_ldarg (mb
, argnum
);
5499 mono_mb_emit_byte (mb
, CEE_LDIND_I
);
5500 mono_mb_emit_ldloc (mb
, index_var
);
5501 mono_mb_emit_byte (mb
, CEE_LDELEMA
);
5502 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, eklass
));
5503 mono_mb_emit_byte (mb
, CEE_STLOC_1
);
5505 /* emit valuetype conversion code */
5506 emit_struct_conv (mb
, eklass
, TRUE
);
5510 mono_mb_emit_ldloc (mb
, src_ptr
);
5511 mono_mb_emit_stloc (mb
, loc
);
5512 mono_mb_emit_ldloc (mb
, loc
);
5514 emit_struct_free (mb
, eklass
, loc
);
5518 mono_mb_emit_add_to_local (mb
, index_var
, 1);
5519 mono_mb_emit_add_to_local (mb
, src_ptr
, esize
);
5521 mono_mb_emit_byte (mb
, CEE_BR
);
5522 mono_mb_emit_i4 (mb
, label2
- (mb
->pos
+ 4));
5524 mono_mb_patch_addr (mb
, label1
, mb
->pos
- (label1
+ 4));
5525 mono_mb_patch_addr (mb
, label3
, mb
->pos
- (label3
+ 4));
5529 case MARSHAL_ACTION_CONV_RESULT
:
5530 /* fixme: we need conversions here */
5531 mono_mb_emit_byte (mb
, CEE_STLOC_3
);
5534 g_assert_not_reached ();
5541 emit_marshal_boolean (EmitMarshalContext
*m
, int argnum
, MonoType
*t
,
5542 MonoMarshalSpec
*spec
,
5543 int conv_arg
, MonoType
**conv_arg_type
,
5544 MarshalAction action
)
5546 MonoMethodBuilder
*mb
= m
->mb
;
5549 case MARSHAL_ACTION_CONV_IN
: {
5550 MonoType
*local_type
;
5551 int variant_bool
= 0;
5555 local_type
= &mono_defaults
.int32_class
->byval_arg
;
5557 switch (spec
->native
) {
5558 case MONO_NATIVE_I1
:
5559 local_type
= &mono_defaults
.byte_class
->byval_arg
;
5561 case MONO_NATIVE_VARIANTBOOL
:
5562 local_type
= &mono_defaults
.int16_class
->byval_arg
;
5566 g_warning ("marshalling bool as native type %x is currently not supported", spec
->native
);
5567 local_type
= &mono_defaults
.int32_class
->byval_arg
;
5571 *conv_arg_type
= &mono_defaults
.int_class
->byval_arg
;
5572 conv_arg
= mono_mb_add_local (mb
, local_type
);
5573 mono_mb_emit_ldarg (mb
, argnum
);
5574 mono_mb_emit_byte (mb
, CEE_LDIND_I1
);
5576 mono_mb_emit_byte (mb
, CEE_NEG
);
5577 mono_mb_emit_stloc (mb
, conv_arg
);
5581 case MARSHAL_ACTION_CONV_RESULT
:
5582 /* maybe we need to make sure that it fits within 8 bits */
5583 mono_mb_emit_byte (mb
, CEE_STLOC_3
);
5587 g_assert_not_reached ();
5594 emit_marshal (EmitMarshalContext
*m
, int argnum
, MonoType
*t
,
5595 MonoMarshalSpec
*spec
, int conv_arg
,
5596 MonoType
**conv_arg_type
, MarshalAction action
)
5598 /* Ensure that we have marshalling info for this param */
5599 mono_marshal_load_type_info (mono_class_from_mono_type (t
));
5601 if (spec
&& spec
->native
== MONO_NATIVE_CUSTOM
)
5602 return emit_marshal_custom (m
, argnum
, t
, spec
, conv_arg
, conv_arg_type
, action
);
5604 if (spec
&& spec
->native
== MONO_NATIVE_ASANY
)
5605 return emit_marshal_asany (m
, argnum
, t
, spec
, conv_arg
, conv_arg_type
, action
);
5608 case MONO_TYPE_VALUETYPE
:
5609 return emit_marshal_vtype (m
, argnum
, t
, spec
, conv_arg
, conv_arg_type
, action
);
5610 case MONO_TYPE_STRING
:
5611 return emit_marshal_string (m
, argnum
, t
, spec
, conv_arg
, conv_arg_type
, action
);
5612 case MONO_TYPE_CLASS
:
5613 case MONO_TYPE_OBJECT
:
5614 return emit_marshal_object (m
, argnum
, t
, spec
, conv_arg
, conv_arg_type
, action
);
5615 case MONO_TYPE_ARRAY
:
5616 case MONO_TYPE_SZARRAY
:
5617 return emit_marshal_array (m
, argnum
, t
, spec
, conv_arg
, conv_arg_type
, action
);
5618 case MONO_TYPE_BOOLEAN
:
5619 return emit_marshal_boolean (m
, argnum
, t
, spec
, conv_arg
, conv_arg_type
, action
);
5626 * mono_marshal_get_native_wrapper:
5627 * @method: The MonoMethod to wrap.
5629 * generates IL code for the pinvoke wrapper (the generated method
5630 * calls the unmanaged code in piinfo->addr)
5633 mono_marshal_get_native_wrapper (MonoMethod
*method
)
5635 EmitMarshalContext m
;
5636 MonoMethodSignature
*sig
, *csig
;
5637 MonoMethodPInvoke
*piinfo
= (MonoMethodPInvoke
*) method
;
5638 MonoMethodBuilder
*mb
;
5639 MonoMarshalSpec
**mspecs
;
5643 gboolean pinvoke
= FALSE
;
5644 int i
, argnum
, *tmp_locals
;
5646 const char *exc_class
= "MissingMethodException";
5647 const char *exc_arg
= NULL
;
5649 g_assert (method
!= NULL
);
5650 g_assert (method
->signature
->pinvoke
);
5652 cache
= method
->klass
->image
->native_wrapper_cache
;
5653 if ((res
= mono_marshal_find_in_cache (cache
, method
)))
5656 sig
= method
->signature
;
5658 if (!(method
->iflags
& METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL
) &&
5659 (method
->flags
& METHOD_ATTRIBUTE_PINVOKE_IMPL
))
5662 if (!piinfo
->addr
) {
5664 mono_lookup_pinvoke_call (method
, &exc_class
, &exc_arg
);
5666 piinfo
->addr
= mono_lookup_internal_call (method
);
5669 mb
= mono_mb_new (method
->klass
, method
->name
, MONO_WRAPPER_MANAGED_TO_NATIVE
);
5671 mb
->method
->save_lmf
= 1;
5673 if (!piinfo
->addr
) {
5674 mono_mb_emit_exception (mb
, exc_class
, exc_arg
);
5675 csig
= mono_metadata_signature_dup (sig
);
5677 res
= mono_mb_create_and_cache (cache
, method
,
5678 mb
, csig
, csig
->param_count
+ 16);
5686 /* internal calls: we simply push all arguments and call the method (no conversions) */
5687 if (method
->iflags
& (METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL
| METHOD_IMPL_ATTRIBUTE_RUNTIME
)) {
5689 /* hack - string constructors returns a value */
5690 if (method
->string_ctor
) {
5691 csig
= mono_metadata_signature_dup (sig
);
5692 csig
->ret
= &mono_defaults
.string_class
->byval_arg
;
5697 mono_mb_emit_byte (mb
, CEE_LDARG_0
);
5699 for (i
= 0; i
< sig
->param_count
; i
++)
5700 mono_mb_emit_ldarg (mb
, i
+ sig
->hasthis
);
5702 g_assert (piinfo
->addr
);
5703 mono_mb_emit_native_call (mb
, csig
, piinfo
->addr
);
5704 emit_thread_interrupt_checkpoint (mb
);
5705 mono_mb_emit_byte (mb
, CEE_RET
);
5707 csig
= mono_metadata_signature_dup (csig
);
5709 res
= mono_mb_create_and_cache (cache
, method
,
5710 mb
, csig
, csig
->param_count
+ 16);
5717 mspecs
= g_new (MonoMarshalSpec
*, sig
->param_count
+ 1);
5718 mono_method_get_marshal_info (method
, mspecs
);
5720 /* pinvoke: we need to convert the arguments if necessary */
5722 /* we copy the signature, so that we can set pinvoke to 0 */
5723 csig
= mono_metadata_signature_dup (sig
);
5726 /* we allocate local for use with emit_struct_conv() */
5727 /* allocate local 0 (pointer) src_ptr */
5728 mono_mb_add_local (mb
, &mono_defaults
.int_class
->byval_arg
);
5729 /* allocate local 1 (pointer) dst_ptr */
5730 mono_mb_add_local (mb
, &mono_defaults
.int_class
->byval_arg
);
5731 /* allocate local 2 (boolean) delete_old */
5732 mono_mb_add_local (mb
, &mono_defaults
.boolean_class
->byval_arg
);
5734 /* delete_old = FALSE */
5735 mono_mb_emit_icon (mb
, 0);
5736 mono_mb_emit_byte (mb
, CEE_STLOC_2
);
5738 if (!MONO_TYPE_IS_VOID(sig
->ret
)) {
5739 /* allocate local 3 to store the return value */
5740 mono_mb_add_local (mb
, sig
->ret
);
5743 if (mspecs
[0] && mspecs
[0]->native
== MONO_NATIVE_CUSTOM
) {
5744 /* Return type custom marshaling */
5746 * Since we can't determine the return type of the unmanaged function,
5747 * we assume it returns a pointer, and pass that pointer to
5748 * MarshalNativeToManaged.
5750 csig
->ret
= &mono_defaults
.int_class
->byval_arg
;
5753 /* we first do all conversions */
5754 tmp_locals
= alloca (sizeof (int) * sig
->param_count
);
5755 m
.orig_conv_args
= alloca (sizeof (int) * (sig
->param_count
+ 1));
5757 for (i
= 0; i
< sig
->param_count
; i
++) {
5758 tmp_locals
[i
] = emit_marshal (&m
, i
+ sig
->hasthis
, sig
->params
[i
], mspecs
[i
+ 1], 0, &csig
->params
[i
], MARSHAL_ACTION_CONV_IN
);
5761 /* push all arguments */
5764 mono_mb_emit_byte (mb
, CEE_LDARG_0
);
5766 for (i
= 0; i
< sig
->param_count
; i
++) {
5767 MonoType
*t
= sig
->params
[i
];
5768 MonoMarshalSpec
*spec
= mspecs
[i
+ 1];
5770 if (spec
&& ((spec
->native
== MONO_NATIVE_CUSTOM
) || (spec
->native
== MONO_NATIVE_ASANY
)))
5771 emit_marshal (&m
, i
+ sig
->hasthis
, t
, spec
, tmp_locals
[i
], NULL
, MARSHAL_ACTION_PUSH
);
5773 argnum
= i
+ sig
->hasthis
;
5776 case MONO_TYPE_BOOLEAN
:
5778 g_assert (tmp_locals
[i
]);
5779 mono_mb_emit_ldloc_addr (mb
, tmp_locals
[i
]);
5781 mono_mb_emit_ldarg (mb
, argnum
);
5796 mono_mb_emit_ldarg (mb
, argnum
);
5798 case MONO_TYPE_VALUETYPE
:
5799 emit_marshal (&m
, i
+ sig
->hasthis
, t
, spec
, tmp_locals
[i
], NULL
, MARSHAL_ACTION_PUSH
);
5801 case MONO_TYPE_STRING
:
5802 case MONO_TYPE_CLASS
:
5803 case MONO_TYPE_OBJECT
:
5804 case MONO_TYPE_ARRAY
:
5805 case MONO_TYPE_SZARRAY
:
5806 g_assert (tmp_locals
[i
]);
5808 mono_mb_emit_ldloc_addr (mb
, tmp_locals
[i
]);
5810 mono_mb_emit_ldloc (mb
, tmp_locals
[i
]);
5812 case MONO_TYPE_CHAR
:
5813 /* fixme: dont know how to marshal that. We cant simply
5814 * convert it to a one byte UTF8 character, because an
5815 * unicode character may need more that one byte in UTF8 */
5816 mono_mb_emit_ldarg (mb
, argnum
);
5818 case MONO_TYPE_TYPEDBYREF
:
5819 case MONO_TYPE_FNPTR
:
5821 g_warning ("type 0x%02x unknown", t
->type
);
5822 g_assert_not_reached ();
5827 /* call the native method */
5828 mono_mb_emit_native_call (mb
, csig
, piinfo
->addr
);
5830 /* Set LastError if needed */
5831 if (piinfo
->piflags
& PINVOKE_ATTRIBUTE_SUPPORTS_LAST_ERROR
) {
5832 MonoMethodSignature
*lasterr_sig
;
5834 lasterr_sig
= mono_metadata_signature_alloc (mono_defaults
.corlib
, 0);
5835 lasterr_sig
->ret
= &mono_defaults
.void_class
->byval_arg
;
5836 lasterr_sig
->pinvoke
= 1;
5838 mono_mb_emit_native_call (mb
, lasterr_sig
, mono_marshal_set_last_error
);
5841 /* convert the result */
5842 if (!sig
->ret
->byref
) {
5843 MonoMarshalSpec
*spec
= mspecs
[0];
5844 type
= sig
->ret
->type
;
5846 if (spec
&& spec
->native
== MONO_NATIVE_CUSTOM
) {
5847 emit_marshal (&m
, 0, sig
->ret
, spec
, 0, NULL
, MARSHAL_ACTION_CONV_RESULT
);
5852 case MONO_TYPE_VOID
:
5867 /* no conversions necessary */
5868 mono_mb_emit_byte (mb
, CEE_STLOC_3
);
5870 case MONO_TYPE_VALUETYPE
:
5871 klass
= sig
->ret
->data
.klass
;
5872 if (klass
->enumtype
) {
5873 type
= sig
->ret
->data
.klass
->enum_basetype
->type
;
5876 emit_marshal (&m
, 0, sig
->ret
, spec
, 0, NULL
, MARSHAL_ACTION_CONV_RESULT
);
5878 case MONO_TYPE_STRING
:
5879 case MONO_TYPE_CLASS
:
5880 case MONO_TYPE_OBJECT
:
5881 case MONO_TYPE_BOOLEAN
:
5882 case MONO_TYPE_ARRAY
:
5883 case MONO_TYPE_SZARRAY
:
5884 emit_marshal (&m
, 0, sig
->ret
, spec
, 0, NULL
, MARSHAL_ACTION_CONV_RESULT
);
5886 case MONO_TYPE_CHAR
:
5887 /* fixme: we need conversions here */
5888 mono_mb_emit_byte (mb
, CEE_STLOC_3
);
5890 case MONO_TYPE_TYPEDBYREF
:
5891 case MONO_TYPE_FNPTR
:
5893 g_warning ("return type 0x%02x unknown", sig
->ret
->type
);
5894 g_assert_not_reached ();
5898 mono_mb_emit_byte (mb
, CEE_STLOC_3
);
5902 * Need to call this after converting the result since MONO_VTADDR needs
5903 * to be adjacent to the call instruction.
5905 emit_thread_interrupt_checkpoint (mb
);
5907 /* we need to convert byref arguments back and free string arrays */
5908 for (i
= 0; i
< sig
->param_count
; i
++) {
5909 MonoType
*t
= sig
->params
[i
];
5910 MonoMarshalSpec
*spec
= mspecs
[i
+ 1];
5912 argnum
= i
+ sig
->hasthis
;
5914 if (spec
&& ((spec
->native
== MONO_NATIVE_CUSTOM
) || (spec
->native
== MONO_NATIVE_ASANY
))) {
5915 emit_marshal (&m
, argnum
, t
, spec
, tmp_locals
[i
], NULL
, MARSHAL_ACTION_CONV_OUT
);
5920 case MONO_TYPE_STRING
:
5921 case MONO_TYPE_VALUETYPE
:
5922 case MONO_TYPE_CLASS
:
5923 case MONO_TYPE_OBJECT
:
5924 case MONO_TYPE_SZARRAY
:
5925 emit_marshal (&m
, argnum
, t
, spec
, tmp_locals
[i
], NULL
, MARSHAL_ACTION_CONV_OUT
);
5927 case MONO_TYPE_BOOLEAN
:
5930 mono_mb_emit_ldarg (mb
, argnum
);
5931 mono_mb_emit_ldloc (mb
, tmp_locals
[i
]);
5932 if (mspecs
[i
+ 1] != NULL
&& mspecs
[i
+ 1]->native
== MONO_NATIVE_VARIANTBOOL
)
5933 mono_mb_emit_byte (mb
, CEE_NEG
);
5934 mono_mb_emit_byte (mb
, CEE_STIND_I1
);
5938 if (!MONO_TYPE_IS_VOID(sig
->ret
))
5939 mono_mb_emit_byte (mb
, CEE_LDLOC_3
);
5941 mono_mb_emit_byte (mb
, CEE_RET
);
5943 csig
= mono_metadata_signature_dup (sig
);
5945 res
= mono_mb_create_and_cache (cache
, method
,
5946 mb
, csig
, csig
->param_count
+ 16);
5949 for (i
= sig
->param_count
; i
>= 0; i
--)
5950 g_free (mspecs
[i
]);
5953 /* printf ("CODE FOR %s: \n%s.\n", mono_method_full_name (res, TRUE), mono_disasm_code (0, res, ((MonoMethodNormal*)res)->header->code, ((MonoMethodNormal*)res)->header->code + ((MonoMethodNormal*)res)->header->code_size)); */
5959 mono_upgrade_remote_class_wrapper (MonoReflectionType
*rtype
, MonoTransparentProxy
*tproxy
);
5961 static MonoReflectionType
*
5962 type_from_handle (MonoType
*handle
)
5964 MonoDomain
*domain
= mono_domain_get ();
5965 MonoClass
*klass
= mono_class_from_mono_type (handle
);
5967 MONO_ARCH_SAVE_REGS
;
5969 mono_class_init (klass
);
5970 return mono_type_get_object (domain
, handle
);
5974 * mono_marshal_get_isinst:
5975 * @klass: the type of the field
5977 * This method generates a function which can be used to check if an object is
5978 * an instance of the given type, icluding the case where the object is a proxy.
5979 * The generated function has the following signature:
5980 * MonoObject* __isinst_wrapper_ (MonoObject *obj)
5983 mono_marshal_get_isinst (MonoClass
*klass
)
5985 static MonoMethodSignature
*isint_sig
= NULL
;
5986 static GHashTable
*isinst_hash
= NULL
;
5988 int pos_was_ok
, pos_failed
, pos_end
, pos_end2
;
5990 MonoMethodBuilder
*mb
;
5992 EnterCriticalSection (&marshal_mutex
);
5994 isinst_hash
= g_hash_table_new (NULL
, NULL
);
5996 res
= g_hash_table_lookup (isinst_hash
, klass
);
5997 LeaveCriticalSection (&marshal_mutex
);
6002 isint_sig
= mono_metadata_signature_alloc (mono_defaults
.corlib
, 1);
6003 isint_sig
->params
[0] = &mono_defaults
.object_class
->byval_arg
;
6004 isint_sig
->ret
= &mono_defaults
.object_class
->byval_arg
;
6005 isint_sig
->pinvoke
= 0;
6008 name
= g_strdup_printf ("__isinst_wrapper_%s", klass
->name
);
6009 mb
= mono_mb_new (mono_defaults
.object_class
, name
, MONO_WRAPPER_ISINST
);
6012 mb
->method
->save_lmf
= 1;
6014 /* check if the object is a proxy that needs special cast */
6015 mono_mb_emit_ldarg (mb
, 0);
6016 mono_mb_emit_byte (mb
, MONO_CUSTOM_PREFIX
);
6017 mono_mb_emit_byte (mb
, CEE_MONO_CISINST
);
6018 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, klass
));
6020 /* The result of MONO_ISINST can be:
6021 0) the type check succeeded
6022 1) the type check did not succeed
6023 2) a CanCastTo call is needed */
6025 mono_mb_emit_byte (mb
, CEE_DUP
);
6026 pos_was_ok
= mono_mb_emit_branch (mb
, CEE_BRFALSE
);
6028 mono_mb_emit_byte (mb
, CEE_LDC_I4_2
);
6029 pos_failed
= mono_mb_emit_branch (mb
, CEE_BNE_UN
);
6031 /* get the real proxy from the transparent proxy*/
6033 mono_mb_emit_ldarg (mb
, 0);
6034 mono_mb_emit_managed_call (mb
, mono_marshal_get_proxy_cancast (klass
), NULL
);
6035 pos_end
= mono_mb_emit_branch (mb
, CEE_BR
);
6039 mono_mb_patch_addr (mb
, pos_failed
, mb
->pos
- (pos_failed
+ 4));
6040 mono_mb_emit_byte (mb
, CEE_LDNULL
);
6041 pos_end2
= mono_mb_emit_branch (mb
, CEE_BR
);
6045 mono_mb_patch_addr (mb
, pos_was_ok
, mb
->pos
- (pos_was_ok
+ 4));
6046 mono_mb_emit_byte (mb
, CEE_POP
);
6047 mono_mb_emit_ldarg (mb
, 0);
6051 mono_mb_patch_addr (mb
, pos_end
, mb
->pos
- (pos_end
+ 4));
6052 mono_mb_patch_addr (mb
, pos_end2
, mb
->pos
- (pos_end2
+ 4));
6053 mono_mb_emit_byte (mb
, CEE_RET
);
6055 res
= mono_mb_create_and_cache (isinst_hash
, klass
, mb
, isint_sig
, isint_sig
->param_count
+ 16);
6062 * mono_marshal_get_castclass:
6063 * @klass: the type of the field
6065 * This method generates a function which can be used to cast an object to
6066 * an instance of the given type, icluding the case where the object is a proxy.
6067 * The generated function has the following signature:
6068 * MonoObject* __castclass_wrapper_ (MonoObject *obj)
6071 mono_marshal_get_castclass (MonoClass
*klass
)
6073 static MonoMethodSignature
*castclass_sig
= NULL
;
6074 static GHashTable
*castclass_hash
= NULL
;
6076 int pos_was_ok
, pos_was_ok2
;
6078 MonoMethodBuilder
*mb
;
6080 EnterCriticalSection (&marshal_mutex
);
6081 if (!castclass_hash
)
6082 castclass_hash
= g_hash_table_new (NULL
, NULL
);
6084 res
= g_hash_table_lookup (castclass_hash
, klass
);
6085 LeaveCriticalSection (&marshal_mutex
);
6089 if (!castclass_sig
) {
6090 castclass_sig
= mono_metadata_signature_alloc (mono_defaults
.corlib
, 1);
6091 castclass_sig
->params
[0] = &mono_defaults
.object_class
->byval_arg
;
6092 castclass_sig
->ret
= &mono_defaults
.object_class
->byval_arg
;
6093 castclass_sig
->pinvoke
= 0;
6096 name
= g_strdup_printf ("__castclass_wrapper_%s", klass
->name
);
6097 mb
= mono_mb_new (mono_defaults
.object_class
, name
, MONO_WRAPPER_CASTCLASS
);
6100 mb
->method
->save_lmf
= 1;
6102 /* check if the object is a proxy that needs special cast */
6103 mono_mb_emit_ldarg (mb
, 0);
6104 mono_mb_emit_byte (mb
, MONO_CUSTOM_PREFIX
);
6105 mono_mb_emit_byte (mb
, CEE_MONO_CCASTCLASS
);
6106 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, klass
));
6108 /* The result of MONO_ISINST can be:
6109 0) the cast is valid
6110 1) cast of unknown proxy type
6111 or an exception if the cast is is invalid
6114 pos_was_ok
= mono_mb_emit_branch (mb
, CEE_BRFALSE
);
6116 /* get the real proxy from the transparent proxy*/
6118 mono_mb_emit_ldarg (mb
, 0);
6119 mono_mb_emit_managed_call (mb
, mono_marshal_get_proxy_cancast (klass
), NULL
);
6120 pos_was_ok2
= mono_mb_emit_branch (mb
, CEE_BRTRUE
);
6123 mono_mb_emit_exception (mb
, "InvalidCastException", NULL
);
6126 mono_mb_patch_addr (mb
, pos_was_ok
, mb
->pos
- (pos_was_ok
+ 4));
6127 mono_mb_patch_addr (mb
, pos_was_ok2
, mb
->pos
- (pos_was_ok2
+ 4));
6128 mono_mb_emit_ldarg (mb
, 0);
6131 mono_mb_emit_byte (mb
, CEE_RET
);
6133 res
= mono_mb_create_and_cache (castclass_hash
, klass
, mb
, castclass_sig
, castclass_sig
->param_count
+ 16);
6140 mono_marshal_get_proxy_cancast (MonoClass
*klass
)
6142 static MonoMethodSignature
*from_handle_sig
= NULL
;
6143 static MonoMethodSignature
*upgrade_proxy_sig
= NULL
;
6144 static MonoMethodSignature
*isint_sig
= NULL
;
6145 static GHashTable
*proxy_isinst_hash
= NULL
;
6147 int pos_failed
, pos_end
;
6149 MonoMethod
*can_cast_to
;
6150 MonoMethodDesc
*desc
;
6151 MonoMethodBuilder
*mb
;
6153 EnterCriticalSection (&marshal_mutex
);
6154 if (!proxy_isinst_hash
)
6155 proxy_isinst_hash
= g_hash_table_new (NULL
, NULL
);
6157 res
= g_hash_table_lookup (proxy_isinst_hash
, klass
);
6158 LeaveCriticalSection (&marshal_mutex
);
6163 upgrade_proxy_sig
= mono_metadata_signature_alloc (mono_defaults
.corlib
, 2);
6164 upgrade_proxy_sig
->params
[0] = &mono_defaults
.object_class
->byval_arg
;
6165 upgrade_proxy_sig
->params
[1] = &mono_defaults
.object_class
->byval_arg
;
6166 upgrade_proxy_sig
->ret
= &mono_defaults
.void_class
->byval_arg
;
6167 upgrade_proxy_sig
->pinvoke
= 1;
6169 from_handle_sig
= mono_metadata_signature_alloc (mono_defaults
.corlib
, 1);
6170 from_handle_sig
->params
[0] = &mono_defaults
.object_class
->byval_arg
;
6171 from_handle_sig
->ret
= &mono_defaults
.object_class
->byval_arg
;
6173 isint_sig
= mono_metadata_signature_alloc (mono_defaults
.corlib
, 1);
6174 isint_sig
->params
[0] = &mono_defaults
.object_class
->byval_arg
;
6175 isint_sig
->ret
= &mono_defaults
.object_class
->byval_arg
;
6176 isint_sig
->pinvoke
= 0;
6179 name
= g_strdup_printf ("__proxy_isinst_wrapper_%s", klass
->name
);
6180 mb
= mono_mb_new (mono_defaults
.object_class
, name
, MONO_WRAPPER_PROXY_ISINST
);
6183 mb
->method
->save_lmf
= 1;
6185 /* get the real proxy from the transparent proxy*/
6186 mono_mb_emit_ldarg (mb
, 0);
6187 mono_mb_emit_ldflda (mb
, G_STRUCT_OFFSET (MonoTransparentProxy
, rp
));
6188 mono_mb_emit_byte (mb
, CEE_LDIND_I
);
6190 /* get the refletion type from the type handle */
6191 mono_mb_emit_byte (mb
, MONO_CUSTOM_PREFIX
);
6192 mono_mb_emit_byte (mb
, CEE_MONO_LDPTR
);
6193 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, &klass
->byval_arg
));
6194 mono_mb_emit_native_call (mb
, from_handle_sig
, type_from_handle
);
6196 mono_mb_emit_ldarg (mb
, 0);
6198 /* make the call to CanCastTo (type, ob) */
6199 desc
= mono_method_desc_new ("IRemotingTypeInfo:CanCastTo", FALSE
);
6200 can_cast_to
= mono_method_desc_search_in_class (desc
, mono_defaults
.iremotingtypeinfo_class
);
6201 g_assert (can_cast_to
);
6202 mono_method_desc_free (desc
);
6203 mono_mb_emit_byte (mb
, CEE_CALLVIRT
);
6204 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, can_cast_to
));
6207 pos_failed
= mono_mb_emit_branch (mb
, CEE_BRFALSE
);
6209 /* Upgrade the proxy vtable by calling: mono_upgrade_remote_class_wrapper (type, ob)*/
6210 mono_mb_emit_byte (mb
, MONO_CUSTOM_PREFIX
);
6211 mono_mb_emit_byte (mb
, CEE_MONO_LDPTR
);
6212 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, &klass
->byval_arg
));
6213 mono_mb_emit_native_call (mb
, from_handle_sig
, type_from_handle
);
6214 mono_mb_emit_ldarg (mb
, 0);
6216 mono_mb_emit_native_call (mb
, upgrade_proxy_sig
, mono_upgrade_remote_class_wrapper
);
6217 emit_thread_interrupt_checkpoint (mb
);
6219 mono_mb_emit_ldarg (mb
, 0);
6220 pos_end
= mono_mb_emit_branch (mb
, CEE_BR
);
6224 mono_mb_patch_addr (mb
, pos_failed
, mb
->pos
- (pos_failed
+ 4));
6225 mono_mb_emit_byte (mb
, CEE_LDNULL
);
6229 mono_mb_patch_addr (mb
, pos_end
, mb
->pos
- (pos_end
+ 4));
6230 mono_mb_emit_byte (mb
, CEE_RET
);
6232 res
= mono_mb_create_and_cache (proxy_isinst_hash
, klass
, mb
, isint_sig
, isint_sig
->param_count
+ 16);
6239 mono_upgrade_remote_class_wrapper (MonoReflectionType
*rtype
, MonoTransparentProxy
*tproxy
)
6242 MonoDomain
*domain
= ((MonoObject
*)tproxy
)->vtable
->domain
;
6243 klass
= mono_class_from_mono_type (rtype
->type
);
6244 mono_upgrade_remote_class (domain
, tproxy
->remote_class
, klass
);
6245 ((MonoObject
*)tproxy
)->vtable
= mono_remote_class_vtable (domain
, tproxy
->remote_class
, tproxy
->rp
);
6249 * mono_marshal_get_struct_to_ptr:
6252 * generates IL code for StructureToPtr (object structure, IntPtr ptr, bool fDeleteOld)
6255 mono_marshal_get_struct_to_ptr (MonoClass
*klass
)
6257 MonoMethodBuilder
*mb
;
6258 static MonoMethod
*stoptr
= NULL
;
6261 g_assert (klass
!= NULL
);
6263 mono_marshal_load_type_info (klass
);
6265 if (klass
->marshal_info
->str_to_ptr
)
6266 return klass
->marshal_info
->str_to_ptr
;
6269 stoptr
= mono_class_get_method_from_name (mono_defaults
.marshal_class
, "StructureToPtr", 3);
6272 mb
= mono_mb_new (klass
, stoptr
->name
, MONO_WRAPPER_UNKNOWN
);
6274 if (klass
->blittable
) {
6275 mono_mb_emit_byte (mb
, CEE_LDARG_1
);
6276 mono_mb_emit_byte (mb
, CEE_LDARG_0
);
6277 mono_mb_emit_ldflda (mb
, sizeof (MonoObject
));
6278 mono_mb_emit_icon (mb
, mono_class_value_size (klass
, NULL
));
6279 mono_mb_emit_byte (mb
, CEE_PREFIX1
);
6280 mono_mb_emit_byte (mb
, CEE_CPBLK
);
6283 /* allocate local 0 (pointer) src_ptr */
6284 mono_mb_add_local (mb
, &mono_defaults
.int_class
->byval_arg
);
6285 /* allocate local 1 (pointer) dst_ptr */
6286 mono_mb_add_local (mb
, &mono_defaults
.int_class
->byval_arg
);
6287 /* allocate local 2 (boolean) delete_old */
6288 mono_mb_add_local (mb
, &mono_defaults
.boolean_class
->byval_arg
);
6289 mono_mb_emit_byte (mb
, CEE_LDARG_2
);
6290 mono_mb_emit_byte (mb
, CEE_STLOC_2
);
6292 /* initialize src_ptr to point to the start of object data */
6293 mono_mb_emit_byte (mb
, CEE_LDARG_0
);
6294 mono_mb_emit_ldflda (mb
, sizeof (MonoObject
));
6295 mono_mb_emit_byte (mb
, CEE_STLOC_0
);
6297 /* initialize dst_ptr */
6298 mono_mb_emit_byte (mb
, CEE_LDARG_1
);
6299 mono_mb_emit_byte (mb
, CEE_STLOC_1
);
6301 emit_struct_conv (mb
, klass
, FALSE
);
6304 mono_mb_emit_byte (mb
, CEE_RET
);
6306 res
= mono_mb_create_method (mb
, stoptr
->signature
, 0);
6309 klass
->marshal_info
->str_to_ptr
= res
;
6314 * mono_marshal_get_ptr_to_struct:
6317 * generates IL code for PtrToStructure (IntPtr src, object structure)
6320 mono_marshal_get_ptr_to_struct (MonoClass
*klass
)
6322 MonoMethodBuilder
*mb
;
6323 static MonoMethod
*ptostr
= NULL
;
6326 g_assert (klass
!= NULL
);
6328 mono_marshal_load_type_info (klass
);
6330 if (klass
->marshal_info
->ptr_to_str
)
6331 return klass
->marshal_info
->ptr_to_str
;
6334 ptostr
= mono_class_get_method_from_name (mono_defaults
.marshal_class
, "PtrToStructure", 2);
6337 mb
= mono_mb_new (klass
, ptostr
->name
, MONO_WRAPPER_UNKNOWN
);
6339 if (((klass
->flags
& TYPE_ATTRIBUTE_LAYOUT_MASK
) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT
) || klass
->blittable
) {
6340 mono_mb_emit_byte (mb
, CEE_LDARG_1
);
6341 mono_mb_emit_ldflda (mb
, sizeof (MonoObject
));
6342 mono_mb_emit_byte (mb
, CEE_LDARG_0
);
6343 mono_mb_emit_icon (mb
, mono_class_value_size (klass
, NULL
));
6344 mono_mb_emit_byte (mb
, CEE_PREFIX1
);
6345 mono_mb_emit_byte (mb
, CEE_CPBLK
);
6348 /* allocate local 0 (pointer) src_ptr */
6349 mono_mb_add_local (mb
, &mono_defaults
.int_class
->byval_arg
);
6350 /* allocate local 1 (pointer) dst_ptr */
6351 mono_mb_add_local (mb
, &mono_defaults
.int_class
->byval_arg
);
6353 /* initialize src_ptr to point to the start of object data */
6354 mono_mb_emit_byte (mb
, CEE_LDARG_0
);
6355 mono_mb_emit_byte (mb
, CEE_STLOC_0
);
6357 /* initialize dst_ptr */
6358 mono_mb_emit_byte (mb
, CEE_LDARG_1
);
6359 mono_mb_emit_ldflda (mb
, sizeof (MonoObject
));
6360 mono_mb_emit_byte (mb
, CEE_STLOC_1
);
6362 emit_struct_conv (mb
, klass
, TRUE
);
6365 mono_mb_emit_byte (mb
, CEE_RET
);
6367 res
= mono_mb_create_method (mb
, ptostr
->signature
, 0);
6370 klass
->marshal_info
->ptr_to_str
= res
;
6375 * generates IL code for the synchronized wrapper: the generated method
6376 * calls METHOD while locking 'this' or the parent type.
6379 mono_marshal_get_synchronized_wrapper (MonoMethod
*method
)
6381 static MonoMethodSignature
*from_handle_sig
= NULL
;
6382 static MonoMethod
*enter_method
, *exit_method
;
6383 MonoMethodSignature
*sig
;
6384 MonoExceptionClause
*clause
;
6385 MonoMethodHeader
*header
;
6386 MonoMethodBuilder
*mb
;
6389 int i
, pos
, this_local
, ret_local
= 0;
6393 if (method
->wrapper_type
== MONO_WRAPPER_SYNCHRONIZED
)
6396 cache
= method
->klass
->image
->synchronized_cache
;
6397 if ((res
= mono_marshal_find_in_cache (cache
, method
)))
6400 sig
= signature_no_pinvoke (method
->signature
);
6402 mb
= mono_mb_new (method
->klass
, method
->name
, MONO_WRAPPER_SYNCHRONIZED
);
6405 if (!MONO_TYPE_IS_VOID (sig
->ret
))
6406 ret_local
= mono_mb_add_local (mb
, sig
->ret
);
6409 this_local
= mono_mb_add_local (mb
, &mono_defaults
.object_class
->byval_arg
);
6411 clause
= g_new0 (MonoExceptionClause
, 1);
6412 clause
->flags
= MONO_EXCEPTION_CLAUSE_FINALLY
;
6414 if (!enter_method
) {
6415 MonoMethodDesc
*desc
;
6417 desc
= mono_method_desc_new ("Monitor:Enter", FALSE
);
6418 enter_method
= mono_method_desc_search_in_class (desc
, mono_defaults
.monitor_class
);
6419 g_assert (enter_method
);
6420 mono_method_desc_free (desc
);
6421 desc
= mono_method_desc_new ("Monitor:Exit", FALSE
);
6422 exit_method
= mono_method_desc_search_in_class (desc
, mono_defaults
.monitor_class
);
6423 g_assert (exit_method
);
6424 mono_method_desc_free (desc
);
6427 * GetTypeFromHandle isn't called as a managed method because it has
6428 * a funky calling sequence, e.g. ldtoken+GetTypeFromHandle gets
6429 * transformed into something else by the JIT.
6431 from_handle_sig
= mono_metadata_signature_alloc (mono_defaults
.corlib
, 1);
6432 from_handle_sig
->params
[0] = &mono_defaults
.object_class
->byval_arg
;
6433 from_handle_sig
->ret
= &mono_defaults
.object_class
->byval_arg
;
6436 /* Push this or the type object */
6437 if (method
->flags
& METHOD_ATTRIBUTE_STATIC
) {
6438 mono_mb_emit_byte (mb
, MONO_CUSTOM_PREFIX
);
6439 mono_mb_emit_byte (mb
, CEE_MONO_LDPTR
);
6440 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, &method
->klass
->byval_arg
));
6441 mono_mb_emit_native_call (mb
, from_handle_sig
, type_from_handle
);
6444 mono_mb_emit_ldarg (mb
, 0);
6445 mono_mb_emit_stloc (mb
, this_local
);
6447 /* Call Monitor::Enter() */
6448 mono_mb_emit_ldloc (mb
, this_local
);
6449 mono_mb_emit_managed_call (mb
, enter_method
, NULL
);
6451 clause
->try_offset
= mb
->pos
;
6453 /* Call the method */
6455 mono_mb_emit_ldarg (mb
, 0);
6456 for (i
= 0; i
< sig
->param_count
; i
++)
6457 mono_mb_emit_ldarg (mb
, i
+ (sig
->hasthis
== TRUE
));
6459 /* this is needed to avoid recursion */
6460 mono_mb_emit_byte (mb
, CEE_PREFIX1
);
6461 mono_mb_emit_byte (mb
, CEE_LDFTN
);
6462 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, method
));
6463 mono_mb_emit_calli (mb
, method
->signature
);
6465 if (!MONO_TYPE_IS_VOID (sig
->ret
))
6466 mono_mb_emit_stloc (mb
, ret_local
);
6468 mono_mb_emit_byte (mb
, CEE_LEAVE
);
6470 mono_mb_emit_i4 (mb
, 0);
6472 clause
->try_len
= mb
->pos
- clause
->try_offset
;
6473 clause
->handler_offset
= mb
->pos
;
6475 /* Call Monitor::Exit() */
6476 mono_mb_emit_ldloc (mb
, this_local
);
6477 /* mono_mb_emit_native_call (mb, exit_sig, mono_monitor_exit); */
6478 mono_mb_emit_managed_call (mb
, exit_method
, NULL
);
6479 mono_mb_emit_byte (mb
, CEE_ENDFINALLY
);
6481 clause
->handler_len
= mb
->pos
- clause
->handler_offset
;
6483 mono_mb_patch_addr (mb
, pos
, mb
->pos
- (pos
+ 4));
6484 if (!MONO_TYPE_IS_VOID (sig
->ret
))
6485 mono_mb_emit_ldloc (mb
, ret_local
);
6486 mono_mb_emit_byte (mb
, CEE_RET
);
6488 res
= mono_mb_create_and_cache (cache
, method
,
6489 mb
, sig
, sig
->param_count
+ 16);
6492 header
= ((MonoMethodNormal
*)res
)->header
;
6493 header
->num_clauses
= 1;
6494 header
->clauses
= clause
;
6501 * the returned method calls 'method' unboxing the this argument
6504 mono_marshal_get_unbox_wrapper (MonoMethod
*method
)
6506 MonoMethodSignature
*sig
= method
->signature
;
6508 MonoMethodBuilder
*mb
;
6512 cache
= method
->klass
->image
->unbox_wrapper_cache
;
6513 if ((res
= mono_marshal_find_in_cache (cache
, method
)))
6516 mb
= mono_mb_new (method
->klass
, method
->name
, MONO_WRAPPER_UNBOX
);
6518 g_assert (sig
->hasthis
);
6520 mono_mb_emit_ldarg (mb
, 0);
6521 mono_mb_emit_icon (mb
, sizeof (MonoObject
));
6522 mono_mb_emit_byte (mb
, CEE_ADD
);
6523 for (i
= 0; i
< sig
->param_count
; ++i
)
6524 mono_mb_emit_ldarg (mb
, i
+ 1);
6525 mono_mb_emit_managed_call (mb
, method
, NULL
);
6526 mono_mb_emit_byte (mb
, CEE_RET
);
6528 res
= mono_mb_create_and_cache (cache
, method
,
6529 mb
, sig
, sig
->param_count
+ 16);
6532 /* printf ("CODE FOR %s: \n%s.\n", mono_method_full_name (res, TRUE), mono_disasm_code (0, res, ((MonoMethodNormal*)res)->header->code, ((MonoMethodNormal*)res)->header->code + ((MonoMethodNormal*)res)->header->code_size)); */
6538 mono_marshal_get_stelemref ()
6540 static MonoMethod
* ret
= NULL
;
6541 MonoMethodSignature
*sig
;
6542 MonoMethodBuilder
*mb
;
6544 guint32 b1
, b2
, b3
, b4
;
6547 int array_slot_addr
;
6552 mb
= mono_mb_new (mono_defaults
.object_class
, "stelemref", MONO_WRAPPER_STELEMREF
);
6555 sig
= mono_metadata_signature_alloc (mono_defaults
.corlib
, 3);
6557 /* void stelemref (void* array, int idx, void* value) */
6558 sig
->ret
= &mono_defaults
.void_class
->byval_arg
;
6559 sig
->params
[0] = &mono_defaults
.object_class
->byval_arg
;
6560 sig
->params
[1] = &mono_defaults
.int_class
->byval_arg
; /* this is a natural sized int */
6561 sig
->params
[2] = &mono_defaults
.object_class
->byval_arg
;
6563 aklass
= mono_mb_add_local (mb
, &mono_defaults
.int_class
->byval_arg
);
6564 vklass
= mono_mb_add_local (mb
, &mono_defaults
.int_class
->byval_arg
);
6565 array_slot_addr
= mono_mb_add_local (mb
, &mono_defaults
.object_class
->this_arg
);
6569 <ldelema (bound check)>
6573 aklass = array->vtable->klass->element_class;
6574 vklass = value->vtable->klass;
6576 if (vklass->idepth < aklass->idepth)
6579 if (vklass->supertypes [aklass->idepth - 1] != aklass)
6583 *array_slot_addr = value;
6587 if (mono_object_isinst (value, aklass))
6590 throw new ArrayTypeMismatchException ();
6593 /* ldelema (implicit bound check) */
6594 mono_mb_emit_ldarg (mb
, 0);
6595 mono_mb_emit_ldarg (mb
, 1);
6596 mono_mb_emit_byte (mb
, CEE_LDELEMA
);
6597 mono_mb_emit_i4 (mb
, mono_mb_add_data (mb
, mono_defaults
.object_class
));
6598 mono_mb_emit_stloc (mb
, array_slot_addr
);
6600 /* if (!value) goto do_store */
6601 mono_mb_emit_ldarg (mb
, 2);
6602 b1
= mono_mb_emit_branch (mb
, CEE_BRFALSE
);
6604 /* aklass = array->vtable->klass->element_class */
6605 mono_mb_emit_ldarg (mb
, 0);
6606 mono_mb_emit_ldflda (mb
, G_STRUCT_OFFSET (MonoObject
, vtable
));
6607 mono_mb_emit_byte (mb
, CEE_LDIND_I
);
6608 mono_mb_emit_ldflda (mb
, G_STRUCT_OFFSET (MonoVTable
, klass
));
6609 mono_mb_emit_byte (mb
, CEE_LDIND_I
);
6610 mono_mb_emit_ldflda (mb
, G_STRUCT_OFFSET (MonoClass
, element_class
));
6611 mono_mb_emit_byte (mb
, CEE_LDIND_I
);
6612 mono_mb_emit_stloc (mb
, aklass
);
6614 /* vklass = value->vtable->klass */
6615 mono_mb_emit_ldarg (mb
, 2);
6616 mono_mb_emit_ldflda (mb
, G_STRUCT_OFFSET (MonoObject
, vtable
));
6617 mono_mb_emit_byte (mb
, CEE_LDIND_I
);
6618 mono_mb_emit_ldflda (mb
, G_STRUCT_OFFSET (MonoVTable
, klass
));
6619 mono_mb_emit_byte (mb
, CEE_LDIND_I
);
6620 mono_mb_emit_stloc (mb
, vklass
);
6622 /* if (vklass->idepth < aklass->idepth) goto failue */
6623 mono_mb_emit_ldloc (mb
, vklass
);
6624 mono_mb_emit_ldflda (mb
, G_STRUCT_OFFSET (MonoClass
, idepth
));
6625 mono_mb_emit_byte (mb
, CEE_LDIND_U2
);
6627 mono_mb_emit_ldloc (mb
, aklass
);
6628 mono_mb_emit_ldflda (mb
, G_STRUCT_OFFSET (MonoClass
, idepth
));
6629 mono_mb_emit_byte (mb
, CEE_LDIND_U2
);
6631 b2
= mono_mb_emit_branch (mb
, CEE_BLT_UN
);
6633 /* if (vklass->supertypes [aklass->idepth - 1] != aklass) goto failure */
6634 mono_mb_emit_ldloc (mb
, vklass
);
6635 mono_mb_emit_ldflda (mb
, G_STRUCT_OFFSET (MonoClass
, supertypes
));
6636 mono_mb_emit_byte (mb
, CEE_LDIND_I
);
6638 mono_mb_emit_ldloc (mb
, aklass
);
6639 mono_mb_emit_ldflda (mb
, G_STRUCT_OFFSET (MonoClass
, idepth
));
6640 mono_mb_emit_byte (mb
, CEE_LDIND_U2
);
6641 mono_mb_emit_icon (mb
, 1);
6642 mono_mb_emit_byte (mb
, CEE_SUB
);
6643 mono_mb_emit_icon (mb
, sizeof (void*));
6644 mono_mb_emit_byte (mb
, CEE_MUL
);
6645 mono_mb_emit_byte (mb
, CEE_ADD
);
6646 mono_mb_emit_byte (mb
, CEE_LDIND_I
);
6648 mono_mb_emit_ldloc (mb
, aklass
);
6650 b3
= mono_mb_emit_branch (mb
, CEE_BNE_UN
);
6654 mono_mb_patch_addr (mb
, b1
, mb
->pos
- (b1
+ 4));
6655 mono_mb_emit_ldloc (mb
, array_slot_addr
);
6656 mono_mb_emit_ldarg (mb
, 2);
6657 mono_mb_emit_byte (mb
, CEE_STIND_REF
);
6659 mono_mb_emit_byte (mb
, CEE_RET
);
6662 mono_mb_patch_addr (mb
, b2
, mb
->pos
- (b2
+ 4));
6663 mono_mb_patch_addr (mb
, b3
, mb
->pos
- (b3
+ 4));
6665 mono_mb_emit_ldarg (mb
, 2);
6666 mono_mb_emit_ldloc (mb
, aklass
);
6667 mono_mb_emit_icall (mb
, mono_object_isinst
);
6669 b4
= mono_mb_emit_branch (mb
, CEE_BRTRUE
);
6670 mono_mb_patch_addr (mb
, b4
, copy_pos
- (b4
+ 4));
6671 mono_mb_emit_exception (mb
, "ArrayTypeMismatchException", NULL
);
6673 mono_mb_emit_byte (mb
, CEE_RET
);
6674 ret
= mono_mb_create_method (mb
, sig
, 4);
6680 mono_marshal_alloc (gulong size
)
6684 #ifdef PLATFORM_WIN32
6685 res
= CoTaskMemAlloc (size
);
6687 res
= g_try_malloc ((gulong
)size
);
6689 mono_gc_out_of_memory ((gulong
)size
);
6695 mono_marshal_free (gpointer ptr
)
6697 #ifdef PLATFORM_WIN32
6698 CoTaskMemFree (ptr
);
6705 mono_marshal_free_array (gpointer
*ptr
, int size
)
6712 for (i
= 0; i
< size
; i
++)
6718 mono_marshal_realloc (gpointer ptr
, gpointer size
)
6720 MONO_ARCH_SAVE_REGS
;
6722 return g_try_realloc (ptr
, (gulong
)size
);
6726 mono_marshal_string_to_utf16 (MonoString
*s
)
6728 return s
? mono_string_chars (s
) : NULL
;
6732 * mono_marshal_set_last_error:
6734 * This function is invoked to set the last error value from a P/Invoke call
6735 * which has SetLastError set.
6738 mono_marshal_set_last_error (void)
6741 TlsSetValue (last_error_tls_id
, (gpointer
)GetLastError ());
6743 TlsSetValue (last_error_tls_id
, (gpointer
)errno
);
6748 ves_icall_System_Runtime_InteropServices_Marshal_copy_to_unmanaged (MonoArray
*src
, gint32 start_index
,
6749 gpointer dest
, gint32 length
)
6754 MONO_ARCH_SAVE_REGS
;
6756 MONO_CHECK_ARG_NULL (src
);
6757 MONO_CHECK_ARG_NULL (dest
);
6759 g_assert (src
->obj
.vtable
->klass
->rank
== 1);
6760 g_assert (start_index
>= 0);
6761 g_assert (length
>= 0);
6762 g_assert (start_index
+ length
<= mono_array_length (src
));
6764 element_size
= mono_array_element_size (src
->obj
.vtable
->klass
);
6766 source_addr
= mono_array_addr_with_size (src
, element_size
, start_index
);
6768 memcpy (dest
, source_addr
, length
* element_size
);
6772 ves_icall_System_Runtime_InteropServices_Marshal_copy_from_unmanaged (gpointer src
, gint32 start_index
,
6773 MonoArray
*dest
, gint32 length
)
6778 MONO_ARCH_SAVE_REGS
;
6780 MONO_CHECK_ARG_NULL (src
);
6781 MONO_CHECK_ARG_NULL (dest
);
6783 g_assert (dest
->obj
.vtable
->klass
->rank
== 1);
6784 g_assert (start_index
>= 0);
6785 g_assert (length
>= 0);
6786 g_assert (start_index
+ length
<= mono_array_length (dest
));
6788 element_size
= mono_array_element_size (dest
->obj
.vtable
->klass
);
6790 dest_addr
= mono_array_addr_with_size (dest
, element_size
, start_index
);
6792 memcpy (dest_addr
, src
, length
* element_size
);
6795 #if NO_UNALIGNED_ACCESS
6796 #define RETURN_UNALIGNED(type, addr) \
6799 memcpy(&val, p + offset, sizeof(val)); \
6802 #define WRITE_UNALIGNED(type, addr, val) \
6803 memcpy(addr, &val, sizeof(type))
6805 #define RETURN_UNALIGNED(type, addr) \
6806 return *(type*)(p + offset);
6807 #define WRITE_UNALIGNED(type, addr, val) \
6808 (*(type *)(addr) = (val))
6812 ves_icall_System_Runtime_InteropServices_Marshal_ReadIntPtr (gpointer ptr
, gint32 offset
)
6816 MONO_ARCH_SAVE_REGS
;
6818 RETURN_UNALIGNED(gpointer
, p
+ offset
);
6822 ves_icall_System_Runtime_InteropServices_Marshal_ReadByte (gpointer ptr
, gint32 offset
)
6826 MONO_ARCH_SAVE_REGS
;
6828 return *(unsigned char*)(p
+ offset
);
6832 ves_icall_System_Runtime_InteropServices_Marshal_ReadInt16 (gpointer ptr
, gint32 offset
)
6836 MONO_ARCH_SAVE_REGS
;
6838 RETURN_UNALIGNED(gint16
, p
+ offset
);
6842 ves_icall_System_Runtime_InteropServices_Marshal_ReadInt32 (gpointer ptr
, gint32 offset
)
6846 MONO_ARCH_SAVE_REGS
;
6848 RETURN_UNALIGNED(gint32
, p
+ offset
);
6852 ves_icall_System_Runtime_InteropServices_Marshal_ReadInt64 (gpointer ptr
, gint32 offset
)
6856 MONO_ARCH_SAVE_REGS
;
6858 RETURN_UNALIGNED(gint64
, p
+ offset
);
6862 ves_icall_System_Runtime_InteropServices_Marshal_WriteByte (gpointer ptr
, gint32 offset
, unsigned char val
)
6866 MONO_ARCH_SAVE_REGS
;
6868 *(unsigned char*)(p
+ offset
) = val
;
6872 ves_icall_System_Runtime_InteropServices_Marshal_WriteIntPtr (gpointer ptr
, gint32 offset
, gpointer val
)
6876 MONO_ARCH_SAVE_REGS
;
6878 WRITE_UNALIGNED(gpointer
, p
+ offset
, val
);
6882 ves_icall_System_Runtime_InteropServices_Marshal_WriteInt16 (gpointer ptr
, gint32 offset
, gint16 val
)
6886 MONO_ARCH_SAVE_REGS
;
6888 WRITE_UNALIGNED(gint16
, p
+ offset
, val
);
6892 ves_icall_System_Runtime_InteropServices_Marshal_WriteInt32 (gpointer ptr
, gint32 offset
, gint32 val
)
6896 MONO_ARCH_SAVE_REGS
;
6898 WRITE_UNALIGNED(gint32
, p
+ offset
, val
);
6902 ves_icall_System_Runtime_InteropServices_Marshal_WriteInt64 (gpointer ptr
, gint32 offset
, gint64 val
)
6906 MONO_ARCH_SAVE_REGS
;
6908 WRITE_UNALIGNED(gint64
, p
+ offset
, val
);
6912 ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringAnsi (char *ptr
)
6914 MONO_ARCH_SAVE_REGS
;
6919 return mono_string_new (mono_domain_get (), ptr
);
6923 ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringAnsi_len (char *ptr
, gint32 len
)
6925 MONO_ARCH_SAVE_REGS
;
6928 mono_raise_exception (mono_get_exception_argument_null ("ptr"));
6929 g_assert_not_reached ();
6932 return mono_string_new_len (mono_domain_get (), ptr
, len
);
6936 ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringUni (guint16
*ptr
)
6938 MonoDomain
*domain
= mono_domain_get ();
6942 MONO_ARCH_SAVE_REGS
;
6950 return mono_string_new_utf16 (domain
, ptr
, len
);
6954 ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringUni_len (guint16
*ptr
, gint32 len
)
6956 MonoDomain
*domain
= mono_domain_get ();
6958 MONO_ARCH_SAVE_REGS
;
6961 mono_raise_exception (mono_get_exception_argument_null ("ptr"));
6962 g_assert_not_reached ();
6965 return mono_string_new_utf16 (domain
, ptr
, len
);
6969 ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringBSTR (gpointer ptr
)
6971 MONO_ARCH_SAVE_REGS
;
6973 g_warning ("PtrToStringBSTR not implemented");
6974 g_assert_not_reached ();
6980 ves_icall_System_Runtime_InteropServices_Marshal_GetLastWin32Error (void)
6982 MONO_ARCH_SAVE_REGS
;
6984 return ((guint32
)TlsGetValue (last_error_tls_id
));
6988 ves_icall_System_Runtime_InteropServices_Marshal_SizeOf (MonoReflectionType
*rtype
)
6994 MONO_ARCH_SAVE_REGS
;
6996 MONO_CHECK_ARG_NULL (rtype
);
6999 klass
= mono_class_from_mono_type (type
);
7000 layout
= (klass
->flags
& TYPE_ATTRIBUTE_LAYOUT_MASK
);
7002 if (layout
== TYPE_ATTRIBUTE_AUTO_LAYOUT
) {
7006 msg
= g_strdup_printf ("Type %s cannot be marshaled as an unmanaged structure.", klass
->name
);
7007 exc
= mono_get_exception_argument ("t", msg
);
7009 mono_raise_exception (exc
);
7013 return mono_class_native_size (klass
, NULL
);
7017 ves_icall_System_Runtime_InteropServices_Marshal_StructureToPtr (MonoObject
*obj
, gpointer dst
, MonoBoolean delete_old
)
7022 MONO_ARCH_SAVE_REGS
;
7024 MONO_CHECK_ARG_NULL (obj
);
7025 MONO_CHECK_ARG_NULL (dst
);
7027 method
= mono_marshal_get_struct_to_ptr (obj
->vtable
->klass
);
7031 pa
[2] = &delete_old
;
7033 mono_runtime_invoke (method
, NULL
, pa
, NULL
);
7037 ves_icall_System_Runtime_InteropServices_Marshal_PtrToStructure (gpointer src
, MonoObject
*dst
)
7042 MONO_ARCH_SAVE_REGS
;
7044 MONO_CHECK_ARG_NULL (src
);
7045 MONO_CHECK_ARG_NULL (dst
);
7047 method
= mono_marshal_get_ptr_to_struct (dst
->vtable
->klass
);
7052 mono_runtime_invoke (method
, NULL
, pa
, NULL
);
7056 ves_icall_System_Runtime_InteropServices_Marshal_PtrToStructure_type (gpointer src
, MonoReflectionType
*type
)
7058 MonoDomain
*domain
= mono_domain_get ();
7061 MONO_ARCH_SAVE_REGS
;
7063 MONO_CHECK_ARG_NULL (src
);
7064 MONO_CHECK_ARG_NULL (type
);
7066 res
= mono_object_new (domain
, mono_class_from_mono_type (type
->type
));
7068 ves_icall_System_Runtime_InteropServices_Marshal_PtrToStructure (src
, res
);
7074 ves_icall_System_Runtime_InteropServices_Marshal_OffsetOf (MonoReflectionType
*type
, MonoString
*field_name
)
7076 MonoMarshalType
*info
;
7079 int i
, match_index
= -1;
7081 MONO_ARCH_SAVE_REGS
;
7083 MONO_CHECK_ARG_NULL (type
);
7084 MONO_CHECK_ARG_NULL (field_name
);
7086 fname
= mono_string_to_utf8 (field_name
);
7087 klass
= mono_class_from_mono_type (type
->type
);
7089 while (klass
&& match_index
== -1) {
7090 for (i
= 0; i
< klass
->field
.count
; ++i
) {
7091 if (*fname
== *klass
->fields
[i
].name
&& strcmp (fname
, klass
->fields
[i
].name
) == 0) {
7097 if (match_index
== -1)
7098 klass
= klass
->parent
;
7103 if(match_index
== -1) {
7107 /* Get back original class instance */
7108 klass
= mono_class_from_mono_type (type
->type
);
7110 tmp
= g_strdup_printf ("Field passed in is not a marshaled member of the type %s", klass
->name
);
7111 exc
= mono_get_exception_argument ("fieldName", tmp
);
7114 mono_raise_exception ((MonoException
*)exc
);
7117 info
= mono_marshal_load_type_info (klass
);
7118 return info
->fields
[match_index
].offset
;
7122 ves_icall_System_Runtime_InteropServices_Marshal_StringToHGlobalAnsi (MonoString
*string
)
7124 MONO_ARCH_SAVE_REGS
;
7126 return mono_string_to_utf8 (string
);
7130 ves_icall_System_Runtime_InteropServices_Marshal_StringToHGlobalUni (MonoString
*string
)
7132 MONO_ARCH_SAVE_REGS
;
7137 return g_memdup (mono_string_chars (string
), mono_string_length (string
)*2);
7141 mono_struct_delete_old (MonoClass
*klass
, char *ptr
)
7143 MonoMarshalType
*info
;
7146 info
= mono_marshal_load_type_info (klass
);
7148 for (i
= 0; i
< info
->num_fields
; i
++) {
7149 MonoMarshalNative ntype
;
7150 MonoMarshalConv conv
;
7151 MonoType
*ftype
= info
->fields
[i
].field
->type
;
7154 if (ftype
->attrs
& FIELD_ATTRIBUTE_STATIC
)
7157 ntype
= mono_type_to_unmanaged (ftype
, info
->fields
[i
].mspec
, TRUE
,
7158 klass
->unicode
, &conv
);
7160 cpos
= ptr
+ info
->fields
[i
].offset
;
7163 case MONO_MARSHAL_CONV_NONE
:
7164 if (MONO_TYPE_ISSTRUCT (ftype
)) {
7165 mono_struct_delete_old (ftype
->data
.klass
, cpos
);
7169 case MONO_MARSHAL_CONV_STR_LPWSTR
:
7170 /* We assume this field points inside a MonoString */
7172 case MONO_MARSHAL_CONV_STR_LPSTR
:
7173 case MONO_MARSHAL_CONV_STR_LPTSTR
:
7174 case MONO_MARSHAL_CONV_STR_BSTR
:
7175 case MONO_MARSHAL_CONV_STR_ANSIBSTR
:
7176 case MONO_MARSHAL_CONV_STR_TBSTR
:
7177 mono_marshal_free (*(gpointer
*)cpos
);
7186 ves_icall_System_Runtime_InteropServices_Marshal_DestroyStructure (gpointer src
, MonoReflectionType
*type
)
7190 MONO_ARCH_SAVE_REGS
;
7192 MONO_CHECK_ARG_NULL (src
);
7193 MONO_CHECK_ARG_NULL (type
);
7195 klass
= mono_class_from_mono_type (type
->type
);
7197 mono_struct_delete_old (klass
, (char *)src
);
7201 /* FIXME: on win32 we should probably use GlobalAlloc(). */
7203 ves_icall_System_Runtime_InteropServices_Marshal_AllocHGlobal (int size
)
7207 MONO_ARCH_SAVE_REGS
;
7209 if ((gulong
)size
== 0)
7210 /* This returns a valid pointer for size 0 on MS.NET */
7213 res
= g_try_malloc ((gulong
)size
);
7215 mono_gc_out_of_memory ((gulong
)size
);
7221 ves_icall_System_Runtime_InteropServices_Marshal_FreeHGlobal (void *ptr
)
7223 MONO_ARCH_SAVE_REGS
;
7229 ves_icall_System_Runtime_InteropServices_Marshal_AllocCoTaskMem (int size
)
7231 MONO_ARCH_SAVE_REGS
;
7233 #ifdef PLATFORM_WIN32
7234 return CoTaskMemAlloc (size
);
7236 return g_try_malloc ((gulong
)size
);
7241 ves_icall_System_Runtime_InteropServices_Marshal_FreeCoTaskMem (void *ptr
)
7243 MONO_ARCH_SAVE_REGS
;
7245 #ifdef PLATFORM_WIN32
7246 CoTaskMemFree (ptr
);
7253 ves_icall_System_Runtime_InteropServices_Marshal_UnsafeAddrOfPinnedArrayElement (MonoArray
*arrayobj
, int index
)
7255 return mono_array_addr_with_size (arrayobj
, mono_array_element_size (arrayobj
->obj
.vtable
->klass
), index
);
7259 ves_icall_System_Runtime_InteropServices_Marshal_GetDelegateForFunctionPointerInternal (void *ftn
, MonoReflectionType
*type
)
7261 return mono_ftnptr_to_delegate (mono_type_get_class (type
->type
), ftn
);
7265 mono_marshal_load_type_info (MonoClass
* klass
)
7267 int i
, j
, count
= 0, native_size
= 0, min_align
= 1;
7268 MonoMarshalType
*info
;
7271 g_assert (klass
!= NULL
);
7273 if (klass
->marshal_info
)
7274 return klass
->marshal_info
;
7277 mono_class_init (klass
);
7279 for (i
= 0; i
< klass
->field
.count
; ++i
) {
7280 if (klass
->fields
[i
].type
->attrs
& FIELD_ATTRIBUTE_STATIC
)
7282 if (mono_field_is_deleted (&klass
->fields
[i
]))
7287 layout
= klass
->flags
& TYPE_ATTRIBUTE_LAYOUT_MASK
;
7289 klass
->marshal_info
= info
= g_malloc0 (sizeof (MonoMarshalType
) + sizeof (MonoMarshalField
) * count
);
7290 info
->num_fields
= count
;
7292 /* Try to find a size for this type in metadata */
7293 mono_metadata_packing_from_typedef (klass
->image
, klass
->type_token
, NULL
, &native_size
);
7295 if (klass
->parent
) {
7296 int parent_size
= mono_class_native_size (klass
->parent
, NULL
);
7298 /* Add parent size to real size */
7299 native_size
+= parent_size
;
7300 info
->native_size
= parent_size
;
7303 for (j
= i
= 0; i
< klass
->field
.count
; ++i
) {
7306 if (klass
->fields
[i
].type
->attrs
& FIELD_ATTRIBUTE_STATIC
)
7309 if (mono_field_is_deleted (&klass
->fields
[i
]))
7311 if (klass
->fields
[i
].type
->attrs
& FIELD_ATTRIBUTE_HAS_FIELD_MARSHAL
)
7312 mono_metadata_field_info (klass
->image
, klass
->field
.first
+ i
,
7313 NULL
, NULL
, &info
->fields
[j
].mspec
);
7315 info
->fields
[j
].field
= &klass
->fields
[i
];
7317 if ((klass
->field
.count
== 1) && (klass
->instance_size
== sizeof (MonoObject
)) &&
7318 (strcmp (klass
->fields
[i
].name
, "$PRIVATE$") == 0)) {
7319 /* This field is a hack inserted by MCS to empty structures */
7324 case TYPE_ATTRIBUTE_AUTO_LAYOUT
:
7325 case TYPE_ATTRIBUTE_SEQUENTIAL_LAYOUT
:
7326 size
= mono_marshal_type_size (klass
->fields
[i
].type
, info
->fields
[j
].mspec
,
7327 &align
, TRUE
, klass
->unicode
);
7328 align
= klass
->packing_size
? MIN (klass
->packing_size
, align
): align
;
7329 min_align
= MAX (align
, min_align
);
7330 info
->fields
[j
].offset
= info
->native_size
;
7331 info
->fields
[j
].offset
+= align
- 1;
7332 info
->fields
[j
].offset
&= ~(align
- 1);
7333 info
->native_size
= info
->fields
[j
].offset
+ size
;
7335 case TYPE_ATTRIBUTE_EXPLICIT_LAYOUT
:
7336 size
= mono_marshal_type_size (klass
->fields
[i
].type
, info
->fields
[j
].mspec
,
7337 &align
, TRUE
, klass
->unicode
);
7338 align
= klass
->packing_size
? MIN (klass
->packing_size
, align
): align
;
7339 min_align
= MAX (align
, min_align
);
7340 info
->fields
[j
].offset
= klass
->fields
[i
].offset
- sizeof (MonoObject
);
7341 info
->native_size
= MAX (info
->native_size
, info
->fields
[j
].offset
+ size
);
7347 if(layout
!= TYPE_ATTRIBUTE_AUTO_LAYOUT
) {
7348 info
->native_size
= MAX (native_size
, info
->native_size
);
7351 if (info
->native_size
& (min_align
- 1)) {
7352 info
->native_size
+= min_align
- 1;
7353 info
->native_size
&= ~(min_align
- 1);
7356 /* Update the class's blittable info, if the layouts don't match */
7357 if (info
->native_size
!= mono_class_value_size (klass
, NULL
))
7358 klass
->blittable
= FALSE
;
7360 /* If this is an array type, ensure that we have element info */
7361 if (klass
->element_class
) {
7362 mono_marshal_load_type_info (klass
->element_class
);
7365 return klass
->marshal_info
;
7369 * mono_class_native_size:
7372 * Returns: the native size of an object instance (when marshaled
7373 * to unmanaged code)
7376 mono_class_native_size (MonoClass
*klass
, guint32
*align
)
7378 if (!klass
->marshal_info
)
7379 mono_marshal_load_type_info (klass
);
7382 *align
= klass
->min_align
;
7384 return klass
->marshal_info
->native_size
;
7388 * mono_type_native_stack_size:
7389 * @t: the type to return the size it uses on the stack
7391 * Returns: the number of bytes required to hold an instance of this
7392 * type on the native stack
7395 mono_type_native_stack_size (MonoType
*t
, gint
*align
)
7399 g_assert (t
!= NULL
);
7410 case MONO_TYPE_BOOLEAN
:
7411 case MONO_TYPE_CHAR
:
7420 case MONO_TYPE_STRING
:
7421 case MONO_TYPE_OBJECT
:
7422 case MONO_TYPE_CLASS
:
7423 case MONO_TYPE_SZARRAY
:
7425 case MONO_TYPE_FNPTR
:
7426 case MONO_TYPE_ARRAY
:
7427 case MONO_TYPE_TYPEDBYREF
:
7438 case MONO_TYPE_VALUETYPE
: {
7441 if (t
->data
.klass
->enumtype
)
7442 return mono_type_native_stack_size (t
->data
.klass
->enum_basetype
, align
);
7444 size
= mono_class_native_size (t
->data
.klass
, align
);
7445 *align
= *align
+ 3;
7455 g_error ("type 0x%02x unknown", t
->type
);
7460 /* __alignof__ returns the preferred alignment of values not the actual alignment used by
7461 the compiler so is wrong e.g. for Linux where doubles are aligned on a 4 byte boundary
7462 but __alignof__ returns 8 - using G_STRUCT_OFFSET works better */
7463 #define ALIGNMENT(type) G_STRUCT_OFFSET(struct { char c; type x; }, x)
7466 mono_marshal_type_size (MonoType
*type
, MonoMarshalSpec
*mspec
, gint32
*align
,
7467 gboolean as_field
, gboolean unicode
)
7469 MonoMarshalNative native_type
= mono_type_to_unmanaged (type
, mspec
, as_field
, unicode
, NULL
);
7472 switch (native_type
) {
7473 case MONO_NATIVE_BOOLEAN
:
7476 case MONO_NATIVE_I1
:
7477 case MONO_NATIVE_U1
:
7480 case MONO_NATIVE_I2
:
7481 case MONO_NATIVE_U2
:
7482 case MONO_NATIVE_VARIANTBOOL
:
7485 case MONO_NATIVE_I4
:
7486 case MONO_NATIVE_U4
:
7487 case MONO_NATIVE_ERROR
:
7490 case MONO_NATIVE_I8
:
7491 case MONO_NATIVE_U8
:
7492 *align
= ALIGNMENT(guint64
);
7494 case MONO_NATIVE_R4
:
7497 case MONO_NATIVE_R8
:
7498 *align
= ALIGNMENT(double);
7500 case MONO_NATIVE_INT
:
7501 case MONO_NATIVE_UINT
:
7502 case MONO_NATIVE_LPSTR
:
7503 case MONO_NATIVE_LPWSTR
:
7504 case MONO_NATIVE_LPTSTR
:
7505 case MONO_NATIVE_BSTR
:
7506 case MONO_NATIVE_ANSIBSTR
:
7507 case MONO_NATIVE_TBSTR
:
7508 case MONO_NATIVE_LPARRAY
:
7509 case MONO_NATIVE_SAFEARRAY
:
7510 case MONO_NATIVE_IUNKNOWN
:
7511 case MONO_NATIVE_IDISPATCH
:
7512 case MONO_NATIVE_INTERFACE
:
7513 case MONO_NATIVE_ASANY
:
7514 case MONO_NATIVE_FUNC
:
7515 case MONO_NATIVE_LPSTRUCT
:
7516 *align
= ALIGNMENT(gpointer
);
7517 return sizeof (gpointer
);
7518 case MONO_NATIVE_STRUCT
:
7519 klass
= mono_class_from_mono_type (type
);
7520 return mono_class_native_size (klass
, align
);
7521 case MONO_NATIVE_BYVALTSTR
: {
7522 int esize
= unicode
? 2: 1;
7525 return mspec
->data
.array_data
.num_elem
* esize
;
7527 case MONO_NATIVE_BYVALARRAY
: {
7529 klass
= mono_class_from_mono_type (type
);
7530 esize
= mono_class_native_size (klass
->element_class
, align
);
7532 return mspec
->data
.array_data
.num_elem
* esize
;
7534 case MONO_NATIVE_CUSTOM
:
7535 g_assert_not_reached ();
7537 case MONO_NATIVE_CURRENCY
:
7538 case MONO_NATIVE_VBBYREFSTR
:
7540 g_error ("native type %02x not implemented", native_type
);
7543 g_assert_not_reached ();
7548 mono_marshal_asany (MonoObject
*o
, MonoMarshalNative string_encoding
)
7556 t
= &o
->vtable
->klass
->byval_arg
;
7563 case MONO_TYPE_BOOLEAN
:
7566 case MONO_TYPE_CHAR
:
7571 return mono_object_unbox (o
);
7573 case MONO_TYPE_STRING
:
7574 switch (string_encoding
) {
7575 case MONO_NATIVE_LPWSTR
:
7576 return mono_string_to_utf16 ((MonoString
*)o
);
7578 case MONO_NATIVE_LPSTR
:
7579 return mono_string_to_lpstr ((MonoString
*)o
);
7582 g_warning ("marshaling conversion %d not implemented", string_encoding
);
7583 g_assert_not_reached ();
7586 case MONO_TYPE_CLASS
:
7587 case MONO_TYPE_VALUETYPE
: {
7591 MonoBoolean delete_old
= FALSE
;
7593 klass
= t
->data
.klass
;
7595 if ((klass
->flags
& TYPE_ATTRIBUTE_LAYOUT_MASK
) == TYPE_ATTRIBUTE_AUTO_LAYOUT
)
7598 if (((klass
->flags
& TYPE_ATTRIBUTE_LAYOUT_MASK
) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT
) ||
7599 klass
->blittable
|| klass
->enumtype
)
7600 return mono_object_unbox (o
);
7602 res
= mono_marshal_alloc (mono_class_native_size (klass
, NULL
));
7604 method
= mono_marshal_get_struct_to_ptr (o
->vtable
->klass
);
7608 pa
[2] = &delete_old
;
7610 mono_runtime_invoke (method
, NULL
, pa
, NULL
);
7616 mono_raise_exception (mono_get_exception_argument ("", "No PInvoke conversion exists for value passed to Object-typed parameter."));
7622 mono_marshal_free_asany (MonoObject
*o
, gpointer ptr
, MonoMarshalNative string_encoding
)
7630 t
= &o
->vtable
->klass
->byval_arg
;
7632 case MONO_TYPE_STRING
:
7633 switch (string_encoding
) {
7634 case MONO_NATIVE_LPWSTR
:
7635 case MONO_NATIVE_LPSTR
:
7636 mono_marshal_free (ptr
);
7639 g_warning ("marshaling conversion %d not implemented", string_encoding
);
7640 g_assert_not_reached ();
7643 case MONO_TYPE_CLASS
:
7644 case MONO_TYPE_VALUETYPE
: {
7645 klass
= t
->data
.klass
;
7647 if (((klass
->flags
& TYPE_ATTRIBUTE_LAYOUT_MASK
) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT
) ||
7648 klass
->blittable
|| klass
->enumtype
)
7651 mono_struct_delete_old (klass
, ptr
);
7653 mono_marshal_free (ptr
);