mono/metadata/marshal.c

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