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  * (C) 2002 Ximian, Inc.  http://www.ximian.com
   8  *
   9  */
  10
  11 #include "config.h"
  12 #include "object.h"
  13 #include "loader.h"
  14 #include "metadata/marshal.h"
  15 #include "metadata/tabledefs.h"
  16 #include "metadata/exception.h"
  17 #include "metadata/appdomain.h"
  18 #include "mono/metadata/debug-helpers.h"
  19 #include "mono/metadata/threadpool.h"
  20 #include "mono/metadata/threads.h"
  21 #include "mono/metadata/monitor.h"
  22 #include "mono/metadata/metadata-internals.h"
  23 #include "mono/metadata/domain-internals.h"
  24 #include "mono/metadata/gc-internal.h"
  25 #include "mono/metadata/threads-types.h"
  26 #include <mono/os/gc_wrapper.h>
  27 #include <string.h>
  28 #include <errno.h>
  29
  30 /* #define DEBUG_RUNTIME_CODE */
  31
  32 #define OPDEF(a,b,c,d,e,f,g,h,i,j) \
  33         a = i,
  34
  35 typedef enum {
  36         MONO_MARSHAL_NONE,                      /* No marshalling needed */
  37         MONO_MARSHAL_COPY,                      /* Can be copied by value to the new domain */
  38         MONO_MARSHAL_COPY_OUT,          /* out parameter that needs to be copied back to the original instance */
  39         MONO_MARSHAL_SERIALIZE          /* Value needs to be serialized into the new domain */
  40 } MonoXDomainMarshalType;
  41
  42 enum {
  43 #include "mono/cil/opcode.def"
  44         LAST = 0xff
  45 };
  46 #undef OPDEF
  47
  48 struct _MonoMethodBuilder {
  49         MonoMethod *method;
  50         char *name;
  51         GList *locals_list;
  52         int locals;
  53         gboolean dynamic;
  54         guint32 code_size, pos;
  55         unsigned char *code;
  56 };
  57
  58 struct _MonoRemotingMethods {
  59         MonoMethod *invoke;
  60         MonoMethod *invoke_with_check;
  61         MonoMethod *xdomain_invoke;
  62         MonoMethod *xdomain_dispatch;
  63 };
  64
  65 typedef struct _MonoRemotingMethods MonoRemotingMethods;
  66
  67 #ifdef DEBUG_RUNTIME_CODE
  68 static char*
  69 indenter (MonoDisHelper *dh, MonoMethod *method, guint32 ip_offset)
  70 {
  71         return g_strdup (" ");
  72 }
  73
  74 static MonoDisHelper marshal_dh = {
  75         "\n",
  76         "IL_%04x: ",
  77         "IL_%04x",
  78         indenter,
  79         NULL,
  80         NULL
  81 };
  82 #endif
  83
  84 /* This mutex protects the various marshalling related caches in MonoImage */
  85 #define mono_marshal_lock() EnterCriticalSection (&marshal_mutex)
  86 #define mono_marshal_unlock() LeaveCriticalSection (&marshal_mutex)
  87 static CRITICAL_SECTION marshal_mutex;
  88
  89 /* Maps wrapper methods to the methods they wrap */
  90 static GHashTable *wrapper_hash;
  91
  92 static guint32 last_error_tls_id;
  93
  94 static void
  95 delegate_hash_table_add (MonoDelegate *d);
  96
  97 static void
  98 emit_struct_conv (MonoMethodBuilder *mb, MonoClass *klass, gboolean to_object);
  99
 100 static void
 101 mono_struct_delete_old (MonoClass *klass, char *ptr);
 102
 103 void *
 104 mono_marshal_string_to_utf16 (MonoString *s);
 105
 106 static gpointer
 107 mono_string_to_lpstr (MonoString *string_obj);
 108
 109 static MonoString *
 110 mono_string_from_bstr (gpointer bstr);
 111
 112 static void
 113 mono_free_bstr (gpointer bstr);
 114
 115 static void
 116 mono_byvalarray_to_array (MonoArray *arr, gpointer native_arr, MonoClass *eltype, guint32 elnum);
 117
 118 static void
 119 mono_array_to_byvalarray (gpointer native_arr, MonoArray *arr, MonoClass *eltype, guint32 elnum);
 120
 121 static MonoObject *
 122 mono_remoting_wrapper (MonoMethod *method, gpointer *params);
 123
 124 static MonoAsyncResult *
 125 mono_delegate_begin_invoke (MonoDelegate *delegate, gpointer *params);
 126
 127 static MonoObject *
 128 mono_delegate_end_invoke (MonoDelegate *delegate, gpointer *params);
 129
 130 static MonoObject *
 131 mono_marshal_xdomain_copy_value (MonoObject *val);
 132
 133 static void
 134 mono_marshal_xdomain_copy_out_value (MonoObject *src, MonoObject *dst);
 135
 136 static gint32
 137 mono_marshal_set_domain_by_id (gint32 id, MonoBoolean push);
 138
 139 void
 140 mono_upgrade_remote_class_wrapper (MonoReflectionType *rtype, MonoTransparentProxy *tproxy);
 141
 142 static MonoReflectionType *
 143 type_from_handle (MonoType *handle);
 144
 145 static void
 146 mono_marshal_set_last_error_windows (int error);
 147
 148 static void
 149 register_icall (gpointer func, const char *name, const char *sigstr, gboolean save)
 150 {
 151         MonoMethodSignature *sig = mono_create_icall_signature (sigstr);
 152
 153         mono_register_jit_icall (func, name, sig, save);
 154 }
 155
 156 static MonoMethodSignature*
 157 signature_dup (MonoImage *image, MonoMethodSignature *sig)
 158 {
 159         MonoMethodSignature *res;
 160         int sigsize;
 161
 162         sigsize = sizeof (MonoMethodSignature) + ((sig->param_count - MONO_ZERO_LEN_ARRAY) * sizeof (MonoType *));
 163         mono_loader_lock ();
 164         res = mono_mempool_alloc (image->mempool, sigsize);
 165         mono_loader_unlock ();
 166         memcpy (res, sig, sigsize);
 167
 168         return res;
 169 }
 170
 171 static MonoMethodSignature*
 172 signature_no_pinvoke (MonoMethod *method)
 173 {
 174         MonoMethodSignature *sig = mono_method_signature (method);
 175         if (sig->pinvoke) {
 176                 sig = signature_dup (method->klass->image, sig);
 177                 sig->pinvoke = FALSE;
 178         }
 179
 180         return sig;
 181 }
 182
 183 void
 184 mono_marshal_init (void)
 185 {
 186         static gboolean module_initialized = FALSE;
 187
 188         if (!module_initialized) {
 189                 module_initialized = TRUE;
 190                 InitializeCriticalSection (&marshal_mutex);
 191                 wrapper_hash = g_hash_table_new (mono_aligned_addr_hash, NULL);
 192                 last_error_tls_id = TlsAlloc ();
 193
 194                 register_icall (mono_marshal_string_to_utf16, "mono_marshal_string_to_utf16", "ptr obj", FALSE);
 195                 register_icall (mono_string_to_utf16, "mono_string_to_utf16", "ptr obj", FALSE);
 196                 register_icall (mono_string_from_utf16, "mono_string_from_utf16", "obj ptr", FALSE);
 197                 register_icall (mono_string_new_wrapper, "mono_string_new_wrapper", "obj ptr", FALSE);
 198                 register_icall (mono_string_to_utf8, "mono_string_to_utf8", "ptr obj", FALSE);
 199                 register_icall (mono_string_to_lpstr, "mono_string_to_lpstr", "ptr obj", FALSE);
 200                 register_icall (mono_string_to_bstr, "mono_string_to_bstr", "ptr obj", FALSE);
 201                 register_icall (mono_string_from_bstr, "mono_string_from_bstr", "obj ptr", FALSE);
 202                 register_icall (mono_free_bstr, "mono_free_bstr", "void ptr", FALSE);
 203                 register_icall (mono_string_to_ansibstr, "mono_string_to_ansibstr", "ptr object", FALSE);
 204                 register_icall (mono_string_builder_to_utf8, "mono_string_builder_to_utf8", "ptr object", FALSE);
 205                 register_icall (mono_string_builder_to_utf16, "mono_string_builder_to_utf16", "ptr object", FALSE);
 206                 register_icall (mono_array_to_savearray, "mono_array_to_savearray", "ptr object", FALSE);
 207                 register_icall (mono_array_to_lparray, "mono_array_to_lparray", "ptr object", FALSE);
 208                 register_icall (mono_byvalarray_to_array, "mono_byvalarray_to_array", "void object ptr ptr int32", FALSE);
 209                 register_icall (mono_array_to_byvalarray, "mono_array_to_byvalarray", "void ptr object ptr int32", FALSE);
 210                 register_icall (mono_delegate_to_ftnptr, "mono_delegate_to_ftnptr", "ptr object", FALSE);
 211                 register_icall (mono_ftnptr_to_delegate, "mono_ftnptr_to_delegate", "object ptr ptr", FALSE);
 212                 register_icall (mono_marshal_asany, "mono_marshal_asany", "ptr object int32 int32", FALSE);
 213                 register_icall (mono_marshal_free_asany, "mono_marshal_free_asany", "void object ptr int32 int32", FALSE);
 214                 register_icall (mono_marshal_alloc, "mono_marshal_alloc", "ptr int32", FALSE);
 215                 register_icall (mono_marshal_free, "mono_marshal_free", "void ptr", FALSE);
 216                 register_icall (mono_marshal_set_last_error, "mono_marshal_set_last_error", "void", FALSE);
 217                 register_icall (mono_marshal_set_last_error_windows, "mono_marshal_set_last_error_windows", "void int32", FALSE);
 218                 register_icall (mono_string_utf8_to_builder, "mono_string_utf8_to_builder", "void ptr ptr", FALSE);
 219                 register_icall (mono_string_utf16_to_builder, "mono_string_utf16_to_builder", "void ptr ptr", FALSE);
 220                 register_icall (mono_marshal_free_array, "mono_marshal_free_array", "void ptr int32", FALSE);
 221                 register_icall (mono_string_to_byvalstr, "mono_string_to_byvalstr", "void ptr ptr int32", FALSE);
 222                 register_icall (mono_string_to_byvalwstr, "mono_string_to_byvalwstr", "void ptr ptr int32", FALSE);
 223                 register_icall (g_free, "g_free", "void ptr", FALSE);
 224                 register_icall (mono_object_isinst, "mono_object_isinst", "object object ptr", FALSE);
 225                 register_icall (mono_struct_delete_old, "mono_struct_delete_old", "void ptr ptr", FALSE);
 226                 register_icall (mono_remoting_wrapper, "mono_remoting_wrapper", "object ptr ptr", FALSE);
 227                 register_icall (mono_delegate_begin_invoke, "mono_delegate_begin_invoke", "object object ptr", FALSE);
 228                 register_icall (mono_delegate_end_invoke, "mono_delegate_end_invoke", "object object ptr", FALSE);
 229                 register_icall (mono_marshal_xdomain_copy_value, "mono_marshal_xdomain_copy_value", "object object", FALSE);
 230                 register_icall (mono_marshal_xdomain_copy_out_value, "mono_marshal_xdomain_copy_out_value", "void object object", FALSE);
 231                 register_icall (mono_marshal_set_domain_by_id, "mono_marshal_set_domain_by_id", "int32 int32 int32", FALSE);
 232                 register_icall (mono_compile_method, "mono_compile_method", "ptr ptr", FALSE);
 233                 register_icall (mono_context_get, "mono_context_get", "object", FALSE);
 234                 register_icall (mono_context_set, "mono_context_set", "void object", FALSE);
 235                 register_icall (mono_upgrade_remote_class_wrapper, "mono_upgrade_remote_class_wrapper", "void object object", FALSE);
 236                 register_icall (type_from_handle, "type_from_handle", "object ptr", FALSE);
 237                 register_icall (mono_gc_wbarrier_generic_store, "wb_generic", "void ptr object", FALSE);
 238         }
 239 }
 240
 241 void
 242 mono_marshal_cleanup (void)
 243 {
 244         g_hash_table_destroy (wrapper_hash);
 245         TlsFree (last_error_tls_id);
 246         DeleteCriticalSection (&marshal_mutex);
 247 }
 248
 249 MonoClass *byte_array_class;
 250 static MonoMethod *method_rs_serialize, *method_rs_deserialize, *method_exc_fixexc, *method_rs_appdomain_target;
 251 static MonoMethod *method_set_context, *method_get_context;
 252 static MonoMethod *method_set_call_context, *method_needs_context_sink, *method_rs_serialize_exc;
 253
 254 static void
 255 mono_remoting_marshal_init (void)
 256 {
 257         MonoClass *klass;
 258
 259         static gboolean module_initialized = FALSE;
 260
 261         if (!module_initialized) {
 262                 klass = mono_class_from_name (mono_defaults.corlib, "System.Runtime.Remoting", "RemotingServices");
 263                 method_rs_serialize = mono_class_get_method_from_name (klass, "SerializeCallData", -1);
 264                 method_rs_deserialize = mono_class_get_method_from_name (klass, "DeserializeCallData", -1);
 265                 method_rs_serialize_exc = mono_class_get_method_from_name (klass, "SerializeExceptionData", -1);
 266
 267                 klass = mono_defaults.real_proxy_class;
 268                 method_rs_appdomain_target = mono_class_get_method_from_name (klass, "GetAppDomainTarget", -1);
 269
 270                 klass = mono_defaults.exception_class;
 271                 method_exc_fixexc = mono_class_get_method_from_name (klass, "FixRemotingException", -1);
 272
 273                 klass = mono_defaults.thread_class;
 274                 method_get_context = mono_class_get_method_from_name (klass, "get_CurrentContext", -1);
 275
 276                 klass = mono_defaults.appdomain_class;
 277                 method_set_context = mono_class_get_method_from_name (klass, "InternalSetContext", -1);
 278                 byte_array_class = mono_array_class_get (mono_defaults.byte_class, 1);
 279
 280                 klass = mono_class_from_name (mono_defaults.corlib, "System.Runtime.Remoting.Messaging", "CallContext");
 281                 method_set_call_context = mono_class_get_method_from_name (klass, "SetCurrentCallContext", -1);
 282
 283                 klass = mono_class_from_name (mono_defaults.corlib, "System.Runtime.Remoting.Contexts", "Context");
 284                 method_needs_context_sink = mono_class_get_method_from_name (klass, "get_NeedsContextSink", -1);
 285
 286                 module_initialized = TRUE;
 287         }
 288 }
 289
 290 gpointer
 291 mono_delegate_to_ftnptr (MonoDelegate *delegate)
 292 {
 293         MonoMethod *method, *wrapper;
 294         MonoClass *klass;
 295
 296         if (!delegate)
 297                 return NULL;
 298
 299         if (delegate->delegate_trampoline)
 300                 return delegate->delegate_trampoline;
 301
 302         klass = ((MonoObject *)delegate)->vtable->klass;
 303         g_assert (klass->delegate);
 304
 305         method = delegate->method_info->method;
 306
 307         wrapper = mono_marshal_get_managed_wrapper (method, klass, delegate->target);
 308
 309         delegate->delegate_trampoline =  mono_compile_method (wrapper);
 310
 311         // Add the delegate to the delegate hash table
 312         delegate_hash_table_add (delegate);
 313
 314         /* when the object is collected, collect the dunamic method, too */
 315         mono_object_register_finalizer ((MonoObject*)delegate);
 316
 317         return delegate->delegate_trampoline;
 318 }
 319
 320 static GHashTable *delegate_hash_table;
 321
 322 static GHashTable *
 323 delegate_hash_table_new (void) {
 324         return g_hash_table_new (NULL, NULL);
 325 }
 326
 327 static void
 328 delegate_hash_table_remove (MonoDelegate *d)
 329 {
 330         mono_marshal_lock ();
 331         if (delegate_hash_table == NULL)
 332                 delegate_hash_table = delegate_hash_table_new ();
 333         g_hash_table_remove (delegate_hash_table, d->delegate_trampoline);
 334         mono_marshal_unlock ();
 335 }
 336
 337 void
 338 delegate_hash_table_add (MonoDelegate *d)
 339 {
 340         mono_marshal_lock ();
 341         if (delegate_hash_table == NULL)
 342                 delegate_hash_table = delegate_hash_table_new ();
 343         g_hash_table_insert (delegate_hash_table, d->delegate_trampoline, d);
 344         mono_marshal_unlock ();
 345 }
 346
 347 MonoDelegate*
 348 mono_ftnptr_to_delegate (MonoClass *klass, gpointer ftn)
 349 {
 350         MonoDelegate *d;
 351
 352         mono_marshal_lock ();
 353         if (delegate_hash_table == NULL)
 354                 delegate_hash_table = delegate_hash_table_new ();
 355
 356         d = g_hash_table_lookup (delegate_hash_table, ftn);
 357         mono_marshal_unlock ();
 358         if (d == NULL) {
 359                 /* This is a native function, so construct a delegate for it */
 360                 static MonoClass *UnmanagedFunctionPointerAttribute;
 361                 MonoMethodSignature *sig;
 362                 MonoMethod *wrapper;
 363                 MonoMarshalSpec **mspecs;
 364                 MonoCustomAttrInfo *cinfo;
 365                 MonoReflectionUnmanagedFunctionPointerAttribute *attr;
 366                 MonoMethod *invoke = mono_get_delegate_invoke (klass);
 367                 MonoMethodPInvoke piinfo;
 368                 int i;
 369
 370                 memset (&piinfo, 0, sizeof (piinfo));
 371                 if (!UnmanagedFunctionPointerAttribute)
 372                         UnmanagedFunctionPointerAttribute = mono_class_from_name (mono_defaults.corlib, "System.Runtime.InteropServices", "UnmanagedFunctionPointerAttribute");
 373
 374                 /* The attribute is only available in Net 2.0 */
 375                 if (UnmanagedFunctionPointerAttribute) {
 376                         /*
 377                          * The pinvoke attributes are stored in a real custom attribute so we have to
 378                          * construct it.
 379                          */
 380                         cinfo = mono_custom_attrs_from_class (klass);
 381                         if (cinfo) {
 382                                 attr = (MonoReflectionUnmanagedFunctionPointerAttribute*)mono_custom_attrs_get_attr (cinfo, UnmanagedFunctionPointerAttribute);
 383                                 if (attr) {
 384                                         piinfo.piflags = (attr->call_conv << 8) | (attr->charset ? (attr->charset - 1) * 2 : 1) | attr->set_last_error;
 385                                 }
 386                                 if (!cinfo->cached)
 387                                         mono_custom_attrs_free (cinfo);
 388                         }
 389                 }
 390
 391                 mspecs = g_new0 (MonoMarshalSpec*, mono_method_signature (invoke)->param_count + 1);
 392                 mono_method_get_marshal_info (invoke, mspecs);
 393                 sig = signature_dup (invoke->klass->image, mono_method_signature (invoke));
 394                 sig->hasthis = 0;
 395
 396                 wrapper = mono_marshal_get_native_func_wrapper (sig, &piinfo, mspecs, ftn);
 397
 398                 for (i = mono_method_signature (invoke)->param_count; i >= 0; i--)
 399                         if (mspecs [i])
 400                                 mono_metadata_free_marshal_spec (mspecs [i]);
 401                 g_free (mspecs);
 402                 g_free (sig);
 403
 404                 d = (MonoDelegate*)mono_object_new (mono_domain_get (), klass);
 405                 mono_delegate_ctor ((MonoObject*)d, NULL, mono_compile_method (wrapper));
 406         }
 407
 408         if (d->object.vtable->domain != mono_domain_get ())
 409                 mono_raise_exception (mono_get_exception_not_supported ("Delegates cannot be marshalled from native code into a domain other than their home domain"));
 410
 411         return d;
 412 }
 413
 414 void
 415 mono_delegate_free_ftnptr (MonoDelegate *delegate)
 416 {
 417         MonoJitInfo *ji;
 418         void *ptr;
 419
 420         delegate_hash_table_remove (delegate);
 421
 422         ptr = (gpointer)InterlockedExchangePointer (&delegate->delegate_trampoline, NULL);
 423
 424         if (!delegate->target) {
 425                 /* The wrapper method is shared between delegates -> no need to free it */
 426                 return;
 427         }
 428
 429         if (ptr) {
 430                 ji = mono_jit_info_table_find (mono_domain_get (), mono_get_addr_from_ftnptr (ptr));
 431                 g_assert (ji);
 432
 433                 mono_runtime_free_method (mono_object_domain (delegate), ji->method);
 434         }
 435 }
 436
 437 gpointer
 438 mono_array_to_savearray (MonoArray *array)
 439 {
 440         if (!array)
 441                 return NULL;
 442
 443         g_assert_not_reached ();
 444         return NULL;
 445 }
 446
 447 gpointer
 448 mono_array_to_lparray (MonoArray *array)
 449 {
 450         if (!array)
 451                 return NULL;
 452
 453         /* fixme: maybe we need to make a copy */
 454         return array->vector;
 455 }
 456
 457 static void
 458 mono_byvalarray_to_array (MonoArray *arr, gpointer native_arr, MonoClass *elclass, guint32 elnum)
 459 {
 460         g_assert (arr->obj.vtable->klass->element_class == mono_defaults.char_class);
 461
 462         if (elclass == mono_defaults.byte_class) {
 463                 GError *error = NULL;
 464                 guint16 *ut;
 465                 glong items_written;
 466
 467                 ut = g_utf8_to_utf16 (native_arr, elnum, NULL, &items_written, &error);
 468
 469                 if (!error) {
 470                         memcpy (mono_array_addr (arr, guint16, 0), ut, items_written * sizeof (guint16));
 471                         g_free (ut);
 472                 }
 473                 else
 474                         g_error_free (error);
 475         }
 476         else
 477                 g_assert_not_reached ();
 478 }
 479
 480 static void
 481 mono_array_to_byvalarray (gpointer native_arr, MonoArray *arr, MonoClass *elclass, guint32 elnum)
 482 {
 483         g_assert (arr->obj.vtable->klass->element_class == mono_defaults.char_class);
 484
 485         if (elclass == mono_defaults.byte_class) {
 486                 char *as;
 487                 GError *error = NULL;
 488
 489                 as = g_utf16_to_utf8 (mono_array_addr (arr, gunichar2, 0), mono_array_length (arr), NULL, NULL, &error);
 490                 if (error) {
 491                         MonoException *exc = mono_get_exception_argument ("string", error->message);
 492                         g_error_free (error);
 493                         mono_raise_exception (exc);
 494                 }
 495
 496                 memcpy (native_arr, as, MIN (strlen (as), elnum));
 497                 g_free (as);
 498         }
 499         else
 500                 g_assert_not_reached ();
 501 }
 502
 503 void
 504 mono_string_utf8_to_builder (MonoStringBuilder *sb, char *text)
 505 {
 506         GError *error = NULL;
 507         guint16 *ut;
 508         glong items_written;
 509         int l;
 510
 511         if (!sb || !text)
 512                 return;
 513
 514         l = strlen (text);
 515
 516         ut = g_utf8_to_utf16 (text, l, NULL, &items_written, &error);
 517
 518         if (items_written > mono_stringbuilder_capacity (sb))
 519                 items_written = mono_stringbuilder_capacity (sb);
 520
 521         if (!error) {
 522                 if (! sb->str || sb->str == sb->cached_str) {
 523                         MONO_OBJECT_SETREF (sb, str, mono_string_new_size (mono_domain_get (), items_written));
 524                         sb->cached_str = NULL;
 525                 }
 526
 527                 memcpy (mono_string_chars (sb->str), ut, items_written * 2);
 528                 sb->length = items_written;
 529         } else
 530                 g_error_free (error);
 531
 532         g_free (ut);
 533 }
 534
 535 void
 536 mono_string_utf16_to_builder (MonoStringBuilder *sb, gunichar2 *text)
 537 {
 538         guint32 len;
 539
 540         if (!sb || !text)
 541                 return;
 542
 543         g_assert (mono_string_chars (sb->str) == text);
 544
 545         for (len = 0; text [len] != 0; ++len)
 546                 ;
 547
 548         sb->length = len;
 549 }
 550
 551 gpointer
 552 mono_string_builder_to_utf8 (MonoStringBuilder *sb)
 553 {
 554         GError *error = NULL;
 555         glong *res;
 556         gchar *tmp;
 557
 558         if (!sb)
 559                 return NULL;
 560
 561         res = mono_marshal_alloc (mono_stringbuilder_capacity (sb) + 1);
 562
 563         tmp = g_utf16_to_utf8 (mono_string_chars (sb->str), sb->length, NULL, res, &error);
 564         if (error) {
 565                 g_error_free (error);
 566                 mono_raise_exception (mono_get_exception_execution_engine ("Failed to convert StringBuilder from utf16 to utf8"));
 567         }
 568         else {
 569                 memcpy (res, tmp, sb->length + 1);
 570                 g_free (tmp);
 571         }
 572
 573         return res;
 574 }
 575
 576 gpointer
 577 mono_string_builder_to_utf16 (MonoStringBuilder *sb)
 578 {
 579         if (!sb)
 580                 return NULL;
 581
 582         /*
 583          * The sb could have been allocated with the default capacity and be empty.
 584          * we need to alloc a buffer of the default capacity in this case.
 585          */
 586         if (! sb->str)
 587                 MONO_OBJECT_SETREF (sb, str, mono_string_new_size (mono_domain_get (), mono_stringbuilder_capacity (sb)));
 588         /*
 589          * The stringbuilder might not have ownership of this string. If this is
 590          * the case, we must duplicate the string, so that we don't munge immutable
 591          * strings
 592          */
 593         else if (sb->str == sb->cached_str) {
 594                 MONO_OBJECT_SETREF (sb, str, mono_string_new_utf16 (mono_domain_get (), mono_string_chars (sb->str), mono_stringbuilder_capacity (sb)));
 595                 sb->cached_str = NULL;
 596         }
 597
 598         return mono_string_chars (sb->str);
 599 }
 600
 601 static gpointer
 602 mono_string_to_lpstr (MonoString *s)
 603 {
 604 #ifdef PLATFORM_WIN32
 605         char *as, *tmp;
 606         glong len;
 607         GError *error = NULL;
 608
 609         if (s == NULL)
 610                 return NULL;
 611
 612         if (!s->length) {
 613                 as = CoTaskMemAlloc (1);
 614                 as [0] = '\0';
 615                 return as;
 616         }
 617
 618         tmp = g_utf16_to_utf8 (mono_string_chars (s), s->length, NULL, &len, &error);
 619         if (error) {
 620                 MonoException *exc = mono_get_exception_argument ("string", error->message);
 621                 g_error_free (error);
 622                 mono_raise_exception(exc);
 623                 return NULL;
 624         }
 625         else {
 626                 as = CoTaskMemAlloc (len + 1);
 627                 memcpy (as, tmp, len + 1);
 628                 return as;
 629         }
 630 #else
 631         return mono_string_to_utf8 (s);
 632 #endif
 633 }
 634
 635 gpointer
 636 mono_string_to_ansibstr (MonoString *string_obj)
 637 {
 638         g_error ("UnmanagedMarshal.BStr is not implemented.");
 639         return NULL;
 640 }
 641
 642 gpointer
 643 mono_string_to_bstr (MonoString *string_obj)
 644 {
 645 #ifdef PLATFORM_WIN32
 646         return SysAllocStringLen (mono_string_chars (string_obj), mono_string_length (string_obj));
 647 #else
 648         g_error ("UnmanagedMarshal.BStr is not implemented.");
 649         return NULL;
 650 #endif
 651 }
 652
 653 MonoString *
 654 mono_string_from_bstr (gpointer bstr)
 655 {
 656 #ifdef PLATFORM_WIN32
 657         MonoDomain *domain = mono_domain_get ();
 658         return mono_string_new_utf16 (domain, bstr, SysStringLen (bstr));
 659 #else
 660         g_error ("UnmanagedMarshal.BStr is not implemented.");
 661         return NULL;
 662 #endif
 663 }
 664
 665 void
 666 mono_free_bstr (gpointer bstr)
 667 {
 668 #ifdef PLATFORM_WIN32
 669         SysFreeString ((BSTR)bstr);
 670 #else
 671         g_error ("Free BSTR is not implemented.");
 672 #endif
 673 }
 674
 675 void
 676 mono_string_to_byvalstr (gpointer dst, MonoString *src, int size)
 677 {
 678         char *s;
 679         int len;
 680
 681         g_assert (dst != NULL);
 682         g_assert (size > 0);
 683
 684         memset (dst, 0, size);
 685
 686         if (!src)
 687                 return;
 688
 689         s = mono_string_to_utf8 (src);
 690         len = MIN (size, strlen (s));
 691         memcpy (dst, s, len);
 692         g_free (s);
 693
 694         *((char *)dst + size - 1) = 0;
 695 }
 696
 697 void
 698 mono_string_to_byvalwstr (gpointer dst, MonoString *src, int size)
 699 {
 700         int len;
 701
 702         g_assert (dst != NULL);
 703         g_assert (size > 1);
 704
 705         if (!src) {
 706                 memset (dst, 0, size);
 707                 return;
 708         }
 709
 710         len = MIN (size, (mono_string_length (src) * 2));
 711         memcpy (dst, mono_string_chars (src), len);
 712
 713         *((char *)dst + size - 1) = 0;
 714         *((char *)dst + size - 2) = 0;
 715 }
 716
 717 void
 718 mono_mb_free (MonoMethodBuilder *mb)
 719 {
 720         g_list_free (mb->locals_list);
 721         if (!mb->dynamic) {
 722                 g_free (mb->method);
 723                 g_free (mb->name);
 724                 g_free (mb->code);
 725         }
 726         g_free (mb);
 727 }
 728
 729 MonoMethodBuilder *
 730 mono_mb_new (MonoClass *klass, const char *name, MonoWrapperType type)
 731 {
 732         MonoMethodBuilder *mb;
 733         MonoMethod *m;
 734
 735         g_assert (klass != NULL);
 736         g_assert (name != NULL);
 737
 738         mb = g_new0 (MonoMethodBuilder, 1);
 739
 740         mb->method = m = (MonoMethod *)g_new0 (MonoMethodWrapper, 1);
 741
 742         m->klass = klass;
 743         m->inline_info = 1;
 744         m->wrapper_type = type;
 745
 746         mb->name = g_strdup (name);
 747         mb->code_size = 40;
 748         mb->code = g_malloc (mb->code_size);
 749
 750         return mb;
 751 }
 752
 753 int
 754 mono_mb_add_local (MonoMethodBuilder *mb, MonoType *type)
 755 {
 756         int res;
 757
 758         g_assert (mb != NULL);
 759         g_assert (type != NULL);
 760
 761         res = mb->locals;
 762         mb->locals_list = g_list_append (mb->locals_list, type);
 763         mb->locals++;
 764
 765         return res;
 766 }
 767
 768 /**
 769  * mono_mb_create_method:
 770  *
 771  * Create a MonoMethod from this method builder.
 772  * Returns: the newly created method.
 773  *
 774  * LOCKING: Assumes the loader lock is held.
 775  */
 776 MonoMethod *
 777 mono_mb_create_method (MonoMethodBuilder *mb, MonoMethodSignature *signature, int max_stack)
 778 {
 779         MonoMethodHeader *header;
 780         MonoMethodWrapper *mw;
 781         MonoMemPool *mp;
 782         MonoMethod *method;
 783         GList *l;
 784         int i;
 785
 786         g_assert (mb != NULL);
 787
 788         mp = mb->method->klass->image->mempool;
 789
 790         if (mb->dynamic) {
 791                 method = mb->method;
 792
 793                 method->name = mb->name;
 794                 method->dynamic = TRUE;
 795
 796                 ((MonoMethodNormal *)method)->header = header = (MonoMethodHeader *)
 797                         g_malloc0 (sizeof (MonoMethodHeader) + mb->locals * sizeof (MonoType *));
 798
 799                 header->code = mb->code;
 800         } else {
 801                 /* Realloc the method info into a mempool */
 802
 803                 method = mono_mempool_alloc (mp, sizeof (MonoMethodWrapper));
 804                 memcpy (method, mb->method, sizeof (MonoMethodWrapper));
 805
 806                 method->name = mono_mempool_strdup (mp, mb->name);
 807
 808                 ((MonoMethodNormal *)method)->header = header = (MonoMethodHeader *)
 809                         mono_mempool_alloc0 (mp, sizeof (MonoMethodHeader) + mb->locals * sizeof (MonoType *));
 810
 811                 header->code = mono_mempool_alloc (mp, mb->pos);
 812                 memcpy ((char*)header->code, mb->code, mb->pos);
 813         }
 814
 815         if (max_stack < 8)
 816                 max_stack = 8;
 817
 818         header->max_stack = max_stack;
 819
 820         for (i = 0, l = mb->locals_list; l; l = l->next, i++) {
 821                 header->locals [i] = (MonoType *)l->data;
 822         }
 823
 824         method->signature = signature;
 825
 826         header->code_size = mb->pos;
 827         header->num_locals = mb->locals;
 828
 829         mw = (MonoMethodWrapper*) mb->method;
 830         i = g_list_length (mw->method_data);
 831         if (i) {
 832                 GList *tmp;
 833                 void **data;
 834                 l = g_list_reverse (mw->method_data);
 835                 if (method->dynamic)
 836                         data = g_malloc (sizeof (gpointer) * (i + 1));
 837                 else
 838                         data = mono_mempool_alloc (mp, sizeof (gpointer) * (i + 1));
 839                 /* store the size in the first element */
 840                 data [0] = GUINT_TO_POINTER (i);
 841                 i = 1;
 842                 for (tmp = l; tmp; tmp = tmp->next) {
 843                         data [i++] = tmp->data;
 844                 }
 845                 g_list_free (l);
 846
 847                 ((MonoMethodWrapper*)method)->method_data = data;
 848         }
 849         /*{
 850                 static int total_code = 0;
 851                 static int total_alloc = 0;
 852                 total_code += mb->pos;
 853                 total_alloc += mb->code_size;
 854                 g_print ("code size: %d of %d (allocated: %d)\n", mb->pos, total_code, total_alloc);
 855         }*/
 856
 857 #ifdef DEBUG_RUNTIME_CODE
 858         printf ("RUNTIME CODE FOR %s\n", mono_method_full_name (method, TRUE));
 859         printf ("%s\n", mono_disasm_code (&marshal_dh, method, mb->code, mb->code + mb->pos));
 860 #endif
 861
 862         return method;
 863 }
 864
 865 guint32
 866 mono_mb_add_data (MonoMethodBuilder *mb, gpointer data)
 867 {
 868         MonoMethodWrapper *mw;
 869
 870         g_assert (mb != NULL);
 871
 872         mw = (MonoMethodWrapper *)mb->method;
 873
 874         /* one O(n) is enough */
 875         mw->method_data = g_list_prepend (mw->method_data, data);
 876
 877         return g_list_length (mw->method_data);
 878 }
 879
 880 void
 881 mono_mb_patch_addr (MonoMethodBuilder *mb, int pos, int value)
 882 {
 883         mb->code [pos] = value & 0xff;
 884         mb->code [pos + 1] = (value >> 8) & 0xff;
 885         mb->code [pos + 2] = (value >> 16) & 0xff;
 886         mb->code [pos + 3] = (value >> 24) & 0xff;
 887 }
 888
 889 void
 890 mono_mb_patch_addr_s (MonoMethodBuilder *mb, int pos, gint8 value)
 891 {
 892         *((gint8 *)(&mb->code [pos])) = value;
 893 }
 894
 895 void
 896 mono_mb_emit_byte (MonoMethodBuilder *mb, guint8 op)
 897 {
 898         if (mb->pos >= mb->code_size) {
 899                 mb->code_size += mb->code_size >> 1;
 900                 mb->code = g_realloc (mb->code, mb->code_size);
 901         }
 902
 903         mb->code [mb->pos++] = op;
 904 }
 905
 906 void
 907 mono_mb_emit_ldflda (MonoMethodBuilder *mb, gint32 offset)
 908 {
 909         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
 910         mono_mb_emit_byte (mb, CEE_MONO_OBJADDR);
 911
 912         if (offset) {
 913                 mono_mb_emit_icon (mb, offset);
 914                 mono_mb_emit_byte (mb, CEE_ADD);
 915         }
 916 }
 917
 918 static int
 919 mono_mb_emit_proxy_check (MonoMethodBuilder *mb, int branch_code)
 920 {
 921         int pos;
 922         mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoObject, vtable));
 923         mono_mb_emit_byte (mb, CEE_LDIND_I);
 924         mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoVTable, klass));
 925         mono_mb_emit_byte (mb, CEE_ADD);
 926         mono_mb_emit_byte (mb, CEE_LDIND_I);
 927         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
 928         mono_mb_emit_byte (mb, CEE_MONO_CLASSCONST);
 929         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, mono_defaults.transparent_proxy_class));
 930         mono_mb_emit_byte (mb, branch_code);
 931         pos = mb->pos;
 932         mono_mb_emit_i4 (mb, 0);
 933         return pos;
 934 }
 935
 936 static int
 937 mono_mb_emit_xdomain_check (MonoMethodBuilder *mb, int branch_code)
 938 {
 939         int pos;
 940         mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoTransparentProxy, rp));
 941         mono_mb_emit_byte (mb, CEE_LDIND_REF);
 942         mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoRealProxy, target_domain_id));
 943         mono_mb_emit_byte (mb, CEE_LDIND_I4);
 944         mono_mb_emit_icon (mb, -1);
 945         mono_mb_emit_byte (mb, branch_code);
 946         pos = mb->pos;
 947         mono_mb_emit_i4 (mb, 0);
 948         return pos;
 949 }
 950
 951 void
 952 mono_mb_emit_i4 (MonoMethodBuilder *mb, gint32 data)
 953 {
 954         if ((mb->pos + 4) >= mb->code_size) {
 955                 mb->code_size += mb->code_size >> 1;
 956                 mb->code = g_realloc (mb->code, mb->code_size);
 957         }
 958
 959         mono_mb_patch_addr (mb, mb->pos, data);
 960         mb->pos += 4;
 961 }
 962
 963 void
 964 mono_mb_emit_i2 (MonoMethodBuilder *mb, gint16 data)
 965 {
 966         if ((mb->pos + 2) >= mb->code_size) {
 967                 mb->code_size += mb->code_size >> 1;
 968                 mb->code = g_realloc (mb->code, mb->code_size);
 969         }
 970
 971         mb->code [mb->pos] = data & 0xff;
 972         mb->code [mb->pos + 1] = (data >> 8) & 0xff;
 973         mb->pos += 2;
 974 }
 975
 976 void
 977 mono_mb_emit_ldstr (MonoMethodBuilder *mb, char *str)
 978 {
 979         mono_mb_emit_byte (mb, CEE_LDSTR);
 980         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, str));
 981 }
 982
 983
 984 void
 985 mono_mb_emit_ldarg (MonoMethodBuilder *mb, guint argnum)
 986 {
 987         if (argnum < 4) {
 988                 mono_mb_emit_byte (mb, CEE_LDARG_0 + argnum);
 989         } else if (argnum < 256) {
 990                 mono_mb_emit_byte (mb, CEE_LDARG_S);
 991                 mono_mb_emit_byte (mb, argnum);
 992         } else {
 993                 mono_mb_emit_byte (mb, CEE_PREFIX1);
 994                 mono_mb_emit_byte (mb, CEE_LDARG);
 995                 mono_mb_emit_i2 (mb, argnum);
 996         }
 997 }
 998
 999 void
1000 mono_mb_emit_ldarg_addr (MonoMethodBuilder *mb, guint argnum)
1001 {
1002         if (argnum < 256) {
1003                 mono_mb_emit_byte (mb, CEE_LDARGA_S);
1004                 mono_mb_emit_byte (mb, argnum);
1005         } else {
1006                 mono_mb_emit_byte (mb, CEE_PREFIX1);
1007                 mono_mb_emit_byte (mb, CEE_LDARGA);
1008                 mono_mb_emit_i2 (mb, argnum);
1009         }
1010 }
1011
1012 void
1013 mono_mb_emit_ldloc_addr (MonoMethodBuilder *mb, guint locnum)
1014 {
1015         if (locnum < 256) {
1016                 mono_mb_emit_byte (mb, CEE_LDLOCA_S);
1017                 mono_mb_emit_byte (mb, locnum);
1018         } else {
1019                 mono_mb_emit_byte (mb, CEE_PREFIX1);
1020                 mono_mb_emit_byte (mb, CEE_LDLOCA);
1021                 mono_mb_emit_i2 (mb, locnum);
1022         }
1023 }
1024
1025 void
1026 mono_mb_emit_ldloc (MonoMethodBuilder *mb, guint num)
1027 {
1028         if (num < 4) {
1029                 mono_mb_emit_byte (mb, CEE_LDLOC_0 + num);
1030         } else if (num < 256) {
1031                 mono_mb_emit_byte (mb, CEE_LDLOC_S);
1032                 mono_mb_emit_byte (mb, num);
1033         } else {
1034                 mono_mb_emit_byte (mb, CEE_PREFIX1);
1035                 mono_mb_emit_byte (mb, CEE_LDLOC);
1036                 mono_mb_emit_i2 (mb, num);
1037         }
1038 }
1039
1040 void
1041 mono_mb_emit_stloc (MonoMethodBuilder *mb, guint num)
1042 {
1043         if (num < 4) {
1044                 mono_mb_emit_byte (mb, CEE_STLOC_0 + num);
1045         } else if (num < 256) {
1046                 mono_mb_emit_byte (mb, CEE_STLOC_S);
1047                 mono_mb_emit_byte (mb, num);
1048         } else {
1049                 mono_mb_emit_byte (mb, CEE_PREFIX1);
1050                 mono_mb_emit_byte (mb, CEE_STLOC);
1051                 mono_mb_emit_i2 (mb, num);
1052         }
1053 }
1054
1055 void
1056 mono_mb_emit_icon (MonoMethodBuilder *mb, gint32 value)
1057 {
1058         if (value >= -1 && value < 8) {
1059                 mono_mb_emit_byte (mb, CEE_LDC_I4_0 + value);
1060         } else if (value >= -128 && value <= 127) {
1061                 mono_mb_emit_byte (mb, CEE_LDC_I4_S);
1062                 mono_mb_emit_byte (mb, value);
1063         } else {
1064                 mono_mb_emit_byte (mb, CEE_LDC_I4);
1065                 mono_mb_emit_i4 (mb, value);
1066         }
1067 }
1068
1069 guint32
1070 mono_mb_emit_branch (MonoMethodBuilder *mb, guint8 op)
1071 {
1072         guint32 res;
1073         mono_mb_emit_byte (mb, op);
1074         res = mb->pos;
1075         mono_mb_emit_i4 (mb, 0);
1076         return res;
1077 }
1078
1079 static void
1080 mono_mb_emit_ptr (MonoMethodBuilder *mb, gpointer ptr)
1081 {
1082         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
1083         mono_mb_emit_byte (mb, CEE_MONO_LDPTR);
1084         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, ptr));
1085 }
1086
1087 static void
1088 mono_mb_emit_calli (MonoMethodBuilder *mb, MonoMethodSignature *sig)
1089 {
1090         mono_mb_emit_byte (mb, CEE_CALLI);
1091         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, sig));
1092 }
1093
1094 void
1095 mono_mb_emit_managed_call (MonoMethodBuilder *mb, MonoMethod *method, MonoMethodSignature *opt_sig)
1096 {
1097         mono_mb_emit_byte (mb, CEE_CALL);
1098         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, method));
1099 }
1100
1101 void
1102 mono_mb_emit_native_call (MonoMethodBuilder *mb, MonoMethodSignature *sig, gpointer func)
1103 {
1104         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
1105         mono_mb_emit_byte (mb, CEE_MONO_SAVE_LMF);
1106         mono_mb_emit_ptr (mb, func);
1107         mono_mb_emit_calli (mb, sig);
1108         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
1109         mono_mb_emit_byte (mb, CEE_MONO_RESTORE_LMF);
1110 }
1111
1112 static void
1113 mono_mb_emit_icall (MonoMethodBuilder *mb, gpointer func)
1114 {
1115         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
1116         mono_mb_emit_byte (mb, CEE_MONO_ICALL);
1117         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, func));
1118 }
1119
1120 static void
1121 mono_mb_emit_exception_full (MonoMethodBuilder *mb, const char *exc_nspace, const char *exc_name, const char *msg)
1122 {
1123         MonoMethod *ctor = NULL;
1124
1125         MonoClass *mme = mono_class_from_name (mono_defaults.corlib, exc_nspace, exc_name);
1126         mono_class_init (mme);
1127         ctor = mono_class_get_method_from_name (mme, ".ctor", 0);
1128         g_assert (ctor);
1129         mono_mb_emit_byte (mb, CEE_NEWOBJ);
1130         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, ctor));
1131         if (msg != NULL) {
1132                 mono_mb_emit_byte (mb, CEE_DUP);
1133                 mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoException, message));
1134                 mono_mb_emit_ldstr (mb, (char*)msg);
1135                 mono_mb_emit_byte (mb, CEE_STIND_REF);
1136         }
1137         mono_mb_emit_byte (mb, CEE_THROW);
1138 }
1139
1140 void
1141 mono_mb_emit_exception (MonoMethodBuilder *mb, const char *exc_name, const char *msg)
1142 {
1143         mono_mb_emit_exception_full (mb, "System", exc_name, msg);
1144 }
1145
1146 static void
1147 mono_mb_emit_exception_marshal_directive (MonoMethodBuilder *mb, const char *msg)
1148 {
1149         mono_mb_emit_exception_full (mb, "System.Runtime.InteropServices", "MarshalDirectiveException", msg);
1150 }
1151
1152 void
1153 mono_mb_emit_add_to_local (MonoMethodBuilder *mb, guint16 local, gint32 incr)
1154 {
1155         mono_mb_emit_ldloc (mb, local);
1156         mono_mb_emit_icon (mb, incr);
1157         mono_mb_emit_byte (mb, CEE_ADD);
1158         mono_mb_emit_stloc (mb, local);
1159 }
1160
1161 guint
1162 mono_type_to_ldind (MonoType *type)
1163 {
1164         if (type->byref)
1165                 return CEE_LDIND_I;
1166
1167 handle_enum:
1168         switch (type->type) {
1169         case MONO_TYPE_I1:
1170                 return CEE_LDIND_I1;
1171         case MONO_TYPE_U1:
1172         case MONO_TYPE_BOOLEAN:
1173                 return CEE_LDIND_U1;
1174         case MONO_TYPE_I2:
1175                 return CEE_LDIND_I2;
1176         case MONO_TYPE_U2:
1177         case MONO_TYPE_CHAR:
1178                 return CEE_LDIND_U2;
1179         case MONO_TYPE_I4:
1180                 return CEE_LDIND_I4;
1181         case MONO_TYPE_U4:
1182                 return CEE_LDIND_U4;
1183         case MONO_TYPE_I:
1184         case MONO_TYPE_U:
1185         case MONO_TYPE_PTR:
1186         case MONO_TYPE_FNPTR:
1187                 return CEE_LDIND_I;
1188         case MONO_TYPE_CLASS:
1189         case MONO_TYPE_STRING:
1190         case MONO_TYPE_OBJECT:
1191         case MONO_TYPE_SZARRAY:
1192         case MONO_TYPE_ARRAY:
1193                 return CEE_LDIND_REF;
1194         case MONO_TYPE_I8:
1195         case MONO_TYPE_U8:
1196                 return CEE_LDIND_I8;
1197         case MONO_TYPE_R4:
1198                 return CEE_LDIND_R4;
1199         case MONO_TYPE_R8:
1200                 return CEE_LDIND_R8;
1201         case MONO_TYPE_VALUETYPE:
1202                 if (type->data.klass->enumtype) {
1203                         type = type->data.klass->enum_basetype;
1204                         goto handle_enum;
1205                 }
1206                 return CEE_LDOBJ;
1207         case MONO_TYPE_TYPEDBYREF:
1208                 return CEE_LDOBJ;
1209         case MONO_TYPE_GENERICINST:
1210                 type = &type->data.generic_class->container_class->byval_arg;
1211                 goto handle_enum;
1212         default:
1213                 g_error ("unknown type 0x%02x in type_to_ldind", type->type);
1214         }
1215         return -1;
1216 }
1217
1218 guint
1219 mono_type_to_stind (MonoType *type)
1220 {
1221         if (type->byref)
1222                 return CEE_STIND_I;
1223
1224 handle_enum:
1225         switch (type->type) {
1226         case MONO_TYPE_I1:
1227         case MONO_TYPE_U1:
1228         case MONO_TYPE_BOOLEAN:
1229                 return CEE_STIND_I1;
1230         case MONO_TYPE_I2:
1231         case MONO_TYPE_U2:
1232         case MONO_TYPE_CHAR:
1233                 return CEE_STIND_I2;
1234         case MONO_TYPE_I4:
1235         case MONO_TYPE_U4:
1236                 return CEE_STIND_I4;
1237         case MONO_TYPE_I:
1238         case MONO_TYPE_U:
1239         case MONO_TYPE_PTR:
1240         case MONO_TYPE_FNPTR:
1241                 return CEE_STIND_I;
1242         case MONO_TYPE_CLASS:
1243         case MONO_TYPE_STRING:
1244         case MONO_TYPE_OBJECT:
1245         case MONO_TYPE_SZARRAY:
1246         case MONO_TYPE_ARRAY:
1247                 return CEE_STIND_REF;
1248         case MONO_TYPE_I8:
1249         case MONO_TYPE_U8:
1250                 return CEE_STIND_I8;
1251         case MONO_TYPE_R4:
1252                 return CEE_STIND_R4;
1253         case MONO_TYPE_R8:
1254                 return CEE_STIND_R8;
1255         case MONO_TYPE_VALUETYPE:
1256                 if (type->data.klass->enumtype) {
1257                         type = type->data.klass->enum_basetype;
1258                         goto handle_enum;
1259                 }
1260                 return CEE_STOBJ;
1261         case MONO_TYPE_TYPEDBYREF:
1262                 return CEE_STOBJ;
1263         case MONO_TYPE_GENERICINST:
1264                 type = &type->data.generic_class->container_class->byval_arg;
1265                 goto handle_enum;
1266         default:
1267                 g_error ("unknown type 0x%02x in type_to_stind", type->type);
1268         }
1269         return -1;
1270 }
1271
1272 static void
1273 emit_ptr_to_object_conv (MonoMethodBuilder *mb, MonoType *type, MonoMarshalConv conv, MonoMarshalSpec *mspec)
1274 {
1275         switch (conv) {
1276         case MONO_MARSHAL_CONV_BOOL_I4:
1277                 mono_mb_emit_ldloc (mb, 1);
1278                 mono_mb_emit_ldloc (mb, 0);
1279                 mono_mb_emit_byte (mb, CEE_LDIND_I4);
1280                 mono_mb_emit_byte (mb, CEE_BRFALSE_S);
1281                 mono_mb_emit_byte (mb, 3);
1282                 mono_mb_emit_byte (mb, CEE_LDC_I4_1);
1283                 mono_mb_emit_byte (mb, CEE_BR_S);
1284                 mono_mb_emit_byte (mb, 1);
1285                 mono_mb_emit_byte (mb, CEE_LDC_I4_0);
1286                 mono_mb_emit_byte (mb, CEE_STIND_I1);
1287                 break;
1288         case MONO_MARSHAL_CONV_BOOL_VARIANTBOOL:
1289                 mono_mb_emit_ldloc (mb, 1);
1290                 mono_mb_emit_ldloc (mb, 0);
1291                 mono_mb_emit_byte (mb, CEE_LDIND_I2);
1292                 mono_mb_emit_byte (mb, CEE_BRFALSE_S);
1293                 mono_mb_emit_byte (mb, 3);
1294                 mono_mb_emit_byte (mb, CEE_LDC_I4_1);
1295                 mono_mb_emit_byte (mb, CEE_BR_S);
1296                 mono_mb_emit_byte (mb, 1);
1297                 mono_mb_emit_byte (mb, CEE_LDC_I4_0);
1298                 mono_mb_emit_byte (mb, CEE_STIND_I1);
1299                 break;
1300         case MONO_MARSHAL_CONV_ARRAY_BYVALARRAY: {
1301                 MonoClass *eklass = NULL;
1302                 int esize;
1303
1304                 if (type->type == MONO_TYPE_SZARRAY) {
1305                         eklass = type->data.klass;
1306                 } else {
1307                         g_assert_not_reached ();
1308                 }
1309
1310                 esize = mono_class_native_size (eklass, NULL);
1311
1312                 /* create a new array */
1313                 mono_mb_emit_ldloc (mb, 1);
1314                 mono_mb_emit_icon (mb, mspec->data.array_data.num_elem);
1315                 mono_mb_emit_byte (mb, CEE_NEWARR);
1316                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, eklass));
1317                 mono_mb_emit_byte (mb, CEE_STIND_I);
1318
1319                 if (eklass->blittable) {
1320                         /* copy the elements */
1321                         mono_mb_emit_ldloc (mb, 1);
1322                         mono_mb_emit_byte (mb, CEE_LDIND_I);
1323                         mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoArray, vector));
1324                         mono_mb_emit_byte (mb, CEE_ADD);
1325                         mono_mb_emit_ldloc (mb, 0);
1326                         mono_mb_emit_icon (mb, mspec->data.array_data.num_elem * esize);
1327                         mono_mb_emit_byte (mb, CEE_PREFIX1);
1328                         mono_mb_emit_byte (mb, CEE_CPBLK);
1329                 }
1330                 else {
1331                         int array_var, src_var, dst_var, index_var;
1332                         guint32 label2, label3;
1333
1334                         array_var = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
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                         /* set array_var */
1339                         mono_mb_emit_ldloc (mb, 1);
1340                         mono_mb_emit_byte (mb, CEE_LDIND_REF);
1341                         mono_mb_emit_stloc (mb, array_var);
1342
1343                         /* save the old src pointer */
1344                         mono_mb_emit_ldloc (mb, 0);
1345                         mono_mb_emit_stloc (mb, src_var);
1346                         /* save the old dst pointer */
1347                         mono_mb_emit_ldloc (mb, 1);
1348                         mono_mb_emit_stloc (mb, dst_var);
1349
1350                         /* Emit marshalling loop */
1351                         index_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
1352                         mono_mb_emit_byte (mb, CEE_LDC_I4_0);
1353                         mono_mb_emit_stloc (mb, index_var);
1354
1355                         /* Loop header */
1356                         label2 = mb->pos;
1357                         mono_mb_emit_ldloc (mb, index_var);
1358                         mono_mb_emit_ldloc (mb, array_var);
1359                         mono_mb_emit_byte (mb, CEE_LDLEN);
1360                         mono_mb_emit_byte (mb, CEE_BGE);
1361                         label3 = mb->pos;
1362                         mono_mb_emit_i4 (mb, 0);
1363
1364                         /* src is already set */
1365
1366                         /* Set dst */
1367                         mono_mb_emit_ldloc (mb, array_var);
1368                         mono_mb_emit_ldloc (mb, index_var);
1369                         mono_mb_emit_byte (mb, CEE_LDELEMA);
1370                         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, eklass));
1371                         mono_mb_emit_stloc (mb, 1);
1372
1373                         /* Do the conversion */
1374                         emit_struct_conv (mb, eklass, TRUE);
1375
1376                         /* Loop footer */
1377                         mono_mb_emit_add_to_local (mb, index_var, 1);
1378
1379                         mono_mb_emit_byte (mb, CEE_BR);
1380                         mono_mb_emit_i4 (mb, label2 - (mb->pos + 4));
1381
1382                         mono_mb_patch_addr (mb, label3, mb->pos - (label3 + 4));
1383
1384                         /* restore the old src pointer */
1385                         mono_mb_emit_ldloc (mb, src_var);
1386                         mono_mb_emit_stloc (mb, 0);
1387                         /* restore the old dst pointer */
1388                         mono_mb_emit_ldloc (mb, dst_var);
1389                         mono_mb_emit_stloc (mb, 1);
1390                 }
1391                 break;
1392         }
1393         case MONO_MARSHAL_CONV_ARRAY_BYVALCHARARRAY: {
1394                 MonoClass *eclass = mono_defaults.char_class;
1395
1396                 /* create a new array */
1397                 mono_mb_emit_ldloc (mb, 1);
1398                 mono_mb_emit_icon (mb, mspec->data.array_data.num_elem);
1399                 mono_mb_emit_byte (mb, CEE_NEWARR);
1400                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, eclass));
1401                 mono_mb_emit_byte (mb, CEE_STIND_REF);
1402
1403                 mono_mb_emit_ldloc (mb, 1);
1404                 mono_mb_emit_byte (mb, CEE_LDIND_REF);
1405                 mono_mb_emit_ldloc (mb, 0);
1406                 mono_mb_emit_ptr (mb, mono_defaults.byte_class);
1407                 mono_mb_emit_icon (mb, mspec->data.array_data.num_elem);
1408                 mono_mb_emit_icall (mb, mono_byvalarray_to_array);
1409                 break;
1410         }
1411         case MONO_MARSHAL_CONV_STR_BYVALSTR:
1412                 mono_mb_emit_ldloc (mb, 1);
1413                 mono_mb_emit_ldloc (mb, 0);
1414                 mono_mb_emit_icall (mb, mono_string_new_wrapper);
1415                 mono_mb_emit_byte (mb, CEE_STIND_REF);
1416                 break;
1417         case MONO_MARSHAL_CONV_STR_BYVALWSTR:
1418                 mono_mb_emit_ldloc (mb, 1);
1419                 mono_mb_emit_ldloc (mb, 0);
1420                 mono_mb_emit_icall (mb, mono_string_from_utf16);
1421                 mono_mb_emit_byte (mb, CEE_STIND_REF);
1422                 break;
1423         case MONO_MARSHAL_CONV_STR_LPTSTR:
1424         case MONO_MARSHAL_CONV_STR_LPSTR:
1425                 mono_mb_emit_ldloc (mb, 1);
1426                 mono_mb_emit_ldloc (mb, 0);
1427                 mono_mb_emit_byte (mb, CEE_LDIND_I);
1428                 mono_mb_emit_icall (mb, mono_string_new_wrapper);
1429                 mono_mb_emit_byte (mb, CEE_STIND_REF);
1430                 break;
1431         case MONO_MARSHAL_CONV_STR_LPWSTR:
1432                 mono_mb_emit_ldloc (mb, 1);
1433                 mono_mb_emit_ldloc (mb, 0);
1434                 mono_mb_emit_byte (mb, CEE_LDIND_I);
1435                 mono_mb_emit_icall (mb, mono_string_from_utf16);
1436                 mono_mb_emit_byte (mb, CEE_STIND_REF);
1437                 break;
1438         case MONO_MARSHAL_CONV_OBJECT_STRUCT: {
1439                 MonoClass *klass = mono_class_from_mono_type (type);
1440                 int src_var, dst_var;
1441
1442                 src_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
1443                 dst_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
1444
1445                 /* *dst = new object */
1446                 mono_mb_emit_ldloc (mb, 1);
1447                 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
1448                 mono_mb_emit_byte (mb, CEE_MONO_NEWOBJ);
1449                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, klass));
1450                 mono_mb_emit_byte (mb, CEE_STIND_REF);
1451
1452                 /* save the old src pointer */
1453                 mono_mb_emit_ldloc (mb, 0);
1454                 mono_mb_emit_stloc (mb, src_var);
1455                 /* save the old dst pointer */
1456                 mono_mb_emit_ldloc (mb, 1);
1457                 mono_mb_emit_stloc (mb, dst_var);
1458
1459                 /* dst = pointer to newly created object data */
1460                 mono_mb_emit_ldloc (mb, 1);
1461                 mono_mb_emit_byte (mb, CEE_LDIND_I);
1462                 mono_mb_emit_icon (mb, sizeof (MonoObject));
1463                 mono_mb_emit_byte (mb, CEE_ADD);
1464                 mono_mb_emit_stloc (mb, 1);
1465
1466                 emit_struct_conv (mb, klass, TRUE);
1467
1468                 /* restore the old src pointer */
1469                 mono_mb_emit_ldloc (mb, src_var);
1470                 mono_mb_emit_stloc (mb, 0);
1471                 /* restore the old dst pointer */
1472                 mono_mb_emit_ldloc (mb, dst_var);
1473                 mono_mb_emit_stloc (mb, 1);
1474                 break;
1475         }
1476         case MONO_MARSHAL_CONV_DEL_FTN: {
1477                 MonoClass *klass = mono_class_from_mono_type (type);
1478
1479                 mono_mb_emit_ldloc (mb, 1);
1480                 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
1481                 mono_mb_emit_byte (mb, CEE_MONO_CLASSCONST);
1482                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, klass));
1483                 mono_mb_emit_ldloc (mb, 0);
1484                 mono_mb_emit_byte (mb, CEE_LDIND_I);
1485                 mono_mb_emit_icall (mb, mono_ftnptr_to_delegate);
1486                 mono_mb_emit_byte (mb, CEE_STIND_REF);
1487                 break;
1488         }
1489         case MONO_MARSHAL_CONV_ARRAY_LPARRAY:
1490                 g_error ("Structure field of type %s can't be marshalled as LPArray", mono_class_from_mono_type (type)->name);
1491                 break;
1492         case MONO_MARSHAL_CONV_STR_BSTR:
1493         case MONO_MARSHAL_CONV_STR_ANSIBSTR:
1494         case MONO_MARSHAL_CONV_STR_TBSTR:
1495         case MONO_MARSHAL_CONV_ARRAY_SAVEARRAY:
1496         default:
1497                 g_warning ("marshaling conversion %d not implemented", conv);
1498                 g_assert_not_reached ();
1499         }
1500 }
1501
1502 static gpointer
1503 conv_to_icall (MonoMarshalConv conv)
1504 {
1505         switch (conv) {
1506         case MONO_MARSHAL_CONV_STR_LPWSTR:
1507                 return mono_marshal_string_to_utf16;
1508         case MONO_MARSHAL_CONV_LPWSTR_STR:
1509                 return mono_string_from_utf16;
1510         case MONO_MARSHAL_CONV_LPSTR_STR:
1511                 return mono_string_new_wrapper;
1512         case MONO_MARSHAL_CONV_STR_LPTSTR:
1513         case MONO_MARSHAL_CONV_STR_LPSTR:
1514                 return mono_string_to_lpstr;
1515         case MONO_MARSHAL_CONV_STR_BSTR:
1516                 return mono_string_to_bstr;
1517         case MONO_MARSHAL_CONV_BSTR_STR:
1518                 return mono_string_from_bstr;
1519         case MONO_MARSHAL_CONV_STR_TBSTR:
1520         case MONO_MARSHAL_CONV_STR_ANSIBSTR:
1521                 return mono_string_to_ansibstr;
1522         case MONO_MARSHAL_CONV_SB_LPSTR:
1523         case MONO_MARSHAL_CONV_SB_LPTSTR:
1524                 return mono_string_builder_to_utf8;
1525         case MONO_MARSHAL_CONV_SB_LPWSTR:
1526                 return mono_string_builder_to_utf16;
1527         case MONO_MARSHAL_CONV_ARRAY_SAVEARRAY:
1528                 return mono_array_to_savearray;
1529         case MONO_MARSHAL_CONV_ARRAY_LPARRAY:
1530                 return mono_array_to_lparray;
1531         case MONO_MARSHAL_CONV_DEL_FTN:
1532                 return mono_delegate_to_ftnptr;
1533         case MONO_MARSHAL_CONV_FTN_DEL:
1534                 return mono_ftnptr_to_delegate;
1535         case MONO_MARSHAL_CONV_LPSTR_SB:
1536         case MONO_MARSHAL_CONV_LPTSTR_SB:
1537                 return mono_string_utf8_to_builder;
1538         case MONO_MARSHAL_CONV_LPWSTR_SB:
1539                 return mono_string_utf16_to_builder;
1540         case MONO_MARSHAL_FREE_ARRAY:
1541                 return mono_marshal_free_array;
1542         case MONO_MARSHAL_CONV_STR_BYVALSTR:
1543                 return mono_string_to_byvalstr;
1544         case MONO_MARSHAL_CONV_STR_BYVALWSTR:
1545                 return mono_string_to_byvalwstr;
1546         default:
1547                 g_assert_not_reached ();
1548         }
1549
1550         return NULL;
1551 }
1552
1553 static void
1554 emit_object_to_ptr_conv (MonoMethodBuilder *mb, MonoType *type, MonoMarshalConv conv, MonoMarshalSpec *mspec)
1555 {
1556         int pos;
1557
1558         switch (conv) {
1559         case MONO_MARSHAL_CONV_BOOL_I4:
1560                 mono_mb_emit_ldloc (mb, 1);
1561                 mono_mb_emit_ldloc (mb, 0);
1562                 mono_mb_emit_byte (mb, CEE_LDIND_U1);
1563                 mono_mb_emit_byte (mb, CEE_STIND_I4);
1564                 break;
1565         case MONO_MARSHAL_CONV_BOOL_VARIANTBOOL:
1566                 mono_mb_emit_ldloc (mb, 1);
1567                 mono_mb_emit_ldloc (mb, 0);
1568                 mono_mb_emit_byte (mb, CEE_LDIND_U1);
1569                 mono_mb_emit_byte (mb, CEE_NEG);
1570                 mono_mb_emit_byte (mb, CEE_STIND_I2);
1571                 break;
1572         case MONO_MARSHAL_CONV_STR_LPWSTR:
1573         case MONO_MARSHAL_CONV_STR_LPSTR:
1574         case MONO_MARSHAL_CONV_STR_LPTSTR:
1575         case MONO_MARSHAL_CONV_STR_BSTR:
1576         case MONO_MARSHAL_CONV_STR_ANSIBSTR:
1577         case MONO_MARSHAL_CONV_STR_TBSTR: {
1578                 int pos;
1579
1580                 /* free space if free == true */
1581                 mono_mb_emit_ldloc (mb, 2);
1582                 mono_mb_emit_byte (mb, CEE_BRFALSE_S);
1583                 pos = mb->pos;
1584                 mono_mb_emit_byte (mb, 0);
1585                 mono_mb_emit_ldloc (mb, 1);
1586                 mono_mb_emit_byte (mb, CEE_LDIND_I);
1587                 mono_mb_emit_icall (mb, g_free);
1588                 mono_mb_patch_addr_s (mb, pos, mb->pos - pos - 1);
1589
1590                 mono_mb_emit_ldloc (mb, 1);
1591                 mono_mb_emit_ldloc (mb, 0);
1592                 mono_mb_emit_byte (mb, CEE_LDIND_REF);
1593                 mono_mb_emit_icall (mb, conv_to_icall (conv));
1594                 mono_mb_emit_byte (mb, CEE_STIND_I);
1595                 break;
1596         }
1597         case MONO_MARSHAL_CONV_ARRAY_SAVEARRAY:
1598         case MONO_MARSHAL_CONV_ARRAY_LPARRAY:
1599         case MONO_MARSHAL_CONV_DEL_FTN:
1600                 mono_mb_emit_ldloc (mb, 1);
1601                 mono_mb_emit_ldloc (mb, 0);
1602                 mono_mb_emit_byte (mb, CEE_LDIND_REF);
1603                 mono_mb_emit_icall (mb, conv_to_icall (conv));
1604                 mono_mb_emit_byte (mb, CEE_STIND_I);
1605                 break;
1606         case MONO_MARSHAL_CONV_STR_BYVALSTR:
1607         case MONO_MARSHAL_CONV_STR_BYVALWSTR: {
1608                 g_assert (mspec);
1609
1610                 mono_mb_emit_ldloc (mb, 1); /* dst */
1611                 mono_mb_emit_ldloc (mb, 0);
1612                 mono_mb_emit_byte (mb, CEE_LDIND_REF); /* src String */
1613                 mono_mb_emit_icon (mb, mspec->data.array_data.num_elem);
1614                 mono_mb_emit_icall (mb, conv_to_icall (conv));
1615                 break;
1616         }
1617         case MONO_MARSHAL_CONV_ARRAY_BYVALARRAY: {
1618                 MonoClass *eklass = NULL;
1619                 int esize;
1620
1621                 if (type->type == MONO_TYPE_SZARRAY) {
1622                         eklass = type->data.klass;
1623                 } else {
1624                         g_assert_not_reached ();
1625                 }
1626
1627                 if (eklass->valuetype)
1628                         esize = mono_class_native_size (eklass, NULL);
1629                 else
1630                         esize = sizeof (gpointer);
1631
1632                 mono_mb_emit_ldloc (mb, 0);
1633                 mono_mb_emit_byte (mb, CEE_LDIND_REF);
1634                 mono_mb_emit_byte (mb, CEE_BRFALSE_S);
1635                 pos = mb->pos;
1636                 mono_mb_emit_byte (mb, 0);
1637
1638                 if (eklass->blittable) {
1639                         mono_mb_emit_ldloc (mb, 1);
1640                         mono_mb_emit_ldloc (mb, 0);
1641                         mono_mb_emit_byte (mb, CEE_LDIND_REF);
1642                         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
1643                         mono_mb_emit_byte (mb, CEE_MONO_OBJADDR);
1644                         mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoArray, vector));
1645                         mono_mb_emit_byte (mb, CEE_ADD);
1646                         mono_mb_emit_icon (mb, mspec->data.array_data.num_elem * esize);
1647                         mono_mb_emit_byte (mb, CEE_PREFIX1);
1648                         mono_mb_emit_byte (mb, CEE_CPBLK);
1649                 } else {
1650                         int array_var, src_var, dst_var, index_var;
1651                         guint32 label2, label3;
1652
1653                         array_var = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
1654                         src_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
1655                         dst_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
1656
1657                         /* set array_var */
1658                         mono_mb_emit_ldloc (mb, 0);
1659                         mono_mb_emit_byte (mb, CEE_LDIND_REF);
1660                         mono_mb_emit_stloc (mb, array_var);
1661
1662                         /* save the old src pointer */
1663                         mono_mb_emit_ldloc (mb, 0);
1664                         mono_mb_emit_stloc (mb, src_var);
1665                         /* save the old dst pointer */
1666                         mono_mb_emit_ldloc (mb, 1);
1667                         mono_mb_emit_stloc (mb, dst_var);
1668
1669                         /* Emit marshalling loop */
1670                         index_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
1671                         mono_mb_emit_byte (mb, CEE_LDC_I4_0);
1672                         mono_mb_emit_stloc (mb, index_var);
1673
1674                         /* Loop header */
1675                         label2 = mb->pos;
1676                         mono_mb_emit_ldloc (mb, index_var);
1677                         mono_mb_emit_ldloc (mb, array_var);
1678                         mono_mb_emit_byte (mb, CEE_LDLEN);
1679                         mono_mb_emit_byte (mb, CEE_BGE);
1680                         label3 = mb->pos;
1681                         mono_mb_emit_i4 (mb, 0);
1682
1683                         /* Set src */
1684                         mono_mb_emit_ldloc (mb, array_var);
1685                         mono_mb_emit_ldloc (mb, index_var);
1686                         mono_mb_emit_byte (mb, CEE_LDELEMA);
1687                         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, eklass));
1688                         mono_mb_emit_stloc (mb, 0);
1689
1690                         /* dst is already set */
1691
1692                         /* Do the conversion */
1693                         emit_struct_conv (mb, eklass, FALSE);
1694
1695                         /* Loop footer */
1696                         mono_mb_emit_add_to_local (mb, index_var, 1);
1697
1698                         mono_mb_emit_byte (mb, CEE_BR);
1699                         mono_mb_emit_i4 (mb, label2 - (mb->pos + 4));
1700
1701                         mono_mb_patch_addr (mb, label3, mb->pos - (label3 + 4));
1702
1703                         /* restore the old src pointer */
1704                         mono_mb_emit_ldloc (mb, src_var);
1705                         mono_mb_emit_stloc (mb, 0);
1706                         /* restore the old dst pointer */
1707                         mono_mb_emit_ldloc (mb, dst_var);
1708                         mono_mb_emit_stloc (mb, 1);
1709                 }
1710
1711                 mono_mb_patch_addr_s (mb, pos, mb->pos - pos - 1);
1712                 break;
1713         }
1714         case MONO_MARSHAL_CONV_ARRAY_BYVALCHARARRAY: {
1715                 mono_mb_emit_ldloc (mb, 0);
1716                 mono_mb_emit_byte (mb, CEE_LDIND_REF);
1717                 mono_mb_emit_byte (mb, CEE_BRFALSE_S);
1718                 pos = mb->pos;
1719                 mono_mb_emit_byte (mb, 0);
1720
1721                 mono_mb_emit_ldloc (mb, 1);
1722                 mono_mb_emit_ldloc (mb, 0);
1723                 mono_mb_emit_byte (mb, CEE_LDIND_REF);
1724                 mono_mb_emit_ptr (mb, mono_defaults.byte_class);
1725                 mono_mb_emit_icon (mb, mspec->data.array_data.num_elem);
1726                 mono_mb_emit_icall (mb, mono_array_to_byvalarray);
1727                 mono_mb_patch_addr_s (mb, pos, mb->pos - pos - 1);
1728                 break;
1729         }
1730         case MONO_MARSHAL_CONV_OBJECT_STRUCT: {
1731                 int src_var, dst_var;
1732
1733                 src_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
1734                 dst_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
1735
1736                 mono_mb_emit_ldloc (mb, 0);
1737                 mono_mb_emit_byte (mb, CEE_LDIND_I);
1738                 mono_mb_emit_byte (mb, CEE_BRFALSE_S);
1739                 pos = mb->pos;
1740                 mono_mb_emit_byte (mb, 0);
1741
1742                 /* save the old src pointer */
1743                 mono_mb_emit_ldloc (mb, 0);
1744                 mono_mb_emit_stloc (mb, src_var);
1745                 /* save the old dst pointer */
1746                 mono_mb_emit_ldloc (mb, 1);
1747                 mono_mb_emit_stloc (mb, dst_var);
1748
1749                 /* src = pointer to object data */
1750                 mono_mb_emit_ldloc (mb, 0);
1751                 mono_mb_emit_byte (mb, CEE_LDIND_I);
1752                 mono_mb_emit_icon (mb, sizeof (MonoObject));
1753                 mono_mb_emit_byte (mb, CEE_ADD);
1754                 mono_mb_emit_stloc (mb, 0);
1755
1756                 emit_struct_conv (mb, mono_class_from_mono_type (type), FALSE);
1757
1758                 /* restore the old src pointer */
1759                 mono_mb_emit_ldloc (mb, src_var);
1760                 mono_mb_emit_stloc (mb, 0);
1761                 /* restore the old dst pointer */
1762                 mono_mb_emit_ldloc (mb, dst_var);
1763                 mono_mb_emit_stloc (mb, 1);
1764
1765                 mono_mb_patch_addr_s (mb, pos, mb->pos - pos - 1);
1766                 break;
1767         }
1768         default: {
1769                 char *msg = g_strdup_printf ("marshalling conversion %d not implemented", conv);
1770                 MonoException *exc = mono_get_exception_not_implemented (msg);
1771                 g_warning (msg);
1772                 g_free (msg);
1773                 mono_raise_exception (exc);
1774         }
1775         }
1776 }
1777
1778 static void
1779 emit_struct_conv (MonoMethodBuilder *mb, MonoClass *klass, gboolean to_object)
1780 {
1781         MonoMarshalType *info;
1782         int i;
1783
1784         if (klass->parent)
1785                 emit_struct_conv(mb, klass->parent, to_object);
1786
1787         info = mono_marshal_load_type_info (klass);
1788
1789         if (info->native_size == 0)
1790                 return;
1791
1792         if (klass->blittable) {
1793                 int msize = mono_class_value_size (klass, NULL);
1794                 g_assert (msize == info->native_size);
1795                 mono_mb_emit_ldloc (mb, 1);
1796                 mono_mb_emit_ldloc (mb, 0);
1797                 mono_mb_emit_icon (mb, msize);
1798                 mono_mb_emit_byte (mb, CEE_PREFIX1);
1799                 mono_mb_emit_byte (mb, CEE_CPBLK);
1800
1801                 mono_mb_emit_add_to_local (mb, 0, msize);
1802                 mono_mb_emit_add_to_local (mb, 1, msize);
1803                 return;
1804         }
1805
1806         for (i = 0; i < info->num_fields; i++) {
1807                 MonoMarshalNative ntype;
1808                 MonoMarshalConv conv;
1809                 MonoType *ftype = info->fields [i].field->type;
1810                 int msize = 0;
1811                 int usize = 0;
1812                 gboolean last_field = i < (info->num_fields -1) ? 0 : 1;
1813
1814                 if (ftype->attrs & FIELD_ATTRIBUTE_STATIC)
1815                         continue;
1816
1817                 ntype = mono_type_to_unmanaged (ftype, info->fields [i].mspec, TRUE, klass->unicode, &conv);
1818
1819                 if (last_field) {
1820                         msize = klass->instance_size - info->fields [i].field->offset;
1821                         usize = info->native_size - info->fields [i].offset;
1822                 } else {
1823                         msize = info->fields [i + 1].field->offset - info->fields [i].field->offset;
1824                         usize = info->fields [i + 1].offset - info->fields [i].offset;
1825                 }
1826
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                 if (((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) && (usize == 0)) {
1832                         if (MONO_TYPE_IS_REFERENCE (info->fields [i].field->type) || ((!last_field && MONO_TYPE_IS_REFERENCE (info->fields [i + 1].field->type))))
1833                         g_error ("Type %s which has an [ExplicitLayout] attribute cannot have a reference field at the same offset as another field.", mono_type_full_name (&klass->byval_arg));
1834                 }
1835
1836                 if ((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_AUTO_LAYOUT)
1837                         g_error ("Type %s which is passed to unmanaged code must have a StructLayout attribute", mono_type_full_name (&klass->byval_arg));
1838
1839                 switch (conv) {
1840                 case MONO_MARSHAL_CONV_NONE: {
1841                         int t;
1842
1843                         if (ftype->byref || ftype->type == MONO_TYPE_I ||
1844                             ftype->type == MONO_TYPE_U) {
1845                                 mono_mb_emit_ldloc (mb, 1);
1846                                 mono_mb_emit_ldloc (mb, 0);
1847                                 mono_mb_emit_byte (mb, CEE_LDIND_I);
1848                                 mono_mb_emit_byte (mb, CEE_STIND_I);
1849                                 break;
1850                         }
1851
1852                 handle_enum:
1853                         t = ftype->type;
1854                         switch (t) {
1855                         case MONO_TYPE_I4:
1856                         case MONO_TYPE_U4:
1857                         case MONO_TYPE_I1:
1858                         case MONO_TYPE_U1:
1859                         case MONO_TYPE_BOOLEAN:
1860                         case MONO_TYPE_I2:
1861                         case MONO_TYPE_U2:
1862                         case MONO_TYPE_CHAR:
1863                         case MONO_TYPE_I8:
1864                         case MONO_TYPE_U8:
1865                         case MONO_TYPE_PTR:
1866                         case MONO_TYPE_R4:
1867                         case MONO_TYPE_R8:
1868                                 mono_mb_emit_ldloc (mb, 1);
1869                                 mono_mb_emit_ldloc (mb, 0);
1870                                 mono_mb_emit_byte (mb, mono_type_to_ldind (ftype));
1871                                 mono_mb_emit_byte (mb, mono_type_to_stind (ftype));
1872                                 break;
1873                         case MONO_TYPE_VALUETYPE: {
1874                                 int src_var, dst_var;
1875
1876                                 if (ftype->data.klass->enumtype) {
1877                                         ftype = ftype->data.klass->enum_basetype;
1878                                         goto handle_enum;
1879                                 }
1880
1881                                 src_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
1882                                 dst_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
1883
1884                                 /* save the old src pointer */
1885                                 mono_mb_emit_ldloc (mb, 0);
1886                                 mono_mb_emit_stloc (mb, src_var);
1887                                 /* save the old dst pointer */
1888                                 mono_mb_emit_ldloc (mb, 1);
1889                                 mono_mb_emit_stloc (mb, dst_var);
1890
1891                                 emit_struct_conv (mb, ftype->data.klass, to_object);
1892
1893                                 /* restore the old src pointer */
1894                                 mono_mb_emit_ldloc (mb, src_var);
1895                                 mono_mb_emit_stloc (mb, 0);
1896                                 /* restore the old dst pointer */
1897                                 mono_mb_emit_ldloc (mb, dst_var);
1898                                 mono_mb_emit_stloc (mb, 1);
1899                                 break;
1900                         }
1901
1902                         default:
1903                                 g_warning ("marshaling type %02x not implemented", ftype->type);
1904                                 g_assert_not_reached ();
1905                         }
1906                         break;
1907                 }
1908                 default: {
1909                         int src_var, dst_var;
1910
1911                         src_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
1912                         dst_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
1913
1914                         /* save the old src pointer */
1915                         mono_mb_emit_ldloc (mb, 0);
1916                         mono_mb_emit_stloc (mb, src_var);
1917                         /* save the old dst pointer */
1918                         mono_mb_emit_ldloc (mb, 1);
1919                         mono_mb_emit_stloc (mb, dst_var);
1920
1921                         if (to_object)
1922                                 emit_ptr_to_object_conv (mb, ftype, conv, info->fields [i].mspec);
1923                         else
1924                                 emit_object_to_ptr_conv (mb, ftype, conv, info->fields [i].mspec);
1925
1926                         /* restore the old src pointer */
1927                         mono_mb_emit_ldloc (mb, src_var);
1928                         mono_mb_emit_stloc (mb, 0);
1929                         /* restore the old dst pointer */
1930                         mono_mb_emit_ldloc (mb, dst_var);
1931                         mono_mb_emit_stloc (mb, 1);
1932                 }
1933                 }
1934
1935                 if (to_object) {
1936                         mono_mb_emit_add_to_local (mb, 0, usize);
1937                         mono_mb_emit_add_to_local (mb, 1, msize);
1938                 } else {
1939                         mono_mb_emit_add_to_local (mb, 0, msize);
1940                         mono_mb_emit_add_to_local (mb, 1, usize);
1941                 }
1942         }
1943 }
1944
1945 static void
1946 emit_struct_free (MonoMethodBuilder *mb, MonoClass *klass, int struct_var)
1947 {
1948         /* Call DestroyStructure */
1949         /* FIXME: Only do this if needed */
1950         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
1951         mono_mb_emit_byte (mb, CEE_MONO_CLASSCONST);
1952         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, klass));
1953         mono_mb_emit_ldloc (mb, struct_var);
1954         mono_mb_emit_icall (mb, mono_struct_delete_old);
1955 }
1956
1957 static void
1958 emit_thread_interrupt_checkpoint_call (MonoMethodBuilder *mb, gpointer checkpoint_func)
1959 {
1960         int pos_noabort;
1961
1962         mono_mb_emit_ptr (mb, (gpointer) mono_thread_interruption_request_flag ());
1963         mono_mb_emit_byte (mb, CEE_LDIND_U4);
1964         pos_noabort = mono_mb_emit_branch (mb, CEE_BRFALSE);
1965
1966         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
1967         mono_mb_emit_byte (mb, CEE_MONO_NOT_TAKEN);
1968
1969         mono_mb_emit_icall (mb, checkpoint_func);
1970
1971         mono_mb_patch_addr (mb, pos_noabort, mb->pos - (pos_noabort + 4));
1972 }
1973
1974 static void
1975 emit_thread_interrupt_checkpoint (MonoMethodBuilder *mb)
1976 {
1977         if (strstr (mb->name, "mono_thread_interruption_checkpoint"))
1978                 return;
1979
1980         emit_thread_interrupt_checkpoint_call (mb, mono_thread_interruption_checkpoint);
1981 }
1982
1983 static void
1984 emit_thread_force_interrupt_checkpoint (MonoMethodBuilder *mb)
1985 {
1986         emit_thread_interrupt_checkpoint_call (mb, mono_thread_force_interruption_checkpoint);
1987 }
1988
1989 static MonoAsyncResult *
1990 mono_delegate_begin_invoke (MonoDelegate *delegate, gpointer *params)
1991 {
1992         MonoMethodMessage *msg;
1993         MonoDelegate *async_callback;
1994         MonoObject *state;
1995         MonoMethod *im;
1996         MonoClass *klass;
1997         MonoMethod *method = NULL, *method2 = NULL;
1998
1999         g_assert (delegate);
2000
2001         if (delegate->target && mono_object_class (delegate->target) == mono_defaults.transparent_proxy_class) {
2002
2003                 MonoTransparentProxy* tp = (MonoTransparentProxy *)delegate->target;
2004                 if (!tp->remote_class->proxy_class->contextbound || tp->rp->context != (MonoObject *) mono_context_get ()) {
2005
2006                         /* If the target is a proxy, make a direct call. Is proxy's work
2007                         // to make the call asynchronous.
2008                         */
2009                         MonoAsyncResult *ares;
2010                         MonoObject *exc;
2011                         MonoArray *out_args;
2012                         HANDLE handle;
2013                         method = delegate->method_info->method;
2014
2015                         msg = mono_method_call_message_new (mono_marshal_method_from_wrapper (method), params, NULL, &async_callback, &state);
2016                         handle = CreateEvent (NULL, TRUE, FALSE, NULL);
2017                         ares = mono_async_result_new (mono_domain_get (), handle, state, handle, NULL);
2018                         MONO_OBJECT_SETREF (ares, async_delegate, (MonoObject *)delegate);
2019                         MONO_OBJECT_SETREF (ares, async_callback, (MonoObject *)async_callback);
2020                         MONO_OBJECT_SETREF (msg, async_result, ares);
2021                         msg->call_type = CallType_BeginInvoke;
2022
2023                         mono_remoting_invoke ((MonoObject *)tp->rp, msg, &exc, &out_args);
2024                         return ares;
2025                 }
2026         }
2027
2028         klass = delegate->object.vtable->klass;
2029
2030         method = mono_get_delegate_invoke (klass);
2031         method2 = mono_class_get_method_from_name (klass, "BeginInvoke", -1);
2032         if (method2)
2033                 method = method2;
2034         g_assert (method != NULL);
2035
2036         im = mono_get_delegate_invoke (method->klass);
2037         msg = mono_method_call_message_new (method, params, im, &async_callback, &state);
2038
2039         return mono_thread_pool_add ((MonoObject *)delegate, msg, async_callback, state);
2040 }
2041
2042 static int
2043 mono_mb_emit_save_args (MonoMethodBuilder *mb, MonoMethodSignature *sig, gboolean save_this)
2044 {
2045         int i, params_var, tmp_var;
2046
2047         /* allocate local (pointer) *params[] */
2048         params_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
2049         /* allocate local (pointer) tmp */
2050         tmp_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
2051
2052         /* alloate space on stack to store an array of pointers to the arguments */
2053         mono_mb_emit_icon (mb, sizeof (gpointer) * (sig->param_count + 1));
2054         mono_mb_emit_byte (mb, CEE_PREFIX1);
2055         mono_mb_emit_byte (mb, CEE_LOCALLOC);
2056         mono_mb_emit_stloc (mb, params_var);
2057
2058         /* tmp = params */
2059         mono_mb_emit_ldloc (mb, params_var);
2060         mono_mb_emit_stloc (mb, tmp_var);
2061
2062         if (save_this && sig->hasthis) {
2063                 mono_mb_emit_ldloc (mb, tmp_var);
2064                 mono_mb_emit_ldarg_addr (mb, 0);
2065                 mono_mb_emit_byte (mb, CEE_STIND_I);
2066                 /* tmp = tmp + sizeof (gpointer) */
2067                 if (sig->param_count)
2068                         mono_mb_emit_add_to_local (mb, tmp_var, sizeof (gpointer));
2069
2070         }
2071
2072         for (i = 0; i < sig->param_count; i++) {
2073                 mono_mb_emit_ldloc (mb, tmp_var);
2074                 mono_mb_emit_ldarg_addr (mb, i + sig->hasthis);
2075                 mono_mb_emit_byte (mb, CEE_STIND_I);
2076                 /* tmp = tmp + sizeof (gpointer) */
2077                 if (i < (sig->param_count - 1))
2078                         mono_mb_emit_add_to_local (mb, tmp_var, sizeof (gpointer));
2079         }
2080
2081         return params_var;
2082 }
2083
2084 static char*
2085 mono_signature_to_name (MonoMethodSignature *sig, const char *prefix)
2086 {
2087         int i;
2088         char *result;
2089         GString *res = g_string_new ("");
2090
2091         if (prefix) {
2092                 g_string_append (res, prefix);
2093                 g_string_append_c (res, '_');
2094         }
2095
2096         mono_type_get_desc (res, sig->ret, FALSE);
2097
2098         for (i = 0; i < sig->param_count; ++i) {
2099                 g_string_append_c (res, '_');
2100                 mono_type_get_desc (res, sig->params [i], FALSE);
2101         }
2102         result = res->str;
2103         g_string_free (res, FALSE);
2104         return result;
2105 }
2106
2107 /**
2108  * mono_marshal_get_string_encoding:
2109  *
2110  *  Return the string encoding which should be used for a given parameter.
2111  */
2112 static MonoMarshalNative
2113 mono_marshal_get_string_encoding (MonoMethodPInvoke *piinfo, MonoMarshalSpec *spec)
2114 {
2115         /* First try the parameter marshal info */
2116         if (spec) {
2117                 if (spec->native == MONO_NATIVE_LPARRAY) {
2118                         if ((spec->data.array_data.elem_type != 0) && (spec->data.array_data.elem_type != MONO_NATIVE_MAX))
2119                                 return spec->data.array_data.elem_type;
2120                 }
2121                 else
2122                         return spec->native;
2123         }
2124
2125         if (!piinfo)
2126                 return MONO_NATIVE_LPSTR;
2127
2128         /* Then try the method level marshal info */
2129         switch (piinfo->piflags & PINVOKE_ATTRIBUTE_CHAR_SET_MASK) {
2130         case PINVOKE_ATTRIBUTE_CHAR_SET_ANSI:
2131                 return MONO_NATIVE_LPSTR;
2132         case PINVOKE_ATTRIBUTE_CHAR_SET_UNICODE:
2133                 return MONO_NATIVE_LPWSTR;
2134         case PINVOKE_ATTRIBUTE_CHAR_SET_AUTO:
2135 #ifdef PLATFORM_WIN32
2136                 return MONO_NATIVE_LPWSTR;
2137 #else
2138                 return MONO_NATIVE_LPSTR;
2139 #endif
2140         default:
2141                 return MONO_NATIVE_LPSTR;
2142         }
2143 }
2144
2145 static MonoMarshalConv
2146 mono_marshal_get_string_to_ptr_conv (MonoMethodPInvoke *piinfo, MonoMarshalSpec *spec)
2147 {
2148         MonoMarshalNative encoding = mono_marshal_get_string_encoding (piinfo, spec);
2149
2150         switch (encoding) {
2151         case MONO_NATIVE_LPWSTR:
2152                 return MONO_MARSHAL_CONV_STR_LPWSTR;
2153         case MONO_NATIVE_LPSTR:
2154                 return MONO_MARSHAL_CONV_STR_LPSTR;
2155         case MONO_NATIVE_LPTSTR:
2156                 return MONO_MARSHAL_CONV_STR_LPTSTR;
2157         case MONO_NATIVE_BSTR:
2158                 return MONO_MARSHAL_CONV_STR_BSTR;
2159         default:
2160                 return -1;
2161         }
2162 }
2163
2164 static MonoMarshalConv
2165 mono_marshal_get_stringbuilder_to_ptr_conv (MonoMethodPInvoke *piinfo, MonoMarshalSpec *spec)
2166 {
2167         MonoMarshalNative encoding = mono_marshal_get_string_encoding (piinfo, spec);
2168
2169         switch (encoding) {
2170         case MONO_NATIVE_LPWSTR:
2171                 return MONO_MARSHAL_CONV_SB_LPWSTR;
2172                 break;
2173         case MONO_NATIVE_LPSTR:
2174                 return MONO_MARSHAL_CONV_SB_LPSTR;
2175                 break;
2176         case MONO_NATIVE_LPTSTR:
2177                 return MONO_MARSHAL_CONV_SB_LPTSTR;
2178                 break;
2179         default:
2180                 return -1;
2181         }
2182 }
2183
2184 static MonoMarshalConv
2185 mono_marshal_get_ptr_to_string_conv (MonoMethodPInvoke *piinfo, MonoMarshalSpec *spec, gboolean *need_free)
2186 {
2187         MonoMarshalNative encoding = mono_marshal_get_string_encoding (piinfo, spec);
2188
2189         *need_free = TRUE;
2190
2191         switch (encoding) {
2192         case MONO_NATIVE_LPWSTR:
2193                 return MONO_MARSHAL_CONV_LPWSTR_STR;
2194         case MONO_NATIVE_LPSTR:
2195                 return MONO_MARSHAL_CONV_LPSTR_STR;
2196         case MONO_NATIVE_LPTSTR:
2197                 return MONO_MARSHAL_CONV_LPTSTR_STR;
2198         case MONO_NATIVE_BSTR:
2199                 return MONO_MARSHAL_CONV_BSTR_STR;
2200         default:
2201                 return -1;
2202         }
2203 }
2204
2205 static MonoMarshalConv
2206 mono_marshal_get_ptr_to_stringbuilder_conv (MonoMethodPInvoke *piinfo, MonoMarshalSpec *spec, gboolean *need_free)
2207 {
2208         MonoMarshalNative encoding = mono_marshal_get_string_encoding (piinfo, spec);
2209
2210         *need_free = TRUE;
2211
2212         switch (encoding) {
2213         case MONO_NATIVE_LPWSTR:
2214                 /*
2215                  * mono_string_builder_to_utf16 does not allocate a
2216                  * new buffer, so no need to free it.
2217                  */
2218                 *need_free = FALSE;
2219                 return MONO_MARSHAL_CONV_LPWSTR_SB;
2220         case MONO_NATIVE_LPSTR:
2221                 return MONO_MARSHAL_CONV_LPSTR_SB;
2222                 break;
2223         case MONO_NATIVE_LPTSTR:
2224                 return MONO_MARSHAL_CONV_LPTSTR_SB;
2225                 break;
2226         default:
2227                 return -1;
2228         }
2229 }
2230
2231 /*
2232  * Return whenever a field of a native structure or an array member needs to
2233  * be freed.
2234  */
2235 static gboolean
2236 mono_marshal_need_free (MonoType *t, MonoMethodPInvoke *piinfo, MonoMarshalSpec *spec)
2237 {
2238         MonoMarshalNative encoding;
2239         MonoMarshalConv conv;
2240
2241         switch (t->type) {
2242         case MONO_TYPE_VALUETYPE:
2243                 /* FIXME: Optimize this */
2244                 return TRUE;
2245         case MONO_TYPE_OBJECT:
2246         case MONO_TYPE_CLASS:
2247                 if (t->data.klass == mono_defaults.stringbuilder_class) {
2248                         gboolean need_free;
2249                         conv = mono_marshal_get_ptr_to_stringbuilder_conv (piinfo, spec, &need_free);
2250                         return need_free;
2251                 }
2252                 return FALSE;
2253         case MONO_TYPE_STRING:
2254                 encoding = mono_marshal_get_string_encoding (piinfo, spec);
2255                 return (encoding == MONO_NATIVE_LPWSTR) ? FALSE : TRUE;
2256         default:
2257                 return FALSE;
2258         }
2259 }
2260
2261 static inline MonoMethod*
2262 mono_marshal_find_in_cache (GHashTable *cache, gpointer key)
2263 {
2264         MonoMethod *res;
2265
2266         mono_marshal_lock ();
2267         res = g_hash_table_lookup (cache, key);
2268         mono_marshal_unlock ();
2269         return res;
2270 }
2271
2272 /* Create the method from the builder and place it in the cache */
2273 static inline MonoMethod*
2274 mono_mb_create_and_cache (GHashTable *cache, gpointer key,
2275                                                            MonoMethodBuilder *mb, MonoMethodSignature *sig,
2276                                                            int max_stack)
2277 {
2278         MonoMethod *res;
2279
2280         mono_loader_lock ();
2281         mono_marshal_lock ();
2282         res = g_hash_table_lookup (cache, key);
2283         if (!res) {
2284                 /* This does not acquire any locks */
2285                 res = mono_mb_create_method (mb, sig, max_stack);
2286                 g_hash_table_insert (cache, key, res);
2287                 g_hash_table_insert (wrapper_hash, res, key);
2288         }
2289         mono_marshal_unlock ();
2290         mono_loader_unlock ();
2291
2292         return res;
2293 }
2294
2295
2296 static inline MonoMethod*
2297 mono_marshal_remoting_find_in_cache (MonoMethod *method, int wrapper_type)
2298 {
2299         MonoMethod *res = NULL;
2300         MonoRemotingMethods *wrps;
2301
2302         mono_marshal_lock ();
2303         wrps = g_hash_table_lookup (method->klass->image->remoting_invoke_cache, method);
2304
2305         if (wrps) {
2306                 switch (wrapper_type) {
2307                 case MONO_WRAPPER_REMOTING_INVOKE: res = wrps->invoke; break;
2308                 case MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK: res = wrps->invoke_with_check; break;
2309                 case MONO_WRAPPER_XDOMAIN_INVOKE: res = wrps->xdomain_invoke; break;
2310                 case MONO_WRAPPER_XDOMAIN_DISPATCH: res = wrps->xdomain_dispatch; break;
2311                 }
2312         }
2313
2314         mono_marshal_unlock ();
2315         return res;
2316 }
2317
2318 /* Create the method from the builder and place it in the cache */
2319 static inline MonoMethod*
2320 mono_remoting_mb_create_and_cache (MonoMethod *key, MonoMethodBuilder *mb,
2321                                                                 MonoMethodSignature *sig, int max_stack)
2322 {
2323         MonoMethod **res = NULL;
2324         MonoRemotingMethods *wrps;
2325         GHashTable *cache = key->klass->image->remoting_invoke_cache;
2326
2327         mono_loader_lock ();
2328         mono_marshal_lock ();
2329         wrps = g_hash_table_lookup (cache, key);
2330         if (!wrps) {
2331                 wrps = g_new0 (MonoRemotingMethods, 1);
2332                 g_hash_table_insert (cache, key, wrps);
2333         }
2334
2335         switch (mb->method->wrapper_type) {
2336         case MONO_WRAPPER_REMOTING_INVOKE: res = &wrps->invoke; break;
2337         case MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK: res = &wrps->invoke_with_check; break;
2338         case MONO_WRAPPER_XDOMAIN_INVOKE: res = &wrps->xdomain_invoke; break;
2339         case MONO_WRAPPER_XDOMAIN_DISPATCH: res = &wrps->xdomain_dispatch; break;
2340         default: g_assert_not_reached (); break;
2341         }
2342
2343         if (*res == NULL) {
2344                 /* This does not acquire any locks */
2345                 *res = mono_mb_create_method (mb, sig, max_stack);
2346                 g_hash_table_insert (wrapper_hash, *res, key);
2347         }
2348
2349         mono_marshal_unlock ();
2350         mono_loader_unlock ();
2351
2352         return *res;
2353 }
2354
2355 MonoMethod *
2356 mono_marshal_method_from_wrapper (MonoMethod *wrapper)
2357 {
2358         MonoMethod *res;
2359
2360         if (wrapper->wrapper_type == MONO_WRAPPER_NONE)
2361                 return wrapper;
2362
2363         mono_marshal_lock ();
2364         res = g_hash_table_lookup (wrapper_hash, wrapper);
2365         mono_marshal_unlock ();
2366         return res;
2367 }
2368
2369 MonoMethod *
2370 mono_marshal_get_delegate_begin_invoke (MonoMethod *method)
2371 {
2372         MonoMethodSignature *sig;
2373         MonoMethodBuilder *mb;
2374         MonoMethod *res;
2375         GHashTable *cache;
2376         int params_var;
2377         char *name;
2378
2379         g_assert (method && method->klass->parent == mono_defaults.multicastdelegate_class &&
2380                   !strcmp (method->name, "BeginInvoke"));
2381
2382         sig = signature_no_pinvoke (method);
2383
2384         cache = method->klass->image->delegate_begin_invoke_cache;
2385         if ((res = mono_marshal_find_in_cache (cache, sig)))
2386                 return res;
2387
2388         g_assert (sig->hasthis);
2389
2390         name = mono_signature_to_name (sig, "begin_invoke");
2391         mb = mono_mb_new (mono_defaults.multicastdelegate_class, name, MONO_WRAPPER_DELEGATE_BEGIN_INVOKE);
2392         g_free (name);
2393
2394         mb->method->save_lmf = 1;
2395
2396         params_var = mono_mb_emit_save_args (mb, sig, FALSE);
2397
2398         mono_mb_emit_ldarg (mb, 0);
2399         mono_mb_emit_ldloc (mb, params_var);
2400         mono_mb_emit_icall (mb, mono_delegate_begin_invoke);
2401         emit_thread_interrupt_checkpoint (mb);
2402         mono_mb_emit_byte (mb, CEE_RET);
2403
2404         res = mono_mb_create_and_cache (cache, sig, mb, sig, sig->param_count + 16);
2405         mono_mb_free (mb);
2406         return res;
2407 }
2408
2409 static MonoObject *
2410 mono_delegate_end_invoke (MonoDelegate *delegate, gpointer *params)
2411 {
2412         MonoDomain *domain = mono_domain_get ();
2413         MonoAsyncResult *ares;
2414         MonoMethod *method = NULL;
2415         MonoMethodSignature *sig;
2416         MonoMethodMessage *msg;
2417         MonoObject *res, *exc;
2418         MonoArray *out_args;
2419         MonoClass *klass;
2420
2421         g_assert (delegate);
2422
2423         if (!delegate->method_info || !delegate->method_info->method)
2424                 g_assert_not_reached ();
2425
2426         klass = delegate->object.vtable->klass;
2427
2428         method = mono_class_get_method_from_name (klass, "EndInvoke", -1);
2429         g_assert (method != NULL);
2430
2431         sig = signature_no_pinvoke (method);
2432
2433         msg = mono_method_call_message_new (method, params, NULL, NULL, NULL);
2434
2435         ares = mono_array_get (msg->args, gpointer, sig->param_count - 1);
2436         g_assert (ares);
2437
2438         if (delegate->target && mono_object_class (delegate->target) == mono_defaults.transparent_proxy_class) {
2439                 MonoTransparentProxy* tp = (MonoTransparentProxy *)delegate->target;
2440                 msg = (MonoMethodMessage *)mono_object_new (domain, mono_defaults.mono_method_message_class);
2441                 mono_message_init (domain, msg, delegate->method_info, NULL);
2442                 msg->call_type = CallType_EndInvoke;
2443                 MONO_OBJECT_SETREF (msg, async_result, ares);
2444                 res = mono_remoting_invoke ((MonoObject *)tp->rp, msg, &exc, &out_args);
2445         }
2446         else
2447                 res = mono_thread_pool_finish (ares, &out_args, &exc);
2448
2449         if (exc) {
2450                 if (((MonoException*)exc)->stack_trace) {
2451                         char *strace = mono_string_to_utf8 (((MonoException*)exc)->stack_trace);
2452                         char  *tmp;
2453                         tmp = g_strdup_printf ("%s\nException Rethrown at:\n", strace);
2454                         g_free (strace);
2455                         MONO_OBJECT_SETREF (((MonoException*)exc), stack_trace, mono_string_new (domain, tmp));
2456                         g_free (tmp);
2457                 }
2458                 mono_raise_exception ((MonoException*)exc);
2459         }
2460
2461         mono_method_return_message_restore (method, params, out_args);
2462         return res;
2463 }
2464
2465 static void
2466 mono_mb_emit_restore_result (MonoMethodBuilder *mb, MonoType *return_type)
2467 {
2468         MonoType *t = mono_type_get_underlying_type (return_type);
2469
2470         if (return_type->byref)
2471                 return_type = &mono_defaults.int_class->byval_arg;
2472
2473         switch (t->type) {
2474         case MONO_TYPE_VOID:
2475                 g_assert_not_reached ();
2476                 break;
2477         case MONO_TYPE_PTR:
2478         case MONO_TYPE_STRING:
2479         case MONO_TYPE_CLASS:
2480         case MONO_TYPE_OBJECT:
2481         case MONO_TYPE_ARRAY:
2482         case MONO_TYPE_SZARRAY:
2483                 /* nothing to do */
2484                 break;
2485         case MONO_TYPE_U1:
2486         case MONO_TYPE_BOOLEAN:
2487         case MONO_TYPE_I1:
2488         case MONO_TYPE_U2:
2489         case MONO_TYPE_CHAR:
2490         case MONO_TYPE_I2:
2491         case MONO_TYPE_I:
2492         case MONO_TYPE_U:
2493         case MONO_TYPE_I4:
2494         case MONO_TYPE_U4:
2495         case MONO_TYPE_U8:
2496         case MONO_TYPE_I8:
2497         case MONO_TYPE_R4:
2498         case MONO_TYPE_R8:
2499                 mono_mb_emit_byte (mb, CEE_UNBOX);
2500                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, mono_class_from_mono_type (return_type)));
2501                 mono_mb_emit_byte (mb, mono_type_to_ldind (return_type));
2502                 break;
2503         case MONO_TYPE_GENERICINST:
2504                 if (!mono_type_generic_inst_is_valuetype (return_type))
2505                         break;
2506                 /* fall through */
2507         case MONO_TYPE_VALUETYPE: {
2508                 int class;
2509                 mono_mb_emit_byte (mb, CEE_UNBOX);
2510                 class = mono_mb_add_data (mb, mono_class_from_mono_type (return_type));
2511                 mono_mb_emit_i4 (mb, class);
2512                 mono_mb_emit_byte (mb, CEE_LDOBJ);
2513                 mono_mb_emit_i4 (mb, class);
2514                 break;
2515         }
2516         default:
2517                 g_warning ("type 0x%x not handled", return_type->type);
2518                 g_assert_not_reached ();
2519         }
2520
2521         mono_mb_emit_byte (mb, CEE_RET);
2522 }
2523
2524 MonoMethod *
2525 mono_marshal_get_delegate_end_invoke (MonoMethod *method)
2526 {
2527         MonoMethodSignature *sig;
2528         MonoMethodBuilder *mb;
2529         MonoMethod *res;
2530         GHashTable *cache;
2531         int params_var;
2532         char *name;
2533
2534         g_assert (method && method->klass->parent == mono_defaults.multicastdelegate_class &&
2535                   !strcmp (method->name, "EndInvoke"));
2536
2537         sig = signature_no_pinvoke (method);
2538
2539         cache = method->klass->image->delegate_end_invoke_cache;
2540         if ((res = mono_marshal_find_in_cache (cache, sig)))
2541                 return res;
2542
2543         g_assert (sig->hasthis);
2544
2545         name = mono_signature_to_name (sig, "end_invoke");
2546         mb = mono_mb_new (mono_defaults.multicastdelegate_class, name, MONO_WRAPPER_DELEGATE_END_INVOKE);
2547         g_free (name);
2548
2549         mb->method->save_lmf = 1;
2550
2551         params_var = mono_mb_emit_save_args (mb, sig, FALSE);
2552
2553         mono_mb_emit_ldarg (mb, 0);
2554         mono_mb_emit_ldloc (mb, params_var);
2555         mono_mb_emit_icall (mb, mono_delegate_end_invoke);
2556         emit_thread_interrupt_checkpoint (mb);
2557
2558         if (sig->ret->type == MONO_TYPE_VOID) {
2559                 mono_mb_emit_byte (mb, CEE_POP);
2560                 mono_mb_emit_byte (mb, CEE_RET);
2561         } else
2562                 mono_mb_emit_restore_result (mb, sig->ret);
2563
2564         res = mono_mb_create_and_cache (cache, sig,
2565                                                                                  mb, sig, sig->param_count + 16);
2566         mono_mb_free (mb);
2567
2568         return res;
2569 }
2570
2571 static MonoObject *
2572 mono_remoting_wrapper (MonoMethod *method, gpointer *params)
2573 {
2574         MonoMethodMessage *msg;
2575         MonoTransparentProxy *this;
2576         MonoObject *res, *exc;
2577         MonoArray *out_args;
2578
2579         this = *((MonoTransparentProxy **)params [0]);
2580
2581         g_assert (this);
2582         g_assert (((MonoObject *)this)->vtable->klass == mono_defaults.transparent_proxy_class);
2583
2584         /* skip the this pointer */
2585         params++;
2586
2587         if (this->remote_class->proxy_class->contextbound && this->rp->context == (MonoObject *) mono_context_get ())
2588         {
2589                 int i;
2590                 MonoMethodSignature *sig = mono_method_signature (method);
2591                 int count = sig->param_count;
2592                 gpointer* mparams = (gpointer*) alloca(count*sizeof(gpointer));
2593
2594                 for (i=0; i<count; i++) {
2595                         MonoClass *class = mono_class_from_mono_type (sig->params [i]);
2596                         if (class->valuetype) {
2597                                 if (sig->params [i]->byref)
2598                                         mparams[i] = *((gpointer *)params [i]);
2599                                 else
2600                                         mparams[i] = params [i];
2601                         } else {
2602                                 mparams[i] = *((gpointer**)params [i]);
2603                         }
2604                 }
2605
2606                 return mono_runtime_invoke (method, method->klass->valuetype? mono_object_unbox ((MonoObject*)this): this, mparams, NULL);
2607         }
2608
2609         msg = mono_method_call_message_new (method, params, NULL, NULL, NULL);
2610
2611         res = mono_remoting_invoke ((MonoObject *)this->rp, msg, &exc, &out_args);
2612
2613         if (exc)
2614                 mono_raise_exception ((MonoException *)exc);
2615
2616         mono_method_return_message_restore (method, params, out_args);
2617
2618         return res;
2619 }
2620
2621 MonoMethod *
2622 mono_marshal_get_remoting_invoke (MonoMethod *method)
2623 {
2624         MonoMethodSignature *sig;
2625         MonoMethodBuilder *mb;
2626         MonoMethod *res;
2627         int params_var;
2628
2629         g_assert (method);
2630
2631         if (method->wrapper_type == MONO_WRAPPER_REMOTING_INVOKE || method->wrapper_type == MONO_WRAPPER_XDOMAIN_INVOKE)
2632                 return method;
2633
2634         sig = signature_no_pinvoke (method);
2635
2636         /* we cant remote methods without this pointer */
2637         if (!sig->hasthis)
2638                 return method;
2639
2640         if ((res = mono_marshal_remoting_find_in_cache (method, MONO_WRAPPER_REMOTING_INVOKE)))
2641                 return res;
2642
2643         mb = mono_mb_new (method->klass, method->name, MONO_WRAPPER_REMOTING_INVOKE);
2644         mb->method->save_lmf = 1;
2645
2646         params_var = mono_mb_emit_save_args (mb, sig, TRUE);
2647
2648         mono_mb_emit_ptr (mb, method);
2649         mono_mb_emit_ldloc (mb, params_var);
2650         mono_mb_emit_icall (mb, mono_remoting_wrapper);
2651         emit_thread_interrupt_checkpoint (mb);
2652
2653         if (sig->ret->type == MONO_TYPE_VOID) {
2654                 mono_mb_emit_byte (mb, CEE_POP);
2655                 mono_mb_emit_byte (mb, CEE_RET);
2656         } else {
2657                  mono_mb_emit_restore_result (mb, sig->ret);
2658         }
2659
2660         res = mono_remoting_mb_create_and_cache (method, mb, sig, sig->param_count + 16);
2661         mono_mb_free (mb);
2662
2663         return res;
2664 }
2665
2666 /* mono_get_xdomain_marshal_type()
2667  * Returns the kind of marshalling that a type needs for cross domain calls.
2668  */
2669 static MonoXDomainMarshalType
2670 mono_get_xdomain_marshal_type (MonoType *t)
2671 {
2672         switch (t->type) {
2673         case MONO_TYPE_VOID:
2674                 g_assert_not_reached ();
2675                 break;
2676         case MONO_TYPE_U1:
2677         case MONO_TYPE_I1:
2678         case MONO_TYPE_BOOLEAN:
2679         case MONO_TYPE_U2:
2680         case MONO_TYPE_I2:
2681         case MONO_TYPE_CHAR:
2682         case MONO_TYPE_U4:
2683         case MONO_TYPE_I4:
2684         case MONO_TYPE_I8:
2685         case MONO_TYPE_U8:
2686         case MONO_TYPE_R4:
2687         case MONO_TYPE_R8:
2688                 return MONO_MARSHAL_NONE;
2689         case MONO_TYPE_STRING:
2690                 return MONO_MARSHAL_COPY;
2691         case MONO_TYPE_ARRAY:
2692         case MONO_TYPE_SZARRAY: {
2693                 MonoClass *elem_class = mono_class_from_mono_type (t)->element_class;
2694                 if (mono_get_xdomain_marshal_type (&(elem_class->byval_arg)) != MONO_MARSHAL_SERIALIZE)
2695                         return MONO_MARSHAL_COPY;
2696                 break;
2697         }
2698         }
2699
2700         if (mono_class_from_mono_type (t) == mono_defaults.stringbuilder_class)
2701                 return MONO_MARSHAL_COPY;
2702
2703         return MONO_MARSHAL_SERIALIZE;
2704 }
2705
2706
2707 /* mono_marshal_xdomain_copy_value
2708  * Makes a copy of "val" suitable for the current domain.
2709  */
2710 static MonoObject *
2711 mono_marshal_xdomain_copy_value (MonoObject *val)
2712 {
2713         MonoDomain *domain;
2714         if (val == NULL) return NULL;
2715
2716         domain = mono_domain_get ();
2717
2718         switch (mono_object_class (val)->byval_arg.type) {
2719         case MONO_TYPE_VOID:
2720                 g_assert_not_reached ();
2721                 break;
2722         case MONO_TYPE_U1:
2723         case MONO_TYPE_I1:
2724         case MONO_TYPE_BOOLEAN:
2725         case MONO_TYPE_U2:
2726         case MONO_TYPE_I2:
2727         case MONO_TYPE_CHAR:
2728         case MONO_TYPE_U4:
2729         case MONO_TYPE_I4:
2730         case MONO_TYPE_I8:
2731         case MONO_TYPE_U8:
2732         case MONO_TYPE_R4:
2733         case MONO_TYPE_R8: {
2734                 return mono_value_box (domain, mono_object_class (val), ((char*)val) + sizeof(MonoObject));
2735         }
2736         case MONO_TYPE_STRING: {
2737                 MonoString *str = (MonoString *) val;
2738                 return (MonoObject *) mono_string_new_utf16 (domain, mono_string_chars (str), mono_string_length (str));
2739         }
2740         case MONO_TYPE_ARRAY:
2741         case MONO_TYPE_SZARRAY: {
2742                 MonoArray *acopy;
2743                 MonoXDomainMarshalType mt = mono_get_xdomain_marshal_type (&(mono_object_class (val)->element_class->byval_arg));
2744                 if (mt == MONO_MARSHAL_SERIALIZE) return NULL;
2745                 acopy = mono_array_clone_in_domain (domain, (MonoArray *) val);
2746                 if (mt == MONO_MARSHAL_COPY) {
2747                         int i, len = mono_array_length (acopy);
2748                         for (i = 0; i < len; i++) {
2749                                 MonoObject *item = mono_array_get (acopy, gpointer, i);
2750                                 mono_array_setref (acopy, i, mono_marshal_xdomain_copy_value (item));
2751                         }
2752                 }
2753                 return (MonoObject *) acopy;
2754         }
2755         }
2756
2757         if (mono_object_class (val) == mono_defaults.stringbuilder_class) {
2758                 MonoStringBuilder *oldsb = (MonoStringBuilder *) val;
2759                 MonoStringBuilder *newsb = (MonoStringBuilder *) mono_object_new (domain, mono_defaults.stringbuilder_class);
2760                 MONO_OBJECT_SETREF (newsb, str, mono_string_new_utf16 (domain, mono_string_chars (oldsb->str), mono_string_length (oldsb->str)));
2761                 newsb->length = oldsb->length;
2762                 newsb->max_capacity = (gint32)0x7fffffff;
2763                 return (MonoObject *) newsb;
2764         }
2765         return NULL;
2766 }
2767
2768 /* mono_marshal_xdomain_copy_out_value()
2769  * Copies the contents of the src instance into the dst instance. src and dst
2770  * must have the same type, and if they are arrays, the same size.
2771  */
2772 static void
2773 mono_marshal_xdomain_copy_out_value (MonoObject *src, MonoObject *dst)
2774 {
2775         if (src == NULL || dst == NULL) return;
2776
2777         g_assert (mono_object_class (src) == mono_object_class (dst));
2778
2779         switch (mono_object_class (src)->byval_arg.type) {
2780         case MONO_TYPE_ARRAY:
2781         case MONO_TYPE_SZARRAY: {
2782                 int mt = mono_get_xdomain_marshal_type (&(mono_object_class (src)->element_class->byval_arg));
2783                 if (mt == MONO_MARSHAL_SERIALIZE) return;
2784                 if (mt == MONO_MARSHAL_COPY) {
2785                         int i, len = mono_array_length ((MonoArray *)dst);
2786                         for (i = 0; i < len; i++) {
2787                                 MonoObject *item = mono_array_get ((MonoArray *)src, gpointer, i);
2788                                 mono_array_setref ((MonoArray *)dst, i, mono_marshal_xdomain_copy_value (item));
2789                         }
2790                 } else {
2791                         mono_array_full_copy ((MonoArray *)src, (MonoArray *)dst);
2792                 }
2793                 return;
2794         }
2795         }
2796
2797         if (mono_object_class (src) == mono_defaults.stringbuilder_class) {
2798                 MonoStringBuilder *src_sb = (MonoStringBuilder *) src;
2799                 MonoStringBuilder *dst_sb = (MonoStringBuilder *) dst;
2800
2801                 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)));
2802                 dst_sb->cached_str = NULL;
2803                 dst_sb->length = src_sb->length;
2804         }
2805 }
2806
2807 static void
2808 mono_marshal_emit_xdomain_copy_value (MonoMethodBuilder *mb, MonoClass *pclass)
2809 {
2810         mono_mb_emit_icall (mb, mono_marshal_xdomain_copy_value);
2811         mono_mb_emit_byte (mb, CEE_CASTCLASS);
2812         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, pclass));
2813 }
2814
2815 static void
2816 mono_marshal_emit_xdomain_copy_out_value (MonoMethodBuilder *mb, MonoClass *pclass)
2817 {
2818         mono_mb_emit_icall (mb, mono_marshal_xdomain_copy_out_value);
2819 }
2820
2821 /* mono_marshal_supports_fast_xdomain()
2822  * Returns TRUE if the method can use the fast xdomain wrapper.
2823  */
2824 static gboolean
2825 mono_marshal_supports_fast_xdomain (MonoMethod *method)
2826 {
2827         return !method->klass->contextbound &&
2828                    !((method->flags & METHOD_ATTRIBUTE_SPECIAL_NAME) && (strcmp (".ctor", method->name) == 0));
2829 }
2830
2831 static gint32
2832 mono_marshal_set_domain_by_id (gint32 id, MonoBoolean push)
2833 {
2834         MonoDomain *current_domain = mono_domain_get ();
2835         MonoDomain *domain = mono_domain_get_by_id (id);
2836
2837         if (!domain || !mono_domain_set (domain, FALSE))
2838                 mono_raise_exception (mono_get_exception_appdomain_unloaded ());
2839
2840         if (push)
2841                 mono_thread_push_appdomain_ref (domain);
2842         else
2843                 mono_thread_pop_appdomain_ref ();
2844
2845         return current_domain->domain_id;
2846 }
2847
2848 static void
2849 mono_marshal_emit_switch_domain (MonoMethodBuilder *mb)
2850 {
2851         mono_mb_emit_icall (mb, mono_marshal_set_domain_by_id);
2852 }
2853
2854 /* mono_marshal_emit_load_domain_method ()
2855  * Loads into the stack a pointer to the code of the provided method for
2856  * the current domain.
2857  */
2858 static void
2859 mono_marshal_emit_load_domain_method (MonoMethodBuilder *mb, MonoMethod *method)
2860 {
2861         /* We need a pointer to the method for the running domain (not the domain
2862          * that compiles the method).
2863          */
2864         mono_mb_emit_ptr (mb, method);
2865         mono_mb_emit_icall (mb, mono_compile_method);
2866 }
2867
2868 /* mono_marshal_get_xappdomain_dispatch ()
2869  * Generates a method that dispatches a method call from another domain into
2870  * the current domain.
2871  */
2872 static MonoMethod *
2873 mono_marshal_get_xappdomain_dispatch (MonoMethod *method, int *marshal_types, int complex_count, int complex_out_count, int ret_marshal_type)
2874 {
2875         MonoMethodSignature *sig, *csig;
2876         MonoMethodBuilder *mb;
2877         MonoMethod *res;
2878         int i, j, param_index, copy_locals_base;
2879         MonoClass *ret_class = NULL;
2880         int loc_array=0, loc_return=0, loc_serialized_exc=0;
2881         MonoExceptionClause *main_clause;
2882         MonoMethodHeader *header;
2883         int pos, pos_leave;
2884         gboolean copy_return;
2885
2886         if ((res = mono_marshal_remoting_find_in_cache (method, MONO_WRAPPER_XDOMAIN_DISPATCH)))
2887                 return res;
2888
2889         sig = mono_method_signature (method);
2890         copy_return = (sig->ret->type != MONO_TYPE_VOID && ret_marshal_type != MONO_MARSHAL_SERIALIZE);
2891
2892         j = 0;
2893         csig = mono_metadata_signature_alloc (mono_defaults.corlib, 3 + sig->param_count - complex_count);
2894         csig->params [j++] = &mono_defaults.object_class->byval_arg;
2895         csig->params [j++] = &byte_array_class->this_arg;
2896         csig->params [j++] = &byte_array_class->this_arg;
2897         for (i = 0; i < sig->param_count; i++) {
2898                 if (marshal_types [i] != MONO_MARSHAL_SERIALIZE)
2899                         csig->params [j++] = sig->params [i];
2900         }
2901         if (copy_return)
2902                 csig->ret = sig->ret;
2903         else
2904                 csig->ret = &mono_defaults.void_class->byval_arg;
2905         csig->pinvoke = 1;
2906         csig->hasthis = FALSE;
2907
2908         mb = mono_mb_new (method->klass, method->name, MONO_WRAPPER_XDOMAIN_DISPATCH);
2909         mb->method->save_lmf = 1;
2910
2911         /* Locals */
2912
2913         loc_serialized_exc = mono_mb_add_local (mb, &byte_array_class->byval_arg);
2914         if (complex_count > 0)
2915                 loc_array = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
2916         if (sig->ret->type != MONO_TYPE_VOID) {
2917                 loc_return = mono_mb_add_local (mb, sig->ret);
2918                 ret_class = mono_class_from_mono_type (sig->ret);
2919         }
2920
2921         /* try */
2922
2923         main_clause = g_new0 (MonoExceptionClause, 1);
2924         main_clause->try_offset = mb->pos;
2925
2926         /* Clean the call context */
2927
2928         mono_mb_emit_byte (mb, CEE_LDNULL);
2929         mono_mb_emit_managed_call (mb, method_set_call_context, NULL);
2930         mono_mb_emit_byte (mb, CEE_POP);
2931
2932         /* Deserialize call data */
2933
2934         mono_mb_emit_ldarg (mb, 1);
2935         mono_mb_emit_byte (mb, CEE_LDIND_REF);
2936         mono_mb_emit_byte (mb, CEE_DUP);
2937         mono_mb_emit_byte (mb, CEE_BRFALSE_S);
2938         pos = mb->pos;
2939         mono_mb_emit_byte (mb, 0);
2940
2941         mono_marshal_emit_xdomain_copy_value (mb, byte_array_class);
2942         mono_mb_emit_managed_call (mb, method_rs_deserialize, NULL);
2943
2944         if (complex_count > 0)
2945                 mono_mb_emit_stloc (mb, loc_array);
2946         else
2947                 mono_mb_emit_byte (mb, CEE_POP);
2948
2949         mono_mb_patch_addr_s (mb, pos, mb->pos - (pos + 1));
2950
2951         /* Get the target object */
2952
2953         mono_mb_emit_ldarg (mb, 0);
2954         mono_mb_emit_managed_call (mb, method_rs_appdomain_target, NULL);
2955
2956         /* Load the arguments */
2957
2958         copy_locals_base = mb->locals;
2959         param_index = 3;        // Index of the first non-serialized parameter of this wrapper
2960         j = 0;
2961         for (i = 0; i < sig->param_count; i++) {
2962                 MonoType *pt = sig->params [i];
2963                 MonoClass *pclass = mono_class_from_mono_type (pt);
2964                 switch (marshal_types [i]) {
2965                 case MONO_MARSHAL_SERIALIZE: {
2966                         /* take the value from the serialized array */
2967                         mono_mb_emit_ldloc (mb, loc_array);
2968                         mono_mb_emit_icon (mb, j++);
2969                         if (pt->byref) {
2970                                 if (pclass->valuetype) {
2971                                         mono_mb_emit_byte (mb, CEE_LDELEM_REF);
2972                                         mono_mb_emit_byte (mb, CEE_UNBOX);
2973                                         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, pclass));
2974                                 } else {
2975                                         mono_mb_emit_byte (mb, CEE_LDELEMA);
2976                                         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, pclass));
2977                                 }
2978                         } else {
2979                                 if (pclass->valuetype) {
2980                                         mono_mb_emit_byte (mb, CEE_LDELEM_REF);
2981                                         mono_mb_emit_byte (mb, CEE_UNBOX);
2982                                         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, pclass));
2983                                         mono_mb_emit_byte (mb, CEE_LDOBJ);
2984                                         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, pclass));
2985                                 } else {
2986                                         mono_mb_emit_byte (mb, CEE_LDELEM_REF);
2987                                         if (pclass != mono_defaults.object_class) {
2988                                                 mono_mb_emit_byte (mb, CEE_CASTCLASS);
2989                                                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, pclass));
2990                                         }
2991                                 }
2992                         }
2993                         break;
2994                 }
2995                 case MONO_MARSHAL_COPY_OUT: {
2996                         /* Keep a local copy of the value since we need to copy it back after the call */
2997                         int copy_local = mono_mb_add_local (mb, &(pclass->byval_arg));
2998                         mono_mb_emit_ldarg (mb, param_index++);
2999                         mono_marshal_emit_xdomain_copy_value (mb, pclass);
3000                         mono_mb_emit_byte (mb, CEE_DUP);
3001                         mono_mb_emit_stloc (mb, copy_local);
3002                         break;
3003                 }
3004                 case MONO_MARSHAL_COPY: {
3005                         mono_mb_emit_ldarg (mb, param_index);
3006                         if (pt->byref) {
3007                                 mono_mb_emit_byte (mb, CEE_DUP);
3008                                 mono_mb_emit_byte (mb, CEE_DUP);
3009                                 mono_mb_emit_byte (mb, CEE_LDIND_REF);
3010                                 mono_marshal_emit_xdomain_copy_value (mb, pclass);
3011                                 mono_mb_emit_byte (mb, CEE_STIND_REF);
3012                         } else {
3013                                 mono_marshal_emit_xdomain_copy_value (mb, pclass);
3014                         }
3015                         param_index++;
3016                         break;
3017                 }
3018                 case MONO_MARSHAL_NONE:
3019                         mono_mb_emit_ldarg (mb, param_index++);
3020                         break;
3021                 }
3022         }
3023
3024         /* Make the call to the real object */
3025
3026         emit_thread_force_interrupt_checkpoint (mb);
3027
3028         mono_mb_emit_byte (mb, CEE_CALLVIRT);
3029         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, method));
3030
3031         if (sig->ret->type != MONO_TYPE_VOID)
3032                 mono_mb_emit_stloc (mb, loc_return);
3033
3034         /* copy back MONO_MARSHAL_COPY_OUT parameters */
3035
3036         j = 0;
3037         param_index = 3;
3038         for (i = 0; i < sig->param_count; i++) {
3039                 if (marshal_types [i] == MONO_MARSHAL_SERIALIZE) continue;
3040                 if (marshal_types [i] == MONO_MARSHAL_COPY_OUT) {
3041                         mono_mb_emit_ldloc (mb, copy_locals_base + (j++));
3042                         mono_mb_emit_ldarg (mb, param_index);
3043                         mono_marshal_emit_xdomain_copy_out_value (mb, mono_class_from_mono_type (sig->params [i]));
3044                 }
3045                 param_index++;
3046         }
3047
3048         /* Serialize the return values */
3049
3050         if (complex_out_count > 0) {
3051                 /* Reset parameters in the array that don't need to be serialized back */
3052                 j = 0;
3053                 for (i = 0; i < sig->param_count; i++) {
3054                         if (marshal_types[i] != MONO_MARSHAL_SERIALIZE) continue;
3055                         if (!sig->params [i]->byref) {
3056                                 mono_mb_emit_ldloc (mb, loc_array);
3057                                 mono_mb_emit_icon (mb, j);
3058                                 mono_mb_emit_byte (mb, CEE_LDNULL);
3059                                 mono_mb_emit_byte (mb, CEE_STELEM_REF);
3060                         }
3061                         j++;
3062                 }
3063
3064                 /* Add the return value to the array */
3065
3066                 if (ret_marshal_type == MONO_MARSHAL_SERIALIZE) {
3067                         mono_mb_emit_ldloc (mb, loc_array);
3068                         mono_mb_emit_icon (mb, complex_count);  /* The array has an additional slot to hold the ret value */
3069                         mono_mb_emit_ldloc (mb, loc_return);
3070                         if (ret_class->valuetype) {
3071                                 mono_mb_emit_byte (mb, CEE_BOX);
3072                                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, ret_class));
3073                         }
3074                         mono_mb_emit_byte (mb, CEE_STELEM_REF);
3075                 }
3076
3077                 /* Serialize */
3078
3079                 mono_mb_emit_ldarg (mb, 1);
3080                 mono_mb_emit_ldloc (mb, loc_array);
3081                 mono_mb_emit_managed_call (mb, method_rs_serialize, NULL);
3082                 mono_mb_emit_byte (mb, CEE_STIND_REF);
3083         } else if (ret_marshal_type == MONO_MARSHAL_SERIALIZE) {
3084                 mono_mb_emit_ldarg (mb, 1);
3085                 mono_mb_emit_ldloc (mb, loc_return);
3086                 if (ret_class->valuetype) {
3087                         mono_mb_emit_byte (mb, CEE_BOX);
3088                         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, ret_class));
3089                 }
3090                 mono_mb_emit_managed_call (mb, method_rs_serialize, NULL);
3091                 mono_mb_emit_byte (mb, CEE_STIND_REF);
3092         } else {
3093                 mono_mb_emit_ldarg (mb, 1);
3094                 mono_mb_emit_byte (mb, CEE_LDNULL);
3095                 mono_mb_emit_managed_call (mb, method_rs_serialize, NULL);
3096                 mono_mb_emit_byte (mb, CEE_STIND_REF);
3097         }
3098
3099         mono_mb_emit_ldarg (mb, 2);
3100         mono_mb_emit_byte (mb, CEE_LDNULL);
3101         mono_mb_emit_byte (mb, CEE_STIND_REF);
3102         mono_mb_emit_byte (mb, CEE_LEAVE);
3103         pos_leave = mb->pos;
3104         mono_mb_emit_i4 (mb, 0);
3105
3106         /* Main exception catch */
3107         main_clause->flags = MONO_EXCEPTION_CLAUSE_NONE;
3108         main_clause->try_len = mb->pos - main_clause->try_offset;
3109         main_clause->data.catch_class = mono_defaults.object_class;
3110
3111         /* handler code */
3112         main_clause->handler_offset = mb->pos;
3113         mono_mb_emit_managed_call (mb, method_rs_serialize_exc, NULL);
3114         mono_mb_emit_stloc (mb, loc_serialized_exc);
3115         mono_mb_emit_ldarg (mb, 2);
3116         mono_mb_emit_ldloc (mb, loc_serialized_exc);
3117         mono_mb_emit_byte (mb, CEE_STIND_REF);
3118         mono_mb_emit_byte (mb, CEE_LEAVE);
3119         mono_mb_emit_i4 (mb, 0);
3120         main_clause->handler_len = mb->pos - main_clause->handler_offset;
3121         /* end catch */
3122
3123         mono_mb_patch_addr (mb, pos_leave, mb->pos - (pos_leave + 4));
3124
3125         if (copy_return)
3126                 mono_mb_emit_ldloc (mb, loc_return);
3127
3128         mono_mb_emit_byte (mb, CEE_RET);
3129
3130         res = mono_remoting_mb_create_and_cache (method, mb, csig, csig->param_count + 16);
3131         mono_mb_free (mb);
3132
3133         header = ((MonoMethodNormal *)res)->header;
3134         header->num_clauses = 1;
3135         header->clauses = main_clause;
3136
3137         return res;
3138 }
3139
3140 /* mono_marshal_get_xappdomain_invoke ()
3141  * Generates a fast remoting wrapper for cross app domain calls.
3142  */
3143 MonoMethod *
3144 mono_marshal_get_xappdomain_invoke (MonoMethod *method)
3145 {
3146         MonoMethodSignature *sig;
3147         MonoMethodBuilder *mb;
3148         MonoMethod *res;
3149         int i, j, complex_count, complex_out_count, copy_locals_base;
3150         int *marshal_types;
3151         MonoClass *ret_class = NULL;
3152         MonoMethod *xdomain_method;
3153         int ret_marshal_type = MONO_MARSHAL_NONE;
3154         int loc_array=0, loc_serialized_data=-1, loc_real_proxy;
3155         int loc_old_domainid, loc_return=0, loc_serialized_exc=0, loc_context;
3156         int pos, pos_noex;
3157         gboolean copy_return = FALSE;
3158
3159         g_assert (method);
3160
3161         if (method->wrapper_type == MONO_WRAPPER_REMOTING_INVOKE || method->wrapper_type == MONO_WRAPPER_XDOMAIN_INVOKE)
3162                 return method;
3163
3164         /* we cant remote methods without this pointer */
3165         if (!mono_method_signature (method)->hasthis)
3166                 return method;
3167
3168         if (!mono_marshal_supports_fast_xdomain (method))
3169                 return mono_marshal_get_remoting_invoke (method);
3170
3171         mono_remoting_marshal_init ();
3172
3173         if ((res = mono_marshal_remoting_find_in_cache (method, MONO_WRAPPER_XDOMAIN_INVOKE)))
3174                 return res;
3175
3176         sig = signature_no_pinvoke (method);
3177
3178         mb = mono_mb_new (method->klass, method->name, MONO_WRAPPER_XDOMAIN_INVOKE);
3179         mb->method->save_lmf = 1;
3180
3181         /* Count the number of parameters that need to be serialized */
3182
3183         marshal_types = alloca (sizeof (int) * sig->param_count);
3184         complex_count = complex_out_count = 0;
3185         for (i = 0; i < sig->param_count; i++) {
3186                 MonoType *ptype = sig->params[i];
3187                 int mt = mono_get_xdomain_marshal_type (ptype);
3188
3189                 /* If the [Out] attribute is applied to a parameter that can be internally copied,
3190                  * the copy will be made by reusing the original object instance
3191                  */
3192                 if ((ptype->attrs & PARAM_ATTRIBUTE_OUT) != 0 && mt == MONO_MARSHAL_COPY && !ptype->byref)
3193                         mt = MONO_MARSHAL_COPY_OUT;
3194                 else if (mt == MONO_MARSHAL_SERIALIZE) {
3195                         complex_count++;
3196                         if (ptype->byref) complex_out_count++;
3197                 }
3198                 marshal_types [i] = mt;
3199         }
3200
3201         if (sig->ret->type != MONO_TYPE_VOID) {
3202                 ret_marshal_type = mono_get_xdomain_marshal_type (sig->ret);
3203                 ret_class = mono_class_from_mono_type (sig->ret);
3204                 copy_return = ret_marshal_type != MONO_MARSHAL_SERIALIZE;
3205         }
3206
3207         /* Locals */
3208
3209         if (complex_count > 0)
3210                 loc_array = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
3211         loc_serialized_data = mono_mb_add_local (mb, &byte_array_class->byval_arg);
3212         loc_real_proxy = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
3213         if (copy_return)
3214                 loc_return = mono_mb_add_local (mb, sig->ret);
3215         loc_old_domainid = mono_mb_add_local (mb, &mono_defaults.int32_class->byval_arg);
3216         loc_serialized_exc = mono_mb_add_local (mb, &byte_array_class->byval_arg);
3217         loc_context = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
3218
3219         /* Save thread domain data */
3220
3221         mono_mb_emit_icall (mb, mono_context_get);
3222         mono_mb_emit_byte (mb, CEE_DUP);
3223         mono_mb_emit_stloc (mb, loc_context);
3224
3225         /* If the thread is not running in the default context, it needs to go
3226          * through the whole remoting sink, since the context is going to change
3227          */
3228         mono_mb_emit_managed_call (mb, method_needs_context_sink, NULL);
3229         mono_mb_emit_byte (mb, CEE_BRFALSE_S);
3230         pos = mb->pos;
3231         mono_mb_emit_byte (mb, 0);
3232
3233         mono_mb_emit_ldarg (mb, 0);
3234         for (i = 0; i < sig->param_count; i++)
3235                 mono_mb_emit_ldarg (mb, i + 1);
3236
3237         mono_mb_emit_managed_call (mb, mono_marshal_get_remoting_invoke (method), NULL);
3238         mono_mb_emit_byte (mb, CEE_RET);
3239         mono_mb_patch_addr_s (mb, pos, mb->pos - pos - 1);
3240
3241         /* Create the array that will hold the parameters to be serialized */
3242
3243         if (complex_count > 0) {
3244                 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 */
3245                 mono_mb_emit_byte (mb, CEE_NEWARR);
3246                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, mono_defaults.object_class));
3247
3248                 j = 0;
3249                 for (i = 0; i < sig->param_count; i++) {
3250                         MonoClass *pclass;
3251                         if (marshal_types [i] != MONO_MARSHAL_SERIALIZE) continue;
3252                         pclass = mono_class_from_mono_type (sig->params[i]);
3253                         mono_mb_emit_byte (mb, CEE_DUP);
3254                         mono_mb_emit_icon (mb, j);
3255                         mono_mb_emit_ldarg (mb, i + 1);         /* 0=this */
3256                         if (sig->params[i]->byref) {
3257                                 if (pclass->valuetype) {
3258                                         mono_mb_emit_byte (mb, CEE_LDOBJ);
3259                                         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, pclass));
3260                                 } else {
3261                                         mono_mb_emit_byte (mb, CEE_LDIND_REF);
3262                                 }
3263                         }
3264                         if (pclass->valuetype) {
3265                                 mono_mb_emit_byte (mb, CEE_BOX);
3266                                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, pclass));
3267                         }
3268                         mono_mb_emit_byte (mb, CEE_STELEM_REF);
3269                         j++;
3270                 }
3271                 mono_mb_emit_stloc (mb, loc_array);
3272
3273                 /* Serialize parameters */
3274
3275                 mono_mb_emit_ldloc (mb, loc_array);
3276                 mono_mb_emit_managed_call (mb, method_rs_serialize, NULL);
3277                 mono_mb_emit_stloc (mb, loc_serialized_data);
3278         } else {
3279                 mono_mb_emit_byte (mb, CEE_LDNULL);
3280                 mono_mb_emit_managed_call (mb, method_rs_serialize, NULL);
3281                 mono_mb_emit_stloc (mb, loc_serialized_data);
3282         }
3283
3284         /* Get the target domain id */
3285
3286         mono_mb_emit_ldarg (mb, 0);
3287         mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoTransparentProxy, rp));
3288         mono_mb_emit_byte (mb, CEE_LDIND_REF);
3289         mono_mb_emit_byte (mb, CEE_DUP);
3290         mono_mb_emit_stloc (mb, loc_real_proxy);
3291
3292         mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoRealProxy, target_domain_id));
3293         mono_mb_emit_byte (mb, CEE_LDIND_I4);
3294         mono_mb_emit_byte (mb, CEE_LDC_I4_1);
3295
3296         /* switch domain */
3297
3298         mono_marshal_emit_switch_domain (mb);
3299         mono_mb_emit_stloc (mb, loc_old_domainid);
3300
3301         /* Load the arguments */
3302
3303         mono_mb_emit_ldloc (mb, loc_real_proxy);
3304         mono_mb_emit_ldloc_addr (mb, loc_serialized_data);
3305         mono_mb_emit_ldloc_addr (mb, loc_serialized_exc);
3306
3307         copy_locals_base = mb->locals;
3308         for (i = 0; i < sig->param_count; i++) {
3309                 switch (marshal_types [i]) {
3310                 case MONO_MARSHAL_SERIALIZE:
3311                         continue;
3312                 case MONO_MARSHAL_COPY: {
3313                         mono_mb_emit_ldarg (mb, i+1);
3314                         if (sig->params [i]->byref) {
3315                                 /* make a local copy of the byref parameter. The real parameter
3316                                  * will be updated after the xdomain call
3317                                  */
3318                                 MonoClass *pclass = mono_class_from_mono_type (sig->params [i]);
3319                                 int copy_local = mono_mb_add_local (mb, &(pclass->byval_arg));
3320                                 mono_mb_emit_byte (mb, CEE_LDIND_REF);
3321                                 mono_mb_emit_stloc (mb, copy_local);
3322                                 mono_mb_emit_ldloc_addr (mb, copy_local);
3323                         }
3324                         break;
3325                 }
3326                 case MONO_MARSHAL_COPY_OUT:
3327                 case MONO_MARSHAL_NONE:
3328                         mono_mb_emit_ldarg (mb, i+1);
3329                         break;
3330                 }
3331         }
3332
3333         /* Make the call to the invoke wrapper in the target domain */
3334
3335         xdomain_method = mono_marshal_get_xappdomain_dispatch (method, marshal_types, complex_count, complex_out_count, ret_marshal_type);
3336         mono_marshal_emit_load_domain_method (mb, xdomain_method);
3337         mono_mb_emit_calli (mb, mono_method_signature (xdomain_method));
3338
3339         if (copy_return)
3340                 mono_mb_emit_stloc (mb, loc_return);
3341
3342         /* Switch domain */
3343
3344         mono_mb_emit_ldloc (mb, loc_old_domainid);
3345         mono_mb_emit_byte (mb, CEE_LDC_I4_0);
3346         mono_marshal_emit_switch_domain (mb);
3347         mono_mb_emit_byte (mb, CEE_POP);
3348
3349         /* Restore thread domain data */
3350
3351         mono_mb_emit_ldloc (mb, loc_context);
3352         mono_mb_emit_icall (mb, mono_context_set);
3353
3354         /* if (loc_serialized_exc != null) ... */
3355
3356         mono_mb_emit_ldloc (mb, loc_serialized_exc);
3357         mono_mb_emit_byte (mb, CEE_BRFALSE_S);
3358         pos_noex = mb->pos;
3359         mono_mb_emit_byte (mb, 0);
3360
3361         mono_mb_emit_ldloc (mb, loc_serialized_exc);
3362         mono_marshal_emit_xdomain_copy_value (mb, byte_array_class);
3363         mono_mb_emit_managed_call (mb, method_rs_deserialize, NULL);
3364         mono_mb_emit_byte (mb, CEE_CASTCLASS);
3365         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, mono_defaults.exception_class));
3366         mono_mb_emit_managed_call (mb, method_exc_fixexc, NULL);
3367         mono_mb_emit_byte (mb, CEE_THROW);
3368         mono_mb_patch_addr_s (mb, pos_noex, mb->pos - pos_noex - 1);
3369
3370         /* copy back non-serialized output parameters */
3371
3372         j = 0;
3373         for (i = 0; i < sig->param_count; i++) {
3374                 if (!sig->params [i]->byref || marshal_types [i] != MONO_MARSHAL_COPY) continue;
3375                 mono_mb_emit_ldarg (mb, i + 1);
3376                 mono_mb_emit_ldloc (mb, copy_locals_base + (j++));
3377                 mono_marshal_emit_xdomain_copy_value (mb, mono_class_from_mono_type (sig->params [i]));
3378                 mono_mb_emit_byte (mb, CEE_STIND_REF);
3379         }
3380
3381         /* Deserialize out parameters */
3382
3383         if (complex_out_count > 0) {
3384                 mono_mb_emit_ldloc (mb, loc_serialized_data);
3385                 mono_marshal_emit_xdomain_copy_value (mb, byte_array_class);
3386                 mono_mb_emit_managed_call (mb, method_rs_deserialize, NULL);
3387                 mono_mb_emit_stloc (mb, loc_array);
3388
3389                 /* Copy back output parameters and return type */
3390
3391                 j = 0;
3392                 for (i = 0; i < sig->param_count; i++) {
3393                         if (marshal_types [i] != MONO_MARSHAL_SERIALIZE) continue;
3394                         if (sig->params[i]->byref) {
3395                                 MonoClass *pclass = mono_class_from_mono_type (sig->params [i]);
3396                                 mono_mb_emit_ldarg (mb, i + 1);
3397                                 mono_mb_emit_ldloc (mb, loc_array);
3398                                 mono_mb_emit_icon (mb, j);
3399                                 mono_mb_emit_byte (mb, CEE_LDELEM_REF);
3400                                 if (pclass->valuetype) {
3401                                         mono_mb_emit_byte (mb, CEE_UNBOX);
3402                                         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, pclass));
3403                                         mono_mb_emit_byte (mb, CEE_LDOBJ);
3404                                         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, pclass));
3405                                         mono_mb_emit_byte (mb, CEE_STOBJ);
3406                                         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, pclass));
3407                                 } else {
3408                                         if (pclass != mono_defaults.object_class) {
3409                                                 mono_mb_emit_byte (mb, CEE_CASTCLASS);
3410                                                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, pclass));
3411                                         }
3412                                         mono_mb_emit_byte (mb, CEE_STIND_REF);
3413                                 }
3414                         }
3415                         j++;
3416                 }
3417
3418                 if (ret_marshal_type == MONO_MARSHAL_SERIALIZE) {
3419                         mono_mb_emit_ldloc (mb, loc_array);
3420                         mono_mb_emit_icon (mb, complex_count);
3421                         mono_mb_emit_byte (mb, CEE_LDELEM_REF);
3422                         if (ret_class->valuetype) {
3423                                 mono_mb_emit_byte (mb, CEE_UNBOX);
3424                                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, ret_class));
3425                                 mono_mb_emit_byte (mb, CEE_LDOBJ);
3426                                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, ret_class));
3427                         }
3428                 }
3429         } else if (ret_marshal_type == MONO_MARSHAL_SERIALIZE) {
3430                 mono_mb_emit_ldloc (mb, loc_serialized_data);
3431                 mono_marshal_emit_xdomain_copy_value (mb, byte_array_class);
3432                 mono_mb_emit_managed_call (mb, method_rs_deserialize, NULL);
3433                 if (ret_class->valuetype) {
3434                         mono_mb_emit_byte (mb, CEE_UNBOX);
3435                         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, ret_class));
3436                         mono_mb_emit_byte (mb, CEE_LDOBJ);
3437                         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, ret_class));
3438                 } else if (ret_class != mono_defaults.object_class) {
3439                         mono_mb_emit_byte (mb, CEE_CASTCLASS);
3440                         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, ret_class));
3441                 }
3442         } else {
3443                 mono_mb_emit_ldloc (mb, loc_serialized_data);
3444                 mono_mb_emit_byte (mb, CEE_DUP);
3445                 mono_mb_emit_byte (mb, CEE_BRFALSE_S);
3446                 pos = mb->pos;
3447                 mono_mb_emit_byte (mb, 0);
3448                 mono_marshal_emit_xdomain_copy_value (mb, byte_array_class);
3449
3450                 mono_mb_patch_addr_s (mb, pos, mb->pos - (pos + 1));
3451                 mono_mb_emit_managed_call (mb, method_rs_deserialize, NULL);
3452                 mono_mb_emit_byte (mb, CEE_POP);
3453         }
3454
3455         if (copy_return) {
3456                 mono_mb_emit_ldloc (mb, loc_return);
3457                 if (ret_marshal_type == MONO_MARSHAL_COPY)
3458                         mono_marshal_emit_xdomain_copy_value (mb, ret_class);
3459         }
3460
3461         mono_mb_emit_byte (mb, CEE_RET);
3462
3463         res = mono_remoting_mb_create_and_cache (method, mb, sig, sig->param_count + 16);
3464         mono_mb_free (mb);
3465
3466         return res;
3467 }
3468
3469 MonoMethod *
3470 mono_marshal_get_remoting_invoke_for_target (MonoMethod *method, MonoRemotingTarget target_type)
3471 {
3472         if (target_type == MONO_REMOTING_TARGET_APPDOMAIN)
3473                 return mono_marshal_get_xappdomain_invoke (method);
3474         else
3475                 return mono_marshal_get_remoting_invoke (method);
3476 }
3477
3478 G_GNUC_UNUSED static gpointer
3479 mono_marshal_load_remoting_wrapper (MonoRealProxy *rp, MonoMethod *method)
3480 {
3481         if (rp->target_domain_id != -1)
3482                 return mono_compile_method (mono_marshal_get_xappdomain_invoke (method));
3483         else
3484                 return mono_compile_method (mono_marshal_get_remoting_invoke (method));
3485 }
3486
3487 MonoMethod *
3488 mono_marshal_get_remoting_invoke_with_check (MonoMethod *method)
3489 {
3490         MonoMethodSignature *sig;
3491         MonoMethodBuilder *mb;
3492         MonoMethod *res, *native;
3493         int i, pos, pos_rem;
3494
3495         g_assert (method);
3496
3497         if (method->wrapper_type == MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK)
3498                 return method;
3499
3500         sig = signature_no_pinvoke (method);
3501
3502         /* we cant remote methods without this pointer */
3503         g_assert (sig->hasthis);
3504
3505         if ((res = mono_marshal_remoting_find_in_cache (method, MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK)))
3506                 return res;
3507
3508         mb = mono_mb_new (method->klass, method->name, MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK);
3509
3510         for (i = 0; i <= sig->param_count; i++)
3511                 mono_mb_emit_ldarg (mb, i);
3512
3513         mono_mb_emit_ldarg (mb, 0);
3514         pos = mono_mb_emit_proxy_check (mb, CEE_BNE_UN);
3515
3516         if (mono_marshal_supports_fast_xdomain (method)) {
3517                 mono_mb_emit_ldarg (mb, 0);
3518                 pos_rem = mono_mb_emit_xdomain_check (mb, CEE_BEQ);
3519
3520                 /* wrapper for cross app domain calls */
3521                 native = mono_marshal_get_xappdomain_invoke (method);
3522                 mono_mb_emit_managed_call (mb, native, mono_method_signature (native));
3523                 mono_mb_emit_byte (mb, CEE_RET);
3524
3525                 mono_mb_patch_addr (mb, pos_rem, mb->pos - (pos_rem + 4));
3526         }
3527         /* wrapper for normal remote calls */
3528         native = mono_marshal_get_remoting_invoke (method);
3529         mono_mb_emit_managed_call (mb, native, mono_method_signature (native));
3530         mono_mb_emit_byte (mb, CEE_RET);
3531
3532         /* not a proxy */
3533         mono_mb_patch_addr (mb, pos, mb->pos - (pos + 4));
3534         mono_mb_emit_managed_call (mb, method, mono_method_signature (method));
3535         mono_mb_emit_byte (mb, CEE_RET);
3536
3537         res = mono_remoting_mb_create_and_cache (method, mb, sig, sig->param_count + 16);
3538         mono_mb_free (mb);
3539
3540         return res;
3541 }
3542
3543 /*
3544  * the returned method invokes all methods in a multicast delegate
3545  */
3546 MonoMethod *
3547 mono_marshal_get_delegate_invoke (MonoMethod *method)
3548 {
3549         MonoMethodSignature *sig, *static_sig;
3550         int i;
3551         MonoMethodBuilder *mb;
3552         MonoMethod *res;
3553         GHashTable *cache;
3554         int pos0, pos1;
3555         char *name;
3556
3557         g_assert (method && method->klass->parent == mono_defaults.multicastdelegate_class &&
3558                   !strcmp (method->name, "Invoke"));
3559
3560         sig = signature_no_pinvoke (method);
3561
3562         cache = method->klass->image->delegate_invoke_cache;
3563         if ((res = mono_marshal_find_in_cache (cache, sig)))
3564                 return res;
3565
3566         static_sig = signature_dup (method->klass->image, sig);
3567         static_sig->hasthis = 0;
3568
3569         name = mono_signature_to_name (sig, "invoke");
3570         mb = mono_mb_new (mono_defaults.multicastdelegate_class, name,  MONO_WRAPPER_DELEGATE_INVOKE);
3571         g_free (name);
3572
3573         /* allocate local 0 (object) */
3574         mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
3575
3576         g_assert (sig->hasthis);
3577
3578         /*
3579          * if (prev != null)
3580          *      prev.Invoke( args .. );
3581          * return this.<target>( args .. );
3582          */
3583
3584         /* this wrapper can be used in unmanaged-managed transitions */
3585         emit_thread_interrupt_checkpoint (mb);
3586
3587         /* get this->prev */
3588         mono_mb_emit_ldarg (mb, 0);
3589         mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoMulticastDelegate, prev));
3590         mono_mb_emit_byte (mb, CEE_LDIND_REF);
3591         mono_mb_emit_stloc (mb, 0);
3592
3593         /* if prev != null */
3594         mono_mb_emit_ldloc (mb, 0);
3595         mono_mb_emit_byte (mb, CEE_BRFALSE);
3596
3597         pos0 = mb->pos;
3598         mono_mb_emit_i4 (mb, 0);
3599
3600         /* then recurse */
3601         mono_mb_emit_ldloc (mb, 0);
3602         for (i = 0; i < sig->param_count; i++)
3603                 mono_mb_emit_ldarg (mb, i + 1);
3604         mono_mb_emit_managed_call (mb, method, mono_method_signature (method));
3605         if (sig->ret->type != MONO_TYPE_VOID)
3606                 mono_mb_emit_byte (mb, CEE_POP);
3607
3608         /* continued or prev == null */
3609         mono_mb_patch_addr (mb, pos0, mb->pos - (pos0 + 4));
3610
3611         /* get this->target */
3612         mono_mb_emit_ldarg (mb, 0);
3613         mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoDelegate, target));
3614         mono_mb_emit_byte (mb, CEE_LDIND_REF);
3615         mono_mb_emit_stloc (mb, 0);
3616
3617         /* if target != null */
3618         mono_mb_emit_ldloc (mb, 0);
3619         mono_mb_emit_byte (mb, CEE_BRFALSE);
3620         pos0 = mb->pos;
3621         mono_mb_emit_i4 (mb, 0);
3622
3623         /* then call this->method_ptr nonstatic */
3624         mono_mb_emit_ldloc (mb, 0);
3625         for (i = 0; i < sig->param_count; ++i)
3626                 mono_mb_emit_ldarg (mb, i + 1);
3627         mono_mb_emit_ldarg (mb, 0);
3628         mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoDelegate, method_ptr));
3629         mono_mb_emit_byte (mb, CEE_LDIND_I );
3630         mono_mb_emit_byte (mb, CEE_CALLI);
3631         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, sig));
3632
3633         mono_mb_emit_byte (mb, CEE_BR);
3634         pos1 = mb->pos;
3635         mono_mb_emit_i4 (mb, 0);
3636
3637         /* else [target == null] call this->method_ptr static */
3638         mono_mb_patch_addr (mb, pos0, mb->pos - (pos0 + 4));
3639
3640         for (i = 0; i < sig->param_count; ++i)
3641                 mono_mb_emit_ldarg (mb, i + 1);
3642         mono_mb_emit_ldarg (mb, 0);
3643         mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoDelegate, method_ptr));
3644         mono_mb_emit_byte (mb, CEE_LDIND_I );
3645         mono_mb_emit_byte (mb, CEE_CALLI);
3646         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, static_sig));
3647
3648         /* return */
3649         mono_mb_patch_addr (mb, pos1, mb->pos - (pos1 + 4));
3650         mono_mb_emit_byte (mb, CEE_RET);
3651
3652         res = mono_mb_create_and_cache (cache, sig,
3653                                                                                  mb, sig, sig->param_count + 16);
3654         mono_mb_free (mb);
3655
3656         return res;
3657 }
3658
3659 /*
3660  * signature_dup_add_this:
3661  *
3662  *  Make a copy of @sig, adding an explicit this argument.
3663  */
3664 static MonoMethodSignature*
3665 signature_dup_add_this (MonoMethodSignature *sig, MonoClass *klass)
3666 {
3667         MonoMethodSignature *res;
3668         int i;
3669
3670         res = mono_metadata_signature_alloc (klass->image, sig->param_count + 1);
3671         memcpy (res, sig, sizeof (MonoMethodSignature));
3672         res->param_count = sig->param_count + 1;
3673         res->hasthis = FALSE;
3674         for (i = sig->param_count - 1; i >= 0; i --)
3675                 res->params [i + 1] = sig->params [i];
3676         res->params [0] = &mono_ptr_class_get (&klass->byval_arg)->byval_arg;
3677
3678         return res;
3679 }
3680
3681 typedef struct {
3682         MonoMethod *ctor;
3683         MonoMethodSignature *sig;
3684 } CtorSigPair;
3685
3686
3687
3688 /*
3689  * generates IL code for the runtime invoke function
3690  * MonoObject *runtime_invoke (MonoObject *this, void **params, MonoObject **exc, void* method)
3691  *
3692  * we also catch exceptions if exc != null
3693  */
3694 MonoMethod *
3695 mono_marshal_get_runtime_invoke (MonoMethod *method)
3696 {
3697         MonoMethodSignature *sig, *csig, *callsig;
3698         MonoExceptionClause *clause;
3699         MonoMethodHeader *header;
3700         MonoMethodBuilder *mb;
3701         GHashTable *cache = NULL;
3702         MonoClass *target_klass;
3703         MonoMethod *res = NULL;
3704         GSList *item;
3705         static MonoString *string_dummy = NULL;
3706         static MonoMethodSignature *dealy_abort_sig = NULL;
3707         int i, pos, posna;
3708         char *name;
3709
3710         g_assert (method);
3711
3712         target_klass = method->klass;
3713
3714         mono_marshal_lock ();
3715
3716         if (method->string_ctor) {
3717                 static GSList *strsig_list = NULL;
3718                 CtorSigPair *cs;
3719
3720                 callsig = NULL;
3721                 for (item = strsig_list; item; item = item->next) {
3722                         cs = item->data;
3723                         if (mono_metadata_signature_equal (mono_method_signature (method), mono_method_signature (cs->ctor))) {
3724                                 callsig = cs->sig;
3725                                 break;
3726                         }
3727                 }
3728                 if (!callsig) {
3729                         callsig = signature_dup (method->klass->image, mono_method_signature (method));
3730                         callsig->ret = &mono_defaults.string_class->byval_arg;
3731                         cs = g_new (CtorSigPair, 1);
3732                         cs->sig = callsig;
3733                         cs->ctor = method;
3734                         strsig_list = g_slist_prepend (strsig_list, cs);
3735                 }
3736         } else {
3737                 if (method->klass->valuetype && mono_method_signature (method)->hasthis) {
3738                         /*
3739                          * Valuetype methods receive a managed pointer as the this argument.
3740                          * Create a new signature to reflect this.
3741                          */
3742                         callsig = signature_dup_add_this (mono_method_signature (method), method->klass);
3743                 } else {
3744                         callsig = mono_method_signature (method);
3745                 }
3746         }
3747
3748         cache = method->klass->image->runtime_invoke_cache;
3749
3750         /* from mono_marshal_find_in_cache */
3751         res = g_hash_table_lookup (cache, callsig);
3752         mono_marshal_unlock ();
3753
3754         if (res) {
3755                 return res;
3756         }
3757
3758         if (!dealy_abort_sig) {
3759                 dealy_abort_sig = mono_metadata_signature_alloc (mono_defaults.corlib, 0);
3760                 dealy_abort_sig->ret = &mono_defaults.void_class->byval_arg;
3761                 dealy_abort_sig->pinvoke = 0;
3762         }
3763
3764         target_klass = mono_defaults.object_class;
3765
3766         /* to make it work with our special string constructors */
3767         if (!string_dummy) {
3768                 MONO_GC_REGISTER_ROOT (string_dummy);
3769                 string_dummy = mono_string_new_wrapper ("dummy");
3770         }
3771
3772         sig = mono_method_signature (method);
3773
3774         csig = mono_metadata_signature_alloc (method->klass->image, 4);
3775
3776         csig->ret = &mono_defaults.object_class->byval_arg;
3777         if (method->klass->valuetype && mono_method_signature (method)->hasthis)
3778                 csig->params [0] = callsig->params [0];
3779         else
3780                 csig->params [0] = &mono_defaults.object_class->byval_arg;
3781         csig->params [1] = &mono_defaults.int_class->byval_arg;
3782         csig->params [2] = &mono_defaults.int_class->byval_arg;
3783         csig->params [3] = &mono_defaults.int_class->byval_arg;
3784
3785         name = mono_signature_to_name (callsig, "runtime_invoke");
3786         mb = mono_mb_new (target_klass, name,  MONO_WRAPPER_RUNTIME_INVOKE);
3787         g_free (name);
3788
3789         /* allocate local 0 (object) tmp */
3790         mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
3791         /* allocate local 1 (object) exc */
3792         mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
3793
3794         /* cond set *exc to null */
3795         mono_mb_emit_byte (mb, CEE_LDARG_2);
3796         mono_mb_emit_byte (mb, CEE_BRFALSE_S);
3797         mono_mb_emit_byte (mb, 3);
3798         mono_mb_emit_byte (mb, CEE_LDARG_2);
3799         mono_mb_emit_byte (mb, CEE_LDNULL);
3800         mono_mb_emit_byte (mb, CEE_STIND_REF);
3801
3802         emit_thread_force_interrupt_checkpoint (mb);
3803
3804         if (sig->hasthis) {
3805                 if (method->string_ctor) {
3806                         mono_mb_emit_ptr (mb, string_dummy);
3807                 } else {
3808                         mono_mb_emit_ldarg (mb, 0);
3809                 }
3810         }
3811
3812         for (i = 0; i < sig->param_count; i++) {
3813                 MonoType *t = sig->params [i];
3814                 int type;
3815
3816                 mono_mb_emit_ldarg (mb, 1);
3817                 if (i) {
3818                         mono_mb_emit_icon (mb, sizeof (gpointer) * i);
3819                         mono_mb_emit_byte (mb, CEE_ADD);
3820                 }
3821                 mono_mb_emit_byte (mb, CEE_LDIND_I);
3822
3823                 if (t->byref)
3824                         continue;
3825
3826                 type = sig->params [i]->type;
3827 handle_enum:
3828                 switch (type) {
3829                 case MONO_TYPE_I1:
3830                 case MONO_TYPE_BOOLEAN:
3831                 case MONO_TYPE_U1:
3832                 case MONO_TYPE_I2:
3833                 case MONO_TYPE_U2:
3834                 case MONO_TYPE_CHAR:
3835                 case MONO_TYPE_I:
3836                 case MONO_TYPE_U:
3837                 case MONO_TYPE_I4:
3838                 case MONO_TYPE_U4:
3839                 case MONO_TYPE_R4:
3840                 case MONO_TYPE_R8:
3841                 case MONO_TYPE_I8:
3842                 case MONO_TYPE_U8:
3843                         mono_mb_emit_byte (mb, mono_type_to_ldind (sig->params [i]));
3844                         break;
3845                 case MONO_TYPE_STRING:
3846                 case MONO_TYPE_CLASS:
3847                 case MONO_TYPE_ARRAY:
3848                 case MONO_TYPE_PTR:
3849                 case MONO_TYPE_SZARRAY:
3850                 case MONO_TYPE_OBJECT:
3851                         /* do nothing */
3852                         break;
3853                 case MONO_TYPE_VALUETYPE:
3854                         if (t->data.klass->enumtype) {
3855                                 type = t->data.klass->enum_basetype->type;
3856                                 goto handle_enum;
3857                         }
3858                         if (mono_class_is_nullable (mono_class_from_mono_type (sig->params [i]))) {
3859                                 /* Need to convert a boxed vtype to an mp to a Nullable struct */
3860                                 mono_mb_emit_byte (mb, CEE_UNBOX);
3861                                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, mono_class_from_mono_type (sig->params [i])));
3862                                 mono_mb_emit_byte (mb, CEE_LDOBJ);
3863                                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, mono_class_from_mono_type (sig->params [i])));
3864                         } else {
3865                                 mono_mb_emit_byte (mb, CEE_LDOBJ);
3866                                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, t->data.klass));
3867                         }
3868                         break;
3869                 case MONO_TYPE_GENERICINST:
3870                         t = &t->data.generic_class->container_class->byval_arg;
3871                         type = t->type;
3872                         goto handle_enum;
3873                 default:
3874                         g_assert_not_reached ();
3875                 }
3876         }
3877
3878         mono_mb_emit_ldarg (mb, 3);
3879         mono_mb_emit_calli (mb, callsig);
3880
3881         if (sig->ret->byref) {
3882                 /* fixme: */
3883                 g_assert_not_reached ();
3884         }
3885
3886
3887         switch (sig->ret->type) {
3888         case MONO_TYPE_VOID:
3889                 if (!method->string_ctor)
3890                         mono_mb_emit_byte (mb, CEE_LDNULL);
3891                 break;
3892         case MONO_TYPE_BOOLEAN:
3893         case MONO_TYPE_CHAR:
3894         case MONO_TYPE_I1:
3895         case MONO_TYPE_U1:
3896         case MONO_TYPE_I2:
3897         case MONO_TYPE_U2:
3898         case MONO_TYPE_I4:
3899         case MONO_TYPE_U4:
3900         case MONO_TYPE_I:
3901         case MONO_TYPE_U:
3902         case MONO_TYPE_R4:
3903         case MONO_TYPE_R8:
3904         case MONO_TYPE_I8:
3905         case MONO_TYPE_U8:
3906         case MONO_TYPE_VALUETYPE:
3907         case MONO_TYPE_TYPEDBYREF:
3908         case MONO_TYPE_GENERICINST:
3909                 /* box value types */
3910                 mono_mb_emit_byte (mb, CEE_BOX);
3911                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, mono_class_from_mono_type (sig->ret)));
3912                 break;
3913         case MONO_TYPE_STRING:
3914         case MONO_TYPE_CLASS:
3915         case MONO_TYPE_ARRAY:
3916         case MONO_TYPE_SZARRAY:
3917         case MONO_TYPE_OBJECT:
3918                 /* nothing to do */
3919                 break;
3920         case MONO_TYPE_PTR:
3921         default:
3922                 g_assert_not_reached ();
3923         }
3924
3925         mono_mb_emit_stloc (mb, 0);
3926
3927         mono_mb_emit_byte (mb, CEE_LEAVE);
3928         pos = mb->pos;
3929         mono_mb_emit_i4 (mb, 0);
3930
3931         mono_loader_lock ();
3932         clause = mono_mempool_alloc0 (target_klass->image->mempool, sizeof (MonoExceptionClause));
3933         mono_loader_unlock ();
3934         clause->flags = MONO_EXCEPTION_CLAUSE_FILTER;
3935         clause->try_len = mb->pos;
3936
3937         /* filter code */
3938         clause->data.filter_offset = mb->pos;
3939
3940         mono_mb_emit_byte (mb, CEE_POP);
3941         mono_mb_emit_byte (mb, CEE_LDARG_2);
3942         mono_mb_emit_byte (mb, CEE_LDC_I4_0);
3943         mono_mb_emit_byte (mb, CEE_PREFIX1);
3944         mono_mb_emit_byte (mb, CEE_CGT_UN);
3945         mono_mb_emit_byte (mb, CEE_PREFIX1);
3946         mono_mb_emit_byte (mb, CEE_ENDFILTER);
3947
3948         clause->handler_offset = mb->pos;
3949
3950         /* handler code */
3951         /* store exception */
3952         mono_mb_emit_stloc (mb, 1);
3953
3954         mono_mb_emit_byte (mb, CEE_LDARG_2);
3955         mono_mb_emit_ldloc (mb, 1);
3956         mono_mb_emit_byte (mb, CEE_STIND_REF);
3957
3958         mono_mb_emit_byte (mb, CEE_LDNULL);
3959         mono_mb_emit_stloc (mb, 0);
3960
3961         /* Check for the abort exception */
3962         mono_mb_emit_ldloc (mb, 1);
3963         mono_mb_emit_byte (mb, CEE_ISINST);
3964         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, mono_defaults.threadabortexception_class));
3965         mono_mb_emit_byte (mb, CEE_BRFALSE_S);
3966         posna = mb->pos;
3967         mono_mb_emit_byte (mb, 0);
3968
3969         /* Delay the abort exception */
3970         mono_mb_emit_native_call (mb, dealy_abort_sig, ves_icall_System_Threading_Thread_ResetAbort);
3971
3972         mono_mb_patch_addr_s (mb, posna, mb->pos - posna - 1);
3973         mono_mb_emit_byte (mb, CEE_LEAVE);
3974         mono_mb_emit_i4 (mb, 0);
3975
3976         clause->handler_len = mb->pos - clause->handler_offset;
3977
3978         /* return result */
3979         mono_mb_patch_addr (mb, pos, mb->pos - (pos + 4));
3980         mono_mb_emit_ldloc (mb, 0);
3981         mono_mb_emit_byte (mb, CEE_RET);
3982
3983         /* taken from mono_mb_create_and_cache */
3984         mono_loader_lock ();
3985         mono_marshal_lock ();
3986
3987         res = g_hash_table_lookup (cache, callsig);
3988         /* Somebody may have created it before us */
3989         if (!res) {
3990                 res = mono_mb_create_method (mb, csig, sig->param_count + 16);
3991                 g_hash_table_insert (cache, callsig, res);
3992                 g_hash_table_insert (wrapper_hash, res, callsig);
3993         }
3994
3995         mono_marshal_unlock ();
3996         mono_loader_unlock ();
3997         /* end mono_mb_create_and_cache */
3998
3999         mono_mb_free (mb);
4000
4001         header = ((MonoMethodNormal *)res)->header;
4002         header->num_clauses = 1;
4003         header->clauses = clause;
4004
4005         return res;
4006 }
4007
4008 static void
4009 mono_mb_emit_auto_layout_exception (MonoMethodBuilder *mb, MonoClass *klass)
4010 {
4011         char *msg = g_strdup_printf ("The type `%s.%s' layout needs to be Sequential or Explicit",
4012                                      klass->name_space, klass->name);
4013
4014         mono_mb_emit_exception_marshal_directive (mb, msg);
4015 }
4016
4017 /*
4018  * mono_marshal_get_ldfld_remote_wrapper:
4019  * @klass: The return type
4020  *
4021  * This method generates a wrapper for calling mono_load_remote_field_new with
4022  * the appropriate return type.
4023  */
4024 MonoMethod *
4025 mono_marshal_get_ldfld_remote_wrapper (MonoClass *klass)
4026 {
4027         MonoMethodSignature *sig, *csig;
4028         MonoMethodBuilder *mb;
4029         MonoMethod *res;
4030         GHashTable *cache;
4031         char *name;
4032
4033         cache = klass->image->ldfld_remote_wrapper_cache;
4034         if ((res = mono_marshal_find_in_cache (cache, klass)))
4035                 return res;
4036
4037         /*
4038          * This wrapper is similar to an icall wrapper but all the wrappers
4039          * call the same C function, but with a different signature.
4040          */
4041         name = g_strdup_printf ("__mono_load_remote_field_new_wrapper_%s.%s", klass->name_space, klass->name);
4042         mb = mono_mb_new (mono_defaults.object_class, name, MONO_WRAPPER_LDFLD_REMOTE);
4043         g_free (name);
4044
4045         mb->method->save_lmf = 1;
4046
4047         sig = mono_metadata_signature_alloc (mono_defaults.corlib, 3);
4048         sig->params [0] = &mono_defaults.object_class->byval_arg;
4049         sig->params [1] = &mono_defaults.int_class->byval_arg;
4050         sig->params [2] = &mono_defaults.int_class->byval_arg;
4051         sig->ret = &klass->this_arg;
4052
4053         mono_mb_emit_ldarg (mb, 0);
4054         mono_mb_emit_ldarg (mb, 1);
4055         mono_mb_emit_ldarg (mb, 2);
4056
4057         csig = mono_metadata_signature_alloc (mono_defaults.corlib, 3);
4058         csig->params [0] = &mono_defaults.object_class->byval_arg;
4059         csig->params [1] = &mono_defaults.int_class->byval_arg;
4060         csig->params [2] = &mono_defaults.int_class->byval_arg;
4061         csig->ret = &klass->this_arg;
4062         csig->pinvoke = 1;
4063
4064         mono_mb_emit_native_call (mb, csig, mono_load_remote_field_new);
4065         emit_thread_interrupt_checkpoint (mb);
4066
4067         mono_mb_emit_byte (mb, CEE_RET);
4068
4069         res = mono_mb_create_and_cache (cache, klass,
4070                                                                         mb, sig, sig->param_count + 16);
4071         mono_mb_free (mb);
4072
4073         return res;
4074 }
4075
4076 /*
4077  * mono_marshal_get_ldfld_wrapper:
4078  * @type: the type of the field
4079  *
4080  * This method generates a function which can be use to load a field with type
4081  * @type from an object. The generated function has the following signature:
4082  * <@type> ldfld_wrapper (MonoObject *this, MonoClass *class, MonoClassField *field, int offset)
4083  */
4084 MonoMethod *
4085 mono_marshal_get_ldfld_wrapper (MonoType *type)
4086 {
4087         MonoMethodSignature *sig;
4088         MonoMethodBuilder *mb;
4089         MonoMethod *res;
4090         MonoClass *klass;
4091         GHashTable *cache;
4092         char *name;
4093         int t, pos0, pos1 = 0;
4094
4095         type = mono_type_get_underlying_type (type);
4096
4097         t = type->type;
4098
4099         if (!type->byref) {
4100                 if (type->type == MONO_TYPE_SZARRAY) {
4101                         klass = mono_defaults.array_class;
4102                 } else if (type->type == MONO_TYPE_VALUETYPE) {
4103                         klass = type->data.klass;
4104                 } else if (t == MONO_TYPE_OBJECT || t == MONO_TYPE_CLASS || t == MONO_TYPE_STRING) {
4105                         klass = mono_defaults.object_class;
4106                 } else if (t == MONO_TYPE_PTR || t == MONO_TYPE_FNPTR) {
4107                         klass = mono_defaults.int_class;
4108                 } else if (t == MONO_TYPE_GENERICINST) {
4109                         if (mono_type_generic_inst_is_valuetype (type))
4110                                 klass = mono_class_from_mono_type (type);
4111                         else
4112                                 klass = mono_defaults.object_class;
4113                 } else {
4114                         klass = mono_class_from_mono_type (type);
4115                 }
4116         } else {
4117                 klass = mono_defaults.int_class;
4118         }
4119
4120         cache = klass->image->ldfld_wrapper_cache;
4121         if ((res = mono_marshal_find_in_cache (cache, klass)))
4122                 return res;
4123
4124         /* we add the %p pointer value of klass because class names are not unique */
4125         name = g_strdup_printf ("__ldfld_wrapper_%p_%s.%s", klass, klass->name_space, klass->name);
4126         mb = mono_mb_new (mono_defaults.object_class, name, MONO_WRAPPER_LDFLD);
4127         g_free (name);
4128
4129         sig = mono_metadata_signature_alloc (mono_defaults.corlib, 4);
4130         sig->params [0] = &mono_defaults.object_class->byval_arg;
4131         sig->params [1] = &mono_defaults.int_class->byval_arg;
4132         sig->params [2] = &mono_defaults.int_class->byval_arg;
4133         sig->params [3] = &mono_defaults.int_class->byval_arg;
4134         sig->ret = &klass->byval_arg;
4135
4136         mono_mb_emit_ldarg (mb, 0);
4137         pos0 = mono_mb_emit_proxy_check (mb, CEE_BNE_UN);
4138
4139         mono_mb_emit_ldarg (mb, 0);
4140         mono_mb_emit_ldarg (mb, 1);
4141         mono_mb_emit_ldarg (mb, 2);
4142
4143         mono_mb_emit_managed_call (mb, mono_marshal_get_ldfld_remote_wrapper (klass), NULL);
4144
4145         /*
4146         csig = mono_metadata_signature_alloc (mono_defaults.corlib, 3);
4147         csig->params [0] = &mono_defaults.object_class->byval_arg;
4148         csig->params [1] = &mono_defaults.int_class->byval_arg;
4149         csig->params [2] = &mono_defaults.int_class->byval_arg;
4150         csig->ret = &klass->this_arg;
4151         csig->pinvoke = 1;
4152
4153         mono_mb_emit_native_call (mb, csig, mono_load_remote_field_new);
4154         emit_thread_interrupt_checkpoint (mb);
4155         */
4156
4157         if (klass->valuetype) {
4158                 mono_mb_emit_byte (mb, CEE_UNBOX);
4159                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, klass));
4160                 mono_mb_emit_byte (mb, CEE_BR);
4161                 pos1 = mb->pos;
4162                 mono_mb_emit_i4 (mb, 0);
4163         } else {
4164                 mono_mb_emit_byte (mb, CEE_RET);
4165         }
4166
4167
4168         mono_mb_patch_addr (mb, pos0, mb->pos - (pos0 + 4));
4169
4170         mono_mb_emit_ldarg (mb, 0);
4171         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
4172         mono_mb_emit_byte (mb, CEE_MONO_OBJADDR);
4173         mono_mb_emit_ldarg (mb, 3);
4174         mono_mb_emit_byte (mb, CEE_ADD);
4175
4176         if (klass->valuetype)
4177                 mono_mb_patch_addr (mb, pos1, mb->pos - (pos1 + 4));
4178
4179         switch (t) {
4180         case MONO_TYPE_I1:
4181         case MONO_TYPE_U1:
4182         case MONO_TYPE_BOOLEAN:
4183         case MONO_TYPE_CHAR:
4184         case MONO_TYPE_I2:
4185         case MONO_TYPE_U2:
4186         case MONO_TYPE_I4:
4187         case MONO_TYPE_U4:
4188         case MONO_TYPE_I8:
4189         case MONO_TYPE_U8:
4190         case MONO_TYPE_R4:
4191         case MONO_TYPE_R8:
4192         case MONO_TYPE_ARRAY:
4193         case MONO_TYPE_SZARRAY:
4194         case MONO_TYPE_OBJECT:
4195         case MONO_TYPE_CLASS:
4196         case MONO_TYPE_STRING:
4197         case MONO_TYPE_I:
4198         case MONO_TYPE_U:
4199         case MONO_TYPE_PTR:
4200         case MONO_TYPE_FNPTR:
4201                 mono_mb_emit_byte (mb, mono_type_to_ldind (type));
4202                 break;
4203         case MONO_TYPE_VALUETYPE:
4204                 g_assert (!klass->enumtype);
4205                 mono_mb_emit_byte (mb, CEE_LDOBJ);
4206                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, klass));
4207                 break;
4208         case MONO_TYPE_GENERICINST:
4209                 if (mono_type_generic_inst_is_valuetype (type)) {
4210                         mono_mb_emit_byte (mb, CEE_LDOBJ);
4211                         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, klass));
4212                 } else {
4213                         mono_mb_emit_byte (mb, CEE_LDIND_REF);
4214                 }
4215                 break;
4216         default:
4217                 g_warning ("type %x not implemented", type->type);
4218                 g_assert_not_reached ();
4219         }
4220
4221         mono_mb_emit_byte (mb, CEE_RET);
4222
4223         res = mono_mb_create_and_cache (cache, klass,
4224                                                                         mb, sig, sig->param_count + 16);
4225         mono_mb_free (mb);
4226
4227         return res;
4228 }
4229
4230 /*
4231  * mono_marshal_get_ldflda_wrapper:
4232  * @type: the type of the field
4233  *
4234  * This method generates a function which can be used to load a field address
4235  * from an object. The generated function has the following signature:
4236  * gpointer ldflda_wrapper (MonoObject *this, MonoClass *class, MonoClassField *field, int offset);
4237  */
4238 MonoMethod *
4239 mono_marshal_get_ldflda_wrapper (MonoType *type)
4240 {
4241         MonoMethodSignature *sig;
4242         MonoMethodBuilder *mb;
4243         MonoMethod *res;
4244         MonoClass *klass;
4245         GHashTable *cache;
4246         char *name;
4247         int t, pos0;
4248
4249         type = mono_type_get_underlying_type (type);
4250         t = type->type;
4251
4252         if (!type->byref) {
4253                 if (type->type == MONO_TYPE_SZARRAY) {
4254                         klass = mono_defaults.array_class;
4255                 } else if (type->type == MONO_TYPE_VALUETYPE) {
4256                         klass = type->data.klass;
4257                 } else if (t == MONO_TYPE_OBJECT || t == MONO_TYPE_CLASS || t == MONO_TYPE_STRING ||
4258                            t == MONO_TYPE_CLASS) {
4259                         klass = mono_defaults.object_class;
4260                 } else if (t == MONO_TYPE_PTR || t == MONO_TYPE_FNPTR) {
4261                         klass = mono_defaults.int_class;
4262                 } else if (t == MONO_TYPE_GENERICINST) {
4263                         if (mono_type_generic_inst_is_valuetype (type))
4264                                 klass = mono_class_from_mono_type (type);
4265                         else
4266                                 klass = mono_defaults.object_class;
4267                 } else {
4268                         klass = mono_class_from_mono_type (type);
4269                 }
4270         } else {
4271                 klass = mono_defaults.int_class;
4272         }
4273
4274         cache = klass->image->ldflda_wrapper_cache;
4275         if ((res = mono_marshal_find_in_cache (cache, klass)))
4276                 return res;
4277
4278         /* we add the %p pointer value of klass because class names are not unique */
4279         name = g_strdup_printf ("__ldflda_wrapper_%p_%s.%s", klass, klass->name_space, klass->name);
4280         mb = mono_mb_new (mono_defaults.object_class, name, MONO_WRAPPER_LDFLDA);
4281         g_free (name);
4282
4283         sig = mono_metadata_signature_alloc (mono_defaults.corlib, 4);
4284         sig->params [0] = &mono_defaults.object_class->byval_arg;
4285         sig->params [1] = &mono_defaults.int_class->byval_arg;
4286         sig->params [2] = &mono_defaults.int_class->byval_arg;
4287         sig->params [3] = &mono_defaults.int_class->byval_arg;
4288         sig->ret = &mono_defaults.int_class->byval_arg;
4289
4290         mono_mb_emit_ldarg (mb, 0);
4291         pos0 = mono_mb_emit_proxy_check (mb, CEE_BNE_UN);
4292
4293         /* FIXME: Only throw this if the object is in another appdomain */
4294         mono_mb_emit_exception_full (mb, "System", "InvalidOperationException", "Attempt to load field address from object in another appdomain.");
4295
4296         mono_mb_patch_addr (mb, pos0, mb->pos - (pos0 + 4));
4297
4298         mono_mb_emit_ldarg (mb, 0);
4299         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
4300         mono_mb_emit_byte (mb, CEE_MONO_OBJADDR);
4301         mono_mb_emit_ldarg (mb, 3);
4302         mono_mb_emit_byte (mb, CEE_ADD);
4303
4304         mono_mb_emit_byte (mb, CEE_RET);
4305
4306         res = mono_mb_create_and_cache (cache, klass,
4307                                                                         mb, sig, sig->param_count + 16);
4308         mono_mb_free (mb);
4309
4310         return res;
4311 }
4312
4313 /*
4314  * mono_marshal_get_stfld_remote_wrapper:
4315  * klass: The type of the field
4316  *
4317  *  This function generates a wrapper for calling mono_store_remote_field_new
4318  * with the appropriate signature.
4319  */
4320 MonoMethod *
4321 mono_marshal_get_stfld_remote_wrapper (MonoClass *klass)
4322 {
4323         MonoMethodSignature *sig, *csig;
4324         MonoMethodBuilder *mb;
4325         MonoMethod *res;
4326         GHashTable *cache;
4327         char *name;
4328
4329         cache = klass->image->stfld_remote_wrapper_cache;
4330         if ((res = mono_marshal_find_in_cache (cache, klass)))
4331                 return res;
4332
4333         name = g_strdup_printf ("__mono_store_remote_field_new_wrapper_%s.%s", klass->name_space, klass->name);
4334         mb = mono_mb_new (mono_defaults.object_class, name, MONO_WRAPPER_STFLD_REMOTE);
4335         g_free (name);
4336
4337         mb->method->save_lmf = 1;
4338
4339         sig = mono_metadata_signature_alloc (mono_defaults.corlib, 4);
4340         sig->params [0] = &mono_defaults.object_class->byval_arg;
4341         sig->params [1] = &mono_defaults.int_class->byval_arg;
4342         sig->params [2] = &mono_defaults.int_class->byval_arg;
4343         sig->params [3] = &klass->byval_arg;
4344         sig->ret = &mono_defaults.void_class->byval_arg;
4345
4346         mono_mb_emit_ldarg (mb, 0);
4347         mono_mb_emit_ldarg (mb, 1);
4348         mono_mb_emit_ldarg (mb, 2);
4349         mono_mb_emit_ldarg (mb, 3);
4350
4351         if (klass->valuetype) {
4352                 mono_mb_emit_byte (mb, CEE_BOX);
4353                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, klass));
4354         }
4355
4356         csig = mono_metadata_signature_alloc (mono_defaults.corlib, 4);
4357         csig->params [0] = &mono_defaults.object_class->byval_arg;
4358         csig->params [1] = &mono_defaults.int_class->byval_arg;
4359         csig->params [2] = &mono_defaults.int_class->byval_arg;
4360         csig->params [3] = &klass->byval_arg;
4361         csig->ret = &mono_defaults.void_class->byval_arg;
4362         csig->pinvoke = 1;
4363
4364         mono_mb_emit_native_call (mb, csig, mono_store_remote_field_new);
4365         emit_thread_interrupt_checkpoint (mb);
4366
4367         mono_mb_emit_byte (mb, CEE_RET);
4368
4369         res = mono_mb_create_and_cache (cache, klass,
4370                                                                         mb, sig, sig->param_count + 16);
4371         mono_mb_free (mb);
4372
4373         return res;
4374 }
4375
4376 /*
4377  * mono_marshal_get_stfld_wrapper:
4378  * @type: the type of the field
4379  *
4380  * This method generates a function which can be use to store a field with type
4381  * @type. The generated function has the following signature:
4382  * void stfld_wrapper (MonoObject *this, MonoClass *class, MonoClassField *field, int offset, <@type> val)
4383  */
4384 MonoMethod *
4385 mono_marshal_get_stfld_wrapper (MonoType *type)
4386 {
4387         MonoMethodSignature *sig;
4388         MonoMethodBuilder *mb;
4389         MonoMethod *res;
4390         MonoClass *klass;
4391         GHashTable *cache;
4392         char *name;
4393         int t, pos;
4394
4395         type = mono_type_get_underlying_type (type);
4396         t = type->type;
4397
4398         if (!type->byref) {
4399                 if (type->type == MONO_TYPE_SZARRAY) {
4400                         klass = mono_defaults.array_class;
4401                 } else if (type->type == MONO_TYPE_VALUETYPE) {
4402                         klass = type->data.klass;
4403                 } else if (t == MONO_TYPE_OBJECT || t == MONO_TYPE_CLASS || t == MONO_TYPE_STRING) {
4404                         klass = mono_defaults.object_class;
4405                 } else if (t == MONO_TYPE_PTR || t == MONO_TYPE_FNPTR) {
4406                         klass = mono_defaults.int_class;
4407                 } else if (t == MONO_TYPE_GENERICINST) {
4408                         if (mono_type_generic_inst_is_valuetype (type))
4409                                 klass = mono_class_from_mono_type (type);
4410                         else
4411                                 klass = mono_defaults.object_class;
4412                 } else {
4413                         klass = mono_class_from_mono_type (type);
4414                 }
4415         } else {
4416                 klass = mono_defaults.int_class;
4417         }
4418
4419         cache = klass->image->stfld_wrapper_cache;
4420         if ((res = mono_marshal_find_in_cache (cache, klass)))
4421                 return res;
4422
4423         /* we add the %p pointer value of klass because class names are not unique */
4424         name = g_strdup_printf ("__stfld_wrapper_%p_%s.%s", klass, klass->name_space, klass->name);
4425         mb = mono_mb_new (mono_defaults.object_class, name, MONO_WRAPPER_STFLD);
4426         g_free (name);
4427
4428         sig = mono_metadata_signature_alloc (mono_defaults.corlib, 5);
4429         sig->params [0] = &mono_defaults.object_class->byval_arg;
4430         sig->params [1] = &mono_defaults.int_class->byval_arg;
4431         sig->params [2] = &mono_defaults.int_class->byval_arg;
4432         sig->params [3] = &mono_defaults.int_class->byval_arg;
4433         sig->params [4] = &klass->byval_arg;
4434         sig->ret = &mono_defaults.void_class->byval_arg;
4435
4436         mono_mb_emit_ldarg (mb, 0);
4437         pos = mono_mb_emit_proxy_check (mb, CEE_BNE_UN);
4438
4439         mono_mb_emit_ldarg (mb, 0);
4440         mono_mb_emit_ldarg (mb, 1);
4441         mono_mb_emit_ldarg (mb, 2);
4442         mono_mb_emit_ldarg (mb, 4);
4443
4444         mono_mb_emit_managed_call (mb, mono_marshal_get_stfld_remote_wrapper (klass), NULL);
4445
4446         mono_mb_emit_byte (mb, CEE_RET);
4447
4448         mono_mb_patch_addr (mb, pos, mb->pos - (pos + 4));
4449
4450         mono_mb_emit_ldarg (mb, 0);
4451         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
4452         mono_mb_emit_byte (mb, CEE_MONO_OBJADDR);
4453         mono_mb_emit_ldarg (mb, 3);
4454         mono_mb_emit_byte (mb, CEE_ADD);
4455         mono_mb_emit_ldarg (mb, 4);
4456
4457         switch (t) {
4458         case MONO_TYPE_I1:
4459         case MONO_TYPE_U1:
4460         case MONO_TYPE_BOOLEAN:
4461         case MONO_TYPE_CHAR:
4462         case MONO_TYPE_I2:
4463         case MONO_TYPE_U2:
4464         case MONO_TYPE_I4:
4465         case MONO_TYPE_U4:
4466         case MONO_TYPE_I8:
4467         case MONO_TYPE_U8:
4468         case MONO_TYPE_R4:
4469         case MONO_TYPE_R8:
4470         case MONO_TYPE_ARRAY:
4471         case MONO_TYPE_SZARRAY:
4472         case MONO_TYPE_OBJECT:
4473         case MONO_TYPE_CLASS:
4474         case MONO_TYPE_STRING:
4475         case MONO_TYPE_I:
4476         case MONO_TYPE_U:
4477         case MONO_TYPE_PTR:
4478         case MONO_TYPE_FNPTR:
4479                 mono_mb_emit_byte (mb, mono_type_to_stind (type));
4480                 break;
4481         case MONO_TYPE_VALUETYPE:
4482                 g_assert (!klass->enumtype);
4483                 mono_mb_emit_byte (mb, CEE_STOBJ);
4484                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, klass));
4485                 break;
4486         case MONO_TYPE_GENERICINST:
4487                 mono_mb_emit_byte (mb, CEE_STOBJ);
4488                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, klass));
4489                 break;
4490         default:
4491                 g_warning ("type %x not implemented", type->type);
4492                 g_assert_not_reached ();
4493         }
4494
4495         mono_mb_emit_byte (mb, CEE_RET);
4496
4497         res = mono_mb_create_and_cache (cache, klass,
4498                                                                         mb, sig, sig->param_count + 16);
4499         mono_mb_free (mb);
4500
4501         return res;
4502 }
4503
4504 /*
4505  * generates IL code for the icall wrapper (the generated method
4506  * calls the unmanaged code in func)
4507  */
4508 MonoMethod *
4509 mono_marshal_get_icall_wrapper (MonoMethodSignature *sig, const char *name, gconstpointer func)
4510 {
4511         MonoMethodSignature *csig;
4512         MonoMethodBuilder *mb;
4513         MonoMethod *res;
4514         int i;
4515
4516         g_assert (sig->pinvoke);
4517
4518         mb = mono_mb_new (mono_defaults.object_class, name, MONO_WRAPPER_MANAGED_TO_NATIVE);
4519
4520         mb->method->save_lmf = 1;
4521
4522         /* we copy the signature, so that we can modify it */
4523
4524         if (sig->hasthis)
4525                 mono_mb_emit_byte (mb, CEE_LDARG_0);
4526
4527         for (i = 0; i < sig->param_count; i++)
4528                 mono_mb_emit_ldarg (mb, i + sig->hasthis);
4529
4530         mono_mb_emit_native_call (mb, sig, (gpointer) func);
4531         emit_thread_interrupt_checkpoint (mb);
4532         mono_mb_emit_byte (mb, CEE_RET);
4533
4534         csig = signature_dup (mono_defaults.corlib, sig);
4535         csig->pinvoke = 0;
4536         if (csig->call_convention == MONO_CALL_VARARG)
4537                 csig->call_convention = 0;
4538
4539         res = mono_mb_create_method (mb, csig, csig->param_count + 16);
4540         mono_mb_free (mb);
4541
4542         return res;
4543 }
4544
4545 typedef struct {
4546         MonoMethodBuilder *mb;
4547         MonoMethodSignature *sig;
4548         MonoMethodPInvoke *piinfo;
4549         int *orig_conv_args; /* Locals containing the original values of byref args */
4550         int retobj_var;
4551         MonoClass *retobj_class;
4552         MonoMethodSignature *csig; /* Might need to be changed due to MarshalAs directives */
4553 } EmitMarshalContext;
4554
4555 typedef enum {
4556         MARSHAL_ACTION_CONV_IN,
4557         MARSHAL_ACTION_PUSH,
4558         MARSHAL_ACTION_CONV_OUT,
4559         MARSHAL_ACTION_CONV_RESULT,
4560         MARSHAL_ACTION_MANAGED_CONV_IN,
4561         MARSHAL_ACTION_MANAGED_CONV_OUT,
4562         MARSHAL_ACTION_MANAGED_CONV_RESULT
4563 } MarshalAction;
4564
4565 static int
4566 emit_marshal_custom (EmitMarshalContext *m, int argnum, MonoType *t,
4567                                          MonoMarshalSpec *spec,
4568                                          int conv_arg, MonoType **conv_arg_type,
4569                                          MarshalAction action)
4570 {
4571         MonoType *mtype;
4572         MonoClass *mklass;
4573         static MonoClass *ICustomMarshaler = NULL;
4574         static MonoMethod *cleanup_native, *cleanup_managed;
4575         static MonoMethod *marshal_managed_to_native, *marshal_native_to_managed;
4576         MonoMethod *get_instance;
4577         MonoMethodBuilder *mb = m->mb;
4578         char *exception_msg = NULL;
4579         guint32 loc1;
4580         int pos2;
4581
4582         if (!ICustomMarshaler) {
4583                 ICustomMarshaler = mono_class_from_name (mono_defaults.corlib, "System.Runtime.InteropServices", "ICustomMarshaler");
4584                 g_assert (ICustomMarshaler);
4585
4586                 cleanup_native = mono_class_get_method_from_name (ICustomMarshaler, "CleanUpNativeData", 1);
4587                 g_assert (cleanup_native);
4588                 cleanup_managed = mono_class_get_method_from_name (ICustomMarshaler, "CleanUpManagedData", 1);
4589                 g_assert (cleanup_managed);
4590                 marshal_managed_to_native = mono_class_get_method_from_name (ICustomMarshaler, "MarshalManagedToNative", 1);
4591                 g_assert (marshal_managed_to_native);
4592                 marshal_native_to_managed = mono_class_get_method_from_name (ICustomMarshaler, "MarshalNativeToManaged", 1);
4593                 g_assert (marshal_native_to_managed);
4594         }
4595
4596         mtype = mono_reflection_type_from_name (spec->data.custom_data.custom_name, mb->method->klass->image);
4597         g_assert (mtype != NULL);
4598         mklass = mono_class_from_mono_type (mtype);
4599         g_assert (mklass != NULL);
4600
4601         if (!mono_class_is_assignable_from (ICustomMarshaler, mklass))
4602                 exception_msg = g_strdup_printf ("Custom marshaler '%s' does not implement the ICustomMarshaler interface.", mklass->name);
4603
4604         get_instance = mono_class_get_method_from_name_flags (mklass, "GetInstance", 1, METHOD_ATTRIBUTE_STATIC);
4605         if (get_instance) {
4606                 MonoMethodSignature *get_sig = mono_method_signature (get_instance);
4607                 if ((get_sig->ret->type != MONO_TYPE_CLASS) ||
4608                         (mono_class_from_mono_type (get_sig->ret) != ICustomMarshaler) ||
4609                         (get_sig->params [0]->type != MONO_TYPE_STRING))
4610                         get_instance = NULL;
4611         }
4612
4613         if (!get_instance)
4614                 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);
4615
4616         /* Throw exception and emit compensation code if neccesary */
4617         if (exception_msg) {
4618                 switch (action) {
4619                 case MARSHAL_ACTION_CONV_IN:
4620                 case MARSHAL_ACTION_CONV_RESULT:
4621                 case MARSHAL_ACTION_MANAGED_CONV_RESULT:
4622                         if ((action == MARSHAL_ACTION_CONV_RESULT) || (action == MARSHAL_ACTION_MANAGED_CONV_RESULT))
4623                                 mono_mb_emit_byte (mb, CEE_POP);
4624
4625                         mono_mb_emit_exception_full (mb, "System", "ApplicationException", exception_msg);
4626                         g_free (exception_msg);
4627
4628                         break;
4629                 case MARSHAL_ACTION_PUSH:
4630                         mono_mb_emit_byte (mb, CEE_LDNULL);
4631                         break;
4632                 default:
4633                         break;
4634                 }
4635                 return 0;
4636         }
4637
4638         /* FIXME: MS.NET seems to create one instance for each klass + cookie pair */
4639         /* FIXME: MS.NET throws an exception if GetInstance returns null */
4640
4641         switch (action) {
4642         case MARSHAL_ACTION_CONV_IN:
4643                 switch (t->type) {
4644                 case MONO_TYPE_CLASS:
4645                 case MONO_TYPE_OBJECT:
4646                 case MONO_TYPE_STRING:
4647                 case MONO_TYPE_ARRAY:
4648                 case MONO_TYPE_SZARRAY:
4649                 case MONO_TYPE_VALUETYPE:
4650                         break;
4651
4652                 default:
4653                         g_warning ("custom marshalling of type %x is currently not supported", t->type);
4654                         g_assert_not_reached ();
4655                         break;
4656                 }
4657
4658                 conv_arg = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
4659
4660                 mono_mb_emit_byte (mb, CEE_LDNULL);
4661                 mono_mb_emit_stloc (mb, conv_arg);
4662
4663                 if (t->byref && (t->attrs & PARAM_ATTRIBUTE_OUT))
4664                         break;
4665
4666                 /* Check for null */
4667                 mono_mb_emit_ldarg (mb, argnum);
4668                 if (t->byref)
4669                         mono_mb_emit_byte (mb, CEE_LDIND_I);
4670                 pos2 = mono_mb_emit_branch (mb, CEE_BRFALSE);
4671
4672                 mono_mb_emit_ldstr (mb, g_strdup (spec->data.custom_data.cookie));
4673
4674                 mono_mb_emit_byte (mb, CEE_CALL);
4675                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, get_instance));
4676
4677                 mono_mb_emit_ldarg (mb, argnum);
4678                 if (t->byref)
4679                         mono_mb_emit_byte (mb, CEE_LDIND_REF);
4680
4681                 if (t->type == MONO_TYPE_VALUETYPE) {
4682                         /*
4683                          * Since we can't determine the type of the argument, we
4684                          * will assume the unmanaged function takes a pointer.
4685                          */
4686                         *conv_arg_type = &mono_defaults.int_class->byval_arg;
4687
4688                         mono_mb_emit_byte (mb, CEE_BOX);
4689                         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, mono_class_from_mono_type (t)));
4690                 }
4691
4692                 mono_mb_emit_byte (mb, CEE_CALLVIRT);
4693                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, marshal_managed_to_native));
4694                 mono_mb_emit_stloc (mb, conv_arg);
4695
4696                 mono_mb_patch_addr (mb, pos2, mb->pos - (pos2 + 4));
4697                 break;
4698
4699         case MARSHAL_ACTION_CONV_OUT:
4700                 /* Check for null */
4701                 mono_mb_emit_ldloc (mb, conv_arg);
4702                 pos2 = mono_mb_emit_branch (mb, CEE_BRFALSE);
4703
4704                 if (t->byref) {
4705                         mono_mb_emit_ldarg (mb, argnum);
4706
4707                         mono_mb_emit_ldstr (mb, g_strdup (spec->data.custom_data.cookie));
4708
4709                         mono_mb_emit_byte (mb, CEE_CALL);
4710                         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, get_instance));
4711
4712                         mono_mb_emit_ldloc (mb, conv_arg);
4713                         mono_mb_emit_byte (mb, CEE_CALLVIRT);
4714                         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, marshal_native_to_managed));
4715                         mono_mb_emit_byte (mb, CEE_STIND_REF);
4716                 }
4717
4718                 mono_mb_emit_ldstr (mb, g_strdup (spec->data.custom_data.cookie));
4719
4720                 mono_mb_emit_byte (mb, CEE_CALL);
4721                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, get_instance));
4722
4723                 mono_mb_emit_ldloc (mb, conv_arg);
4724
4725                 mono_mb_emit_byte (mb, CEE_CALLVIRT);
4726                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, cleanup_native));
4727
4728                 mono_mb_patch_addr (mb, pos2, mb->pos - (pos2 + 4));
4729                 break;
4730
4731         case MARSHAL_ACTION_PUSH:
4732                 if (t->byref)
4733                         mono_mb_emit_ldloc_addr (mb, conv_arg);
4734                 else
4735                         mono_mb_emit_ldloc (mb, conv_arg);
4736                 break;
4737
4738         case MARSHAL_ACTION_CONV_RESULT:
4739                 loc1 = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
4740
4741                 mono_mb_emit_stloc (mb, 3);
4742
4743                 mono_mb_emit_ldloc (mb, 3);
4744                 mono_mb_emit_stloc (mb, loc1);
4745
4746                 /* Check for null */
4747                 mono_mb_emit_ldloc (mb, 3);
4748                 pos2 = mono_mb_emit_branch (mb, CEE_BRFALSE);
4749
4750                 mono_mb_emit_ldstr (mb, g_strdup (spec->data.custom_data.cookie));
4751
4752                 mono_mb_emit_byte (mb, CEE_CALL);
4753                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, get_instance));
4754                 mono_mb_emit_byte (mb, CEE_DUP);
4755
4756                 mono_mb_emit_ldloc (mb, 3);
4757                 mono_mb_emit_byte (mb, CEE_CALLVIRT);
4758                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, marshal_native_to_managed));
4759                 mono_mb_emit_stloc (mb, 3);
4760
4761                 mono_mb_emit_ldloc (mb, loc1);
4762                 mono_mb_emit_byte (mb, CEE_CALLVIRT);
4763                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, cleanup_native));
4764
4765                 mono_mb_patch_addr (mb, pos2, mb->pos - (pos2 + 4));
4766                 break;
4767
4768         case MARSHAL_ACTION_MANAGED_CONV_IN:
4769                 if (t->byref) {
4770                         conv_arg = 0;
4771                         break;
4772                 }
4773
4774                 conv_arg = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
4775
4776                 mono_mb_emit_byte (mb, CEE_LDNULL);
4777                 mono_mb_emit_stloc (mb, conv_arg);
4778
4779                 /* Check for null */
4780                 mono_mb_emit_ldarg (mb, argnum);
4781                 pos2 = mono_mb_emit_branch (mb, CEE_BRFALSE);
4782
4783                 mono_mb_emit_ldstr (mb, g_strdup (spec->data.custom_data.cookie));
4784                 mono_mb_emit_byte (mb, CEE_CALL);
4785                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, get_instance));
4786
4787                 mono_mb_emit_ldarg (mb, argnum);
4788
4789                 mono_mb_emit_byte (mb, CEE_CALLVIRT);
4790                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, marshal_native_to_managed));
4791                 mono_mb_emit_stloc (mb, conv_arg);
4792
4793                 mono_mb_patch_addr (mb, pos2, mb->pos - (pos2 + 4));
4794                 break;
4795
4796         case MARSHAL_ACTION_MANAGED_CONV_RESULT:
4797                 g_assert (!t->byref);
4798
4799                 loc1 = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
4800
4801                 mono_mb_emit_stloc (mb, 3);
4802
4803                 mono_mb_emit_ldloc (mb, 3);
4804                 mono_mb_emit_stloc (mb, loc1);
4805
4806                 /* Check for null */
4807                 mono_mb_emit_ldloc (mb, 3);
4808                 pos2 = mono_mb_emit_branch (mb, CEE_BRFALSE);
4809
4810                 mono_mb_emit_ldstr (mb, g_strdup (spec->data.custom_data.cookie));
4811                 mono_mb_emit_byte (mb, CEE_CALL);
4812                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, get_instance));
4813                 mono_mb_emit_byte (mb, CEE_DUP);
4814
4815                 mono_mb_emit_ldloc (mb, 3);
4816                 mono_mb_emit_byte (mb, CEE_CALLVIRT);
4817                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, marshal_managed_to_native));
4818                 mono_mb_emit_stloc (mb, 3);
4819
4820                 mono_mb_emit_ldloc (mb, loc1);
4821                 mono_mb_emit_byte (mb, CEE_CALLVIRT);
4822                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, cleanup_managed));
4823
4824                 mono_mb_patch_addr (mb, pos2, mb->pos - (pos2 + 4));
4825                 break;
4826
4827         case MARSHAL_ACTION_MANAGED_CONV_OUT:
4828                 g_assert (!t->byref);
4829
4830                 /* Check for null */
4831                 mono_mb_emit_ldloc (mb, conv_arg);
4832                 pos2 = mono_mb_emit_branch (mb, CEE_BRFALSE);
4833
4834                 /* Call CleanUpManagedData */
4835                 mono_mb_emit_ldstr (mb, g_strdup (spec->data.custom_data.cookie));
4836
4837                 mono_mb_emit_byte (mb, CEE_CALL);
4838                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, get_instance));
4839
4840                 mono_mb_emit_ldloc (mb, conv_arg);
4841                 mono_mb_emit_byte (mb, CEE_CALLVIRT);
4842                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, cleanup_managed));
4843
4844                 mono_mb_patch_addr (mb, pos2, mb->pos - (pos2 + 4));
4845                 break;
4846
4847         default:
4848                 g_assert_not_reached ();
4849         }
4850
4851         return conv_arg;
4852 }
4853
4854 static int
4855 emit_marshal_asany (EmitMarshalContext *m, int argnum, MonoType *t,
4856                                         MonoMarshalSpec *spec,
4857                                         int conv_arg, MonoType **conv_arg_type,
4858                                         MarshalAction action)
4859 {
4860         MonoMethodBuilder *mb = m->mb;
4861
4862         switch (action) {
4863         case MARSHAL_ACTION_CONV_IN: {
4864                 MonoMarshalNative encoding = mono_marshal_get_string_encoding (m->piinfo, NULL);
4865
4866                 g_assert (t->type == MONO_TYPE_OBJECT);
4867                 g_assert (!t->byref);
4868
4869                 conv_arg = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
4870                 mono_mb_emit_ldarg (mb, argnum);
4871                 mono_mb_emit_icon (mb, encoding);
4872                 mono_mb_emit_icon (mb, t->attrs);
4873                 mono_mb_emit_icall (mb, mono_marshal_asany);
4874                 mono_mb_emit_stloc (mb, conv_arg);
4875                 break;
4876         }
4877
4878         case MARSHAL_ACTION_PUSH:
4879                 mono_mb_emit_ldloc (mb, conv_arg);
4880                 break;
4881
4882         case MARSHAL_ACTION_CONV_OUT: {
4883                 MonoMarshalNative encoding = mono_marshal_get_string_encoding (m->piinfo, NULL);
4884
4885                 mono_mb_emit_ldarg (mb, argnum);
4886                 mono_mb_emit_ldloc (mb, conv_arg);
4887                 mono_mb_emit_icon (mb, encoding);
4888                 mono_mb_emit_icon (mb, t->attrs);
4889                 mono_mb_emit_icall (mb, mono_marshal_free_asany);
4890                 break;
4891         }
4892
4893         default:
4894                 g_assert_not_reached ();
4895         }
4896
4897         return conv_arg;
4898 }
4899
4900 static int
4901 emit_marshal_vtype (EmitMarshalContext *m, int argnum, MonoType *t,
4902                                         MonoMarshalSpec *spec,
4903                                         int conv_arg, MonoType **conv_arg_type,
4904                                         MarshalAction action)
4905 {
4906         MonoMethodBuilder *mb = m->mb;
4907         MonoClass *klass;
4908         int pos = 0, pos2;
4909
4910         klass = t->data.klass;
4911
4912         switch (action) {
4913         case MARSHAL_ACTION_CONV_IN:
4914                 if (((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) ||
4915                         klass->blittable || klass->enumtype)
4916                         break;
4917
4918                 conv_arg = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
4919
4920                 /* store the address of the source into local variable 0 */
4921                 if (t->byref)
4922                         mono_mb_emit_ldarg (mb, argnum);
4923                 else
4924                         mono_mb_emit_ldarg_addr (mb, argnum);
4925
4926                 mono_mb_emit_stloc (mb, 0);
4927
4928                 /* allocate space for the native struct and
4929                  * store the address into local variable 1 (dest) */
4930                 mono_mb_emit_icon (mb, mono_class_native_size (klass, NULL));
4931                 mono_mb_emit_byte (mb, CEE_PREFIX1);
4932                 mono_mb_emit_byte (mb, CEE_LOCALLOC);
4933                 mono_mb_emit_stloc (mb, conv_arg);
4934
4935                 if (t->byref) {
4936                         mono_mb_emit_ldloc (mb, 0);
4937                         mono_mb_emit_byte (mb, CEE_BRFALSE);
4938                         pos = mb->pos;
4939                         mono_mb_emit_i4 (mb, 0);
4940                 }
4941
4942                 if (!(t->byref && !(t->attrs & PARAM_ATTRIBUTE_IN) && (t->attrs & PARAM_ATTRIBUTE_OUT))) {
4943                         /* set dst_ptr */
4944                         mono_mb_emit_ldloc (mb, conv_arg);
4945                         mono_mb_emit_stloc (mb, 1);
4946
4947                         /* emit valuetype conversion code */
4948                         emit_struct_conv (mb, klass, FALSE);
4949                 }
4950
4951                 if (t->byref)
4952                         mono_mb_patch_addr (mb, pos, mb->pos - (pos + 4));
4953                 break;
4954
4955         case MARSHAL_ACTION_PUSH:
4956                 if (spec && spec->native == MONO_NATIVE_LPSTRUCT) {
4957                         /* FIXME: */
4958                         g_assert (!t->byref);
4959
4960                         /* Have to change the signature since the vtype is passed byref */
4961                         m->csig->params [argnum - m->csig->hasthis] = &mono_defaults.int_class->byval_arg;
4962
4963                         if (((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) ||
4964                                 klass->blittable || klass->enumtype)
4965                                 mono_mb_emit_ldarg_addr (mb, argnum);
4966                         else
4967                                 mono_mb_emit_ldloc (mb, conv_arg);
4968                         break;
4969                 }
4970
4971                 if (((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) ||
4972                         klass->blittable || klass->enumtype) {
4973                         mono_mb_emit_ldarg (mb, argnum);
4974                         break;
4975                 }
4976                 mono_mb_emit_ldloc (mb, conv_arg);
4977                 if (!t->byref) {
4978                         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
4979                         mono_mb_emit_byte (mb, CEE_MONO_LDNATIVEOBJ);
4980                         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, klass));
4981                 }
4982                 break;
4983
4984         case MARSHAL_ACTION_CONV_OUT:
4985                 if (((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) ||
4986                         klass->blittable || klass->enumtype)
4987                         break;
4988
4989                 if (t->byref) {
4990                         /* dst = argument */
4991                         mono_mb_emit_ldarg (mb, argnum);
4992                         mono_mb_emit_stloc (mb, 1);
4993
4994                         mono_mb_emit_ldloc (mb, 1);
4995                         mono_mb_emit_byte (mb, CEE_BRFALSE);
4996                         pos = mb->pos;
4997                         mono_mb_emit_i4 (mb, 0);
4998
4999                         if (!((t->attrs & PARAM_ATTRIBUTE_IN) && !(t->attrs & PARAM_ATTRIBUTE_OUT))) {
5000                                 /* src = tmp_locals [i] */
5001                                 mono_mb_emit_ldloc (mb, conv_arg);
5002                                 mono_mb_emit_stloc (mb, 0);
5003
5004                                 /* emit valuetype conversion code */
5005                                 emit_struct_conv (mb, klass, TRUE);
5006                         }
5007                 }
5008
5009                 emit_struct_free (mb, klass, conv_arg);
5010
5011                 if (t->byref)
5012                         mono_mb_patch_addr (mb, pos, mb->pos - (pos + 4));
5013                 break;
5014
5015         case MARSHAL_ACTION_CONV_RESULT:
5016                 if (((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) ||
5017                         klass->blittable) {
5018                         mono_mb_emit_stloc (mb, 3);
5019                         break;
5020                 }
5021                 /* load pointer to returned value type */
5022                 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
5023                 mono_mb_emit_byte (mb, CEE_MONO_VTADDR);
5024                 /* store the address of the source into local variable 0 */
5025                 mono_mb_emit_stloc (mb, 0);
5026                 /* set dst_ptr */
5027                 mono_mb_emit_ldloc_addr (mb, 3);
5028                 mono_mb_emit_stloc (mb, 1);
5029
5030                 /* emit valuetype conversion code */
5031                 emit_struct_conv (mb, klass, TRUE);
5032                 break;
5033
5034         case MARSHAL_ACTION_MANAGED_CONV_IN:
5035                 if (((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) ||
5036                         klass->blittable || klass->enumtype) {
5037                         conv_arg = 0;
5038                         break;
5039                 }
5040
5041                 conv_arg = mono_mb_add_local (mb, &klass->byval_arg);
5042
5043                 if (t->attrs & PARAM_ATTRIBUTE_OUT)
5044                         break;
5045
5046                 if (t->byref)
5047                         mono_mb_emit_ldarg (mb, argnum);
5048                 else
5049                         mono_mb_emit_ldarg_addr (mb, argnum);
5050                 mono_mb_emit_stloc (mb, 0);
5051
5052                 if (t->byref) {
5053                         mono_mb_emit_ldloc (mb, 0);
5054                         mono_mb_emit_byte (mb, CEE_BRFALSE);
5055                         pos = mb->pos;
5056                         mono_mb_emit_i4 (mb, 0);
5057                 }
5058
5059                 mono_mb_emit_ldloc_addr (mb, conv_arg);
5060                 mono_mb_emit_stloc (mb, 1);
5061
5062                 /* emit valuetype conversion code */
5063                 emit_struct_conv (mb, klass, TRUE);
5064
5065                 if (t->byref)
5066                         mono_mb_patch_addr (mb, pos, mb->pos - (pos + 4));
5067                 break;
5068
5069         case MARSHAL_ACTION_MANAGED_CONV_OUT:
5070                 if (((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) ||
5071                         klass->blittable || klass->enumtype) {
5072                         break;
5073                 }
5074
5075                 /* Check for null */
5076                 mono_mb_emit_ldarg (mb, argnum);
5077                 pos2 = mono_mb_emit_branch (mb, CEE_BRFALSE);
5078
5079                 /* Set src */
5080                 mono_mb_emit_ldloc_addr (mb, conv_arg);
5081                 mono_mb_emit_stloc (mb, 0);
5082
5083                 /* Set dest */
5084                 mono_mb_emit_ldarg (mb, argnum);
5085                 mono_mb_emit_stloc (mb, 1);
5086
5087                 /* emit valuetype conversion code */
5088                 emit_struct_conv (mb, klass, FALSE);
5089
5090                 mono_mb_patch_addr (mb, pos2, mb->pos - (pos2 + 4));
5091                 break;
5092
5093         case MARSHAL_ACTION_MANAGED_CONV_RESULT:
5094                 if (((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) ||
5095                         klass->blittable || klass->enumtype) {
5096                         mono_mb_emit_stloc (mb, 3);
5097                         m->retobj_var = 0;
5098                         break;
5099                 }
5100
5101                 /* load pointer to returned value type */
5102                 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
5103                 mono_mb_emit_byte (mb, CEE_MONO_VTADDR);
5104
5105                 /* store the address of the source into local variable 0 */
5106                 mono_mb_emit_stloc (mb, 0);
5107                 /* allocate space for the native struct and
5108                  * store the address into dst_ptr */
5109                 m->retobj_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
5110                 m->retobj_class = klass;
5111                 g_assert (m->retobj_var);
5112                 mono_mb_emit_icon (mb, mono_class_native_size (klass, NULL));
5113                 mono_mb_emit_byte (mb, CEE_CONV_I);
5114                 mono_mb_emit_icall (mb, mono_marshal_alloc);
5115                 mono_mb_emit_stloc (mb, 1);
5116                 mono_mb_emit_ldloc (mb, 1);
5117                 mono_mb_emit_stloc (mb, m->retobj_var);
5118
5119                 /* emit valuetype conversion code */
5120                 emit_struct_conv (mb, klass, FALSE);
5121                 break;
5122
5123         default:
5124                 g_assert_not_reached ();
5125         }
5126
5127         return conv_arg;
5128 }
5129
5130 static int
5131 emit_marshal_string (EmitMarshalContext *m, int argnum, MonoType *t,
5132                                          MonoMarshalSpec *spec,
5133                                          int conv_arg, MonoType **conv_arg_type,
5134                                          MarshalAction action)
5135 {
5136         MonoMethodBuilder *mb = m->mb;
5137         MonoMarshalNative encoding = mono_marshal_get_string_encoding (m->piinfo, spec);
5138         MonoMarshalConv conv = mono_marshal_get_string_to_ptr_conv (m->piinfo, spec);
5139         gboolean need_free;
5140
5141         switch (action) {
5142         case MARSHAL_ACTION_CONV_IN:
5143                 *conv_arg_type = &mono_defaults.int_class->byval_arg;
5144                 conv_arg = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
5145
5146                 if (t->byref) {
5147                         if (t->attrs & PARAM_ATTRIBUTE_OUT)
5148                                 break;
5149
5150                         mono_mb_emit_ldarg (mb, argnum);
5151                         mono_mb_emit_byte (mb, CEE_LDIND_I);
5152                 } else {
5153                         mono_mb_emit_ldarg (mb, argnum);
5154                 }
5155
5156                 if (conv == -1) {
5157                         char *msg = g_strdup_printf ("string marshalling conversion %d not implemented", encoding);
5158                         MonoException *exc = mono_get_exception_not_implemented (msg);
5159                         g_warning (msg);
5160                         g_free (msg);
5161                         mono_raise_exception (exc);
5162                 }
5163                 else
5164                         mono_mb_emit_icall (mb, conv_to_icall (conv));
5165
5166                 mono_mb_emit_stloc (mb, conv_arg);
5167                 break;
5168
5169         case MARSHAL_ACTION_CONV_OUT:
5170                 if (t->byref && (t->attrs & PARAM_ATTRIBUTE_OUT)) {
5171                         mono_mb_emit_ldarg (mb, argnum);
5172                         mono_mb_emit_ldloc (mb, conv_arg);
5173                         if (conv == MONO_MARSHAL_CONV_STR_BSTR) {
5174                                 mono_mb_emit_icall (mb, conv_to_icall (MONO_MARSHAL_CONV_BSTR_STR));
5175                                 // BSTRs always need freed
5176                                 mono_mb_emit_ldloc (mb, conv_arg);
5177                                 mono_mb_emit_icall (mb, mono_free_bstr);
5178                         }
5179                         else
5180                                 mono_mb_emit_icall (mb, conv_to_icall (MONO_MARSHAL_CONV_LPSTR_STR));
5181                         mono_mb_emit_byte (mb, CEE_STIND_REF);
5182                 } else {
5183                         if (mono_marshal_need_free (t, m->piinfo, spec)) {
5184                                 mono_mb_emit_ldloc (mb, conv_arg);
5185                                 if (conv == MONO_MARSHAL_CONV_STR_BSTR)
5186                                         mono_mb_emit_icall (mb, mono_free_bstr);
5187                                 else
5188                                         mono_mb_emit_icall (mb, mono_marshal_free);
5189                         }
5190                 }
5191                 break;
5192
5193         case MARSHAL_ACTION_PUSH:
5194                 if (t->byref)
5195                         mono_mb_emit_ldloc_addr (mb, conv_arg);
5196                 else
5197                         mono_mb_emit_ldloc (mb, conv_arg);
5198                 break;
5199
5200         case MARSHAL_ACTION_CONV_RESULT:
5201                 mono_mb_emit_stloc (mb, 0);
5202
5203                 conv = mono_marshal_get_ptr_to_string_conv (m->piinfo, spec, &need_free);
5204                 if (conv == -1) {
5205                         char *msg = g_strdup_printf ("string marshalling conversion %d not implemented", encoding);
5206                         mono_mb_emit_exception_marshal_directive (mb, msg);
5207                         break;
5208                 }
5209
5210                 mono_mb_emit_ldloc (mb, 0);
5211                 mono_mb_emit_icall (mb, conv_to_icall (conv));
5212                 mono_mb_emit_stloc (mb, 3);
5213
5214                 /* free the string */
5215                 mono_mb_emit_ldloc (mb, 0);
5216                 if (conv == MONO_MARSHAL_CONV_BSTR_STR)
5217                         mono_mb_emit_icall (mb, mono_free_bstr);
5218                 else
5219                         mono_mb_emit_icall (mb, g_free);
5220                 break;
5221
5222         case MARSHAL_ACTION_MANAGED_CONV_IN:
5223                 if (t->byref) {
5224                         conv_arg = 0;
5225                         break;
5226                 }
5227
5228                 conv_arg = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
5229                 *conv_arg_type = &mono_defaults.int_class->byval_arg;
5230
5231                 conv = mono_marshal_get_ptr_to_string_conv (m->piinfo, spec, &need_free);
5232                 if (conv == -1) {
5233                         char *msg = g_strdup_printf ("string marshalling conversion %d not implemented", encoding);
5234                         mono_mb_emit_exception_marshal_directive (mb, msg);
5235                         break;
5236                 }
5237
5238                 mono_mb_emit_ldarg (mb, argnum);
5239                 mono_mb_emit_icall (mb, conv_to_icall (conv));
5240                 mono_mb_emit_stloc (mb, conv_arg);
5241                 break;
5242
5243         case MARSHAL_ACTION_MANAGED_CONV_RESULT:
5244                 mono_mb_emit_icall (mb, conv_to_icall (MONO_MARSHAL_CONV_STR_LPSTR));
5245                 mono_mb_emit_stloc (mb, 3);
5246                 break;
5247
5248         default:
5249                 g_assert_not_reached ();
5250         }
5251
5252         return conv_arg;
5253 }
5254
5255 static int
5256 emit_marshal_object (EmitMarshalContext *m, int argnum, MonoType *t,
5257                                          MonoMarshalSpec *spec,
5258                                          int conv_arg, MonoType **conv_arg_type,
5259                                          MarshalAction action)
5260 {
5261         MonoMethodBuilder *mb = m->mb;
5262         MonoClass *klass = t->data.klass;
5263         int pos, pos2, loc;
5264
5265         if (mono_class_from_mono_type (t) == mono_defaults.object_class &&
5266                 (!spec || (spec && spec->native != MONO_NATIVE_STRUCT))) {
5267                 mono_raise_exception (mono_get_exception_not_implemented ("Marshalling of type object is not implemented"));
5268         }
5269
5270         switch (action) {
5271         case MARSHAL_ACTION_CONV_IN:
5272                 *conv_arg_type = &mono_defaults.int_class->byval_arg;
5273                 conv_arg = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
5274
5275                 m->orig_conv_args [argnum] = 0;
5276
5277                 if (spec && spec->native == MONO_NATIVE_STRUCT)
5278                 {
5279                         static MonoMethod *get_native_variant_for_object = NULL;
5280                         int local_variant;
5281                         if (!get_native_variant_for_object)
5282                                 get_native_variant_for_object = mono_class_get_method_from_name (mono_defaults.marshal_class, "GetNativeVariantForObject", 2);
5283
5284                         *conv_arg_type = &mono_defaults.variant_class->byval_arg;
5285
5286                         local_variant = mono_mb_add_local (mb, &mono_defaults.variant_class->byval_arg);
5287                         conv_arg = local_variant;
5288                         mono_mb_emit_ldarg (mb, argnum);
5289                         if (t->byref)
5290                                 mono_mb_emit_byte(mb, CEE_LDIND_REF);
5291                         mono_mb_emit_ldloc_addr (mb, local_variant);
5292                         mono_mb_emit_managed_call (mb, get_native_variant_for_object, NULL);
5293                 }
5294                 else if (klass->delegate) {
5295                         g_assert (!t->byref);
5296                         mono_mb_emit_ldarg (mb, argnum);
5297                         mono_mb_emit_icall (mb, conv_to_icall (MONO_MARSHAL_CONV_DEL_FTN));
5298                         mono_mb_emit_stloc (mb, conv_arg);
5299                 } else if (klass == mono_defaults.stringbuilder_class) {
5300                         MonoMarshalNative encoding = mono_marshal_get_string_encoding (m->piinfo, spec);
5301                         MonoMarshalConv conv = mono_marshal_get_stringbuilder_to_ptr_conv (m->piinfo, spec);
5302
5303                         g_assert (!t->byref);
5304                         mono_mb_emit_ldarg (mb, argnum);
5305
5306                         if (conv != -1)
5307                                 mono_mb_emit_icall (mb, conv_to_icall (conv));
5308                         else {
5309                                 char *msg = g_strdup_printf ("stringbuilder marshalling conversion %d not implemented", encoding);
5310                                 MonoException *exc = mono_get_exception_not_implemented (msg);
5311                                 g_warning (msg);
5312                                 g_free (msg);
5313                                 mono_raise_exception (exc);
5314                         }
5315
5316                         mono_mb_emit_stloc (mb, conv_arg);
5317                 } else if (klass->blittable) {
5318                         mono_mb_emit_ldarg (mb, argnum);
5319                         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
5320                         mono_mb_emit_byte (mb, CEE_MONO_OBJADDR);
5321                         mono_mb_emit_icon (mb, sizeof (MonoObject));
5322                         mono_mb_emit_byte (mb, CEE_ADD);
5323                         mono_mb_emit_stloc (mb, conv_arg);
5324                         break;
5325                 } else {
5326                         mono_mb_emit_byte (mb, CEE_LDNULL);
5327                         mono_mb_emit_stloc (mb, conv_arg);
5328
5329                         if (t->byref) {
5330                                 /* we dont need any conversions for out parameters */
5331                                 if (t->attrs & PARAM_ATTRIBUTE_OUT)
5332                                         break;
5333
5334                                 mono_mb_emit_ldarg (mb, argnum);
5335                                 mono_mb_emit_byte (mb, CEE_LDIND_I);
5336
5337                         } else {
5338                                 mono_mb_emit_ldarg (mb, argnum);
5339                                 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
5340                                 mono_mb_emit_byte (mb, CEE_MONO_OBJADDR);
5341                         }
5342
5343                         /* store the address of the source into local variable 0 */
5344                         mono_mb_emit_stloc (mb, 0);
5345                         mono_mb_emit_ldloc (mb, 0);
5346                         mono_mb_emit_byte (mb, CEE_BRFALSE);
5347                         pos = mb->pos;
5348                         mono_mb_emit_i4 (mb, 0);
5349
5350                         /* allocate space for the native struct and store the address */
5351                         mono_mb_emit_icon (mb, mono_class_native_size (klass, NULL));
5352                         mono_mb_emit_byte (mb, CEE_PREFIX1);
5353                         mono_mb_emit_byte (mb, CEE_LOCALLOC);
5354                         mono_mb_emit_stloc (mb, conv_arg);
5355
5356                         if (t->byref) {
5357                                 /* Need to store the original buffer so we can free it later */
5358                                 m->orig_conv_args [argnum] = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
5359                                 mono_mb_emit_ldloc (mb, conv_arg);
5360                                 mono_mb_emit_stloc (mb, m->orig_conv_args [argnum]);
5361                         }
5362
5363                         /* set the src_ptr */
5364                         mono_mb_emit_ldloc (mb, 0);
5365                         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
5366                         mono_mb_emit_byte (mb, CEE_MONO_OBJADDR);
5367                         mono_mb_emit_icon (mb, sizeof (MonoObject));
5368                         mono_mb_emit_byte (mb, CEE_ADD);
5369                         mono_mb_emit_stloc (mb, 0);
5370
5371                         /* set dst_ptr */
5372                         mono_mb_emit_ldloc (mb, conv_arg);
5373                         mono_mb_emit_stloc (mb, 1);
5374
5375                         /* emit valuetype conversion code */
5376                         emit_struct_conv (mb, klass, FALSE);
5377
5378                         mono_mb_patch_addr (mb, pos, mb->pos - (pos + 4));
5379                 }
5380                 break;
5381
5382         case MARSHAL_ACTION_CONV_OUT:
5383                 if (spec && spec->native == MONO_NATIVE_STRUCT) {
5384                         static MonoMethod *variant_clear = NULL;
5385                         static MonoMethod *get_object_for_native_variant = NULL;
5386                         if (!variant_clear)
5387                                 variant_clear = mono_class_get_method_from_name (mono_defaults.variant_class, "Clear", 0);
5388                         if (!get_object_for_native_variant)
5389                                 get_object_for_native_variant = mono_class_get_method_from_name (mono_defaults.marshal_class, "GetObjectForNativeVariant", 1);
5390                         if (t->byref) {
5391                                 mono_mb_emit_ldarg (mb, argnum);
5392                                 mono_mb_emit_ldloc_addr (mb, conv_arg);
5393                                 mono_mb_emit_managed_call (mb, get_object_for_native_variant, NULL);
5394                                 mono_mb_emit_byte (mb, CEE_STIND_REF);
5395                         }
5396
5397                         mono_mb_emit_ldloc_addr (mb, conv_arg);
5398                         mono_mb_emit_managed_call (mb, variant_clear, NULL);
5399                         break;
5400                 }
5401                 if (klass == mono_defaults.stringbuilder_class) {
5402                         gboolean need_free;
5403                         MonoMarshalNative encoding;
5404                         MonoMarshalConv conv;
5405
5406                         encoding = mono_marshal_get_string_encoding (m->piinfo, spec);
5407                         conv = mono_marshal_get_ptr_to_stringbuilder_conv (m->piinfo, spec, &need_free);
5408
5409                         g_assert (!t->byref);
5410                         g_assert (encoding != -1);
5411
5412                         mono_mb_emit_ldarg (mb, argnum);
5413                         mono_mb_emit_ldloc (mb, conv_arg);
5414
5415                         mono_mb_emit_icall (mb, conv_to_icall (conv));
5416
5417                         if (need_free) {
5418                                 mono_mb_emit_ldloc (mb, conv_arg);
5419                                 mono_mb_emit_icall (mb, mono_marshal_free);
5420                         }
5421                         break;
5422                 }
5423
5424                 if (klass->delegate)
5425                         break;
5426
5427                 if (t->byref && (t->attrs & PARAM_ATTRIBUTE_OUT)) {
5428                         /* allocate a new object */
5429                         mono_mb_emit_ldarg (mb, argnum);
5430                         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
5431                         mono_mb_emit_byte (mb, CEE_MONO_NEWOBJ);
5432                         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, t->data.klass));
5433                         mono_mb_emit_byte (mb, CEE_STIND_REF);
5434                 }
5435
5436                 /* dst = *argument */
5437                 mono_mb_emit_ldarg (mb, argnum);
5438
5439                 if (t->byref)
5440                         mono_mb_emit_byte (mb, CEE_LDIND_I);
5441
5442                 mono_mb_emit_stloc (mb, 1);
5443
5444                 mono_mb_emit_ldloc (mb, 1);
5445                 mono_mb_emit_byte (mb, CEE_BRFALSE);
5446                 pos = mb->pos;
5447                 mono_mb_emit_i4 (mb, 0);
5448
5449                 if (t->byref || (t->attrs & PARAM_ATTRIBUTE_OUT)) {
5450                         mono_mb_emit_ldloc (mb, 1);
5451                         mono_mb_emit_icon (mb, sizeof (MonoObject));
5452                         mono_mb_emit_byte (mb, CEE_ADD);
5453                         mono_mb_emit_stloc (mb, 1);
5454
5455                         /* src = tmp_locals [i] */
5456                         mono_mb_emit_ldloc (mb, conv_arg);
5457                         mono_mb_emit_stloc (mb, 0);
5458
5459                         /* emit valuetype conversion code */
5460                         emit_struct_conv (mb, t->data.klass, TRUE);
5461
5462                         /* Free the structure returned by the native code */
5463                         emit_struct_free (mb, klass, conv_arg);
5464
5465                         if (m->orig_conv_args [argnum]) {
5466                                 /*
5467                                  * If the native function changed the pointer, then free
5468                                  * the original structure plus the new pointer.
5469                                  */
5470                                 mono_mb_emit_ldloc (mb, m->orig_conv_args [argnum]);
5471                                 mono_mb_emit_ldloc (mb, conv_arg);
5472                                 mono_mb_emit_byte (mb, CEE_BEQ);
5473                                 pos2 = mb->pos;
5474                                 mono_mb_emit_i4 (mb, 0);
5475
5476                                 if (!(t->attrs & PARAM_ATTRIBUTE_OUT)) {
5477                                         g_assert (m->orig_conv_args [argnum]);
5478
5479                                         emit_struct_free (mb, klass, m->orig_conv_args [argnum]);
5480                                 }
5481
5482                                 mono_mb_emit_ldloc (mb, conv_arg);
5483                                 mono_mb_emit_icall (mb, g_free);
5484
5485                                 mono_mb_patch_addr (mb, pos2, mb->pos - (pos2 + 4));
5486                         }
5487                 }
5488                 else
5489                         /* Free the original structure passed to native code */
5490                         emit_struct_free (mb, klass, conv_arg);
5491
5492                 mono_mb_patch_addr (mb, pos, mb->pos - (pos + 4));
5493                 break;
5494
5495         case MARSHAL_ACTION_PUSH:
5496                 if (t->byref)
5497                         mono_mb_emit_ldloc_addr (mb, conv_arg);
5498                 else
5499                         mono_mb_emit_ldloc (mb, conv_arg);
5500                 break;
5501
5502         case MARSHAL_ACTION_CONV_RESULT:
5503                 if (klass->delegate) {
5504                         g_assert (!t->byref);
5505                         mono_mb_emit_stloc (mb, 0);
5506                         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
5507                         mono_mb_emit_byte (mb, CEE_MONO_CLASSCONST);
5508                         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, klass));
5509                         mono_mb_emit_ldloc (mb, 0);
5510                         mono_mb_emit_icall (mb, conv_to_icall (MONO_MARSHAL_CONV_FTN_DEL));
5511                         mono_mb_emit_stloc (mb, 3);
5512                 } else {
5513                         /* set src */
5514                         mono_mb_emit_stloc (mb, 0);
5515
5516                         /* Make a copy since emit_conv modifies local 0 */
5517                         loc = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
5518                         mono_mb_emit_ldloc (mb, 0);
5519                         mono_mb_emit_stloc (mb, loc);
5520
5521                         mono_mb_emit_byte (mb, CEE_LDNULL);
5522                         mono_mb_emit_stloc (mb, 3);
5523
5524                         mono_mb_emit_ldloc (mb, 0);
5525                         mono_mb_emit_byte (mb, CEE_BRFALSE);
5526                         pos = mb->pos;
5527                         mono_mb_emit_i4 (mb, 0);
5528
5529                         /* allocate result object */
5530
5531                         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
5532                         mono_mb_emit_byte (mb, CEE_MONO_NEWOBJ);
5533                         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, klass));
5534                         mono_mb_emit_stloc (mb, 3);
5535
5536                         /* set dst  */
5537
5538                         mono_mb_emit_ldloc (mb, 3);
5539                         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
5540                         mono_mb_emit_byte (mb, CEE_MONO_OBJADDR);
5541                         mono_mb_emit_icon (mb, sizeof (MonoObject));
5542                         mono_mb_emit_byte (mb, CEE_ADD);
5543                         mono_mb_emit_stloc (mb, 1);
5544
5545                         /* emit conversion code */
5546                         emit_struct_conv (mb, klass, TRUE);
5547
5548                         emit_struct_free (mb, klass, loc);
5549
5550                         /* Free the pointer allocated by unmanaged code */
5551                         mono_mb_emit_ldloc (mb, loc);
5552                         mono_mb_emit_icall (mb, g_free);
5553                         mono_mb_patch_addr (mb, pos, mb->pos - (pos + 4));
5554                 }
5555                 break;
5556
5557         case MARSHAL_ACTION_MANAGED_CONV_IN:
5558                 conv_arg = mono_mb_add_local (mb, &klass->byval_arg);
5559
5560                 if (klass->delegate) {
5561                         g_assert (!t->byref);
5562                         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
5563                         mono_mb_emit_byte (mb, CEE_MONO_CLASSCONST);
5564                         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, klass));
5565                         mono_mb_emit_ldarg (mb, argnum);
5566                         mono_mb_emit_icall (mb, conv_to_icall (MONO_MARSHAL_CONV_FTN_DEL));
5567                         mono_mb_emit_stloc (mb, conv_arg);
5568                         break;
5569                 }
5570
5571                 /* The class can not have an automatic layout */
5572                 if ((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_AUTO_LAYOUT) {
5573                         mono_mb_emit_auto_layout_exception (mb, klass);
5574                         break;
5575                 }
5576
5577                 if (t->attrs & PARAM_ATTRIBUTE_OUT) {
5578                         mono_mb_emit_byte (mb, CEE_LDNULL);
5579                         mono_mb_emit_stloc (mb, conv_arg);
5580                         break;
5581                 }
5582
5583                 /* Set src */
5584                 mono_mb_emit_ldarg (mb, argnum);
5585                 if (t->byref) {
5586                         int pos2;
5587
5588                         /* Check for NULL and raise an exception */
5589                         mono_mb_emit_byte (mb, CEE_BRTRUE);
5590                         pos2 = mb->pos;
5591                         mono_mb_emit_i4 (mb, 0);
5592
5593                         mono_mb_emit_exception (mb, "ArgumentNullException", NULL);
5594
5595                         mono_mb_patch_addr (mb, pos2, mb->pos - (pos2 + 4));
5596                         mono_mb_emit_ldarg (mb, argnum);
5597                         mono_mb_emit_byte (mb, CEE_LDIND_I);
5598                 }
5599
5600                 mono_mb_emit_stloc (mb, 0);
5601
5602                 mono_mb_emit_byte (mb, CEE_LDC_I4_0);
5603                 mono_mb_emit_stloc (mb, conv_arg);
5604
5605                 mono_mb_emit_ldloc (mb, 0);
5606                 mono_mb_emit_byte (mb, CEE_BRFALSE);
5607                 pos = mb->pos;
5608                 mono_mb_emit_i4 (mb, 0);
5609
5610                 /* Create and set dst */
5611                 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
5612                 mono_mb_emit_byte (mb, CEE_MONO_NEWOBJ);
5613                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, klass));
5614                 mono_mb_emit_stloc (mb, conv_arg);
5615                 mono_mb_emit_ldloc (mb, conv_arg);
5616                 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
5617                 mono_mb_emit_byte (mb, CEE_MONO_OBJADDR);
5618                 mono_mb_emit_icon (mb, sizeof (MonoObject));
5619                 mono_mb_emit_byte (mb, CEE_ADD);
5620                 mono_mb_emit_stloc (mb, 1);
5621
5622                 /* emit valuetype conversion code */
5623                 emit_struct_conv (mb, klass, TRUE);
5624
5625                 mono_mb_patch_addr (mb, pos, mb->pos - (pos + 4));
5626                 break;
5627
5628         case MARSHAL_ACTION_MANAGED_CONV_OUT:
5629                 /* Check for null */
5630                 mono_mb_emit_ldloc (mb, conv_arg);
5631                 pos = mono_mb_emit_branch (mb, CEE_BRTRUE);
5632                 mono_mb_emit_ldarg (mb, argnum);
5633                 mono_mb_emit_byte (mb, CEE_LDC_I4_0);
5634                 mono_mb_emit_byte (mb, CEE_STIND_REF);
5635                 pos2 = mono_mb_emit_branch (mb, CEE_BR);
5636
5637                 mono_mb_patch_addr (mb, pos, mb->pos - (pos + 4));
5638
5639                 /* Set src */
5640                 mono_mb_emit_ldloc (mb, conv_arg);
5641                 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
5642                 mono_mb_emit_byte (mb, CEE_MONO_OBJADDR);
5643                 mono_mb_emit_icon (mb, sizeof (MonoObject));
5644                 mono_mb_emit_byte (mb, CEE_ADD);
5645                 mono_mb_emit_stloc (mb, 0);
5646
5647                 /* Allocate and set dest */
5648                 mono_mb_emit_icon (mb, mono_class_native_size (klass, NULL));
5649                 mono_mb_emit_byte (mb, CEE_CONV_I);
5650                 mono_mb_emit_icall (mb, mono_marshal_alloc);
5651                 mono_mb_emit_stloc (mb, 1);
5652
5653                 /* Update argument pointer */
5654                 mono_mb_emit_ldarg (mb, argnum);
5655                 mono_mb_emit_ldloc (mb, 1);
5656                 mono_mb_emit_byte (mb, CEE_STIND_I);
5657
5658                 /* emit valuetype conversion code */
5659                 emit_struct_conv (mb, klass, FALSE);
5660
5661                 mono_mb_patch_addr (mb, pos2, mb->pos - (pos2 + 4));
5662                 break;
5663
5664         case MARSHAL_ACTION_MANAGED_CONV_RESULT:
5665                 if (klass->delegate) {
5666                         mono_mb_emit_icall (mb, conv_to_icall (MONO_MARSHAL_CONV_DEL_FTN));
5667                         mono_mb_emit_stloc (mb, 3);
5668                         break;
5669                 }
5670
5671                 /* The class can not have an automatic layout */
5672                 if ((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_AUTO_LAYOUT) {
5673                         mono_mb_emit_auto_layout_exception (mb, klass);
5674                         break;
5675                 }
5676
5677                 mono_mb_emit_stloc (mb, 0);
5678                 /* Check for null */
5679                 mono_mb_emit_ldloc (mb, 0);
5680                 pos = mono_mb_emit_branch (mb, CEE_BRTRUE);
5681                 mono_mb_emit_byte (mb, CEE_LDNULL);
5682                 mono_mb_emit_stloc (mb, 3);
5683                 pos2 = mono_mb_emit_branch (mb, CEE_BR);
5684
5685                 mono_mb_patch_addr (mb, pos, mb->pos - (pos + 4));
5686
5687                 /* Set src */
5688                 mono_mb_emit_ldloc (mb, 0);
5689                 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
5690                 mono_mb_emit_byte (mb, CEE_MONO_OBJADDR);
5691                 mono_mb_emit_icon (mb, sizeof (MonoObject));
5692                 mono_mb_emit_byte (mb, CEE_ADD);
5693                 mono_mb_emit_stloc (mb, 0);
5694
5695                 /* Allocate and set dest */
5696                 mono_mb_emit_icon (mb, mono_class_native_size (klass, NULL));
5697                 mono_mb_emit_byte (mb, CEE_CONV_I);
5698                 mono_mb_emit_icall (mb, mono_marshal_alloc);
5699                 mono_mb_emit_byte (mb, CEE_DUP);
5700                 mono_mb_emit_stloc (mb, 1);
5701                 mono_mb_emit_stloc (mb, 3);
5702
5703                 emit_struct_conv (mb, klass, FALSE);
5704
5705                 mono_mb_patch_addr (mb, pos2, mb->pos - (pos2 + 4));
5706                 break;
5707
5708         default:
5709                 g_assert_not_reached ();
5710         }
5711
5712         return conv_arg;
5713 }
5714
5715 static int
5716 emit_marshal_array (EmitMarshalContext *m, int argnum, MonoType *t,
5717                                         MonoMarshalSpec *spec,
5718                                         int conv_arg, MonoType **conv_arg_type,
5719                                         MarshalAction action)
5720 {
5721         MonoMethodBuilder *mb = m->mb;
5722         MonoClass *klass = mono_class_from_mono_type (t);
5723         gboolean need_convert, need_free;
5724         MonoMarshalNative encoding;
5725
5726         encoding = mono_marshal_get_string_encoding (m->piinfo, spec);
5727
5728         switch (action) {
5729         case MARSHAL_ACTION_CONV_IN:
5730                 *conv_arg_type = &mono_defaults.object_class->byval_arg;
5731                 conv_arg = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
5732
5733                 if (klass->element_class->blittable) {
5734                         mono_mb_emit_ldarg (mb, argnum);
5735                         if (t->byref)
5736                                 mono_mb_emit_byte (mb, CEE_LDIND_I);
5737                         mono_mb_emit_icall (mb, conv_to_icall (MONO_MARSHAL_CONV_ARRAY_LPARRAY));
5738                         mono_mb_emit_stloc (mb, conv_arg);
5739                 } else {
5740                         MonoClass *eklass;
5741                         guint32 label1, label2, label3;
5742                         int index_var, src_var, dest_ptr, esize;
5743                         MonoMarshalConv conv;
5744                         gboolean is_string = FALSE;
5745
5746                         dest_ptr = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
5747
5748                         eklass = klass->element_class;
5749
5750                         if (eklass == mono_defaults.string_class) {
5751                                 is_string = TRUE;
5752                                 conv = mono_marshal_get_string_to_ptr_conv (m->piinfo, spec);
5753                         }
5754                         else if (eklass == mono_defaults.stringbuilder_class) {
5755                                 is_string = TRUE;
5756                                 conv = mono_marshal_get_stringbuilder_to_ptr_conv (m->piinfo, spec);
5757                         }
5758                         else
5759                                 conv = -1;
5760
5761                         src_var = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
5762                         mono_mb_emit_ldarg (mb, argnum);
5763                         if (t->byref)
5764                                 mono_mb_emit_byte (mb, CEE_LDIND_I);
5765                         mono_mb_emit_stloc (mb, src_var);
5766
5767                         /* Check null */
5768                         mono_mb_emit_ldloc (mb, src_var);
5769                         mono_mb_emit_stloc (mb, conv_arg);
5770                         mono_mb_emit_ldloc (mb, src_var);
5771                         mono_mb_emit_byte (mb, CEE_BRFALSE);
5772                         label1 = mb->pos;
5773                         mono_mb_emit_i4 (mb, 0);
5774
5775                         if (is_string) {
5776                                 if (conv == -1) {
5777                                         char *msg = g_strdup_printf ("string/stringbuilder marshalling conversion %d not implemented", encoding);
5778                                         MonoException *exc = mono_get_exception_not_implemented (msg);
5779                                         g_warning (msg);
5780                                         g_free (msg);
5781                                         mono_raise_exception (exc);
5782                                 }
5783                         }
5784
5785                         if (is_string)
5786                                 esize = sizeof (gpointer);
5787                         else
5788                                 esize = mono_class_native_size (eklass, NULL);
5789
5790                         /* allocate space for the native struct and store the address */
5791                         mono_mb_emit_icon (mb, esize);
5792                         mono_mb_emit_ldloc (mb, src_var);
5793                         mono_mb_emit_byte (mb, CEE_LDLEN);
5794
5795                         if (eklass == mono_defaults.string_class) {
5796                                 /* Make the array bigger for the terminating null */
5797                                 mono_mb_emit_byte (mb, CEE_LDC_I4_1);
5798                                 mono_mb_emit_byte (mb, CEE_ADD);
5799                         }
5800                         mono_mb_emit_byte (mb, CEE_MUL);
5801                         mono_mb_emit_byte (mb, CEE_PREFIX1);
5802                         mono_mb_emit_byte (mb, CEE_LOCALLOC);
5803                         mono_mb_emit_stloc (mb, conv_arg);
5804
5805                         mono_mb_emit_ldloc (mb, conv_arg);
5806                         mono_mb_emit_stloc (mb, dest_ptr);
5807
5808                         /* Emit marshalling loop */
5809                         index_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
5810                         mono_mb_emit_byte (mb, CEE_LDC_I4_0);
5811                         mono_mb_emit_stloc (mb, index_var);
5812                         label2 = mb->pos;
5813                         mono_mb_emit_ldloc (mb, index_var);
5814                         mono_mb_emit_ldloc (mb, src_var);
5815                         mono_mb_emit_byte (mb, CEE_LDLEN);
5816                         mono_mb_emit_byte (mb, CEE_BGE);
5817                         label3 = mb->pos;
5818                         mono_mb_emit_i4 (mb, 0);
5819
5820                         /* Emit marshalling code */
5821
5822                         if (is_string) {
5823                                 mono_mb_emit_ldloc (mb, dest_ptr);
5824                                 mono_mb_emit_ldloc (mb, src_var);
5825                                 mono_mb_emit_ldloc (mb, index_var);
5826                                 mono_mb_emit_byte (mb, CEE_LDELEM_REF);
5827                                 mono_mb_emit_icall (mb, conv_to_icall (conv));
5828                                 mono_mb_emit_byte (mb, CEE_STIND_I);
5829                         } else {
5830                                 /* set the src_ptr */
5831                                 mono_mb_emit_ldloc (mb, src_var);
5832                                 mono_mb_emit_ldloc (mb, index_var);
5833                                 mono_mb_emit_byte (mb, CEE_LDELEMA);
5834                                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, eklass));
5835                                 mono_mb_emit_stloc (mb, 0);
5836
5837                                 /* set dst_ptr */
5838                                 mono_mb_emit_ldloc (mb, dest_ptr);
5839                                 mono_mb_emit_stloc (mb, 1);
5840
5841                                 /* emit valuetype conversion code */
5842                                 emit_struct_conv (mb, eklass, FALSE);
5843                         }
5844
5845                         mono_mb_emit_add_to_local (mb, index_var, 1);
5846                         mono_mb_emit_add_to_local (mb, dest_ptr, esize);
5847
5848                         mono_mb_emit_byte (mb, CEE_BR);
5849                         mono_mb_emit_i4 (mb, label2 - (mb->pos + 4));
5850
5851                         mono_mb_patch_addr (mb, label3, mb->pos - (label3 + 4));
5852
5853                         if (eklass == mono_defaults.string_class) {
5854                                 /* Null terminate */
5855                                 mono_mb_emit_ldloc (mb, dest_ptr);
5856                                 mono_mb_emit_byte (mb, CEE_LDC_I4_0);
5857                                 mono_mb_emit_byte (mb, CEE_STIND_REF);
5858                         }
5859
5860                         mono_mb_patch_addr (mb, label1, mb->pos - (label1 + 4));
5861                 }
5862
5863                 break;
5864
5865         case MARSHAL_ACTION_CONV_OUT:
5866                 /* Unicode character arrays are implicitly marshalled as [Out] under MS.NET */
5867                 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);
5868                 need_free = mono_marshal_need_free (&klass->element_class->byval_arg,
5869                                                                                         m->piinfo, spec);
5870
5871                 if (need_convert || need_free) {
5872                         /* FIXME: Optimize blittable case */
5873                         MonoClass *eklass;
5874                         guint32 label1, label2, label3;
5875                         int index_var, src_ptr, loc, esize;
5876
5877                         eklass = klass->element_class;
5878                         if ((eklass == mono_defaults.stringbuilder_class) || (eklass == mono_defaults.string_class))
5879                                 esize = sizeof (gpointer);
5880                         else
5881                                 esize = mono_class_native_size (eklass, NULL);
5882                         src_ptr = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
5883                         loc = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
5884
5885                         /* Check null */
5886                         mono_mb_emit_ldarg (mb, argnum);
5887                         if (t->byref)
5888                                 mono_mb_emit_byte (mb, CEE_LDIND_I);
5889                         mono_mb_emit_byte (mb, CEE_BRFALSE);
5890                         label1 = mb->pos;
5891                         mono_mb_emit_i4 (mb, 0);
5892
5893                         mono_mb_emit_ldloc (mb, conv_arg);
5894                         mono_mb_emit_stloc (mb, src_ptr);
5895
5896                         /* Emit marshalling loop */
5897                         index_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
5898                         mono_mb_emit_byte (mb, CEE_LDC_I4_0);
5899                         mono_mb_emit_stloc (mb, index_var);
5900                         label2 = mb->pos;
5901                         mono_mb_emit_ldloc (mb, index_var);
5902                         mono_mb_emit_ldarg (mb, argnum);
5903                         if (t->byref)
5904                                 mono_mb_emit_byte (mb, CEE_LDIND_REF);
5905                         mono_mb_emit_byte (mb, CEE_LDLEN);
5906                         mono_mb_emit_byte (mb, CEE_BGE);
5907                         label3 = mb->pos;
5908                         mono_mb_emit_i4 (mb, 0);
5909
5910                         /* Emit marshalling code */
5911
5912                         if (eklass == mono_defaults.stringbuilder_class) {
5913                                 gboolean need_free2;
5914                                 MonoMarshalConv conv = mono_marshal_get_ptr_to_stringbuilder_conv (m->piinfo, spec, &need_free2);
5915
5916                                 g_assert (conv != -1);
5917
5918                                 /* dest */
5919                                 mono_mb_emit_ldarg (mb, argnum);
5920                                 if (t->byref)
5921                                         mono_mb_emit_byte (mb, CEE_LDIND_I);
5922                                 mono_mb_emit_ldloc (mb, index_var);
5923                                 mono_mb_emit_byte (mb, CEE_LDELEM_REF);
5924
5925                                 /* src */
5926                                 mono_mb_emit_ldloc (mb, src_ptr);
5927                                 mono_mb_emit_byte (mb, CEE_LDIND_I);
5928
5929                                 mono_mb_emit_icall (mb, conv_to_icall (conv));
5930
5931                                 if (need_free) {
5932                                         /* src */
5933                                         mono_mb_emit_ldloc (mb, src_ptr);
5934                                         mono_mb_emit_byte (mb, CEE_LDIND_I);
5935
5936                                         mono_mb_emit_icall (mb, mono_marshal_free);
5937                                 }
5938                         }
5939                         else if (eklass == mono_defaults.string_class) {
5940                                 if (need_free) {
5941                                         /* src */
5942                                         mono_mb_emit_ldloc (mb, src_ptr);
5943                                         mono_mb_emit_byte (mb, CEE_LDIND_I);
5944
5945                                         mono_mb_emit_icall (mb, mono_marshal_free);
5946                                 }
5947                         }
5948                         else {
5949                                 if (need_convert) {
5950                                         /* set the src_ptr */
5951                                         mono_mb_emit_ldloc (mb, src_ptr);
5952                                         mono_mb_emit_stloc (mb, 0);
5953
5954                                         /* set dst_ptr */
5955                                         mono_mb_emit_ldarg (mb, argnum);
5956                                         if (t->byref)
5957                                                 mono_mb_emit_byte (mb, CEE_LDIND_I);
5958                                         mono_mb_emit_ldloc (mb, index_var);
5959                                         mono_mb_emit_byte (mb, CEE_LDELEMA);
5960                                         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, eklass));
5961                                         mono_mb_emit_stloc (mb, 1);
5962
5963                                         /* emit valuetype conversion code */
5964                                         emit_struct_conv (mb, eklass, TRUE);
5965                                 }
5966
5967                                 if (need_free) {
5968                                         mono_mb_emit_ldloc (mb, src_ptr);
5969                                         mono_mb_emit_stloc (mb, loc);
5970                                         mono_mb_emit_ldloc (mb, loc);
5971
5972                                         emit_struct_free (mb, eklass, loc);
5973                                 }
5974                         }
5975
5976                         mono_mb_emit_add_to_local (mb, index_var, 1);
5977                         mono_mb_emit_add_to_local (mb, src_ptr, esize);
5978
5979                         mono_mb_emit_byte (mb, CEE_BR);
5980                         mono_mb_emit_i4 (mb, label2 - (mb->pos + 4));
5981
5982                         mono_mb_patch_addr (mb, label1, mb->pos - (label1 + 4));
5983                         mono_mb_patch_addr (mb, label3, mb->pos - (label3 + 4));
5984                 }
5985                 break;
5986
5987         case MARSHAL_ACTION_PUSH:
5988                 if (t->byref)
5989                         mono_mb_emit_ldloc_addr (mb, conv_arg);
5990                 else
5991                         mono_mb_emit_ldloc (mb, conv_arg);
5992                 break;
5993
5994         case MARSHAL_ACTION_CONV_RESULT:
5995                 /* fixme: we need conversions here */
5996                 mono_mb_emit_stloc (mb, 3);
5997                 break;
5998
5999         case MARSHAL_ACTION_MANAGED_CONV_IN: {
6000                 MonoClass *eklass;
6001                 guint32 label1, label2, label3;
6002                 int index_var, src_ptr, loc, esize, param_num, num_elem;
6003                 MonoMarshalConv conv;
6004                 gboolean is_string = FALSE;
6005
6006                 conv_arg = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
6007                 *conv_arg_type = &mono_defaults.int_class->byval_arg;
6008
6009                 if (t->byref) {
6010                         char *msg = g_strdup ("Byref array marshalling to managed code is not implemented.");
6011                         mono_mb_emit_exception_marshal_directive (mb, msg);
6012                         return conv_arg;
6013                 }
6014                 if (spec->native != MONO_NATIVE_LPARRAY) {
6015                         char *msg = g_strdup ("Non LPArray marshalling of arrays to managed code is not implemented.");
6016                         mono_mb_emit_exception_marshal_directive (mb, msg);
6017                         return conv_arg;
6018                 }
6019
6020                 /* FIXME: t is from the method which is wrapped, not the delegate type */
6021                 /* g_assert (t->attrs & PARAM_ATTRIBUTE_IN); */
6022
6023                 param_num = spec->data.array_data.param_num;
6024                 num_elem = spec->data.array_data.num_elem;
6025                 if (spec->data.array_data.elem_mult == 0)
6026                         /* param_num is not specified */
6027                         param_num = -1;
6028
6029                 if (param_num == -1) {
6030                         if (num_elem <= 0) {
6031                                 char *msg = g_strdup ("Either SizeConst or SizeParamIndex should be specified when marshalling arrays to managed code.");
6032                                 mono_mb_emit_exception_marshal_directive (mb, msg);
6033                                 return conv_arg;
6034                         }
6035                 }
6036
6037                 /* FIXME: Optimize blittable case */
6038
6039                 eklass = klass->element_class;
6040                 if (eklass == mono_defaults.string_class) {
6041                         is_string = TRUE;
6042                         conv = mono_marshal_get_ptr_to_string_conv (m->piinfo, spec, &need_free);
6043                 }
6044                 else if (eklass == mono_defaults.stringbuilder_class) {
6045                         is_string = TRUE;
6046                         conv = mono_marshal_get_ptr_to_stringbuilder_conv (m->piinfo, spec, &need_free);
6047                 }
6048                 else
6049                         conv = -1;
6050
6051                 mono_marshal_load_type_info (eklass);
6052
6053                 if (is_string)
6054                         esize = sizeof (gpointer);
6055                 else
6056                         esize = mono_class_native_size (eklass, NULL);
6057                 src_ptr = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
6058                 loc = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
6059
6060                 mono_mb_emit_byte (mb, CEE_LDNULL);
6061                 mono_mb_emit_stloc (mb, conv_arg);
6062
6063                 /* Check param index */
6064                 if (param_num != -1) {
6065                         if (param_num >= m->sig->param_count) {
6066                                 char *msg = g_strdup ("Array size control parameter index is out of range.");
6067                                 mono_mb_emit_exception_marshal_directive (mb, msg);
6068                                 return conv_arg;
6069                         }
6070                         switch (m->sig->params [param_num]->type) {
6071                         case MONO_TYPE_I1:
6072                         case MONO_TYPE_U1:
6073                         case MONO_TYPE_I2:
6074                         case MONO_TYPE_U2:
6075                         case MONO_TYPE_I4:
6076                         case MONO_TYPE_U4:
6077                         case MONO_TYPE_I:
6078                         case MONO_TYPE_U:
6079                         case MONO_TYPE_I8:
6080                         case MONO_TYPE_U8:
6081                                 break;
6082                         default: {
6083                                 char *msg = g_strdup ("Array size control parameter must be an integral type.");
6084                                 mono_mb_emit_exception_marshal_directive (mb, msg);
6085                                 return conv_arg;
6086                         }
6087                         }
6088                 }
6089
6090                 /* Check null */
6091                 mono_mb_emit_ldarg (mb, argnum);
6092                 mono_mb_emit_byte (mb, CEE_BRFALSE);
6093                 label1 = mb->pos;
6094                 mono_mb_emit_i4 (mb, 0);
6095
6096                 mono_mb_emit_ldarg (mb, argnum);
6097                 mono_mb_emit_stloc (mb, src_ptr);
6098
6099                 /* Create managed array */
6100                 /*
6101                  * The LPArray marshalling spec says that sometimes param_num starts
6102                  * from 1, sometimes it starts from 0. But MS seems to allways start
6103                  * from 0.
6104                  */
6105
6106                 if (param_num == -1)
6107                         mono_mb_emit_icon (mb, num_elem);
6108                 else {
6109                         /* FIXME: Add the two together */
6110                         mono_mb_emit_ldarg (mb, param_num);
6111                         if (num_elem > 0) {
6112                                 mono_mb_emit_icon (mb, num_elem);
6113                                 mono_mb_emit_byte (mb, CEE_ADD);
6114                         }
6115                 }
6116
6117                 mono_mb_emit_byte (mb, CEE_NEWARR);
6118                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, eklass));
6119                 mono_mb_emit_stloc (mb, conv_arg);
6120
6121                 if (eklass->blittable) {
6122                         mono_mb_emit_ldloc (mb, conv_arg);
6123                         mono_mb_emit_byte (mb, CEE_CONV_I);
6124                         mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoArray, vector));
6125                         mono_mb_emit_byte (mb, CEE_ADD);
6126                         mono_mb_emit_ldarg (mb, argnum);
6127                         mono_mb_emit_ldloc (mb, conv_arg);
6128                         mono_mb_emit_byte (mb, CEE_LDLEN);
6129                         mono_mb_emit_icon (mb, esize);
6130                         mono_mb_emit_byte (mb, CEE_MUL);
6131                         mono_mb_emit_byte (mb, CEE_PREFIX1);
6132                         mono_mb_emit_byte (mb, CEE_CPBLK);
6133                         break;
6134                 }
6135
6136                 /* Emit marshalling loop */
6137                 index_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
6138                 mono_mb_emit_byte (mb, CEE_LDC_I4_0);
6139                 mono_mb_emit_stloc (mb, index_var);
6140                 label2 = mb->pos;
6141                 mono_mb_emit_ldloc (mb, index_var);
6142                 mono_mb_emit_ldloc (mb, conv_arg);
6143                 mono_mb_emit_byte (mb, CEE_LDLEN);
6144                 mono_mb_emit_byte (mb, CEE_BGE);
6145                 label3 = mb->pos;
6146                 mono_mb_emit_i4 (mb, 0);
6147
6148                 /* Emit marshalling code */
6149                 if (is_string) {
6150                         g_assert (conv != -1);
6151
6152                         mono_mb_emit_ldloc (mb, conv_arg);
6153                         mono_mb_emit_ldloc (mb, index_var);
6154
6155                         mono_mb_emit_ldloc (mb, src_ptr);
6156                         mono_mb_emit_byte (mb, CEE_LDIND_I);
6157
6158                         mono_mb_emit_icall (mb, conv_to_icall (conv));
6159                         mono_mb_emit_byte (mb, CEE_STELEM_REF);
6160                 }
6161                 else {
6162                         char *msg = g_strdup ("Marshalling of non-string and non-blittable arrays to managed code is not implemented.");
6163                         mono_mb_emit_exception_marshal_directive (mb, msg);
6164                         return conv_arg;
6165                 }
6166
6167                 mono_mb_emit_add_to_local (mb, index_var, 1);
6168                 mono_mb_emit_add_to_local (mb, src_ptr, esize);
6169
6170                 mono_mb_emit_byte (mb, CEE_BR);
6171                 mono_mb_emit_i4 (mb, label2 - (mb->pos + 4));
6172
6173                 mono_mb_patch_addr (mb, label1, mb->pos - (label1 + 4));
6174                 mono_mb_patch_addr (mb, label3, mb->pos - (label3 + 4));
6175
6176                 break;
6177         }
6178         case MARSHAL_ACTION_MANAGED_CONV_OUT: {
6179                 MonoClass *eklass;
6180                 guint32 label1, label2, label3;
6181                 int index_var, dest_ptr, loc, esize, param_num, num_elem;
6182                 MonoMarshalConv conv;
6183                 gboolean is_string = FALSE;
6184
6185                 /* These are already checked in CONV_IN */
6186                 g_assert (!t->byref);
6187                 g_assert (spec->native == MONO_NATIVE_LPARRAY);
6188                 g_assert (t->attrs & PARAM_ATTRIBUTE_OUT);
6189
6190                 param_num = spec->data.array_data.param_num;
6191                 num_elem = spec->data.array_data.num_elem;
6192
6193                 if (spec->data.array_data.elem_mult == 0)
6194                         /* param_num is not specified */
6195                         param_num = -1;
6196
6197                 if (param_num == -1) {
6198                         if (num_elem <= 0) {
6199                                 g_assert_not_reached ();
6200                         }
6201                 }
6202
6203                 /* FIXME: Optimize blittable case */
6204
6205                 eklass = klass->element_class;
6206                 if (eklass == mono_defaults.string_class) {
6207                         is_string = TRUE;
6208                         conv = mono_marshal_get_string_to_ptr_conv (m->piinfo, spec);
6209                 }
6210                 else if (eklass == mono_defaults.stringbuilder_class) {
6211                         is_string = TRUE;
6212                         conv = mono_marshal_get_stringbuilder_to_ptr_conv (m->piinfo, spec);
6213                 }
6214                 else
6215                         conv = -1;
6216
6217                 mono_marshal_load_type_info (eklass);
6218
6219                 if (is_string)
6220                         esize = sizeof (gpointer);
6221                 else
6222                         esize = mono_class_native_size (eklass, NULL);
6223
6224                 dest_ptr = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
6225                 loc = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
6226
6227                 /* Check null */
6228                 mono_mb_emit_ldloc (mb, conv_arg);
6229                 mono_mb_emit_byte (mb, CEE_BRFALSE);
6230                 label1 = mb->pos;
6231                 mono_mb_emit_i4 (mb, 0);
6232
6233                 mono_mb_emit_ldarg (mb, argnum);
6234                 mono_mb_emit_stloc (mb, dest_ptr);
6235
6236                 if (eklass->blittable) {
6237                         /* dest */
6238                         mono_mb_emit_ldarg (mb, argnum);
6239                         /* src */
6240                         mono_mb_emit_ldloc (mb, conv_arg);
6241                         mono_mb_emit_byte (mb, CEE_CONV_I);
6242                         mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoArray, vector));
6243                         mono_mb_emit_byte (mb, CEE_ADD);
6244                         /* length */
6245                         mono_mb_emit_ldloc (mb, conv_arg);
6246                         mono_mb_emit_byte (mb, CEE_LDLEN);
6247                         mono_mb_emit_icon (mb, esize);
6248                         mono_mb_emit_byte (mb, CEE_MUL);
6249                         mono_mb_emit_byte (mb, CEE_PREFIX1);
6250                         mono_mb_emit_byte (mb, CEE_CPBLK);
6251                         break;
6252                 }
6253
6254                 /* Emit marshalling loop */
6255                 index_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
6256                 mono_mb_emit_byte (mb, CEE_LDC_I4_0);
6257                 mono_mb_emit_stloc (mb, index_var);
6258                 label2 = mb->pos;
6259                 mono_mb_emit_ldloc (mb, index_var);
6260                 mono_mb_emit_ldloc (mb, conv_arg);
6261                 mono_mb_emit_byte (mb, CEE_LDLEN);
6262                 mono_mb_emit_byte (mb, CEE_BGE);
6263                 label3 = mb->pos;
6264                 mono_mb_emit_i4 (mb, 0);
6265
6266                 /* Emit marshalling code */
6267                 if (is_string) {
6268                         g_assert (conv != -1);
6269
6270                         /* dest */
6271                         mono_mb_emit_ldloc (mb, dest_ptr);
6272
6273                         /* src */
6274                         mono_mb_emit_ldloc (mb, conv_arg);
6275                         mono_mb_emit_ldloc (mb, index_var);
6276
6277                         mono_mb_emit_byte (mb, CEE_LDELEM_REF);
6278
6279                         mono_mb_emit_icall (mb, conv_to_icall (conv));
6280                         mono_mb_emit_byte (mb, CEE_STIND_I);
6281                 }
6282                 else {
6283                         char *msg = g_strdup ("Marshalling of non-string and non-blittable arrays to managed code is not implemented.");
6284                         mono_mb_emit_exception_marshal_directive (mb, msg);
6285                         return conv_arg;
6286                 }
6287
6288                 mono_mb_emit_add_to_local (mb, index_var, 1);
6289                 mono_mb_emit_add_to_local (mb, dest_ptr, esize);
6290
6291                 mono_mb_emit_byte (mb, CEE_BR);
6292                 mono_mb_emit_i4 (mb, label2 - (mb->pos + 4));
6293
6294                 mono_mb_patch_addr (mb, label1, mb->pos - (label1 + 4));
6295                 mono_mb_patch_addr (mb, label3, mb->pos - (label3 + 4));
6296
6297                 break;
6298         }
6299         case MARSHAL_ACTION_MANAGED_CONV_RESULT: {
6300                 MonoClass *eklass;
6301                 guint32 label1, label2, label3;
6302                 int index_var, src, dest, esize;
6303                 MonoMarshalConv conv = -1;
6304                 gboolean is_string = FALSE;
6305
6306                 g_assert (!t->byref);
6307
6308                 eklass = klass->element_class;
6309
6310                 mono_marshal_load_type_info (eklass);
6311
6312                 if (eklass == mono_defaults.string_class) {
6313                         is_string = TRUE;
6314                         conv = mono_marshal_get_string_to_ptr_conv (m->piinfo, spec);
6315                 }
6316                 else {
6317                         g_assert_not_reached ();
6318                 }
6319
6320                 if (is_string)
6321                         esize = sizeof (gpointer);
6322                 else
6323                         esize = mono_class_native_size (eklass, NULL);
6324
6325                 src = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
6326                 dest = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
6327
6328                 mono_mb_emit_stloc (mb, src);
6329                 mono_mb_emit_ldloc (mb, src);
6330                 mono_mb_emit_stloc (mb, 3);
6331
6332                 /* Check for null */
6333                 mono_mb_emit_ldloc (mb, src);
6334                 label1 = mono_mb_emit_branch (mb, CEE_BRFALSE);
6335
6336                 /* Allocate native array */
6337                 mono_mb_emit_icon (mb, esize);
6338                 mono_mb_emit_ldloc (mb, src);
6339                 mono_mb_emit_byte (mb, CEE_LDLEN);
6340
6341                 if (eklass == mono_defaults.string_class) {
6342                         /* Make the array bigger for the terminating null */
6343                         mono_mb_emit_byte (mb, CEE_LDC_I4_1);
6344                         mono_mb_emit_byte (mb, CEE_ADD);
6345                 }
6346                 mono_mb_emit_byte (mb, CEE_MUL);
6347                 mono_mb_emit_icall (mb, mono_marshal_alloc);
6348                 mono_mb_emit_stloc (mb, dest);
6349                 mono_mb_emit_ldloc (mb, dest);
6350                 mono_mb_emit_stloc (mb, 3);
6351
6352                 /* Emit marshalling loop */
6353                 index_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
6354                 mono_mb_emit_byte (mb, CEE_LDC_I4_0);
6355                 mono_mb_emit_stloc (mb, index_var);
6356                 label2 = mb->pos;
6357                 mono_mb_emit_ldloc (mb, index_var);
6358                 mono_mb_emit_ldloc (mb, src);
6359                 mono_mb_emit_byte (mb, CEE_LDLEN);
6360                 label3 = mono_mb_emit_branch (mb, CEE_BGE);
6361
6362                 /* Emit marshalling code */
6363                 if (is_string) {
6364                         g_assert (conv != -1);
6365
6366                         /* dest */
6367                         mono_mb_emit_ldloc (mb, dest);
6368
6369                         /* src */
6370                         mono_mb_emit_ldloc (mb, src);
6371                         mono_mb_emit_ldloc (mb, index_var);
6372
6373                         mono_mb_emit_byte (mb, CEE_LDELEM_REF);
6374
6375                         mono_mb_emit_icall (mb, conv_to_icall (conv));
6376                         mono_mb_emit_byte (mb, CEE_STIND_I);
6377                 }
6378                 else {
6379                         char *msg = g_strdup ("Marshalling of non-string arrays to managed code is not implemented.");
6380                         mono_mb_emit_exception_marshal_directive (mb, msg);
6381                         return conv_arg;
6382                 }
6383
6384                 mono_mb_emit_add_to_local (mb, index_var, 1);
6385                 mono_mb_emit_add_to_local (mb, dest, esize);
6386
6387                 mono_mb_emit_byte (mb, CEE_BR);
6388                 mono_mb_emit_i4 (mb, label2 - (mb->pos + 4));
6389
6390                 mono_mb_patch_addr (mb, label3, mb->pos - (label3 + 4));
6391                 mono_mb_patch_addr (mb, label1, mb->pos - (label1 + 4));
6392                 break;
6393         }
6394         default:
6395                 g_assert_not_reached ();
6396         }
6397
6398         return conv_arg;
6399 }
6400
6401 static int
6402 emit_marshal_boolean (EmitMarshalContext *m, int argnum, MonoType *t,
6403                                           MonoMarshalSpec *spec,
6404                                           int conv_arg, MonoType **conv_arg_type,
6405                                           MarshalAction action)
6406 {
6407         MonoMethodBuilder *mb = m->mb;
6408
6409         switch (action) {
6410         case MARSHAL_ACTION_CONV_IN: {
6411                 MonoType *local_type;
6412                 int variant_bool = 0;
6413                 if (!t->byref)
6414                         break;
6415                 if (spec == NULL) {
6416                         local_type = &mono_defaults.int32_class->byval_arg;
6417                 } else {
6418                         switch (spec->native) {
6419                         case MONO_NATIVE_I1:
6420                                 local_type = &mono_defaults.byte_class->byval_arg;
6421                                 break;
6422                         case MONO_NATIVE_VARIANTBOOL:
6423                                 local_type = &mono_defaults.int16_class->byval_arg;
6424                                 variant_bool = 1;
6425                                 break;
6426                         default:
6427                                 g_warning ("marshalling bool as native type %x is currently not supported", spec->native);
6428                                 local_type = &mono_defaults.int32_class->byval_arg;
6429                                 break;
6430                         }
6431                 }
6432                 *conv_arg_type = &mono_defaults.int_class->byval_arg;
6433                 conv_arg = mono_mb_add_local (mb, local_type);
6434                 mono_mb_emit_ldarg (mb, argnum);
6435                 mono_mb_emit_byte (mb, CEE_LDIND_I1);
6436                 if (variant_bool)
6437                         mono_mb_emit_byte (mb, CEE_NEG);
6438                 mono_mb_emit_stloc (mb, conv_arg);
6439                 break;
6440         }
6441
6442         case MARSHAL_ACTION_CONV_OUT:
6443                 if (!t->byref)
6444                         break;
6445                 mono_mb_emit_ldarg (mb, argnum);
6446                 mono_mb_emit_ldloc (mb, conv_arg);
6447                 if (spec != NULL && spec->native == MONO_NATIVE_VARIANTBOOL)
6448                         mono_mb_emit_byte (mb, CEE_NEG);
6449                 mono_mb_emit_byte (mb, CEE_STIND_I1);
6450                 break;
6451
6452         case MARSHAL_ACTION_PUSH:
6453                 if (t->byref)
6454                         mono_mb_emit_ldloc_addr (mb, conv_arg);
6455                 else
6456                         mono_mb_emit_ldarg (mb, argnum);
6457                 break;
6458
6459         case MARSHAL_ACTION_CONV_RESULT:
6460                 /* maybe we need to make sure that it fits within 8 bits */
6461                 mono_mb_emit_stloc (mb, 3);
6462                 break;
6463
6464         default:
6465                 g_assert_not_reached ();
6466         }
6467
6468         return conv_arg;
6469 }
6470
6471 static int
6472 emit_marshal_ptr (EmitMarshalContext *m, int argnum, MonoType *t,
6473                                   MonoMarshalSpec *spec, int conv_arg,
6474                                   MonoType **conv_arg_type, MarshalAction action)
6475 {
6476         MonoMethodBuilder *mb = m->mb;
6477
6478         switch (action) {
6479         case MARSHAL_ACTION_CONV_IN:
6480                 if (MONO_TYPE_ISSTRUCT (t->data.type)) {
6481                         char *msg = g_strdup_printf ("Can not marshal 'parameter #%d': Pointers can not reference marshaled structures. Use byref instead.", argnum + 1);
6482                         mono_mb_emit_exception_marshal_directive (m->mb, msg);
6483                 }
6484                 break;
6485
6486         case MARSHAL_ACTION_PUSH:
6487                 mono_mb_emit_ldarg (mb, argnum);
6488                 break;
6489
6490         case MARSHAL_ACTION_CONV_RESULT:
6491                 /* no conversions necessary */
6492                 mono_mb_emit_stloc (mb, 3);
6493                 break;
6494
6495         default:
6496                 break;
6497         }
6498
6499         return conv_arg;
6500 }
6501
6502 static int
6503 emit_marshal_char (EmitMarshalContext *m, int argnum, MonoType *t,
6504                                    MonoMarshalSpec *spec, int conv_arg,
6505                                    MonoType **conv_arg_type, MarshalAction action)
6506 {
6507         MonoMethodBuilder *mb = m->mb;
6508
6509         switch (action) {
6510         case MARSHAL_ACTION_PUSH:
6511                 /* fixme: dont know how to marshal that. We cant simply
6512                  * convert it to a one byte UTF8 character, because an
6513                  * unicode character may need more that one byte in UTF8 */
6514                 mono_mb_emit_ldarg (mb, argnum);
6515                 break;
6516
6517         case MARSHAL_ACTION_CONV_RESULT:
6518                 /* fixme: we need conversions here */
6519                 mono_mb_emit_stloc (mb, 3);
6520                 break;
6521
6522         default:
6523                 break;
6524         }
6525
6526         return conv_arg;
6527 }
6528
6529 static int
6530 emit_marshal_scalar (EmitMarshalContext *m, int argnum, MonoType *t,
6531                                          MonoMarshalSpec *spec, int conv_arg,
6532                                          MonoType **conv_arg_type, MarshalAction action)
6533 {
6534         MonoMethodBuilder *mb = m->mb;
6535
6536         switch (action) {
6537         case MARSHAL_ACTION_PUSH:
6538                 mono_mb_emit_ldarg (mb, argnum);
6539                 break;
6540
6541         case MARSHAL_ACTION_CONV_RESULT:
6542                 /* no conversions necessary */
6543                 mono_mb_emit_stloc (mb, 3);
6544                 break;
6545
6546         default:
6547                 break;
6548         }
6549
6550         return conv_arg;
6551 }
6552
6553 static int
6554 emit_marshal (EmitMarshalContext *m, int argnum, MonoType *t,
6555                           MonoMarshalSpec *spec, int conv_arg,
6556                           MonoType **conv_arg_type, MarshalAction action)
6557 {
6558         /* Ensure that we have marshalling info for this param */
6559         mono_marshal_load_type_info (mono_class_from_mono_type (t));
6560
6561         if (spec && spec->native == MONO_NATIVE_CUSTOM)
6562                 return emit_marshal_custom (m, argnum, t, spec, conv_arg, conv_arg_type, action);
6563
6564         if (spec && spec->native == MONO_NATIVE_ASANY)
6565                 return emit_marshal_asany (m, argnum, t, spec, conv_arg, conv_arg_type, action);
6566
6567         switch (t->type) {
6568         case MONO_TYPE_VALUETYPE:
6569                 return emit_marshal_vtype (m, argnum, t, spec, conv_arg, conv_arg_type, action);
6570         case MONO_TYPE_STRING:
6571                 return emit_marshal_string (m, argnum, t, spec, conv_arg, conv_arg_type, action);
6572         case MONO_TYPE_CLASS:
6573         case MONO_TYPE_OBJECT:
6574                 return emit_marshal_object (m, argnum, t, spec, conv_arg, conv_arg_type, action);
6575         case MONO_TYPE_ARRAY:
6576         case MONO_TYPE_SZARRAY:
6577                 return emit_marshal_array (m, argnum, t, spec, conv_arg, conv_arg_type, action);
6578         case MONO_TYPE_BOOLEAN:
6579                 return emit_marshal_boolean (m, argnum, t, spec, conv_arg, conv_arg_type, action);
6580         case MONO_TYPE_PTR:
6581                 return emit_marshal_ptr (m, argnum, t, spec, conv_arg, conv_arg_type, action);
6582         case MONO_TYPE_CHAR:
6583                 return emit_marshal_char (m, argnum, t, spec, conv_arg, conv_arg_type, action);
6584         case MONO_TYPE_I1:
6585         case MONO_TYPE_U1:
6586         case MONO_TYPE_I2:
6587         case MONO_TYPE_U2:
6588         case MONO_TYPE_I4:
6589         case MONO_TYPE_U4:
6590         case MONO_TYPE_I:
6591         case MONO_TYPE_U:
6592         case MONO_TYPE_R4:
6593         case MONO_TYPE_R8:
6594         case MONO_TYPE_I8:
6595         case MONO_TYPE_U8:
6596         case MONO_TYPE_FNPTR:
6597                 return emit_marshal_scalar (m, argnum, t, spec, conv_arg, conv_arg_type, action);
6598         }
6599
6600         return conv_arg;
6601 }
6602
6603 /**
6604  * mono_marshal_emit_native_wrapper:
6605  * @sig: The signature of the native function
6606  * @piinfo: Marshalling information
6607  * @mspecs: Marshalling information
6608  * @func: the native function to call
6609  *
6610  * generates IL code for the pinvoke wrapper, the generated code calls @func.
6611  */
6612 static void
6613 mono_marshal_emit_native_wrapper (MonoMethodBuilder *mb, MonoMethodSignature *sig, MonoMethodPInvoke *piinfo, MonoMarshalSpec **mspecs, gpointer func)
6614 {
6615         EmitMarshalContext m;
6616         MonoMethodSignature *csig;
6617         MonoClass *klass;
6618         int i, argnum, *tmp_locals;
6619         int type;
6620         static MonoMethodSignature *get_last_error_sig = NULL;
6621
6622         m.mb = mb;
6623         m.piinfo = piinfo;
6624
6625         /* we copy the signature, so that we can set pinvoke to 0 */
6626         csig = signature_dup (mb->method->klass->image, sig);
6627         csig->pinvoke = 1;
6628         m.csig = csig;
6629
6630         /* we allocate local for use with emit_struct_conv() */
6631         /* allocate local 0 (pointer) src_ptr */
6632         mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
6633         /* allocate local 1 (pointer) dst_ptr */
6634         mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
6635         /* allocate local 2 (boolean) delete_old */
6636         mono_mb_add_local (mb, &mono_defaults.boolean_class->byval_arg);
6637
6638         /* delete_old = FALSE */
6639         mono_mb_emit_icon (mb, 0);
6640         mono_mb_emit_stloc (mb, 2);
6641
6642         if (!MONO_TYPE_IS_VOID(sig->ret)) {
6643                 /* allocate local 3 to store the return value */
6644                 mono_mb_add_local (mb, sig->ret);
6645         }
6646
6647         if (mspecs [0] && mspecs [0]->native == MONO_NATIVE_CUSTOM) {
6648                 /* Return type custom marshaling */
6649                 /*
6650                  * Since we can't determine the return type of the unmanaged function,
6651                  * we assume it returns a pointer, and pass that pointer to
6652                  * MarshalNativeToManaged.
6653                  */
6654                 csig->ret = &mono_defaults.int_class->byval_arg;
6655         }
6656
6657         /* we first do all conversions */
6658         tmp_locals = alloca (sizeof (int) * sig->param_count);
6659         m.orig_conv_args = alloca (sizeof (int) * (sig->param_count + 1));
6660
6661         for (i = 0; i < sig->param_count; i ++) {
6662                 tmp_locals [i] = emit_marshal (&m, i + sig->hasthis, sig->params [i], mspecs [i + 1], 0, &csig->params [i], MARSHAL_ACTION_CONV_IN);
6663         }
6664
6665         /* push all arguments */
6666
6667         if (sig->hasthis)
6668                 mono_mb_emit_byte (mb, CEE_LDARG_0);
6669
6670         for (i = 0; i < sig->param_count; i++) {
6671                 emit_marshal (&m, i + sig->hasthis, sig->params [i], mspecs [i + 1], tmp_locals [i], NULL, MARSHAL_ACTION_PUSH);
6672         }
6673
6674         /* call the native method */
6675         mono_mb_emit_native_call (mb, csig, func);
6676
6677         /* Set LastError if needed */
6678         if (piinfo->piflags & PINVOKE_ATTRIBUTE_SUPPORTS_LAST_ERROR) {
6679                 if (!get_last_error_sig) {
6680                         get_last_error_sig = mono_metadata_signature_alloc (mono_defaults.corlib, 0);
6681                         get_last_error_sig->ret = &mono_defaults.int_class->byval_arg;
6682                         get_last_error_sig->pinvoke = 1;
6683                 }
6684
6685 #ifdef PLATFORM_WIN32
6686                 /*
6687                  * Have to call GetLastError () early and without a wrapper, since various runtime components could
6688                  * clobber its value.
6689                  */
6690                 mono_mb_emit_native_call (mb, get_last_error_sig, GetLastError);
6691                 mono_mb_emit_icall (mb, mono_marshal_set_last_error_windows);
6692 #else
6693                 mono_mb_emit_icall (mb, mono_marshal_set_last_error);
6694 #endif
6695         }
6696
6697         /* convert the result */
6698         if (!sig->ret->byref) {
6699                 MonoMarshalSpec *spec = mspecs [0];
6700                 type = sig->ret->type;
6701
6702                 if (spec && spec->native == MONO_NATIVE_CUSTOM) {
6703                         emit_marshal (&m, 0, sig->ret, spec, 0, NULL, MARSHAL_ACTION_CONV_RESULT);
6704                 } else {
6705
6706                 handle_enum:
6707                         switch (type) {
6708                         case MONO_TYPE_VOID:
6709                                 break;
6710                         case MONO_TYPE_VALUETYPE:
6711                                 klass = sig->ret->data.klass;
6712                                 if (klass->enumtype) {
6713                                         type = sig->ret->data.klass->enum_basetype->type;
6714                                         goto handle_enum;
6715                                 }
6716                                 emit_marshal (&m, 0, sig->ret, spec, 0, NULL, MARSHAL_ACTION_CONV_RESULT);
6717                                 break;
6718                         case MONO_TYPE_I1:
6719                         case MONO_TYPE_U1:
6720                         case MONO_TYPE_I2:
6721                         case MONO_TYPE_U2:
6722                         case MONO_TYPE_I4:
6723                         case MONO_TYPE_U4:
6724                         case MONO_TYPE_I:
6725                         case MONO_TYPE_U:
6726                         case MONO_TYPE_R4:
6727                         case MONO_TYPE_R8:
6728                         case MONO_TYPE_I8:
6729                         case MONO_TYPE_U8:
6730                         case MONO_TYPE_FNPTR:
6731                         case MONO_TYPE_STRING:
6732                         case MONO_TYPE_CLASS:
6733                         case MONO_TYPE_OBJECT:
6734                         case MONO_TYPE_BOOLEAN:
6735                         case MONO_TYPE_ARRAY:
6736                         case MONO_TYPE_SZARRAY:
6737                         case MONO_TYPE_CHAR:
6738                         case MONO_TYPE_PTR:
6739                                 emit_marshal (&m, 0, sig->ret, spec, 0, NULL, MARSHAL_ACTION_CONV_RESULT);
6740                                 break;
6741                         case MONO_TYPE_TYPEDBYREF:
6742                         default:
6743                                 g_warning ("return type 0x%02x unknown", sig->ret->type);
6744                                 g_assert_not_reached ();
6745                         }
6746                 }
6747         } else {
6748                 mono_mb_emit_stloc (mb, 3);
6749         }
6750
6751         /*
6752          * Need to call this after converting the result since MONO_VTADDR needs
6753          * to be adjacent to the call instruction.
6754          */
6755         emit_thread_interrupt_checkpoint (mb);
6756
6757         /* we need to convert byref arguments back and free string arrays */
6758         for (i = 0; i < sig->param_count; i++) {
6759                 MonoType *t = sig->params [i];
6760                 MonoMarshalSpec *spec = mspecs [i + 1];
6761
6762                 argnum = i + sig->hasthis;
6763
6764                 if (spec && ((spec->native == MONO_NATIVE_CUSTOM) || (spec->native == MONO_NATIVE_ASANY))) {
6765                         emit_marshal (&m, argnum, t, spec, tmp_locals [i], NULL, MARSHAL_ACTION_CONV_OUT);
6766                         continue;
6767                 }
6768
6769                 switch (t->type) {
6770                 case MONO_TYPE_STRING:
6771                 case MONO_TYPE_VALUETYPE:
6772                 case MONO_TYPE_CLASS:
6773                 case MONO_TYPE_OBJECT:
6774                 case MONO_TYPE_SZARRAY:
6775                 case MONO_TYPE_BOOLEAN:
6776                         emit_marshal (&m, argnum, t, spec, tmp_locals [i], NULL, MARSHAL_ACTION_CONV_OUT);
6777                         break;
6778                 }
6779         }
6780
6781         if (!MONO_TYPE_IS_VOID(sig->ret))
6782                 mono_mb_emit_ldloc (mb, 3);
6783
6784         mono_mb_emit_byte (mb, CEE_RET);
6785 }
6786
6787 /**
6788  * mono_marshal_get_native_wrapper:
6789  * @method: The MonoMethod to wrap.
6790  *
6791  * generates IL code for the pinvoke wrapper (the generated method
6792  * calls the unmanaged code in piinfo->addr)
6793  */
6794 MonoMethod *
6795 mono_marshal_get_native_wrapper (MonoMethod *method)
6796 {
6797         MonoMethodSignature *sig, *csig;
6798         MonoMethodPInvoke *piinfo = (MonoMethodPInvoke *) method;
6799         MonoMethodBuilder *mb;
6800         MonoMarshalSpec **mspecs;
6801         MonoMethod *res;
6802         GHashTable *cache;
6803         gboolean pinvoke = FALSE;
6804         int i;
6805         const char *exc_class = "MissingMethodException";
6806         const char *exc_arg = NULL;
6807
6808         g_assert (method != NULL);
6809         g_assert (mono_method_signature (method)->pinvoke);
6810
6811         cache = method->klass->image->native_wrapper_cache;
6812         if ((res = mono_marshal_find_in_cache (cache, method)))
6813                 return res;
6814
6815         sig = mono_method_signature (method);
6816
6817         if (!(method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) &&
6818             (method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL))
6819                 pinvoke = TRUE;
6820
6821         if (!piinfo->addr) {
6822                 if (pinvoke)
6823                         mono_lookup_pinvoke_call (method, &exc_class, &exc_arg);
6824                 else
6825                         piinfo->addr = mono_lookup_internal_call (method);
6826         }
6827
6828         mb = mono_mb_new (method->klass, method->name, MONO_WRAPPER_MANAGED_TO_NATIVE);
6829
6830         mb->method->save_lmf = 1;
6831
6832         if (!piinfo->addr) {
6833                 mono_mb_emit_exception (mb, exc_class, exc_arg);
6834                 csig = signature_dup (method->klass->image, sig);
6835                 csig->pinvoke = 0;
6836                 res = mono_mb_create_and_cache (cache, method,
6837                                                                                 mb, csig, csig->param_count + 16);
6838                 mono_mb_free (mb);
6839                 return res;
6840         }
6841
6842         /* internal calls: we simply push all arguments and call the method (no conversions) */
6843         if (method->iflags & (METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL | METHOD_IMPL_ATTRIBUTE_RUNTIME)) {
6844
6845                 /* hack - string constructors returns a value */
6846                 if (method->string_ctor) {
6847                         csig = signature_dup (method->klass->image, sig);
6848                         csig->ret = &mono_defaults.string_class->byval_arg;
6849                 } else
6850                         csig = sig;
6851
6852                 if (sig->hasthis)
6853                         mono_mb_emit_byte (mb, CEE_LDARG_0);
6854
6855                 for (i = 0; i < sig->param_count; i++)
6856                         mono_mb_emit_ldarg (mb, i + sig->hasthis);
6857
6858                 g_assert (piinfo->addr);
6859                 mono_mb_emit_native_call (mb, csig, piinfo->addr);
6860                 emit_thread_interrupt_checkpoint (mb);
6861                 mono_mb_emit_byte (mb, CEE_RET);
6862
6863                 csig = signature_dup (method->klass->image, csig);
6864                 csig->pinvoke = 0;
6865                 res = mono_mb_create_and_cache (cache, method,
6866                                                                                 mb, csig, csig->param_count + 16);
6867                 mono_mb_free (mb);
6868                 return res;
6869         }
6870
6871         g_assert (pinvoke);
6872
6873         mspecs = g_new (MonoMarshalSpec*, sig->param_count + 1);
6874         mono_method_get_marshal_info (method, mspecs);
6875
6876         mono_marshal_emit_native_wrapper (mb, sig, piinfo, mspecs, piinfo->addr);
6877
6878         csig = signature_dup (method->klass->image, sig);
6879         csig->pinvoke = 0;
6880         res = mono_mb_create_and_cache (cache, method,
6881                                                                         mb, csig, csig->param_count + 16);
6882         mono_mb_free (mb);
6883
6884         for (i = sig->param_count; i >= 0; i--)
6885                 if (mspecs [i])
6886                         mono_metadata_free_marshal_spec (mspecs [i]);
6887         g_free (mspecs);
6888
6889         /* printf ("CODE FOR %s: \n%s.\n", mono_method_full_name (res, TRUE), mono_disasm_code (0, res, ((MonoMethodNormal*)res)->header->code, ((MonoMethodNormal*)res)->header->code + ((MonoMethodNormal*)res)->header->code_size)); */
6890
6891         return res;
6892 }
6893
6894 /**
6895  * mono_marshal_get_native_func_wrapper:
6896  * @sig: The signature of the function
6897  * @func: The native function to wrap
6898  *
6899  *   Returns a wrapper method around native functions, similar to the pinvoke
6900  * wrapper.
6901  */
6902 MonoMethod *
6903 mono_marshal_get_native_func_wrapper (MonoMethodSignature *sig,
6904                                                                           MonoMethodPInvoke *piinfo, MonoMarshalSpec **mspecs, gpointer func)
6905 {
6906         MonoMethodSignature *csig;
6907
6908         MonoMethodBuilder *mb;
6909         MonoMethod *res;
6910         GHashTable *cache;
6911         char *name;
6912
6913         cache = mono_defaults.corlib->native_wrapper_cache;
6914         if ((res = mono_marshal_find_in_cache (cache, func)))
6915                 return res;
6916
6917         name = g_strdup_printf ("wrapper_native_%p", func);
6918         mb = mono_mb_new (mono_defaults.object_class, name, MONO_WRAPPER_MANAGED_TO_NATIVE);
6919         mb->method->save_lmf = 1;
6920
6921         mono_marshal_emit_native_wrapper (mb, sig, piinfo, mspecs, func);
6922
6923         csig = signature_dup (mb->method->klass->image, sig);
6924         csig->pinvoke = 0;
6925         res = mono_mb_create_and_cache (cache, func,
6926                                                                         mb, csig, csig->param_count + 16);
6927         mono_mb_free (mb);
6928
6929         /* printf ("CODE FOR %s: \n%s.\n", mono_method_full_name (res, TRUE), mono_disasm_code (0, res, ((MonoMethodNormal*)res)->header->code, ((MonoMethodNormal*)res)->header->code + ((MonoMethodNormal*)res)->header->code_size)); */
6930
6931         return res;
6932 }
6933
6934 /*
6935  * generates IL code to call managed methods from unmanaged code
6936  */
6937 MonoMethod *
6938 mono_marshal_get_managed_wrapper (MonoMethod *method, MonoClass *delegate_klass, MonoObject *this)
6939 {
6940         static MonoClass *UnmanagedFunctionPointerAttribute;
6941         MonoMethodSignature *sig, *csig, *invoke_sig;
6942         MonoMethodBuilder *mb;
6943         MonoMethod *res, *invoke;
6944         MonoMarshalSpec **mspecs;
6945         MonoMethodPInvoke piinfo;
6946         GHashTable *cache;
6947         int i, *tmp_locals;
6948         EmitMarshalContext m;
6949
6950         g_assert (method != NULL);
6951         g_assert (!mono_method_signature (method)->pinvoke);
6952
6953         /*
6954          * FIXME: Should cache the method+delegate type pair, since the same method
6955          * could be called with different delegates, thus different marshalling
6956          * options.
6957          */
6958         cache = method->klass->image->managed_wrapper_cache;
6959         if (!this && (res = mono_marshal_find_in_cache (cache, method)))
6960                 return res;
6961
6962         invoke = mono_class_get_method_from_name (delegate_klass, "Invoke", mono_method_signature (method)->param_count);
6963         invoke_sig = mono_method_signature (invoke);
6964
6965         mspecs = g_new0 (MonoMarshalSpec*, mono_method_signature (invoke)->param_count + 1);
6966         mono_method_get_marshal_info (invoke, mspecs);
6967
6968         sig = mono_method_signature (method);
6969
6970         mb = mono_mb_new (method->klass, method->name, MONO_WRAPPER_NATIVE_TO_MANAGED);
6971
6972         /* allocate local 0 (pointer) src_ptr */
6973         mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
6974         /* allocate local 1 (pointer) dst_ptr */
6975         mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
6976         /* allocate local 2 (boolean) delete_old */
6977         mono_mb_add_local (mb, &mono_defaults.boolean_class->byval_arg);
6978
6979         if (!MONO_TYPE_IS_VOID(sig->ret)) {
6980                 /* allocate local 3 to store the return value */
6981                 mono_mb_add_local (mb, sig->ret);
6982         }
6983
6984         mono_mb_emit_icon (mb, 0);
6985         mono_mb_emit_stloc (mb, 2);
6986
6987         /* we copy the signature, so that we can modify it */
6988         csig = signature_dup (method->klass->image, sig);
6989         csig->hasthis = 0;
6990         csig->pinvoke = 1;
6991
6992         m.mb = mb;
6993         m.sig = sig;
6994         m.piinfo = NULL;
6995         m.retobj_var = 0;
6996         m.csig = csig;
6997
6998 #ifdef PLATFORM_WIN32
6999         /*
7000          * Under windows, delegates passed to native code must use the STDCALL
7001          * calling convention.
7002          */
7003         csig->call_convention = MONO_CALL_STDCALL;
7004 #endif
7005
7006         /* Change default calling convention if needed */
7007         /* Why is this a modopt ? */
7008         if (invoke_sig->ret && invoke_sig->ret->num_mods) {
7009                 for (i = 0; i < invoke_sig->ret->num_mods; ++i) {
7010                         MonoClass *cmod_class = mono_class_get (delegate_klass->image, invoke_sig->ret->modifiers [i].token);
7011                         g_assert (cmod_class);
7012                         if ((cmod_class->image == mono_defaults.corlib) && !strcmp (cmod_class->name_space, "System.Runtime.CompilerServices")) {
7013                                 if (!strcmp (cmod_class->name, "CallConvCdecl"))
7014                                         csig->call_convention = MONO_CALL_C;
7015                                 else if (!strcmp (cmod_class->name, "CallConvStdcall"))
7016                                         csig->call_convention = MONO_CALL_STDCALL;
7017                                 else if (!strcmp (cmod_class->name, "CallConvFastcall"))
7018                                         csig->call_convention = MONO_CALL_FASTCALL;
7019                                 else if (!strcmp (cmod_class->name, "CallConvThiscall"))
7020                                         csig->call_convention = MONO_CALL_THISCALL;
7021                         }
7022                 }
7023         }
7024
7025         /* Handle the UnmanagedFunctionPointerAttribute */
7026         if (!UnmanagedFunctionPointerAttribute)
7027                 UnmanagedFunctionPointerAttribute = mono_class_from_name (mono_defaults.corlib, "System.Runtime.InteropServices", "UnmanagedFunctionPointerAttribute");
7028
7029         /* The attribute is only available in Net 2.0 */
7030         if (UnmanagedFunctionPointerAttribute) {
7031                 MonoReflectionUnmanagedFunctionPointerAttribute *attr;
7032                 MonoCustomAttrInfo *cinfo;
7033
7034                 /*
7035                  * The pinvoke attributes are stored in a real custom attribute so we have to
7036                  * construct it.
7037                  */
7038                 cinfo = mono_custom_attrs_from_class (delegate_klass);
7039                 if (cinfo) {
7040                         attr = (MonoReflectionUnmanagedFunctionPointerAttribute*)mono_custom_attrs_get_attr (cinfo, UnmanagedFunctionPointerAttribute);
7041                         if (attr) {
7042                                 memset (&piinfo, 0, sizeof (piinfo));
7043                                 m.piinfo = &piinfo;
7044                                 piinfo.piflags = (attr->call_conv << 8) | (attr->charset ? (attr->charset - 1) * 2 : 1) | attr->set_last_error;
7045
7046                                 csig->call_convention = attr->call_conv - 1;
7047                         }
7048                         if (!cinfo->cached)
7049                                 mono_custom_attrs_free (cinfo);
7050                 }
7051         }
7052
7053         /* fixme: howto handle this ? */
7054         if (sig->hasthis) {
7055                 if (this) {
7056                         mono_mb_emit_ptr (mb, this);
7057                 } else {
7058                         /* fixme: */
7059                         g_assert_not_reached ();
7060                 }
7061         }
7062
7063         /* we first do all conversions */
7064         tmp_locals = alloca (sizeof (int) * sig->param_count);
7065         for (i = 0; i < sig->param_count; i ++) {
7066                 MonoType *t = sig->params [i];
7067
7068                 switch (t->type) {
7069                 case MONO_TYPE_OBJECT:
7070                 case MONO_TYPE_CLASS:
7071                 case MONO_TYPE_VALUETYPE:
7072                 case MONO_TYPE_ARRAY:
7073                 case MONO_TYPE_SZARRAY:
7074                 case MONO_TYPE_STRING:
7075                         tmp_locals [i] = emit_marshal (&m, i, sig->params [i], mspecs [i + 1], 0, &csig->params [i], MARSHAL_ACTION_MANAGED_CONV_IN);
7076
7077                         break;
7078                 default:
7079                         tmp_locals [i] = 0;
7080                         break;
7081                 }
7082         }
7083
7084         emit_thread_interrupt_checkpoint (mb);
7085
7086         for (i = 0; i < sig->param_count; i++) {
7087                 MonoType *t = sig->params [i];
7088
7089                 if (tmp_locals [i]) {
7090                         if (t->byref)
7091                                 mono_mb_emit_ldloc_addr (mb, tmp_locals [i]);
7092                         else
7093                                 mono_mb_emit_ldloc (mb, tmp_locals [i]);
7094                 }
7095                 else
7096                         mono_mb_emit_ldarg (mb, i);
7097         }
7098
7099         mono_mb_emit_managed_call (mb, method, NULL);
7100
7101         if (mspecs [0] && mspecs [0]->native == MONO_NATIVE_CUSTOM) {
7102                 emit_marshal (&m, 0, sig->ret, mspecs [0], 0, NULL, MARSHAL_ACTION_MANAGED_CONV_RESULT);
7103         }
7104         else
7105         if (!sig->ret->byref) {
7106                 switch (sig->ret->type) {
7107                 case MONO_TYPE_VOID:
7108                         break;
7109                 case MONO_TYPE_BOOLEAN:
7110                 case MONO_TYPE_I1:
7111                 case MONO_TYPE_U1:
7112                 case MONO_TYPE_I2:
7113                 case MONO_TYPE_U2:
7114                 case MONO_TYPE_I4:
7115                 case MONO_TYPE_U4:
7116                 case MONO_TYPE_I:
7117                 case MONO_TYPE_U:
7118                 case MONO_TYPE_PTR:
7119                 case MONO_TYPE_R4:
7120                 case MONO_TYPE_R8:
7121                 case MONO_TYPE_I8:
7122                 case MONO_TYPE_U8:
7123                 case MONO_TYPE_OBJECT:
7124                         mono_mb_emit_stloc (mb, 3);
7125                         break;
7126                 case MONO_TYPE_STRING:
7127                         csig->ret = &mono_defaults.int_class->byval_arg;
7128                         emit_marshal (&m, 0, sig->ret, mspecs [0], 0, NULL, MARSHAL_ACTION_MANAGED_CONV_RESULT);
7129                         break;
7130                 case MONO_TYPE_VALUETYPE:
7131                 case MONO_TYPE_CLASS:
7132                 case MONO_TYPE_SZARRAY:
7133                         emit_marshal (&m, 0, sig->ret, mspecs [0], 0, NULL, MARSHAL_ACTION_MANAGED_CONV_RESULT);
7134                         break;
7135                 default:
7136                         g_warning ("return type 0x%02x unknown", sig->ret->type);
7137                         g_assert_not_reached ();
7138                 }
7139         } else {
7140                 mono_mb_emit_stloc (mb, 3);
7141         }
7142
7143         /* Convert byref arguments back */
7144         for (i = 0; i < sig->param_count; i ++) {
7145                 MonoType *t = sig->params [i];
7146                 MonoMarshalSpec *spec = mspecs [i + 1];
7147
7148                 if (spec && spec->native == MONO_NATIVE_CUSTOM) {
7149                         emit_marshal (&m, i, t, mspecs [i + 1], tmp_locals [i], NULL, MARSHAL_ACTION_MANAGED_CONV_OUT);
7150                 }
7151                 else if (t->byref) {
7152                         switch (t->type) {
7153                         case MONO_TYPE_CLASS:
7154                         case MONO_TYPE_VALUETYPE:
7155                                 emit_marshal (&m, i, t, mspecs [i + 1], tmp_locals [i], NULL, MARSHAL_ACTION_MANAGED_CONV_OUT);
7156                                 break;
7157                         }
7158                 }
7159                 else if (invoke_sig->params [i]->attrs & PARAM_ATTRIBUTE_OUT) {
7160                         /* The [Out] information is encoded in the delegate signature */
7161                         switch (t->type) {
7162                         case MONO_TYPE_SZARRAY:
7163                                 emit_marshal (&m, i, invoke_sig->params [i], mspecs [i + 1], tmp_locals [i], NULL, MARSHAL_ACTION_MANAGED_CONV_OUT);
7164                                 break;
7165                         default:
7166                                 g_assert_not_reached ();
7167                         }
7168                 }
7169         }
7170
7171         if (m.retobj_var) {
7172                 mono_mb_emit_ldloc (mb, m.retobj_var);
7173                 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
7174                 mono_mb_emit_byte (mb, CEE_MONO_RETOBJ);
7175                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, m.retobj_class));
7176         }
7177         else {
7178                 if (!MONO_TYPE_IS_VOID(sig->ret))
7179                         mono_mb_emit_ldloc (mb, 3);
7180                 mono_mb_emit_byte (mb, CEE_RET);
7181         }
7182
7183         if (!this)
7184                 res = mono_mb_create_and_cache (cache, method,
7185                                                                                          mb, csig, sig->param_count + 16);
7186         else {
7187                 mb->dynamic = 1;
7188                 res = mono_mb_create_method (mb, csig, sig->param_count + 16);
7189         }
7190         mono_mb_free (mb);
7191
7192         for (i = mono_method_signature (invoke)->param_count; i >= 0; i--)
7193                 if (mspecs [i])
7194                         mono_metadata_free_marshal_spec (mspecs [i]);
7195         g_free (mspecs);
7196
7197         /* printf ("CODE FOR %s: \n%s.\n", mono_method_full_name (res, TRUE), mono_disasm_code (0, res, ((MonoMethodNormal*)res)->header->code, ((MonoMethodNormal*)res)->header->code + ((MonoMethodNormal*)res)->header->code_size)); */
7198
7199         return res;
7200 }
7201
7202 static MonoReflectionType *
7203 type_from_handle (MonoType *handle)
7204 {
7205         MonoDomain *domain = mono_domain_get ();
7206         MonoClass *klass = mono_class_from_mono_type (handle);
7207
7208         MONO_ARCH_SAVE_REGS;
7209
7210         mono_class_init (klass);
7211         return mono_type_get_object (domain, handle);
7212 }
7213
7214 /*
7215  * mono_marshal_get_isinst:
7216  * @klass: the type of the field
7217  *
7218  * This method generates a function which can be used to check if an object is
7219  * an instance of the given type, icluding the case where the object is a proxy.
7220  * The generated function has the following signature:
7221  * MonoObject* __isinst_wrapper_ (MonoObject *obj)
7222  */
7223 MonoMethod *
7224 mono_marshal_get_isinst (MonoClass *klass)
7225 {
7226         static MonoMethodSignature *isint_sig = NULL;
7227         GHashTable *cache;
7228         MonoMethod *res;
7229         int pos_was_ok, pos_failed, pos_end, pos_end2;
7230         char *name;
7231         MonoMethodBuilder *mb;
7232
7233         cache = klass->image->isinst_cache;
7234         if ((res = mono_marshal_find_in_cache (cache, klass)))
7235                 return res;
7236
7237         if (!isint_sig) {
7238                 isint_sig = mono_metadata_signature_alloc (mono_defaults.corlib, 1);
7239                 isint_sig->params [0] = &mono_defaults.object_class->byval_arg;
7240                 isint_sig->ret = &mono_defaults.object_class->byval_arg;
7241                 isint_sig->pinvoke = 0;
7242         }
7243
7244         name = g_strdup_printf ("__isinst_wrapper_%s", klass->name);
7245         mb = mono_mb_new (mono_defaults.object_class, name, MONO_WRAPPER_ISINST);
7246         g_free (name);
7247
7248         mb->method->save_lmf = 1;
7249
7250         /* check if the object is a proxy that needs special cast */
7251         mono_mb_emit_ldarg (mb, 0);
7252         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
7253         mono_mb_emit_byte (mb, CEE_MONO_CISINST);
7254         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, klass));
7255
7256         /* The result of MONO_ISINST can be:
7257                 0) the type check succeeded
7258                 1) the type check did not succeed
7259                 2) a CanCastTo call is needed */
7260
7261         mono_mb_emit_byte (mb, CEE_DUP);
7262         pos_was_ok = mono_mb_emit_branch (mb, CEE_BRFALSE);
7263
7264         mono_mb_emit_byte (mb, CEE_LDC_I4_2);
7265         pos_failed = mono_mb_emit_branch (mb, CEE_BNE_UN);
7266
7267         /* get the real proxy from the transparent proxy*/
7268
7269         mono_mb_emit_ldarg (mb, 0);
7270         mono_mb_emit_managed_call (mb, mono_marshal_get_proxy_cancast (klass), NULL);
7271         pos_end = mono_mb_emit_branch (mb, CEE_BR);
7272
7273         /* fail */
7274
7275         mono_mb_patch_addr (mb, pos_failed, mb->pos - (pos_failed + 4));
7276         mono_mb_emit_byte (mb, CEE_LDNULL);
7277         pos_end2 = mono_mb_emit_branch (mb, CEE_BR);
7278
7279         /* success */
7280
7281         mono_mb_patch_addr (mb, pos_was_ok, mb->pos - (pos_was_ok + 4));
7282         mono_mb_emit_byte (mb, CEE_POP);
7283         mono_mb_emit_ldarg (mb, 0);
7284
7285         /* the end */
7286
7287         mono_mb_patch_addr (mb, pos_end, mb->pos - (pos_end + 4));
7288         mono_mb_patch_addr (mb, pos_end2, mb->pos - (pos_end2 + 4));
7289         mono_mb_emit_byte (mb, CEE_RET);
7290
7291         res = mono_mb_create_and_cache (cache, klass, mb, isint_sig, isint_sig->param_count + 16);
7292         mono_mb_free (mb);
7293
7294         return res;
7295 }
7296
7297 /*
7298  * mono_marshal_get_castclass:
7299  * @klass: the type of the field
7300  *
7301  * This method generates a function which can be used to cast an object to
7302  * an instance of the given type, icluding the case where the object is a proxy.
7303  * The generated function has the following signature:
7304  * MonoObject* __castclass_wrapper_ (MonoObject *obj)
7305  */
7306 MonoMethod *
7307 mono_marshal_get_castclass (MonoClass *klass)
7308 {
7309         static MonoMethodSignature *castclass_sig = NULL;
7310         GHashTable *cache;
7311         MonoMethod *res;
7312         int pos_was_ok, pos_was_ok2;
7313         char *name;
7314         MonoMethodBuilder *mb;
7315
7316         cache = klass->image->castclass_cache;
7317         if ((res = mono_marshal_find_in_cache (cache, klass)))
7318                 return res;
7319
7320         if (!castclass_sig) {
7321                 castclass_sig = mono_metadata_signature_alloc (mono_defaults.corlib, 1);
7322                 castclass_sig->params [0] = &mono_defaults.object_class->byval_arg;
7323                 castclass_sig->ret = &mono_defaults.object_class->byval_arg;
7324                 castclass_sig->pinvoke = 0;
7325         }
7326
7327         name = g_strdup_printf ("__castclass_wrapper_%s", klass->name);
7328         mb = mono_mb_new (mono_defaults.object_class, name, MONO_WRAPPER_CASTCLASS);
7329         g_free (name);
7330
7331         mb->method->save_lmf = 1;
7332
7333         /* check if the object is a proxy that needs special cast */
7334         mono_mb_emit_ldarg (mb, 0);
7335         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
7336         mono_mb_emit_byte (mb, CEE_MONO_CCASTCLASS);
7337         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, klass));
7338
7339         /* The result of MONO_ISINST can be:
7340                 0) the cast is valid
7341                 1) cast of unknown proxy type
7342                 or an exception if the cast is is invalid
7343         */
7344
7345         pos_was_ok = mono_mb_emit_branch (mb, CEE_BRFALSE);
7346
7347         /* get the real proxy from the transparent proxy*/
7348
7349         mono_mb_emit_ldarg (mb, 0);
7350         mono_mb_emit_managed_call (mb, mono_marshal_get_proxy_cancast (klass), NULL);
7351         pos_was_ok2 = mono_mb_emit_branch (mb, CEE_BRTRUE);
7352
7353         /* fail */
7354         mono_mb_emit_exception (mb, "InvalidCastException", NULL);
7355
7356         /* success */
7357         mono_mb_patch_addr (mb, pos_was_ok, mb->pos - (pos_was_ok + 4));
7358         mono_mb_patch_addr (mb, pos_was_ok2, mb->pos - (pos_was_ok2 + 4));
7359         mono_mb_emit_ldarg (mb, 0);
7360
7361         /* the end */
7362         mono_mb_emit_byte (mb, CEE_RET);
7363
7364         res = mono_mb_create_and_cache (cache, klass, mb, castclass_sig, castclass_sig->param_count + 16);
7365         mono_mb_free (mb);
7366
7367         return res;
7368 }
7369
7370 MonoMethod *
7371 mono_marshal_get_proxy_cancast (MonoClass *klass)
7372 {
7373         static MonoMethodSignature *isint_sig = NULL;
7374         GHashTable *cache;
7375         MonoMethod *res;
7376         int pos_failed, pos_end;
7377         char *name;
7378         MonoMethod *can_cast_to;
7379         MonoMethodDesc *desc;
7380         MonoMethodBuilder *mb;
7381
7382         cache = klass->image->proxy_isinst_cache;
7383         if ((res = mono_marshal_find_in_cache (cache, klass)))
7384                 return res;
7385
7386         if (!isint_sig) {
7387                 isint_sig = mono_metadata_signature_alloc (mono_defaults.corlib, 1);
7388                 isint_sig->params [0] = &mono_defaults.object_class->byval_arg;
7389                 isint_sig->ret = &mono_defaults.object_class->byval_arg;
7390                 isint_sig->pinvoke = 0;
7391         }
7392
7393         name = g_strdup_printf ("__proxy_isinst_wrapper_%s", klass->name);
7394         mb = mono_mb_new (mono_defaults.object_class, name, MONO_WRAPPER_PROXY_ISINST);
7395         g_free (name);
7396
7397         mb->method->save_lmf = 1;
7398
7399         /* get the real proxy from the transparent proxy*/
7400         mono_mb_emit_ldarg (mb, 0);
7401         mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoTransparentProxy, rp));
7402         mono_mb_emit_byte (mb, CEE_LDIND_REF);
7403
7404         /* get the reflection type from the type handle */
7405         mono_mb_emit_ptr (mb, &klass->byval_arg);
7406         mono_mb_emit_icall (mb, type_from_handle);
7407
7408         mono_mb_emit_ldarg (mb, 0);
7409
7410         /* make the call to CanCastTo (type, ob) */
7411         desc = mono_method_desc_new ("IRemotingTypeInfo:CanCastTo", FALSE);
7412         can_cast_to = mono_method_desc_search_in_class (desc, mono_defaults.iremotingtypeinfo_class);
7413         g_assert (can_cast_to);
7414         mono_method_desc_free (desc);
7415         mono_mb_emit_byte (mb, CEE_CALLVIRT);
7416         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, can_cast_to));
7417
7418
7419         pos_failed = mono_mb_emit_branch (mb, CEE_BRFALSE);
7420
7421         /* Upgrade the proxy vtable by calling: mono_upgrade_remote_class_wrapper (type, ob)*/
7422         mono_mb_emit_ptr (mb, &klass->byval_arg);
7423         mono_mb_emit_icall (mb, type_from_handle);
7424         mono_mb_emit_ldarg (mb, 0);
7425
7426         mono_mb_emit_icall (mb, mono_upgrade_remote_class_wrapper);
7427         emit_thread_interrupt_checkpoint (mb);
7428
7429         mono_mb_emit_ldarg (mb, 0);
7430         pos_end = mono_mb_emit_branch (mb, CEE_BR);
7431
7432         /* fail */
7433
7434         mono_mb_patch_addr (mb, pos_failed, mb->pos - (pos_failed + 4));
7435         mono_mb_emit_byte (mb, CEE_LDNULL);
7436
7437         /* the end */
7438
7439         mono_mb_patch_addr (mb, pos_end, mb->pos - (pos_end + 4));
7440         mono_mb_emit_byte (mb, CEE_RET);
7441
7442         res = mono_mb_create_and_cache (cache, klass, mb, isint_sig, isint_sig->param_count + 16);
7443         mono_mb_free (mb);
7444
7445         return res;
7446 }
7447
7448 void
7449 mono_upgrade_remote_class_wrapper (MonoReflectionType *rtype, MonoTransparentProxy *tproxy)
7450 {
7451         MonoClass *klass;
7452         MonoDomain *domain = ((MonoObject*)tproxy)->vtable->domain;
7453         klass = mono_class_from_mono_type (rtype->type);
7454         mono_upgrade_remote_class (domain, (MonoObject*)tproxy, klass);
7455 }
7456
7457 /**
7458  * mono_marshal_get_struct_to_ptr:
7459  * @klass:
7460  *
7461  * generates IL code for StructureToPtr (object structure, IntPtr ptr, bool fDeleteOld)
7462  */
7463 MonoMethod *
7464 mono_marshal_get_struct_to_ptr (MonoClass *klass)
7465 {
7466         MonoMethodBuilder *mb;
7467         static MonoMethod *stoptr = NULL;
7468         MonoMethod *res;
7469
7470         g_assert (klass != NULL);
7471
7472         mono_marshal_load_type_info (klass);
7473
7474         if (klass->marshal_info->str_to_ptr)
7475                 return klass->marshal_info->str_to_ptr;
7476
7477         if (!stoptr)
7478                 stoptr = mono_class_get_method_from_name (mono_defaults.marshal_class, "StructureToPtr", 3);
7479         g_assert (stoptr);
7480
7481         mb = mono_mb_new (klass, stoptr->name, MONO_WRAPPER_UNKNOWN);
7482
7483         if (klass->blittable) {
7484                 mono_mb_emit_byte (mb, CEE_LDARG_1);
7485                 mono_mb_emit_byte (mb, CEE_LDARG_0);
7486                 mono_mb_emit_ldflda (mb, sizeof (MonoObject));
7487                 mono_mb_emit_icon (mb, mono_class_value_size (klass, NULL));
7488                 mono_mb_emit_byte (mb, CEE_PREFIX1);
7489                 mono_mb_emit_byte (mb, CEE_CPBLK);
7490         } else {
7491
7492                 /* allocate local 0 (pointer) src_ptr */
7493                 mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
7494                 /* allocate local 1 (pointer) dst_ptr */
7495                 mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
7496                 /* allocate local 2 (boolean) delete_old */
7497                 mono_mb_add_local (mb, &mono_defaults.boolean_class->byval_arg);
7498                 mono_mb_emit_byte (mb, CEE_LDARG_2);
7499                 mono_mb_emit_stloc (mb, 2);
7500
7501                 /* initialize src_ptr to point to the start of object data */
7502                 mono_mb_emit_byte (mb, CEE_LDARG_0);
7503                 mono_mb_emit_ldflda (mb, sizeof (MonoObject));
7504                 mono_mb_emit_stloc (mb, 0);
7505
7506                 /* initialize dst_ptr */
7507                 mono_mb_emit_byte (mb, CEE_LDARG_1);
7508                 mono_mb_emit_stloc (mb, 1);
7509
7510                 emit_struct_conv (mb, klass, FALSE);
7511         }
7512
7513         mono_mb_emit_byte (mb, CEE_RET);
7514
7515         res = mono_mb_create_method (mb, mono_method_signature (stoptr), 0);
7516         mono_mb_free (mb);
7517
7518         klass->marshal_info->str_to_ptr = res;
7519         return res;
7520 }
7521
7522 /**
7523  * mono_marshal_get_ptr_to_struct:
7524  * @klass:
7525  *
7526  * generates IL code for PtrToStructure (IntPtr src, object structure)
7527  */
7528 MonoMethod *
7529 mono_marshal_get_ptr_to_struct (MonoClass *klass)
7530 {
7531         MonoMethodBuilder *mb;
7532         static MonoMethodSignature *ptostr = NULL;
7533         MonoMethod *res;
7534
7535         g_assert (klass != NULL);
7536
7537         mono_marshal_load_type_info (klass);
7538
7539         if (klass->marshal_info->ptr_to_str)
7540                 return klass->marshal_info->ptr_to_str;
7541
7542         if (!ptostr)
7543                 /* Create the signature corresponding to
7544                           static void PtrToStructure (IntPtr ptr, object structure);
7545                    defined in class/corlib/System.Runtime.InteropServices/Marshal.cs */
7546                 ptostr = mono_create_icall_signature ("void ptr object");
7547
7548         mb = mono_mb_new (klass, "PtrToStructure", MONO_WRAPPER_UNKNOWN);
7549
7550         if (klass->blittable) {
7551                 mono_mb_emit_byte (mb, CEE_LDARG_1);
7552                 mono_mb_emit_ldflda (mb, sizeof (MonoObject));
7553                 mono_mb_emit_byte (mb, CEE_LDARG_0);
7554                 mono_mb_emit_icon (mb, mono_class_value_size (klass, NULL));
7555                 mono_mb_emit_byte (mb, CEE_PREFIX1);
7556                 mono_mb_emit_byte (mb, CEE_CPBLK);
7557         } else {
7558
7559                 /* allocate local 0 (pointer) src_ptr */
7560                 mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
7561                 /* allocate local 1 (pointer) dst_ptr */
7562                 mono_mb_add_local (mb, &klass->this_arg);
7563
7564                 /* initialize src_ptr to point to the start of object data */
7565                 mono_mb_emit_byte (mb, CEE_LDARG_0);
7566                 mono_mb_emit_stloc (mb, 0);
7567
7568                 /* initialize dst_ptr */
7569                 mono_mb_emit_byte (mb, CEE_LDARG_1);
7570                 mono_mb_emit_byte (mb, CEE_UNBOX);
7571                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, klass));
7572                 mono_mb_emit_stloc (mb, 1);
7573
7574                 emit_struct_conv (mb, klass, TRUE);
7575         }
7576
7577         mono_mb_emit_byte (mb, CEE_RET);
7578
7579         res = mono_mb_create_method (mb, ptostr, 0);
7580         mono_mb_free (mb);
7581
7582         klass->marshal_info->ptr_to_str = res;
7583         return res;
7584 }
7585
7586 /*
7587  * generates IL code for the synchronized wrapper: the generated method
7588  * calls METHOD while locking 'this' or the parent type.
7589  */
7590 MonoMethod *
7591 mono_marshal_get_synchronized_wrapper (MonoMethod *method)
7592 {
7593         static MonoMethod *enter_method, *exit_method;
7594         MonoMethodSignature *sig;
7595         MonoExceptionClause *clause;
7596         MonoMethodHeader *header;
7597         MonoMethodBuilder *mb;
7598         MonoMethod *res;
7599         GHashTable *cache;
7600         int i, pos, this_local, ret_local = 0;
7601
7602         g_assert (method);
7603
7604         if (method->wrapper_type == MONO_WRAPPER_SYNCHRONIZED)
7605                 return method;
7606
7607         cache = method->klass->image->synchronized_cache;
7608         if ((res = mono_marshal_find_in_cache (cache, method)))
7609                 return res;
7610
7611         sig = signature_dup (method->klass->image, mono_method_signature (method));
7612         sig->pinvoke = 0;
7613
7614         mb = mono_mb_new (method->klass, method->name, MONO_WRAPPER_SYNCHRONIZED);
7615
7616         /* result */
7617         if (!MONO_TYPE_IS_VOID (sig->ret))
7618                 ret_local = mono_mb_add_local (mb, sig->ret);
7619
7620         /* this */
7621         this_local = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
7622
7623         mono_loader_lock ();
7624         clause = mono_mempool_alloc0 (method->klass->image->mempool, sizeof (MonoExceptionClause));
7625         mono_loader_unlock ();
7626         clause->flags = MONO_EXCEPTION_CLAUSE_FINALLY;
7627
7628         if (!enter_method) {
7629                 MonoMethodDesc *desc;
7630
7631                 desc = mono_method_desc_new ("Monitor:Enter", FALSE);
7632                 enter_method = mono_method_desc_search_in_class (desc, mono_defaults.monitor_class);
7633                 g_assert (enter_method);
7634                 mono_method_desc_free (desc);
7635                 desc = mono_method_desc_new ("Monitor:Exit", FALSE);
7636                 exit_method = mono_method_desc_search_in_class (desc, mono_defaults.monitor_class);
7637                 g_assert (exit_method);
7638                 mono_method_desc_free (desc);
7639         }
7640
7641         /* Push this or the type object */
7642         if (method->flags & METHOD_ATTRIBUTE_STATIC) {
7643                 /*
7644                  * GetTypeFromHandle isn't called as a managed method because it has
7645                  * a funky calling sequence, e.g. ldtoken+GetTypeFromHandle gets
7646                  * transformed into something else by the JIT.
7647                  */
7648                 mono_mb_emit_ptr (mb, &method->klass->byval_arg);
7649                 mono_mb_emit_icall (mb, type_from_handle);
7650         }
7651         else
7652                 mono_mb_emit_ldarg (mb, 0);
7653         mono_mb_emit_stloc (mb, this_local);
7654
7655         /* Call Monitor::Enter() */
7656         mono_mb_emit_ldloc (mb, this_local);
7657         mono_mb_emit_managed_call (mb, enter_method, NULL);
7658
7659         clause->try_offset = mb->pos;
7660
7661         /* Call the method */
7662         if (sig->hasthis)
7663                 mono_mb_emit_ldarg (mb, 0);
7664         for (i = 0; i < sig->param_count; i++)
7665                 mono_mb_emit_ldarg (mb, i + (sig->hasthis == TRUE));
7666
7667         /* this is needed to avoid recursion */
7668         mono_mb_emit_byte (mb, CEE_PREFIX1);
7669         mono_mb_emit_byte (mb, CEE_LDFTN);
7670         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, method));
7671         mono_mb_emit_calli (mb, mono_method_signature (method));
7672
7673         if (!MONO_TYPE_IS_VOID (sig->ret))
7674                 mono_mb_emit_stloc (mb, ret_local);
7675
7676         mono_mb_emit_byte (mb, CEE_LEAVE);
7677         pos = mb->pos;
7678         mono_mb_emit_i4 (mb, 0);
7679
7680         clause->try_len = mb->pos - clause->try_offset;
7681         clause->handler_offset = mb->pos;
7682
7683         /* Call Monitor::Exit() */
7684         mono_mb_emit_ldloc (mb, this_local);
7685 /*      mono_mb_emit_native_call (mb, exit_sig, mono_monitor_exit); */
7686         mono_mb_emit_managed_call (mb, exit_method, NULL);
7687         mono_mb_emit_byte (mb, CEE_ENDFINALLY);
7688
7689         clause->handler_len = mb->pos - clause->handler_offset;
7690
7691         mono_mb_patch_addr (mb, pos, mb->pos - (pos + 4));
7692         if (!MONO_TYPE_IS_VOID (sig->ret))
7693                 mono_mb_emit_ldloc (mb, ret_local);
7694         mono_mb_emit_byte (mb, CEE_RET);
7695
7696         res = mono_mb_create_and_cache (cache, method,
7697                                                                         mb, sig, sig->param_count + 16);
7698         mono_mb_free (mb);
7699
7700         header = ((MonoMethodNormal *)res)->header;
7701         header->num_clauses = 1;
7702         header->clauses = clause;
7703
7704         return res;
7705 }
7706
7707
7708 /*
7709  * the returned method calls 'method' unboxing the this argument
7710  */
7711 MonoMethod *
7712 mono_marshal_get_unbox_wrapper (MonoMethod *method)
7713 {
7714         MonoMethodSignature *sig = mono_method_signature (method);
7715         int i;
7716         MonoMethodBuilder *mb;
7717         MonoMethod *res;
7718         GHashTable *cache;
7719
7720         cache = method->klass->image->unbox_wrapper_cache;
7721         if ((res = mono_marshal_find_in_cache (cache, method)))
7722                 return res;
7723
7724         mb = mono_mb_new (method->klass, method->name, MONO_WRAPPER_UNBOX);
7725
7726         g_assert (sig->hasthis);
7727
7728         mono_mb_emit_ldarg (mb, 0);
7729         mono_mb_emit_icon (mb, sizeof (MonoObject));
7730         mono_mb_emit_byte (mb, CEE_ADD);
7731         for (i = 0; i < sig->param_count; ++i)
7732                 mono_mb_emit_ldarg (mb, i + 1);
7733         mono_mb_emit_managed_call (mb, method, NULL);
7734         mono_mb_emit_byte (mb, CEE_RET);
7735
7736         res = mono_mb_create_and_cache (cache, method,
7737                                                                                  mb, sig, sig->param_count + 16);
7738         mono_mb_free (mb);
7739
7740         /* printf ("CODE FOR %s: \n%s.\n", mono_method_full_name (res, TRUE), mono_disasm_code (0, res, ((MonoMethodNormal*)res)->header->code, ((MonoMethodNormal*)res)->header->code + ((MonoMethodNormal*)res)->header->code_size)); */
7741
7742         return res;
7743 }
7744
7745 MonoMethod*
7746 mono_marshal_get_stelemref ()
7747 {
7748         static MonoMethod* ret = NULL;
7749         MonoMethodSignature *sig;
7750         MonoMethodBuilder *mb;
7751
7752         guint32 b1, b2, b3, b4;
7753         guint32 copy_pos;
7754         int aklass, vklass;
7755         int array_slot_addr;
7756
7757         if (ret)
7758                 return ret;
7759
7760         mb = mono_mb_new (mono_defaults.object_class, "stelemref", MONO_WRAPPER_STELEMREF);
7761
7762
7763         sig = mono_metadata_signature_alloc (mono_defaults.corlib, 3);
7764
7765         /* void stelemref (void* array, int idx, void* value) */
7766         sig->ret = &mono_defaults.void_class->byval_arg;
7767         sig->params [0] = &mono_defaults.object_class->byval_arg;
7768         sig->params [1] = &mono_defaults.int_class->byval_arg; /* this is a natural sized int */
7769         sig->params [2] = &mono_defaults.object_class->byval_arg;
7770
7771         aklass = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
7772         vklass = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
7773         array_slot_addr = mono_mb_add_local (mb, &mono_defaults.object_class->this_arg);
7774
7775         /*
7776         the method:
7777         <ldelema (bound check)>
7778         if (!value)
7779                 goto store;
7780
7781         aklass = array->vtable->klass->element_class;
7782         vklass = value->vtable->klass;
7783
7784         if (vklass->idepth < aklass->idepth)
7785                 goto long;
7786
7787         if (vklass->supertypes [aklass->idepth - 1] != aklass)
7788                 goto long;
7789
7790         store:
7791                 *array_slot_addr = value;
7792                 return;
7793
7794         long:
7795                 if (mono_object_isinst (value, aklass))
7796                         goto store;
7797
7798                 throw new ArrayTypeMismatchException ();
7799         */
7800
7801         /* ldelema (implicit bound check) */
7802         mono_mb_emit_ldarg (mb, 0);
7803         mono_mb_emit_ldarg (mb, 1);
7804         mono_mb_emit_byte (mb, CEE_LDELEMA);
7805         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, mono_defaults.object_class));
7806         mono_mb_emit_stloc (mb, array_slot_addr);
7807
7808         /* if (!value) goto do_store */
7809         mono_mb_emit_ldarg (mb, 2);
7810         b1 = mono_mb_emit_branch (mb, CEE_BRFALSE);
7811
7812         /* aklass = array->vtable->klass->element_class */
7813         mono_mb_emit_ldarg (mb, 0);
7814         mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoObject, vtable));
7815         mono_mb_emit_byte (mb, CEE_LDIND_I);
7816         mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoVTable, klass));
7817         mono_mb_emit_byte (mb, CEE_LDIND_I);
7818         mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoClass, element_class));
7819         mono_mb_emit_byte (mb, CEE_LDIND_I);
7820         mono_mb_emit_stloc (mb, aklass);
7821
7822         /* vklass = value->vtable->klass */
7823         mono_mb_emit_ldarg (mb, 2);
7824         mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoObject, vtable));
7825         mono_mb_emit_byte (mb, CEE_LDIND_I);
7826         mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoVTable, klass));
7827         mono_mb_emit_byte (mb, CEE_LDIND_I);
7828         mono_mb_emit_stloc (mb, vklass);
7829
7830         /* if (vklass->idepth < aklass->idepth) goto failue */
7831         mono_mb_emit_ldloc (mb, vklass);
7832         mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoClass, idepth));
7833         mono_mb_emit_byte (mb, CEE_LDIND_U2);
7834
7835         mono_mb_emit_ldloc (mb, aklass);
7836         mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoClass, idepth));
7837         mono_mb_emit_byte (mb, CEE_LDIND_U2);
7838
7839         b2 = mono_mb_emit_branch (mb, CEE_BLT_UN);
7840
7841         /* if (vklass->supertypes [aklass->idepth - 1] != aklass) goto failure */
7842         mono_mb_emit_ldloc (mb, vklass);
7843         mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoClass, supertypes));
7844         mono_mb_emit_byte (mb, CEE_LDIND_I);
7845
7846         mono_mb_emit_ldloc (mb, aklass);
7847         mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoClass, idepth));
7848         mono_mb_emit_byte (mb, CEE_LDIND_U2);
7849         mono_mb_emit_icon (mb, 1);
7850         mono_mb_emit_byte (mb, CEE_SUB);
7851         mono_mb_emit_icon (mb, sizeof (void*));
7852         mono_mb_emit_byte (mb, CEE_MUL);
7853         mono_mb_emit_byte (mb, CEE_ADD);
7854         mono_mb_emit_byte (mb, CEE_LDIND_I);
7855
7856         mono_mb_emit_ldloc (mb, aklass);
7857
7858         b3 = mono_mb_emit_branch (mb, CEE_BNE_UN);
7859
7860         copy_pos = mb->pos;
7861         /* do_store */
7862         mono_mb_patch_addr (mb, b1, mb->pos - (b1 + 4));
7863         mono_mb_emit_ldloc (mb, array_slot_addr);
7864         mono_mb_emit_ldarg (mb, 2);
7865         mono_mb_emit_byte (mb, CEE_STIND_REF);
7866
7867         mono_mb_emit_byte (mb, CEE_RET);
7868
7869         /* the hard way */
7870         mono_mb_patch_addr (mb, b2, mb->pos - (b2 + 4));
7871         mono_mb_patch_addr (mb, b3, mb->pos - (b3 + 4));
7872
7873         mono_mb_emit_ldarg (mb, 2);
7874         mono_mb_emit_ldloc (mb, aklass);
7875         mono_mb_emit_icall (mb, mono_object_isinst);
7876
7877         b4 = mono_mb_emit_branch (mb, CEE_BRTRUE);
7878         mono_mb_patch_addr (mb, b4, copy_pos - (b4 + 4));
7879         mono_mb_emit_exception (mb, "ArrayTypeMismatchException", NULL);
7880
7881         mono_mb_emit_byte (mb, CEE_RET);
7882         ret = mono_mb_create_method (mb, sig, 4);
7883         mono_mb_free (mb);
7884         return ret;
7885 }
7886
7887 MonoMethod*
7888 mono_marshal_get_write_barrier (void)
7889 {
7890         static MonoMethod* ret = NULL;
7891         MonoMethodSignature *sig;
7892         MonoMethodBuilder *mb;
7893         int max_stack = 2;
7894
7895         if (ret)
7896                 return ret;
7897
7898         mb = mono_mb_new (mono_defaults.object_class, "writebarrier", MONO_WRAPPER_WRITE_BARRIER);
7899
7900         sig = mono_metadata_signature_alloc (mono_defaults.corlib, 2);
7901
7902         /* void writebarrier (MonoObject** addr, MonoObject* obj) */
7903         sig->ret = &mono_defaults.void_class->byval_arg;
7904         sig->params [0] = &mono_defaults.object_class->this_arg;
7905         sig->params [1] = &mono_defaults.object_class->byval_arg;
7906
7907         /* just the store right now: add an hook for the GC to use, maybe something
7908          * that can be used for stelemref as well
7909          * We need a write barrier variant to be used with struct copies as well, though
7910          * there are also other approaches possible, like writing a wrapper specific to
7911          * the struct or to the reference pattern in the struct...
7912          * Depending on the GC, we may want variants that take the object we store to
7913          * when it is available.
7914          */
7915         mono_mb_emit_ldarg (mb, 0);
7916         mono_mb_emit_ldarg (mb, 1);
7917         mono_mb_emit_icall (mb, mono_gc_wbarrier_generic_store);
7918         /*mono_mb_emit_byte (mb, CEE_STIND_REF);*/
7919
7920         mono_mb_emit_byte (mb, CEE_RET);
7921
7922         ret = mono_mb_create_method (mb, sig, max_stack);
7923         mono_mb_free (mb);
7924         return ret;
7925 }
7926
7927 void*
7928 mono_marshal_alloc (gulong size)
7929 {
7930         gpointer res;
7931
7932 #ifdef PLATFORM_WIN32
7933         res = CoTaskMemAlloc (size);
7934 #else
7935         res = g_try_malloc ((gulong)size);
7936         if (!res)
7937                 mono_gc_out_of_memory ((gulong)size);
7938 #endif
7939         return res;
7940 }
7941
7942 void
7943 mono_marshal_free (gpointer ptr)
7944 {
7945 #ifdef PLATFORM_WIN32
7946         CoTaskMemFree (ptr);
7947 #else
7948         g_free (ptr);
7949 #endif
7950 }
7951
7952 void
7953 mono_marshal_free_array (gpointer *ptr, int size)
7954 {
7955         int i;
7956
7957         if (!ptr)
7958                 return;
7959
7960         for (i = 0; i < size; i++)
7961                 if (ptr [i])
7962                         g_free (ptr [i]);
7963 }
7964
7965 void *
7966 mono_marshal_realloc (gpointer ptr, gpointer size)
7967 {
7968         MONO_ARCH_SAVE_REGS;
7969
7970         return g_try_realloc (ptr, (gulong)size);
7971 }
7972
7973 void *
7974 mono_marshal_string_to_utf16 (MonoString *s)
7975 {
7976         return s ? mono_string_chars (s) : NULL;
7977 }
7978
7979 /**
7980  * mono_marshal_set_last_error:
7981  *
7982  * This function is invoked to set the last error value from a P/Invoke call
7983  * which has SetLastError set.
7984  */
7985 void
7986 mono_marshal_set_last_error (void)
7987 {
7988 #ifdef WIN32
7989         TlsSetValue (last_error_tls_id, GINT_TO_POINTER (GetLastError ()));
7990 #else
7991         TlsSetValue (last_error_tls_id, GINT_TO_POINTER (errno));
7992 #endif
7993 }
7994
7995 static void
7996 mono_marshal_set_last_error_windows (int error)
7997 {
7998 #ifdef WIN32
7999         TlsSetValue (last_error_tls_id, GINT_TO_POINTER (error));
8000 #endif
8001 }
8002
8003 void
8004 ves_icall_System_Runtime_InteropServices_Marshal_copy_to_unmanaged (MonoArray *src, gint32 start_index,
8005                                                                     gpointer dest, gint32 length)
8006 {
8007         int element_size;
8008         void *source_addr;
8009
8010         MONO_ARCH_SAVE_REGS;
8011
8012         MONO_CHECK_ARG_NULL (src);
8013         MONO_CHECK_ARG_NULL (dest);
8014
8015         g_assert (src->obj.vtable->klass->rank == 1);
8016         g_assert (start_index >= 0);
8017         g_assert (length >= 0);
8018         g_assert (start_index + length <= mono_array_length (src));
8019
8020         element_size = mono_array_element_size (src->obj.vtable->klass);
8021
8022         /* no references should be involved */
8023         source_addr = mono_array_addr_with_size (src, element_size, start_index);
8024
8025         memcpy (dest, source_addr, length * element_size);
8026 }
8027
8028 void
8029 ves_icall_System_Runtime_InteropServices_Marshal_copy_from_unmanaged (gpointer src, gint32 start_index,
8030                                                                       MonoArray *dest, gint32 length)
8031 {
8032         int element_size;
8033         void *dest_addr;
8034
8035         MONO_ARCH_SAVE_REGS;
8036
8037         MONO_CHECK_ARG_NULL (src);
8038         MONO_CHECK_ARG_NULL (dest);
8039
8040         g_assert (dest->obj.vtable->klass->rank == 1);
8041         g_assert (start_index >= 0);
8042         g_assert (length >= 0);
8043         g_assert (start_index + length <= mono_array_length (dest));
8044
8045         element_size = mono_array_element_size (dest->obj.vtable->klass);
8046
8047         /* no references should be involved */
8048         dest_addr = mono_array_addr_with_size (dest, element_size, start_index);
8049
8050         memcpy (dest_addr, src, length * element_size);
8051 }
8052
8053 #if NO_UNALIGNED_ACCESS
8054 #define RETURN_UNALIGNED(type, addr) \
8055         { \
8056                 type val; \
8057                 memcpy(&val, p + offset, sizeof(val)); \
8058                 return val; \
8059         }
8060 #define WRITE_UNALIGNED(type, addr, val) \
8061         memcpy(addr, &val, sizeof(type))
8062 #else
8063 #define RETURN_UNALIGNED(type, addr) \
8064         return *(type*)(p + offset);
8065 #define WRITE_UNALIGNED(type, addr, val) \
8066         (*(type *)(addr) = (val))
8067 #endif
8068
8069 gpointer
8070 ves_icall_System_Runtime_InteropServices_Marshal_ReadIntPtr (gpointer ptr, gint32 offset)
8071 {
8072         char *p = ptr;
8073
8074         MONO_ARCH_SAVE_REGS;
8075
8076         RETURN_UNALIGNED(gpointer, p + offset);
8077 }
8078
8079 unsigned char
8080 ves_icall_System_Runtime_InteropServices_Marshal_ReadByte (gpointer ptr, gint32 offset)
8081 {
8082         char *p = ptr;
8083
8084         MONO_ARCH_SAVE_REGS;
8085
8086         return *(unsigned char*)(p + offset);
8087 }
8088
8089 gint16
8090 ves_icall_System_Runtime_InteropServices_Marshal_ReadInt16 (gpointer ptr, gint32 offset)
8091 {
8092         char *p = ptr;
8093
8094         MONO_ARCH_SAVE_REGS;
8095
8096         RETURN_UNALIGNED(gint16, p + offset);
8097 }
8098
8099 gint32
8100 ves_icall_System_Runtime_InteropServices_Marshal_ReadInt32 (gpointer ptr, gint32 offset)
8101 {
8102         char *p = ptr;
8103
8104         MONO_ARCH_SAVE_REGS;
8105
8106         RETURN_UNALIGNED(gint32, p + offset);
8107 }
8108
8109 gint64
8110 ves_icall_System_Runtime_InteropServices_Marshal_ReadInt64 (gpointer ptr, gint32 offset)
8111 {
8112         char *p = ptr;
8113
8114         MONO_ARCH_SAVE_REGS;
8115
8116         RETURN_UNALIGNED(gint64, p + offset);
8117 }
8118
8119 void
8120 ves_icall_System_Runtime_InteropServices_Marshal_WriteByte (gpointer ptr, gint32 offset, unsigned char val)
8121 {
8122         char *p = ptr;
8123
8124         MONO_ARCH_SAVE_REGS;
8125
8126         *(unsigned char*)(p + offset) = val;
8127 }
8128
8129 void
8130 ves_icall_System_Runtime_InteropServices_Marshal_WriteIntPtr (gpointer ptr, gint32 offset, gpointer val)
8131 {
8132         char *p = ptr;
8133
8134         MONO_ARCH_SAVE_REGS;
8135
8136         WRITE_UNALIGNED(gpointer, p + offset, val);
8137 }
8138
8139 void
8140 ves_icall_System_Runtime_InteropServices_Marshal_WriteInt16 (gpointer ptr, gint32 offset, gint16 val)
8141 {
8142         char *p = ptr;
8143
8144         MONO_ARCH_SAVE_REGS;
8145
8146         WRITE_UNALIGNED(gint16, p + offset, val);
8147 }
8148
8149 void
8150 ves_icall_System_Runtime_InteropServices_Marshal_WriteInt32 (gpointer ptr, gint32 offset, gint32 val)
8151 {
8152         char *p = ptr;
8153
8154         MONO_ARCH_SAVE_REGS;
8155
8156         WRITE_UNALIGNED(gint32, p + offset, val);
8157 }
8158
8159 void
8160 ves_icall_System_Runtime_InteropServices_Marshal_WriteInt64 (gpointer ptr, gint32 offset, gint64 val)
8161 {
8162         char *p = ptr;
8163
8164         MONO_ARCH_SAVE_REGS;
8165
8166         WRITE_UNALIGNED(gint64, p + offset, val);
8167 }
8168
8169 MonoString *
8170 ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringAnsi (char *ptr)
8171 {
8172         MONO_ARCH_SAVE_REGS;
8173
8174         if (ptr == NULL)
8175                 return NULL;
8176         else
8177                 return mono_string_new (mono_domain_get (), ptr);
8178 }
8179
8180 MonoString *
8181 ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringAnsi_len (char *ptr, gint32 len)
8182 {
8183         MONO_ARCH_SAVE_REGS;
8184
8185         if (ptr == NULL) {
8186                 mono_raise_exception (mono_get_exception_argument_null ("ptr"));
8187                 g_assert_not_reached ();
8188                 return NULL;
8189         } else
8190                 return mono_string_new_len (mono_domain_get (), ptr, len);
8191 }
8192
8193 MonoString *
8194 ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringUni (guint16 *ptr)
8195 {
8196         MonoDomain *domain = mono_domain_get ();
8197         int len = 0;
8198         guint16 *t = ptr;
8199
8200         MONO_ARCH_SAVE_REGS;
8201
8202         if (ptr == NULL)
8203                 return NULL;
8204
8205         while (*t++)
8206                 len++;
8207
8208         return mono_string_new_utf16 (domain, ptr, len);
8209 }
8210
8211 MonoString *
8212 ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringUni_len (guint16 *ptr, gint32 len)
8213 {
8214         MonoDomain *domain = mono_domain_get ();
8215
8216         MONO_ARCH_SAVE_REGS;
8217
8218         if (ptr == NULL) {
8219                 mono_raise_exception (mono_get_exception_argument_null ("ptr"));
8220                 g_assert_not_reached ();
8221                 return NULL;
8222         } else
8223                 return mono_string_new_utf16 (domain, ptr, len);
8224 }
8225
8226 MonoString *
8227 ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringBSTR (gpointer ptr)
8228 {
8229         MONO_ARCH_SAVE_REGS;
8230
8231         return mono_string_from_bstr(ptr);
8232 }
8233
8234 gpointer
8235 ves_icall_System_Runtime_InteropServices_Marshal_StringToBSTR (MonoString* ptr)
8236 {
8237         MONO_ARCH_SAVE_REGS;
8238
8239         return mono_string_to_bstr(ptr);
8240 }
8241
8242 void
8243 ves_icall_System_Runtime_InteropServices_Marshal_FreeBSTR (gpointer ptr)
8244 {
8245         MONO_ARCH_SAVE_REGS;
8246
8247         mono_free_bstr (ptr);
8248 }
8249
8250 guint32
8251 ves_icall_System_Runtime_InteropServices_Marshal_GetComSlotForMethodInfoInternal (MonoReflectionMethod *m)
8252 {
8253         MONO_ARCH_SAVE_REGS;
8254         static MonoClass *interface_type_attribute = NULL;
8255         MonoInterfaceTypeAttribute* itf_attr = NULL;
8256         MonoCustomAttrInfo *cinfo = NULL;
8257         guint32 offset = 7;
8258
8259         if (!interface_type_attribute)
8260                 interface_type_attribute = mono_class_from_name (mono_defaults.corlib, "System.Runtime.InteropServices", "InterfaceTypeAttribute");
8261         cinfo = mono_custom_attrs_from_class (m->method->klass);
8262         if (cinfo) {
8263                 itf_attr = (MonoInterfaceTypeAttribute*)mono_custom_attrs_get_attr (cinfo, interface_type_attribute);
8264                 if (!cinfo->cached)
8265                         mono_custom_attrs_free (cinfo);
8266         }
8267
8268         if (itf_attr && itf_attr->intType == 1)
8269                 offset = 3; /* 3 methods in IUnknown*/
8270         else
8271                 offset = 7; /* 7 methods in IDispatch*/
8272
8273         return m->method->slot + offset;
8274 }
8275
8276 guint32
8277 ves_icall_System_Runtime_InteropServices_Marshal_GetLastWin32Error (void)
8278 {
8279         MONO_ARCH_SAVE_REGS;
8280
8281         return (GPOINTER_TO_INT (TlsGetValue (last_error_tls_id)));
8282 }
8283
8284 guint32
8285 ves_icall_System_Runtime_InteropServices_Marshal_SizeOf (MonoReflectionType *rtype)
8286 {
8287         MonoClass *klass;
8288         MonoType *type;
8289         guint32 layout;
8290
8291         MONO_ARCH_SAVE_REGS;
8292
8293         MONO_CHECK_ARG_NULL (rtype);
8294
8295         type = rtype->type;
8296         klass = mono_class_from_mono_type (type);
8297         layout = (klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK);
8298
8299         if (layout == TYPE_ATTRIBUTE_AUTO_LAYOUT) {
8300                 gchar *msg;
8301                 MonoException *exc;
8302
8303                 msg = g_strdup_printf ("Type %s cannot be marshaled as an unmanaged structure.", klass->name);
8304                 exc = mono_get_exception_argument ("t", msg);
8305                 g_free (msg);
8306                 mono_raise_exception (exc);
8307         }
8308
8309
8310         return mono_class_native_size (klass, NULL);
8311 }
8312
8313 void
8314 ves_icall_System_Runtime_InteropServices_Marshal_StructureToPtr (MonoObject *obj, gpointer dst, MonoBoolean delete_old)
8315 {
8316         MonoMethod *method;
8317         gpointer pa [3];
8318
8319         MONO_ARCH_SAVE_REGS;
8320
8321         MONO_CHECK_ARG_NULL (obj);
8322         MONO_CHECK_ARG_NULL (dst);
8323
8324         method = mono_marshal_get_struct_to_ptr (obj->vtable->klass);
8325
8326         pa [0] = obj;
8327         pa [1] = &dst;
8328         pa [2] = &delete_old;
8329
8330         mono_runtime_invoke (method, NULL, pa, NULL);
8331 }
8332
8333 static void
8334 ptr_to_structure (gpointer src, MonoObject *dst)
8335 {
8336         MonoMethod *method;
8337         gpointer pa [2];
8338
8339         method = mono_marshal_get_ptr_to_struct (dst->vtable->klass);
8340
8341         pa [0] = &src;
8342         pa [1] = dst;
8343
8344         mono_runtime_invoke (method, NULL, pa, NULL);
8345 }
8346
8347 void
8348 ves_icall_System_Runtime_InteropServices_Marshal_PtrToStructure (gpointer src, MonoObject *dst)
8349 {
8350         MonoType *t;
8351
8352         MONO_ARCH_SAVE_REGS;
8353
8354         MONO_CHECK_ARG_NULL (src);
8355         MONO_CHECK_ARG_NULL (dst);
8356
8357         t = mono_type_get_underlying_type (mono_class_get_type (dst->vtable->klass));
8358
8359         if (t->type == MONO_TYPE_VALUETYPE) {
8360                 MonoException *exc;
8361                 gchar *tmp;
8362
8363                 tmp = g_strdup_printf ("Destination is a boxed value type.");
8364                 exc = mono_get_exception_argument ("dst", tmp);
8365                 g_free (tmp);
8366
8367                 mono_raise_exception (exc);
8368                 return;
8369         }
8370
8371         ptr_to_structure (src, dst);
8372 }
8373
8374 MonoObject *
8375 ves_icall_System_Runtime_InteropServices_Marshal_PtrToStructure_type (gpointer src, MonoReflectionType *type)
8376 {
8377         MonoDomain *domain = mono_domain_get ();
8378         MonoObject *res;
8379
8380         MONO_ARCH_SAVE_REGS;
8381
8382         MONO_CHECK_ARG_NULL (src);
8383         MONO_CHECK_ARG_NULL (type);
8384
8385         res = mono_object_new (domain, mono_class_from_mono_type (type->type));
8386
8387         ptr_to_structure (src, res);
8388
8389         return res;
8390 }
8391
8392 int
8393 ves_icall_System_Runtime_InteropServices_Marshal_OffsetOf (MonoReflectionType *type, MonoString *field_name)
8394 {
8395         MonoMarshalType *info;
8396         MonoClass *klass;
8397         char *fname;
8398         int match_index = -1;
8399
8400         MONO_ARCH_SAVE_REGS;
8401
8402         MONO_CHECK_ARG_NULL (type);
8403         MONO_CHECK_ARG_NULL (field_name);
8404
8405         fname = mono_string_to_utf8 (field_name);
8406         klass = mono_class_from_mono_type (type->type);
8407
8408         while (klass && match_index == -1) {
8409                 MonoClassField* field;
8410                 int i = 0;
8411                 gpointer iter = NULL;
8412                 while ((field = mono_class_get_fields (klass, &iter))) {
8413                         if (field->type->attrs & FIELD_ATTRIBUTE_STATIC)
8414                                 continue;
8415                         if (!strcmp (fname, field->name)) {
8416                                 match_index = i;
8417                                 break;
8418                         }
8419                         i ++;
8420                 }
8421
8422                 if (match_index == -1)
8423                         klass = klass->parent;
8424         }
8425
8426         g_free (fname);
8427
8428         if(match_index == -1) {
8429                 MonoException* exc;
8430                 gchar *tmp;
8431
8432                 /* Get back original class instance */
8433                 klass = mono_class_from_mono_type (type->type);
8434
8435                 tmp = g_strdup_printf ("Field passed in is not a marshaled member of the type %s", klass->name);
8436                 exc = mono_get_exception_argument ("fieldName", tmp);
8437                 g_free (tmp);
8438
8439                 mono_raise_exception ((MonoException*)exc);
8440         }
8441
8442         info = mono_marshal_load_type_info (klass);
8443         return info->fields [match_index].offset;
8444 }
8445
8446 gpointer
8447 ves_icall_System_Runtime_InteropServices_Marshal_StringToHGlobalAnsi (MonoString *string)
8448 {
8449         MONO_ARCH_SAVE_REGS;
8450
8451         return mono_string_to_utf8 (string);
8452 }
8453
8454 gpointer
8455 ves_icall_System_Runtime_InteropServices_Marshal_StringToHGlobalUni (MonoString *string)
8456 {
8457         MONO_ARCH_SAVE_REGS;
8458
8459         if (string == NULL)
8460                 return NULL;
8461         else {
8462                 gunichar2 *res = g_malloc ((mono_string_length (string) + 1) * 2);
8463                 memcpy (res, mono_string_chars (string), mono_string_length (string) * 2);
8464                 res [mono_string_length (string)] = 0;
8465                 return res;
8466         }
8467 }
8468
8469 static void
8470 mono_struct_delete_old (MonoClass *klass, char *ptr)
8471 {
8472         MonoMarshalType *info;
8473         int i;
8474
8475         info = mono_marshal_load_type_info (klass);
8476
8477         for (i = 0; i < info->num_fields; i++) {
8478                 MonoMarshalNative ntype;
8479                 MonoMarshalConv conv;
8480                 MonoType *ftype = info->fields [i].field->type;
8481                 char *cpos;
8482
8483                 if (ftype->attrs & FIELD_ATTRIBUTE_STATIC)
8484                         continue;
8485
8486                 ntype = mono_type_to_unmanaged (ftype, info->fields [i].mspec, TRUE,
8487                                                 klass->unicode, &conv);
8488
8489                 cpos = ptr + info->fields [i].offset;
8490
8491                 switch (conv) {
8492                 case MONO_MARSHAL_CONV_NONE:
8493                         if (MONO_TYPE_ISSTRUCT (ftype)) {
8494                                 mono_struct_delete_old (ftype->data.klass, cpos);
8495                                 continue;
8496                         }
8497                         break;
8498                 case MONO_MARSHAL_CONV_STR_LPWSTR:
8499                         /* We assume this field points inside a MonoString */
8500                         break;
8501                 case MONO_MARSHAL_CONV_STR_LPSTR:
8502                 case MONO_MARSHAL_CONV_STR_LPTSTR:
8503                 case MONO_MARSHAL_CONV_STR_BSTR:
8504                 case MONO_MARSHAL_CONV_STR_ANSIBSTR:
8505                 case MONO_MARSHAL_CONV_STR_TBSTR:
8506                         mono_marshal_free (*(gpointer *)cpos);
8507                         break;
8508                 default:
8509                         continue;
8510                 }
8511         }
8512 }
8513
8514 void
8515 ves_icall_System_Runtime_InteropServices_Marshal_DestroyStructure (gpointer src, MonoReflectionType *type)
8516 {
8517         MonoClass *klass;
8518
8519         MONO_ARCH_SAVE_REGS;
8520
8521         MONO_CHECK_ARG_NULL (src);
8522         MONO_CHECK_ARG_NULL (type);
8523
8524         klass = mono_class_from_mono_type (type->type);
8525
8526         mono_struct_delete_old (klass, (char *)src);
8527 }
8528
8529
8530 /* FIXME: on win32 we should probably use GlobalAlloc(). */
8531 void*
8532 ves_icall_System_Runtime_InteropServices_Marshal_AllocHGlobal (int size)
8533 {
8534         gpointer res;
8535
8536         MONO_ARCH_SAVE_REGS;
8537
8538         if ((gulong)size == 0)
8539                 /* This returns a valid pointer for size 0 on MS.NET */
8540                 size = 4;
8541
8542         res = g_try_malloc ((gulong)size);
8543         if (!res)
8544                 mono_gc_out_of_memory ((gulong)size);
8545
8546         return res;
8547 }
8548
8549 void
8550 ves_icall_System_Runtime_InteropServices_Marshal_FreeHGlobal (void *ptr)
8551 {
8552         MONO_ARCH_SAVE_REGS;
8553
8554         g_free (ptr);
8555 }
8556
8557 void*
8558 ves_icall_System_Runtime_InteropServices_Marshal_AllocCoTaskMem (int size)
8559 {
8560         MONO_ARCH_SAVE_REGS;
8561
8562 #ifdef PLATFORM_WIN32
8563         return CoTaskMemAlloc (size);
8564 #else
8565         return g_try_malloc ((gulong)size);
8566 #endif
8567 }
8568
8569 void
8570 ves_icall_System_Runtime_InteropServices_Marshal_FreeCoTaskMem (void *ptr)
8571 {
8572         MONO_ARCH_SAVE_REGS;
8573
8574 #ifdef PLATFORM_WIN32
8575         CoTaskMemFree (ptr);
8576 #else
8577         g_free (ptr);
8578 #endif
8579 }
8580
8581 void*
8582 ves_icall_System_Runtime_InteropServices_Marshal_UnsafeAddrOfPinnedArrayElement (MonoArray *arrayobj, int index)
8583 {
8584         return mono_array_addr_with_size (arrayobj, mono_array_element_size (arrayobj->obj.vtable->klass), index);
8585 }
8586
8587 MonoDelegate*
8588 ves_icall_System_Runtime_InteropServices_Marshal_GetDelegateForFunctionPointerInternal (void *ftn, MonoReflectionType *type)
8589 {
8590         return mono_ftnptr_to_delegate (mono_type_get_class (type->type), ftn);
8591 }
8592
8593 MonoMarshalType *
8594 mono_marshal_load_type_info (MonoClass* klass)
8595 {
8596         int j, count = 0;
8597         guint32 native_size = 0, min_align = 1;
8598         MonoMarshalType *info;
8599         MonoClassField* field;
8600         gpointer iter;
8601         guint32 layout;
8602
8603         g_assert (klass != NULL);
8604
8605         if (klass->marshal_info)
8606                 return klass->marshal_info;
8607
8608         if (!klass->inited)
8609                 mono_class_init (klass);
8610
8611         iter = NULL;
8612         while ((field = mono_class_get_fields (klass, &iter))) {
8613                 if (field->type->attrs & FIELD_ATTRIBUTE_STATIC)
8614                         continue;
8615                 if (mono_field_is_deleted (field))
8616                         continue;
8617                 count++;
8618         }
8619
8620         layout = klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK;
8621
8622         klass->marshal_info = info = g_malloc0 (sizeof (MonoMarshalType) + sizeof (MonoMarshalField) * count);
8623         info->num_fields = count;
8624
8625         /* Try to find a size for this type in metadata */
8626         mono_metadata_packing_from_typedef (klass->image, klass->type_token, NULL, &native_size);
8627
8628         if (klass->parent) {
8629                 int parent_size = mono_class_native_size (klass->parent, NULL);
8630
8631                 /* Add parent size to real size */
8632                 native_size += parent_size;
8633                 info->native_size = parent_size;
8634         }
8635
8636         iter = NULL;
8637         j = 0;
8638         while ((field = mono_class_get_fields (klass, &iter))) {
8639                 int size;
8640                 guint32 align;
8641
8642                 if (field->type->attrs & FIELD_ATTRIBUTE_STATIC)
8643                         continue;
8644
8645                 if (mono_field_is_deleted (field))
8646                         continue;
8647                 if (field->type->attrs & FIELD_ATTRIBUTE_HAS_FIELD_MARSHAL)
8648                         mono_metadata_field_info (klass->image, mono_metadata_token_index (mono_class_get_field_token (field)) - 1,
8649                                                   NULL, NULL, &info->fields [j].mspec);
8650
8651                 info->fields [j].field = field;
8652
8653                 if ((mono_class_num_fields (klass) == 1) && (klass->instance_size == sizeof (MonoObject)) &&
8654                         (strcmp (field->name, "$PRIVATE$") == 0)) {
8655                         /* This field is a hack inserted by MCS to empty structures */
8656                         continue;
8657                 }
8658
8659                 switch (layout) {
8660                 case TYPE_ATTRIBUTE_AUTO_LAYOUT:
8661                 case TYPE_ATTRIBUTE_SEQUENTIAL_LAYOUT:
8662                         size = mono_marshal_type_size (field->type, info->fields [j].mspec,
8663                                                        &align, TRUE, klass->unicode);
8664                         align = klass->packing_size ? MIN (klass->packing_size, align): align;
8665                         min_align = MAX (align, min_align);
8666                         info->fields [j].offset = info->native_size;
8667                         info->fields [j].offset += align - 1;
8668                         info->fields [j].offset &= ~(align - 1);
8669                         info->native_size = info->fields [j].offset + size;
8670                         break;
8671                 case TYPE_ATTRIBUTE_EXPLICIT_LAYOUT:
8672                         size = mono_marshal_type_size (field->type, info->fields [j].mspec,
8673                                                        &align, TRUE, klass->unicode);
8674                         align = klass->packing_size ? MIN (klass->packing_size, align): align;
8675                         min_align = MAX (align, min_align);
8676                         info->fields [j].offset = field->offset - sizeof (MonoObject);
8677                         info->native_size = MAX (info->native_size, info->fields [j].offset + size);
8678                         break;
8679                 }
8680                 j++;
8681         }
8682
8683         if(layout != TYPE_ATTRIBUTE_AUTO_LAYOUT) {
8684                 info->native_size = MAX (native_size, info->native_size);
8685         }
8686
8687         if (info->native_size & (min_align - 1)) {
8688                 info->native_size += min_align - 1;
8689                 info->native_size &= ~(min_align - 1);
8690         }
8691
8692         /* Update the class's blittable info, if the layouts don't match */
8693         if (info->native_size != mono_class_value_size (klass, NULL))
8694                 klass->blittable = FALSE;
8695
8696         /* If this is an array type, ensure that we have element info */
8697         if (klass->element_class) {
8698                 mono_marshal_load_type_info (klass->element_class);
8699         }
8700
8701         return klass->marshal_info;
8702 }
8703
8704 /**
8705  * mono_class_native_size:
8706  * @klass: a class
8707  *
8708  * Returns: the native size of an object instance (when marshaled
8709  * to unmanaged code)
8710  */
8711 gint32
8712 mono_class_native_size (MonoClass *klass, guint32 *align)
8713 {
8714         if (!klass->marshal_info)
8715                 mono_marshal_load_type_info (klass);
8716
8717         if (align)
8718                 *align = klass->min_align;
8719
8720         return klass->marshal_info->native_size;
8721 }
8722
8723 /*
8724  * mono_type_native_stack_size:
8725  * @t: the type to return the size it uses on the stack
8726  *
8727  * Returns: the number of bytes required to hold an instance of this
8728  * type on the native stack
8729  */
8730 int
8731 mono_type_native_stack_size (MonoType *t, guint32 *align)
8732 {
8733         guint32 tmp;
8734
8735         g_assert (t != NULL);
8736
8737         if (!align)
8738                 align = &tmp;
8739
8740         if (t->byref) {
8741                 *align = 4;
8742                 return 4;
8743         }
8744
8745         switch (t->type){
8746         case MONO_TYPE_BOOLEAN:
8747         case MONO_TYPE_CHAR:
8748         case MONO_TYPE_I1:
8749         case MONO_TYPE_U1:
8750         case MONO_TYPE_I2:
8751         case MONO_TYPE_U2:
8752         case MONO_TYPE_I4:
8753         case MONO_TYPE_U4:
8754         case MONO_TYPE_I:
8755         case MONO_TYPE_U:
8756         case MONO_TYPE_STRING:
8757         case MONO_TYPE_OBJECT:
8758         case MONO_TYPE_CLASS:
8759         case MONO_TYPE_SZARRAY:
8760         case MONO_TYPE_PTR:
8761         case MONO_TYPE_FNPTR:
8762         case MONO_TYPE_ARRAY:
8763         case MONO_TYPE_TYPEDBYREF:
8764                 *align = 4;
8765                 return 4;
8766         case MONO_TYPE_R4:
8767                 *align = 4;
8768                 return 4;
8769         case MONO_TYPE_I8:
8770         case MONO_TYPE_U8:
8771         case MONO_TYPE_R8:
8772                 *align = 4;
8773                 return 8;
8774         case MONO_TYPE_VALUETYPE: {
8775                 guint32 size;
8776
8777                 if (t->data.klass->enumtype)
8778                         return mono_type_native_stack_size (t->data.klass->enum_basetype, align);
8779                 else {
8780                         size = mono_class_native_size (t->data.klass, align);
8781                         *align = *align + 3;
8782                         *align &= ~3;
8783
8784                         size +=  3;
8785                         size &= ~3;
8786
8787                         return size;
8788                 }
8789         }
8790         default:
8791                 g_error ("type 0x%02x unknown", t->type);
8792         }
8793         return 0;
8794 }
8795
8796 /* __alignof__ returns the preferred alignment of values not the actual alignment used by
8797    the compiler so is wrong e.g. for Linux where doubles are aligned on a 4 byte boundary
8798    but __alignof__ returns 8 - using G_STRUCT_OFFSET works better */
8799 #define ALIGNMENT(type) G_STRUCT_OFFSET(struct { char c; type x; }, x)
8800
8801 gint32
8802 mono_marshal_type_size (MonoType *type, MonoMarshalSpec *mspec, guint32 *align,
8803                         gboolean as_field, gboolean unicode)
8804 {
8805         MonoMarshalNative native_type = mono_type_to_unmanaged (type, mspec, as_field, unicode, NULL);
8806         MonoClass *klass;
8807
8808         switch (native_type) {
8809         case MONO_NATIVE_BOOLEAN:
8810                 *align = 4;
8811                 return 4;
8812         case MONO_NATIVE_I1:
8813         case MONO_NATIVE_U1:
8814                 *align = 1;
8815                 return 1;
8816         case MONO_NATIVE_I2:
8817         case MONO_NATIVE_U2:
8818         case MONO_NATIVE_VARIANTBOOL:
8819                 *align = 2;
8820                 return 2;
8821         case MONO_NATIVE_I4:
8822         case MONO_NATIVE_U4:
8823         case MONO_NATIVE_ERROR:
8824                 *align = 4;
8825                 return 4;
8826         case MONO_NATIVE_I8:
8827         case MONO_NATIVE_U8:
8828                 *align = ALIGNMENT(guint64);
8829                 return 8;
8830         case MONO_NATIVE_R4:
8831                 *align = 4;
8832                 return 4;
8833         case MONO_NATIVE_R8:
8834                 *align = ALIGNMENT(double);
8835                 return 8;
8836         case MONO_NATIVE_INT:
8837         case MONO_NATIVE_UINT:
8838         case MONO_NATIVE_LPSTR:
8839         case MONO_NATIVE_LPWSTR:
8840         case MONO_NATIVE_LPTSTR:
8841         case MONO_NATIVE_BSTR:
8842         case MONO_NATIVE_ANSIBSTR:
8843         case MONO_NATIVE_TBSTR:
8844         case MONO_NATIVE_LPARRAY:
8845         case MONO_NATIVE_SAFEARRAY:
8846         case MONO_NATIVE_IUNKNOWN:
8847         case MONO_NATIVE_IDISPATCH:
8848         case MONO_NATIVE_INTERFACE:
8849         case MONO_NATIVE_ASANY:
8850         case MONO_NATIVE_FUNC:
8851         case MONO_NATIVE_LPSTRUCT:
8852                 *align = ALIGNMENT(gpointer);
8853                 return sizeof (gpointer);
8854         case MONO_NATIVE_STRUCT:
8855                 klass = mono_class_from_mono_type (type);
8856                 return mono_class_native_size (klass, align);
8857         case MONO_NATIVE_BYVALTSTR: {
8858                 int esize = unicode ? 2: 1;
8859                 g_assert (mspec);
8860                 *align = esize;
8861                 return mspec->data.array_data.num_elem * esize;
8862         }
8863         case MONO_NATIVE_BYVALARRAY: {
8864                 // FIXME: Have to consider ArraySubType
8865                 int esize;
8866                 klass = mono_class_from_mono_type (type);
8867                 if (klass->element_class == mono_defaults.char_class) {
8868                         esize = unicode ? 2 : 1;
8869                         *align = esize;
8870                 } else {
8871                         esize = mono_class_native_size (klass->element_class, align);
8872                 }
8873                 g_assert (mspec);
8874                 return mspec->data.array_data.num_elem * esize;
8875         }
8876         case MONO_NATIVE_CUSTOM:
8877                 g_assert_not_reached ();
8878                 break;
8879         case MONO_NATIVE_CURRENCY:
8880         case MONO_NATIVE_VBBYREFSTR:
8881         default:
8882                 g_error ("native type %02x not implemented", native_type);
8883                 break;
8884         }
8885         g_assert_not_reached ();
8886         return 0;
8887 }
8888
8889 gpointer
8890 mono_marshal_asany (MonoObject *o, MonoMarshalNative string_encoding, int param_attrs)
8891 {
8892         MonoType *t;
8893         MonoClass *klass;
8894
8895         if (o == NULL)
8896                 return NULL;
8897
8898         t = &o->vtable->klass->byval_arg;
8899         switch (t->type) {
8900         case MONO_TYPE_I4:
8901         case MONO_TYPE_U4:
8902         case MONO_TYPE_PTR:
8903         case MONO_TYPE_I1:
8904         case MONO_TYPE_U1:
8905         case MONO_TYPE_BOOLEAN:
8906         case MONO_TYPE_I2:
8907         case MONO_TYPE_U2:
8908         case MONO_TYPE_CHAR:
8909         case MONO_TYPE_I8:
8910         case MONO_TYPE_U8:
8911         case MONO_TYPE_R4:
8912         case MONO_TYPE_R8:
8913                 return mono_object_unbox (o);
8914                 break;
8915         case MONO_TYPE_STRING:
8916                 switch (string_encoding) {
8917                 case MONO_NATIVE_LPWSTR:
8918                         return mono_string_to_utf16 ((MonoString*)o);
8919                         break;
8920                 case MONO_NATIVE_LPSTR:
8921                         return mono_string_to_lpstr ((MonoString*)o);
8922                         break;
8923                 default:
8924                         g_warning ("marshaling conversion %d not implemented", string_encoding);
8925                         g_assert_not_reached ();
8926                 }
8927                 break;
8928         case MONO_TYPE_CLASS:
8929         case MONO_TYPE_VALUETYPE: {
8930                 MonoMethod *method;
8931                 gpointer pa [3];
8932                 gpointer res;
8933                 MonoBoolean delete_old = FALSE;
8934
8935                 klass = t->data.klass;
8936
8937                 if ((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_AUTO_LAYOUT)
8938                         break;
8939
8940                 if (klass->valuetype && (((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) ||
8941                         klass->blittable || klass->enumtype))
8942                         return mono_object_unbox (o);
8943
8944                 res = mono_marshal_alloc (mono_class_native_size (klass, NULL));
8945
8946                 if (!((param_attrs & PARAM_ATTRIBUTE_OUT) && !(param_attrs & PARAM_ATTRIBUTE_IN))) {
8947                         method = mono_marshal_get_struct_to_ptr (o->vtable->klass);
8948
8949                         pa [0] = o;
8950                         pa [1] = &res;
8951                         pa [2] = &delete_old;
8952
8953                         mono_runtime_invoke (method, NULL, pa, NULL);
8954                 }
8955
8956                 return res;
8957         }
8958         }
8959
8960         mono_raise_exception (mono_get_exception_argument ("", "No PInvoke conversion exists for value passed to Object-typed parameter."));
8961
8962         return NULL;
8963 }
8964
8965 void
8966 mono_marshal_free_asany (MonoObject *o, gpointer ptr, MonoMarshalNative string_encoding, int param_attrs)
8967 {
8968         MonoType *t;
8969         MonoClass *klass;
8970
8971         if (o == NULL)
8972                 return;
8973
8974         t = &o->vtable->klass->byval_arg;
8975         switch (t->type) {
8976         case MONO_TYPE_STRING:
8977                 switch (string_encoding) {
8978                 case MONO_NATIVE_LPWSTR:
8979                 case MONO_NATIVE_LPSTR:
8980                         mono_marshal_free (ptr);
8981                         break;
8982                 default:
8983                         g_warning ("marshaling conversion %d not implemented", string_encoding);
8984                         g_assert_not_reached ();
8985                 }
8986                 break;
8987         case MONO_TYPE_CLASS:
8988         case MONO_TYPE_VALUETYPE: {
8989                 klass = t->data.klass;
8990
8991                 if (klass->valuetype && (((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) ||
8992                                                                  klass->blittable || klass->enumtype))
8993                         break;
8994
8995                 if (param_attrs & PARAM_ATTRIBUTE_OUT) {
8996                         MonoMethod *method = mono_marshal_get_ptr_to_struct (o->vtable->klass);
8997                         gpointer pa [2];
8998
8999                         pa [0] = &ptr;
9000                         pa [1] = o;
9001
9002                         mono_runtime_invoke (method, NULL, pa, NULL);
9003                 }
9004
9005                 if (!((param_attrs & PARAM_ATTRIBUTE_OUT) && !(param_attrs & PARAM_ATTRIBUTE_IN))) {
9006                         mono_struct_delete_old (klass, ptr);
9007                 }
9008
9009                 mono_marshal_free (ptr);
9010                 break;
9011         }
9012         default:
9013                 break;
9014         }
9015 }