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                 /* Freed below so don't alloc from mempool */
 394                 sig = mono_metadata_signature_dup (mono_method_signature (invoke));
 395                 sig->hasthis = 0;
 396
 397                 wrapper = mono_marshal_get_native_func_wrapper (sig, &piinfo, mspecs, ftn);
 398
 399                 for (i = mono_method_signature (invoke)->param_count; i >= 0; i--)
 400                         if (mspecs [i])
 401                                 mono_metadata_free_marshal_spec (mspecs [i]);
 402                 g_free (mspecs);
 403                 g_free (sig);
 404
 405                 d = (MonoDelegate*)mono_object_new (mono_domain_get (), klass);
 406                 mono_delegate_ctor ((MonoObject*)d, NULL, mono_compile_method (wrapper));
 407         }
 408
 409         if (d->object.vtable->domain != mono_domain_get ())
 410                 mono_raise_exception (mono_get_exception_not_supported ("Delegates cannot be marshalled from native code into a domain other than their home domain"));
 411
 412         return d;
 413 }
 414
 415 void
 416 mono_delegate_free_ftnptr (MonoDelegate *delegate)
 417 {
 418         MonoJitInfo *ji;
 419         void *ptr;
 420
 421         delegate_hash_table_remove (delegate);
 422
 423         ptr = (gpointer)InterlockedExchangePointer (&delegate->delegate_trampoline, NULL);
 424
 425         if (!delegate->target) {
 426                 /* The wrapper method is shared between delegates -> no need to free it */
 427                 return;
 428         }
 429
 430         if (ptr) {
 431                 ji = mono_jit_info_table_find (mono_domain_get (), mono_get_addr_from_ftnptr (ptr));
 432                 g_assert (ji);
 433
 434                 mono_runtime_free_method (mono_object_domain (delegate), ji->method);
 435         }
 436 }
 437
 438 gpointer
 439 mono_array_to_savearray (MonoArray *array)
 440 {
 441         if (!array)
 442                 return NULL;
 443
 444         g_assert_not_reached ();
 445         return NULL;
 446 }
 447
 448 gpointer
 449 mono_array_to_lparray (MonoArray *array)
 450 {
 451         if (!array)
 452                 return NULL;
 453
 454         /* fixme: maybe we need to make a copy */
 455         return array->vector;
 456 }
 457
 458 static void
 459 mono_byvalarray_to_array (MonoArray *arr, gpointer native_arr, MonoClass *elclass, guint32 elnum)
 460 {
 461         g_assert (arr->obj.vtable->klass->element_class == mono_defaults.char_class);
 462
 463         if (elclass == mono_defaults.byte_class) {
 464                 GError *error = NULL;
 465                 guint16 *ut;
 466                 glong items_written;
 467
 468                 ut = g_utf8_to_utf16 (native_arr, elnum, NULL, &items_written, &error);
 469
 470                 if (!error) {
 471                         memcpy (mono_array_addr (arr, guint16, 0), ut, items_written * sizeof (guint16));
 472                         g_free (ut);
 473                 }
 474                 else
 475                         g_error_free (error);
 476         }
 477         else
 478                 g_assert_not_reached ();
 479 }
 480
 481 static void
 482 mono_array_to_byvalarray (gpointer native_arr, MonoArray *arr, MonoClass *elclass, guint32 elnum)
 483 {
 484         g_assert (arr->obj.vtable->klass->element_class == mono_defaults.char_class);
 485
 486         if (elclass == mono_defaults.byte_class) {
 487                 char *as;
 488                 GError *error = NULL;
 489
 490                 as = g_utf16_to_utf8 (mono_array_addr (arr, gunichar2, 0), mono_array_length (arr), NULL, NULL, &error);
 491                 if (error) {
 492                         MonoException *exc = mono_get_exception_argument ("string", error->message);
 493                         g_error_free (error);
 494                         mono_raise_exception (exc);
 495                 }
 496
 497                 memcpy (native_arr, as, MIN (strlen (as), elnum));
 498                 g_free (as);
 499         }
 500         else
 501                 g_assert_not_reached ();
 502 }
 503
 504 void
 505 mono_string_utf8_to_builder (MonoStringBuilder *sb, char *text)
 506 {
 507         GError *error = NULL;
 508         guint16 *ut;
 509         glong items_written;
 510         int l;
 511
 512         if (!sb || !text)
 513                 return;
 514
 515         l = strlen (text);
 516
 517         ut = g_utf8_to_utf16 (text, l, NULL, &items_written, &error);
 518
 519         if (items_written > mono_stringbuilder_capacity (sb))
 520                 items_written = mono_stringbuilder_capacity (sb);
 521
 522         if (!error) {
 523                 if (! sb->str || sb->str == sb->cached_str) {
 524                         MONO_OBJECT_SETREF (sb, str, mono_string_new_size (mono_domain_get (), items_written));
 525                         sb->cached_str = NULL;
 526                 }
 527
 528                 memcpy (mono_string_chars (sb->str), ut, items_written * 2);
 529                 sb->length = items_written;
 530         } else
 531                 g_error_free (error);
 532
 533         g_free (ut);
 534 }
 535
 536 void
 537 mono_string_utf16_to_builder (MonoStringBuilder *sb, gunichar2 *text)
 538 {
 539         guint32 len;
 540
 541         if (!sb || !text)
 542                 return;
 543
 544         g_assert (mono_string_chars (sb->str) == text);
 545
 546         for (len = 0; text [len] != 0; ++len)
 547                 ;
 548
 549         sb->length = len;
 550 }
 551
 552 gpointer
 553 mono_string_builder_to_utf8 (MonoStringBuilder *sb)
 554 {
 555         GError *error = NULL;
 556         glong *res;
 557         gchar *tmp;
 558
 559         if (!sb)
 560                 return NULL;
 561
 562         res = mono_marshal_alloc (mono_stringbuilder_capacity (sb) + 1);
 563
 564         tmp = g_utf16_to_utf8 (mono_string_chars (sb->str), sb->length, NULL, res, &error);
 565         if (error) {
 566                 g_error_free (error);
 567                 mono_raise_exception (mono_get_exception_execution_engine ("Failed to convert StringBuilder from utf16 to utf8"));
 568         }
 569         else {
 570                 memcpy (res, tmp, sb->length + 1);
 571                 g_free (tmp);
 572         }
 573
 574         return res;
 575 }
 576
 577 gpointer
 578 mono_string_builder_to_utf16 (MonoStringBuilder *sb)
 579 {
 580         if (!sb)
 581                 return NULL;
 582
 583         /*
 584          * The sb could have been allocated with the default capacity and be empty.
 585          * we need to alloc a buffer of the default capacity in this case.
 586          */
 587         if (! sb->str)
 588                 MONO_OBJECT_SETREF (sb, str, mono_string_new_size (mono_domain_get (), mono_stringbuilder_capacity (sb)));
 589         /*
 590          * The stringbuilder might not have ownership of this string. If this is
 591          * the case, we must duplicate the string, so that we don't munge immutable
 592          * strings
 593          */
 594         else if (sb->str == sb->cached_str) {
 595                 MONO_OBJECT_SETREF (sb, str, mono_string_new_utf16 (mono_domain_get (), mono_string_chars (sb->str), mono_stringbuilder_capacity (sb)));
 596                 sb->cached_str = NULL;
 597         }
 598
 599         return mono_string_chars (sb->str);
 600 }
 601
 602 static gpointer
 603 mono_string_to_lpstr (MonoString *s)
 604 {
 605 #ifdef PLATFORM_WIN32
 606         char *as, *tmp;
 607         glong len;
 608         GError *error = NULL;
 609
 610         if (s == NULL)
 611                 return NULL;
 612
 613         if (!s->length) {
 614                 as = CoTaskMemAlloc (1);
 615                 as [0] = '\0';
 616                 return as;
 617         }
 618
 619         tmp = g_utf16_to_utf8 (mono_string_chars (s), s->length, NULL, &len, &error);
 620         if (error) {
 621                 MonoException *exc = mono_get_exception_argument ("string", error->message);
 622                 g_error_free (error);
 623                 mono_raise_exception(exc);
 624                 return NULL;
 625         }
 626         else {
 627                 as = CoTaskMemAlloc (len + 1);
 628                 memcpy (as, tmp, len + 1);
 629                 return as;
 630         }
 631 #else
 632         return mono_string_to_utf8 (s);
 633 #endif
 634 }
 635
 636 gpointer
 637 mono_string_to_ansibstr (MonoString *string_obj)
 638 {
 639         g_error ("UnmanagedMarshal.BStr is not implemented.");
 640         return NULL;
 641 }
 642
 643 gpointer
 644 mono_string_to_bstr (MonoString *string_obj)
 645 {
 646 #ifdef PLATFORM_WIN32
 647         return SysAllocStringLen (mono_string_chars (string_obj), mono_string_length (string_obj));
 648 #else
 649         g_error ("UnmanagedMarshal.BStr is not implemented.");
 650         return NULL;
 651 #endif
 652 }
 653
 654 MonoString *
 655 mono_string_from_bstr (gpointer bstr)
 656 {
 657 #ifdef PLATFORM_WIN32
 658         MonoDomain *domain = mono_domain_get ();
 659         return mono_string_new_utf16 (domain, bstr, SysStringLen (bstr));
 660 #else
 661         g_error ("UnmanagedMarshal.BStr is not implemented.");
 662         return NULL;
 663 #endif
 664 }
 665
 666 void
 667 mono_free_bstr (gpointer bstr)
 668 {
 669 #ifdef PLATFORM_WIN32
 670         SysFreeString ((BSTR)bstr);
 671 #else
 672         g_error ("Free BSTR is not implemented.");
 673 #endif
 674 }
 675
 676 void
 677 mono_string_to_byvalstr (gpointer dst, MonoString *src, int size)
 678 {
 679         char *s;
 680         int len;
 681
 682         g_assert (dst != NULL);
 683         g_assert (size > 0);
 684
 685         memset (dst, 0, size);
 686
 687         if (!src)
 688                 return;
 689
 690         s = mono_string_to_utf8 (src);
 691         len = MIN (size, strlen (s));
 692         memcpy (dst, s, len);
 693         g_free (s);
 694
 695         *((char *)dst + size - 1) = 0;
 696 }
 697
 698 void
 699 mono_string_to_byvalwstr (gpointer dst, MonoString *src, int size)
 700 {
 701         int len;
 702
 703         g_assert (dst != NULL);
 704         g_assert (size > 1);
 705
 706         if (!src) {
 707                 memset (dst, 0, size * 2);
 708                 return;
 709         }
 710
 711         len = MIN (size, (mono_string_length (src)));
 712         memcpy (dst, mono_string_chars (src), len * 2);
 713
 714         *((gunichar2 *)dst + len - 1) = 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_GENERICINST:
3854                         if (!mono_type_generic_inst_is_valuetype (sig->params [i])) {
3855                                 /* do nothing */
3856                                 break;
3857                         }
3858
3859                         /* fall through */
3860                 case MONO_TYPE_VALUETYPE:
3861                         if (t->data.klass->enumtype) {
3862                                 type = t->data.klass->enum_basetype->type;
3863                                 goto handle_enum;
3864                         }
3865                         if (mono_class_is_nullable (mono_class_from_mono_type (sig->params [i]))) {
3866                                 /* Need to convert a boxed vtype to an mp to a Nullable struct */
3867                                 mono_mb_emit_byte (mb, CEE_UNBOX);
3868                                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, mono_class_from_mono_type (sig->params [i])));
3869                                 mono_mb_emit_byte (mb, CEE_LDOBJ);
3870                                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, mono_class_from_mono_type (sig->params [i])));
3871                         } else {
3872                                 mono_mb_emit_byte (mb, CEE_LDOBJ);
3873                                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, mono_class_from_mono_type (sig->params [i])));
3874                         }
3875                         break;
3876                 default:
3877                         g_assert_not_reached ();
3878                 }
3879         }
3880
3881         mono_mb_emit_ldarg (mb, 3);
3882         mono_mb_emit_calli (mb, callsig);
3883
3884         if (sig->ret->byref) {
3885                 /* fixme: */
3886                 g_assert_not_reached ();
3887         }
3888
3889
3890         switch (sig->ret->type) {
3891         case MONO_TYPE_VOID:
3892                 if (!method->string_ctor)
3893                         mono_mb_emit_byte (mb, CEE_LDNULL);
3894                 break;
3895         case MONO_TYPE_BOOLEAN:
3896         case MONO_TYPE_CHAR:
3897         case MONO_TYPE_I1:
3898         case MONO_TYPE_U1:
3899         case MONO_TYPE_I2:
3900         case MONO_TYPE_U2:
3901         case MONO_TYPE_I4:
3902         case MONO_TYPE_U4:
3903         case MONO_TYPE_I:
3904         case MONO_TYPE_U:
3905         case MONO_TYPE_R4:
3906         case MONO_TYPE_R8:
3907         case MONO_TYPE_I8:
3908         case MONO_TYPE_U8:
3909         case MONO_TYPE_VALUETYPE:
3910         case MONO_TYPE_TYPEDBYREF:
3911         case MONO_TYPE_GENERICINST:
3912                 /* box value types */
3913                 mono_mb_emit_byte (mb, CEE_BOX);
3914                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, mono_class_from_mono_type (sig->ret)));
3915                 break;
3916         case MONO_TYPE_STRING:
3917         case MONO_TYPE_CLASS:
3918         case MONO_TYPE_ARRAY:
3919         case MONO_TYPE_SZARRAY:
3920         case MONO_TYPE_OBJECT:
3921                 /* nothing to do */
3922                 break;
3923         case MONO_TYPE_PTR:
3924         default:
3925                 g_assert_not_reached ();
3926         }
3927
3928         mono_mb_emit_stloc (mb, 0);
3929
3930         mono_mb_emit_byte (mb, CEE_LEAVE);
3931         pos = mb->pos;
3932         mono_mb_emit_i4 (mb, 0);
3933
3934         mono_loader_lock ();
3935         clause = mono_mempool_alloc0 (target_klass->image->mempool, sizeof (MonoExceptionClause));
3936         mono_loader_unlock ();
3937         clause->flags = MONO_EXCEPTION_CLAUSE_FILTER;
3938         clause->try_len = mb->pos;
3939
3940         /* filter code */
3941         clause->data.filter_offset = mb->pos;
3942
3943         mono_mb_emit_byte (mb, CEE_POP);
3944         mono_mb_emit_byte (mb, CEE_LDARG_2);
3945         mono_mb_emit_byte (mb, CEE_LDC_I4_0);
3946         mono_mb_emit_byte (mb, CEE_PREFIX1);
3947         mono_mb_emit_byte (mb, CEE_CGT_UN);
3948         mono_mb_emit_byte (mb, CEE_PREFIX1);
3949         mono_mb_emit_byte (mb, CEE_ENDFILTER);
3950
3951         clause->handler_offset = mb->pos;
3952
3953         /* handler code */
3954         /* store exception */
3955         mono_mb_emit_stloc (mb, 1);
3956
3957         mono_mb_emit_byte (mb, CEE_LDARG_2);
3958         mono_mb_emit_ldloc (mb, 1);
3959         mono_mb_emit_byte (mb, CEE_STIND_REF);
3960
3961         mono_mb_emit_byte (mb, CEE_LDNULL);
3962         mono_mb_emit_stloc (mb, 0);
3963
3964         /* Check for the abort exception */
3965         mono_mb_emit_ldloc (mb, 1);
3966         mono_mb_emit_byte (mb, CEE_ISINST);
3967         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, mono_defaults.threadabortexception_class));
3968         mono_mb_emit_byte (mb, CEE_BRFALSE_S);
3969         posna = mb->pos;
3970         mono_mb_emit_byte (mb, 0);
3971
3972         /* Delay the abort exception */
3973         mono_mb_emit_native_call (mb, dealy_abort_sig, ves_icall_System_Threading_Thread_ResetAbort);
3974
3975         mono_mb_patch_addr_s (mb, posna, mb->pos - posna - 1);
3976         mono_mb_emit_byte (mb, CEE_LEAVE);
3977         mono_mb_emit_i4 (mb, 0);
3978
3979         clause->handler_len = mb->pos - clause->handler_offset;
3980
3981         /* return result */
3982         mono_mb_patch_addr (mb, pos, mb->pos - (pos + 4));
3983         mono_mb_emit_ldloc (mb, 0);
3984         mono_mb_emit_byte (mb, CEE_RET);
3985
3986         /* taken from mono_mb_create_and_cache */
3987         mono_loader_lock ();
3988         mono_marshal_lock ();
3989
3990         res = g_hash_table_lookup (cache, callsig);
3991         /* Somebody may have created it before us */
3992         if (!res) {
3993                 res = mono_mb_create_method (mb, csig, sig->param_count + 16);
3994                 g_hash_table_insert (cache, callsig, res);
3995                 g_hash_table_insert (wrapper_hash, res, callsig);
3996         }
3997
3998         mono_marshal_unlock ();
3999         mono_loader_unlock ();
4000         /* end mono_mb_create_and_cache */
4001
4002         mono_mb_free (mb);
4003
4004         header = ((MonoMethodNormal *)res)->header;
4005         header->num_clauses = 1;
4006         header->clauses = clause;
4007
4008         return res;
4009 }
4010
4011 static void
4012 mono_mb_emit_auto_layout_exception (MonoMethodBuilder *mb, MonoClass *klass)
4013 {
4014         char *msg = g_strdup_printf ("The type `%s.%s' layout needs to be Sequential or Explicit",
4015                                      klass->name_space, klass->name);
4016
4017         mono_mb_emit_exception_marshal_directive (mb, msg);
4018 }
4019
4020 /*
4021  * mono_marshal_get_ldfld_remote_wrapper:
4022  * @klass: The return type
4023  *
4024  * This method generates a wrapper for calling mono_load_remote_field_new with
4025  * the appropriate return type.
4026  */
4027 MonoMethod *
4028 mono_marshal_get_ldfld_remote_wrapper (MonoClass *klass)
4029 {
4030         MonoMethodSignature *sig, *csig;
4031         MonoMethodBuilder *mb;
4032         MonoMethod *res;
4033         GHashTable *cache;
4034         char *name;
4035
4036         cache = klass->image->ldfld_remote_wrapper_cache;
4037         if ((res = mono_marshal_find_in_cache (cache, klass)))
4038                 return res;
4039
4040         /*
4041          * This wrapper is similar to an icall wrapper but all the wrappers
4042          * call the same C function, but with a different signature.
4043          */
4044         name = g_strdup_printf ("__mono_load_remote_field_new_wrapper_%s.%s", klass->name_space, klass->name);
4045         mb = mono_mb_new (mono_defaults.object_class, name, MONO_WRAPPER_LDFLD_REMOTE);
4046         g_free (name);
4047
4048         mb->method->save_lmf = 1;
4049
4050         sig = mono_metadata_signature_alloc (mono_defaults.corlib, 3);
4051         sig->params [0] = &mono_defaults.object_class->byval_arg;
4052         sig->params [1] = &mono_defaults.int_class->byval_arg;
4053         sig->params [2] = &mono_defaults.int_class->byval_arg;
4054         sig->ret = &klass->this_arg;
4055
4056         mono_mb_emit_ldarg (mb, 0);
4057         mono_mb_emit_ldarg (mb, 1);
4058         mono_mb_emit_ldarg (mb, 2);
4059
4060         csig = mono_metadata_signature_alloc (mono_defaults.corlib, 3);
4061         csig->params [0] = &mono_defaults.object_class->byval_arg;
4062         csig->params [1] = &mono_defaults.int_class->byval_arg;
4063         csig->params [2] = &mono_defaults.int_class->byval_arg;
4064         csig->ret = &klass->this_arg;
4065         csig->pinvoke = 1;
4066
4067         mono_mb_emit_native_call (mb, csig, mono_load_remote_field_new);
4068         emit_thread_interrupt_checkpoint (mb);
4069
4070         mono_mb_emit_byte (mb, CEE_RET);
4071
4072         res = mono_mb_create_and_cache (cache, klass,
4073                                                                         mb, sig, sig->param_count + 16);
4074         mono_mb_free (mb);
4075
4076         return res;
4077 }
4078
4079 /*
4080  * mono_marshal_get_ldfld_wrapper:
4081  * @type: the type of the field
4082  *
4083  * This method generates a function which can be use to load a field with type
4084  * @type from an object. The generated function has the following signature:
4085  * <@type> ldfld_wrapper (MonoObject *this, MonoClass *class, MonoClassField *field, int offset)
4086  */
4087 MonoMethod *
4088 mono_marshal_get_ldfld_wrapper (MonoType *type)
4089 {
4090         MonoMethodSignature *sig;
4091         MonoMethodBuilder *mb;
4092         MonoMethod *res;
4093         MonoClass *klass;
4094         GHashTable *cache;
4095         char *name;
4096         int t, pos0, pos1 = 0;
4097
4098         type = mono_type_get_underlying_type (type);
4099
4100         t = type->type;
4101
4102         if (!type->byref) {
4103                 if (type->type == MONO_TYPE_SZARRAY) {
4104                         klass = mono_defaults.array_class;
4105                 } else if (type->type == MONO_TYPE_VALUETYPE) {
4106                         klass = type->data.klass;
4107                 } else if (t == MONO_TYPE_OBJECT || t == MONO_TYPE_CLASS || t == MONO_TYPE_STRING) {
4108                         klass = mono_defaults.object_class;
4109                 } else if (t == MONO_TYPE_PTR || t == MONO_TYPE_FNPTR) {
4110                         klass = mono_defaults.int_class;
4111                 } else if (t == MONO_TYPE_GENERICINST) {
4112                         if (mono_type_generic_inst_is_valuetype (type))
4113                                 klass = mono_class_from_mono_type (type);
4114                         else
4115                                 klass = mono_defaults.object_class;
4116                 } else {
4117                         klass = mono_class_from_mono_type (type);
4118                 }
4119         } else {
4120                 klass = mono_defaults.int_class;
4121         }
4122
4123         cache = klass->image->ldfld_wrapper_cache;
4124         if ((res = mono_marshal_find_in_cache (cache, klass)))
4125                 return res;
4126
4127         /* we add the %p pointer value of klass because class names are not unique */
4128         name = g_strdup_printf ("__ldfld_wrapper_%p_%s.%s", klass, klass->name_space, klass->name);
4129         mb = mono_mb_new (mono_defaults.object_class, name, MONO_WRAPPER_LDFLD);
4130         g_free (name);
4131
4132         sig = mono_metadata_signature_alloc (mono_defaults.corlib, 4);
4133         sig->params [0] = &mono_defaults.object_class->byval_arg;
4134         sig->params [1] = &mono_defaults.int_class->byval_arg;
4135         sig->params [2] = &mono_defaults.int_class->byval_arg;
4136         sig->params [3] = &mono_defaults.int_class->byval_arg;
4137         sig->ret = &klass->byval_arg;
4138
4139         mono_mb_emit_ldarg (mb, 0);
4140         pos0 = mono_mb_emit_proxy_check (mb, CEE_BNE_UN);
4141
4142         mono_mb_emit_ldarg (mb, 0);
4143         mono_mb_emit_ldarg (mb, 1);
4144         mono_mb_emit_ldarg (mb, 2);
4145
4146         mono_mb_emit_managed_call (mb, mono_marshal_get_ldfld_remote_wrapper (klass), NULL);
4147
4148         /*
4149         csig = mono_metadata_signature_alloc (mono_defaults.corlib, 3);
4150         csig->params [0] = &mono_defaults.object_class->byval_arg;
4151         csig->params [1] = &mono_defaults.int_class->byval_arg;
4152         csig->params [2] = &mono_defaults.int_class->byval_arg;
4153         csig->ret = &klass->this_arg;
4154         csig->pinvoke = 1;
4155
4156         mono_mb_emit_native_call (mb, csig, mono_load_remote_field_new);
4157         emit_thread_interrupt_checkpoint (mb);
4158         */
4159
4160         if (klass->valuetype) {
4161                 mono_mb_emit_byte (mb, CEE_UNBOX);
4162                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, klass));
4163                 mono_mb_emit_byte (mb, CEE_BR);
4164                 pos1 = mb->pos;
4165                 mono_mb_emit_i4 (mb, 0);
4166         } else {
4167                 mono_mb_emit_byte (mb, CEE_RET);
4168         }
4169
4170
4171         mono_mb_patch_addr (mb, pos0, mb->pos - (pos0 + 4));
4172
4173         mono_mb_emit_ldarg (mb, 0);
4174         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
4175         mono_mb_emit_byte (mb, CEE_MONO_OBJADDR);
4176         mono_mb_emit_ldarg (mb, 3);
4177         mono_mb_emit_byte (mb, CEE_ADD);
4178
4179         if (klass->valuetype)
4180                 mono_mb_patch_addr (mb, pos1, mb->pos - (pos1 + 4));
4181
4182         switch (t) {
4183         case MONO_TYPE_I1:
4184         case MONO_TYPE_U1:
4185         case MONO_TYPE_BOOLEAN:
4186         case MONO_TYPE_CHAR:
4187         case MONO_TYPE_I2:
4188         case MONO_TYPE_U2:
4189         case MONO_TYPE_I4:
4190         case MONO_TYPE_U4:
4191         case MONO_TYPE_I8:
4192         case MONO_TYPE_U8:
4193         case MONO_TYPE_R4:
4194         case MONO_TYPE_R8:
4195         case MONO_TYPE_ARRAY:
4196         case MONO_TYPE_SZARRAY:
4197         case MONO_TYPE_OBJECT:
4198         case MONO_TYPE_CLASS:
4199         case MONO_TYPE_STRING:
4200         case MONO_TYPE_I:
4201         case MONO_TYPE_U:
4202         case MONO_TYPE_PTR:
4203         case MONO_TYPE_FNPTR:
4204                 mono_mb_emit_byte (mb, mono_type_to_ldind (type));
4205                 break;
4206         case MONO_TYPE_VALUETYPE:
4207                 g_assert (!klass->enumtype);
4208                 mono_mb_emit_byte (mb, CEE_LDOBJ);
4209                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, klass));
4210                 break;
4211         case MONO_TYPE_GENERICINST:
4212                 if (mono_type_generic_inst_is_valuetype (type)) {
4213                         mono_mb_emit_byte (mb, CEE_LDOBJ);
4214                         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, klass));
4215                 } else {
4216                         mono_mb_emit_byte (mb, CEE_LDIND_REF);
4217                 }
4218                 break;
4219         default:
4220                 g_warning ("type %x not implemented", type->type);
4221                 g_assert_not_reached ();
4222         }
4223
4224         mono_mb_emit_byte (mb, CEE_RET);
4225
4226         res = mono_mb_create_and_cache (cache, klass,
4227                                                                         mb, sig, sig->param_count + 16);
4228         mono_mb_free (mb);
4229
4230         return res;
4231 }
4232
4233 /*
4234  * mono_marshal_get_ldflda_wrapper:
4235  * @type: the type of the field
4236  *
4237  * This method generates a function which can be used to load a field address
4238  * from an object. The generated function has the following signature:
4239  * gpointer ldflda_wrapper (MonoObject *this, MonoClass *class, MonoClassField *field, int offset);
4240  */
4241 MonoMethod *
4242 mono_marshal_get_ldflda_wrapper (MonoType *type)
4243 {
4244         MonoMethodSignature *sig;
4245         MonoMethodBuilder *mb;
4246         MonoMethod *res;
4247         MonoClass *klass;
4248         GHashTable *cache;
4249         char *name;
4250         int t, pos0;
4251
4252         type = mono_type_get_underlying_type (type);
4253         t = type->type;
4254
4255         if (!type->byref) {
4256                 if (type->type == MONO_TYPE_SZARRAY) {
4257                         klass = mono_defaults.array_class;
4258                 } else if (type->type == MONO_TYPE_VALUETYPE) {
4259                         klass = type->data.klass;
4260                 } else if (t == MONO_TYPE_OBJECT || t == MONO_TYPE_CLASS || t == MONO_TYPE_STRING ||
4261                            t == MONO_TYPE_CLASS) {
4262                         klass = mono_defaults.object_class;
4263                 } else if (t == MONO_TYPE_PTR || t == MONO_TYPE_FNPTR) {
4264                         klass = mono_defaults.int_class;
4265                 } else if (t == MONO_TYPE_GENERICINST) {
4266                         if (mono_type_generic_inst_is_valuetype (type))
4267                                 klass = mono_class_from_mono_type (type);
4268                         else
4269                                 klass = mono_defaults.object_class;
4270                 } else {
4271                         klass = mono_class_from_mono_type (type);
4272                 }
4273         } else {
4274                 klass = mono_defaults.int_class;
4275         }
4276
4277         cache = klass->image->ldflda_wrapper_cache;
4278         if ((res = mono_marshal_find_in_cache (cache, klass)))
4279                 return res;
4280
4281         /* we add the %p pointer value of klass because class names are not unique */
4282         name = g_strdup_printf ("__ldflda_wrapper_%p_%s.%s", klass, klass->name_space, klass->name);
4283         mb = mono_mb_new (mono_defaults.object_class, name, MONO_WRAPPER_LDFLDA);
4284         g_free (name);
4285
4286         sig = mono_metadata_signature_alloc (mono_defaults.corlib, 4);
4287         sig->params [0] = &mono_defaults.object_class->byval_arg;
4288         sig->params [1] = &mono_defaults.int_class->byval_arg;
4289         sig->params [2] = &mono_defaults.int_class->byval_arg;
4290         sig->params [3] = &mono_defaults.int_class->byval_arg;
4291         sig->ret = &mono_defaults.int_class->byval_arg;
4292
4293         mono_mb_emit_ldarg (mb, 0);
4294         pos0 = mono_mb_emit_proxy_check (mb, CEE_BNE_UN);
4295
4296         /* FIXME: Only throw this if the object is in another appdomain */
4297         mono_mb_emit_exception_full (mb, "System", "InvalidOperationException", "Attempt to load field address from object in another appdomain.");
4298
4299         mono_mb_patch_addr (mb, pos0, mb->pos - (pos0 + 4));
4300
4301         mono_mb_emit_ldarg (mb, 0);
4302         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
4303         mono_mb_emit_byte (mb, CEE_MONO_OBJADDR);
4304         mono_mb_emit_ldarg (mb, 3);
4305         mono_mb_emit_byte (mb, CEE_ADD);
4306
4307         mono_mb_emit_byte (mb, CEE_RET);
4308
4309         res = mono_mb_create_and_cache (cache, klass,
4310                                                                         mb, sig, sig->param_count + 16);
4311         mono_mb_free (mb);
4312
4313         return res;
4314 }
4315
4316 /*
4317  * mono_marshal_get_stfld_remote_wrapper:
4318  * klass: The type of the field
4319  *
4320  *  This function generates a wrapper for calling mono_store_remote_field_new
4321  * with the appropriate signature.
4322  */
4323 MonoMethod *
4324 mono_marshal_get_stfld_remote_wrapper (MonoClass *klass)
4325 {
4326         MonoMethodSignature *sig, *csig;
4327         MonoMethodBuilder *mb;
4328         MonoMethod *res;
4329         GHashTable *cache;
4330         char *name;
4331
4332         cache = klass->image->stfld_remote_wrapper_cache;
4333         if ((res = mono_marshal_find_in_cache (cache, klass)))
4334                 return res;
4335
4336         name = g_strdup_printf ("__mono_store_remote_field_new_wrapper_%s.%s", klass->name_space, klass->name);
4337         mb = mono_mb_new (mono_defaults.object_class, name, MONO_WRAPPER_STFLD_REMOTE);
4338         g_free (name);
4339
4340         mb->method->save_lmf = 1;
4341
4342         sig = mono_metadata_signature_alloc (mono_defaults.corlib, 4);
4343         sig->params [0] = &mono_defaults.object_class->byval_arg;
4344         sig->params [1] = &mono_defaults.int_class->byval_arg;
4345         sig->params [2] = &mono_defaults.int_class->byval_arg;
4346         sig->params [3] = &klass->byval_arg;
4347         sig->ret = &mono_defaults.void_class->byval_arg;
4348
4349         mono_mb_emit_ldarg (mb, 0);
4350         mono_mb_emit_ldarg (mb, 1);
4351         mono_mb_emit_ldarg (mb, 2);
4352         mono_mb_emit_ldarg (mb, 3);
4353
4354         if (klass->valuetype) {
4355                 mono_mb_emit_byte (mb, CEE_BOX);
4356                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, klass));
4357         }
4358
4359         csig = mono_metadata_signature_alloc (mono_defaults.corlib, 4);
4360         csig->params [0] = &mono_defaults.object_class->byval_arg;
4361         csig->params [1] = &mono_defaults.int_class->byval_arg;
4362         csig->params [2] = &mono_defaults.int_class->byval_arg;
4363         csig->params [3] = &klass->byval_arg;
4364         csig->ret = &mono_defaults.void_class->byval_arg;
4365         csig->pinvoke = 1;
4366
4367         mono_mb_emit_native_call (mb, csig, mono_store_remote_field_new);
4368         emit_thread_interrupt_checkpoint (mb);
4369
4370         mono_mb_emit_byte (mb, CEE_RET);
4371
4372         res = mono_mb_create_and_cache (cache, klass,
4373                                                                         mb, sig, sig->param_count + 16);
4374         mono_mb_free (mb);
4375
4376         return res;
4377 }
4378
4379 /*
4380  * mono_marshal_get_stfld_wrapper:
4381  * @type: the type of the field
4382  *
4383  * This method generates a function which can be use to store a field with type
4384  * @type. The generated function has the following signature:
4385  * void stfld_wrapper (MonoObject *this, MonoClass *class, MonoClassField *field, int offset, <@type> val)
4386  */
4387 MonoMethod *
4388 mono_marshal_get_stfld_wrapper (MonoType *type)
4389 {
4390         MonoMethodSignature *sig;
4391         MonoMethodBuilder *mb;
4392         MonoMethod *res;
4393         MonoClass *klass;
4394         GHashTable *cache;
4395         char *name;
4396         int t, pos;
4397
4398         type = mono_type_get_underlying_type (type);
4399         t = type->type;
4400
4401         if (!type->byref) {
4402                 if (type->type == MONO_TYPE_SZARRAY) {
4403                         klass = mono_defaults.array_class;
4404                 } else if (type->type == MONO_TYPE_VALUETYPE) {
4405                         klass = type->data.klass;
4406                 } else if (t == MONO_TYPE_OBJECT || t == MONO_TYPE_CLASS || t == MONO_TYPE_STRING) {
4407                         klass = mono_defaults.object_class;
4408                 } else if (t == MONO_TYPE_PTR || t == MONO_TYPE_FNPTR) {
4409                         klass = mono_defaults.int_class;
4410                 } else if (t == MONO_TYPE_GENERICINST) {
4411                         if (mono_type_generic_inst_is_valuetype (type))
4412                                 klass = mono_class_from_mono_type (type);
4413                         else
4414                                 klass = mono_defaults.object_class;
4415                 } else {
4416                         klass = mono_class_from_mono_type (type);
4417                 }
4418         } else {
4419                 klass = mono_defaults.int_class;
4420         }
4421
4422         cache = klass->image->stfld_wrapper_cache;
4423         if ((res = mono_marshal_find_in_cache (cache, klass)))
4424                 return res;
4425
4426         /* we add the %p pointer value of klass because class names are not unique */
4427         name = g_strdup_printf ("__stfld_wrapper_%p_%s.%s", klass, klass->name_space, klass->name);
4428         mb = mono_mb_new (mono_defaults.object_class, name, MONO_WRAPPER_STFLD);
4429         g_free (name);
4430
4431         sig = mono_metadata_signature_alloc (mono_defaults.corlib, 5);
4432         sig->params [0] = &mono_defaults.object_class->byval_arg;
4433         sig->params [1] = &mono_defaults.int_class->byval_arg;
4434         sig->params [2] = &mono_defaults.int_class->byval_arg;
4435         sig->params [3] = &mono_defaults.int_class->byval_arg;
4436         sig->params [4] = &klass->byval_arg;
4437         sig->ret = &mono_defaults.void_class->byval_arg;
4438
4439         mono_mb_emit_ldarg (mb, 0);
4440         pos = mono_mb_emit_proxy_check (mb, CEE_BNE_UN);
4441
4442         mono_mb_emit_ldarg (mb, 0);
4443         mono_mb_emit_ldarg (mb, 1);
4444         mono_mb_emit_ldarg (mb, 2);
4445         mono_mb_emit_ldarg (mb, 4);
4446
4447         mono_mb_emit_managed_call (mb, mono_marshal_get_stfld_remote_wrapper (klass), NULL);
4448
4449         mono_mb_emit_byte (mb, CEE_RET);
4450
4451         mono_mb_patch_addr (mb, pos, mb->pos - (pos + 4));
4452
4453         mono_mb_emit_ldarg (mb, 0);
4454         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
4455         mono_mb_emit_byte (mb, CEE_MONO_OBJADDR);
4456         mono_mb_emit_ldarg (mb, 3);
4457         mono_mb_emit_byte (mb, CEE_ADD);
4458         mono_mb_emit_ldarg (mb, 4);
4459
4460         switch (t) {
4461         case MONO_TYPE_I1:
4462         case MONO_TYPE_U1:
4463         case MONO_TYPE_BOOLEAN:
4464         case MONO_TYPE_CHAR:
4465         case MONO_TYPE_I2:
4466         case MONO_TYPE_U2:
4467         case MONO_TYPE_I4:
4468         case MONO_TYPE_U4:
4469         case MONO_TYPE_I8:
4470         case MONO_TYPE_U8:
4471         case MONO_TYPE_R4:
4472         case MONO_TYPE_R8:
4473         case MONO_TYPE_ARRAY:
4474         case MONO_TYPE_SZARRAY:
4475         case MONO_TYPE_OBJECT:
4476         case MONO_TYPE_CLASS:
4477         case MONO_TYPE_STRING:
4478         case MONO_TYPE_I:
4479         case MONO_TYPE_U:
4480         case MONO_TYPE_PTR:
4481         case MONO_TYPE_FNPTR:
4482                 mono_mb_emit_byte (mb, mono_type_to_stind (type));
4483                 break;
4484         case MONO_TYPE_VALUETYPE:
4485                 g_assert (!klass->enumtype);
4486                 mono_mb_emit_byte (mb, CEE_STOBJ);
4487                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, klass));
4488                 break;
4489         case MONO_TYPE_GENERICINST:
4490                 mono_mb_emit_byte (mb, CEE_STOBJ);
4491                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, klass));
4492                 break;
4493         default:
4494                 g_warning ("type %x not implemented", type->type);
4495                 g_assert_not_reached ();
4496         }
4497
4498         mono_mb_emit_byte (mb, CEE_RET);
4499
4500         res = mono_mb_create_and_cache (cache, klass,
4501                                                                         mb, sig, sig->param_count + 16);
4502         mono_mb_free (mb);
4503
4504         return res;
4505 }
4506
4507 /*
4508  * generates IL code for the icall wrapper (the generated method
4509  * calls the unmanaged code in func)
4510  */
4511 MonoMethod *
4512 mono_marshal_get_icall_wrapper (MonoMethodSignature *sig, const char *name, gconstpointer func)
4513 {
4514         MonoMethodSignature *csig;
4515         MonoMethodBuilder *mb;
4516         MonoMethod *res;
4517         int i;
4518
4519         g_assert (sig->pinvoke);
4520
4521         mb = mono_mb_new (mono_defaults.object_class, name, MONO_WRAPPER_MANAGED_TO_NATIVE);
4522
4523         mb->method->save_lmf = 1;
4524
4525         /* we copy the signature, so that we can modify it */
4526
4527         if (sig->hasthis)
4528                 mono_mb_emit_byte (mb, CEE_LDARG_0);
4529
4530         for (i = 0; i < sig->param_count; i++)
4531                 mono_mb_emit_ldarg (mb, i + sig->hasthis);
4532
4533         mono_mb_emit_native_call (mb, sig, (gpointer) func);
4534         emit_thread_interrupt_checkpoint (mb);
4535         mono_mb_emit_byte (mb, CEE_RET);
4536
4537         csig = signature_dup (mono_defaults.corlib, sig);
4538         csig->pinvoke = 0;
4539         if (csig->call_convention == MONO_CALL_VARARG)
4540                 csig->call_convention = 0;
4541
4542         res = mono_mb_create_method (mb, csig, csig->param_count + 16);
4543         mono_mb_free (mb);
4544
4545         return res;
4546 }
4547
4548 typedef struct {
4549         MonoMethodBuilder *mb;
4550         MonoMethodSignature *sig;
4551         MonoMethodPInvoke *piinfo;
4552         int *orig_conv_args; /* Locals containing the original values of byref args */
4553         int retobj_var;
4554         MonoClass *retobj_class;
4555         MonoMethodSignature *csig; /* Might need to be changed due to MarshalAs directives */
4556 } EmitMarshalContext;
4557
4558 typedef enum {
4559         MARSHAL_ACTION_CONV_IN,
4560         MARSHAL_ACTION_PUSH,
4561         MARSHAL_ACTION_CONV_OUT,
4562         MARSHAL_ACTION_CONV_RESULT,
4563         MARSHAL_ACTION_MANAGED_CONV_IN,
4564         MARSHAL_ACTION_MANAGED_CONV_OUT,
4565         MARSHAL_ACTION_MANAGED_CONV_RESULT
4566 } MarshalAction;
4567
4568 static int
4569 emit_marshal_custom (EmitMarshalContext *m, int argnum, MonoType *t,
4570                                          MonoMarshalSpec *spec,
4571                                          int conv_arg, MonoType **conv_arg_type,
4572                                          MarshalAction action)
4573 {
4574         MonoType *mtype;
4575         MonoClass *mklass;
4576         static MonoClass *ICustomMarshaler = NULL;
4577         static MonoMethod *cleanup_native, *cleanup_managed;
4578         static MonoMethod *marshal_managed_to_native, *marshal_native_to_managed;
4579         MonoMethod *get_instance;
4580         MonoMethodBuilder *mb = m->mb;
4581         char *exception_msg = NULL;
4582         guint32 loc1;
4583         int pos2;
4584
4585         if (!ICustomMarshaler) {
4586                 ICustomMarshaler = mono_class_from_name (mono_defaults.corlib, "System.Runtime.InteropServices", "ICustomMarshaler");
4587                 g_assert (ICustomMarshaler);
4588
4589                 cleanup_native = mono_class_get_method_from_name (ICustomMarshaler, "CleanUpNativeData", 1);
4590                 g_assert (cleanup_native);
4591                 cleanup_managed = mono_class_get_method_from_name (ICustomMarshaler, "CleanUpManagedData", 1);
4592                 g_assert (cleanup_managed);
4593                 marshal_managed_to_native = mono_class_get_method_from_name (ICustomMarshaler, "MarshalManagedToNative", 1);
4594                 g_assert (marshal_managed_to_native);
4595                 marshal_native_to_managed = mono_class_get_method_from_name (ICustomMarshaler, "MarshalNativeToManaged", 1);
4596                 g_assert (marshal_native_to_managed);
4597         }
4598
4599         mtype = mono_reflection_type_from_name (spec->data.custom_data.custom_name, mb->method->klass->image);
4600         g_assert (mtype != NULL);
4601         mklass = mono_class_from_mono_type (mtype);
4602         g_assert (mklass != NULL);
4603
4604         if (!mono_class_is_assignable_from (ICustomMarshaler, mklass))
4605                 exception_msg = g_strdup_printf ("Custom marshaler '%s' does not implement the ICustomMarshaler interface.", mklass->name);
4606
4607         get_instance = mono_class_get_method_from_name_flags (mklass, "GetInstance", 1, METHOD_ATTRIBUTE_STATIC);
4608         if (get_instance) {
4609                 MonoMethodSignature *get_sig = mono_method_signature (get_instance);
4610                 if ((get_sig->ret->type != MONO_TYPE_CLASS) ||
4611                         (mono_class_from_mono_type (get_sig->ret) != ICustomMarshaler) ||
4612                         (get_sig->params [0]->type != MONO_TYPE_STRING))
4613                         get_instance = NULL;
4614         }
4615
4616         if (!get_instance)
4617                 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);
4618
4619         /* Throw exception and emit compensation code if neccesary */
4620         if (exception_msg) {
4621                 switch (action) {
4622                 case MARSHAL_ACTION_CONV_IN:
4623                 case MARSHAL_ACTION_CONV_RESULT:
4624                 case MARSHAL_ACTION_MANAGED_CONV_RESULT:
4625                         if ((action == MARSHAL_ACTION_CONV_RESULT) || (action == MARSHAL_ACTION_MANAGED_CONV_RESULT))
4626                                 mono_mb_emit_byte (mb, CEE_POP);
4627
4628                         mono_mb_emit_exception_full (mb, "System", "ApplicationException", exception_msg);
4629                         g_free (exception_msg);
4630
4631                         break;
4632                 case MARSHAL_ACTION_PUSH:
4633                         mono_mb_emit_byte (mb, CEE_LDNULL);
4634                         break;
4635                 default:
4636                         break;
4637                 }
4638                 return 0;
4639         }
4640
4641         /* FIXME: MS.NET seems to create one instance for each klass + cookie pair */
4642         /* FIXME: MS.NET throws an exception if GetInstance returns null */
4643
4644         switch (action) {
4645         case MARSHAL_ACTION_CONV_IN:
4646                 switch (t->type) {
4647                 case MONO_TYPE_CLASS:
4648                 case MONO_TYPE_OBJECT:
4649                 case MONO_TYPE_STRING:
4650                 case MONO_TYPE_ARRAY:
4651                 case MONO_TYPE_SZARRAY:
4652                 case MONO_TYPE_VALUETYPE:
4653                         break;
4654
4655                 default:
4656                         g_warning ("custom marshalling of type %x is currently not supported", t->type);
4657                         g_assert_not_reached ();
4658                         break;
4659                 }
4660
4661                 conv_arg = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
4662
4663                 mono_mb_emit_byte (mb, CEE_LDNULL);
4664                 mono_mb_emit_stloc (mb, conv_arg);
4665
4666                 if (t->byref && (t->attrs & PARAM_ATTRIBUTE_OUT))
4667                         break;
4668
4669                 /* Check for null */
4670                 mono_mb_emit_ldarg (mb, argnum);
4671                 if (t->byref)
4672                         mono_mb_emit_byte (mb, CEE_LDIND_I);
4673                 pos2 = mono_mb_emit_branch (mb, CEE_BRFALSE);
4674
4675                 mono_mb_emit_ldstr (mb, g_strdup (spec->data.custom_data.cookie));
4676
4677                 mono_mb_emit_byte (mb, CEE_CALL);
4678                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, get_instance));
4679
4680                 mono_mb_emit_ldarg (mb, argnum);
4681                 if (t->byref)
4682                         mono_mb_emit_byte (mb, CEE_LDIND_REF);
4683
4684                 if (t->type == MONO_TYPE_VALUETYPE) {
4685                         /*
4686                          * Since we can't determine the type of the argument, we
4687                          * will assume the unmanaged function takes a pointer.
4688                          */
4689                         *conv_arg_type = &mono_defaults.int_class->byval_arg;
4690
4691                         mono_mb_emit_byte (mb, CEE_BOX);
4692                         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, mono_class_from_mono_type (t)));
4693                 }
4694
4695                 mono_mb_emit_byte (mb, CEE_CALLVIRT);
4696                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, marshal_managed_to_native));
4697                 mono_mb_emit_stloc (mb, conv_arg);
4698
4699                 mono_mb_patch_addr (mb, pos2, mb->pos - (pos2 + 4));
4700                 break;
4701
4702         case MARSHAL_ACTION_CONV_OUT:
4703                 /* Check for null */
4704                 mono_mb_emit_ldloc (mb, conv_arg);
4705                 pos2 = mono_mb_emit_branch (mb, CEE_BRFALSE);
4706
4707                 if (t->byref) {
4708                         mono_mb_emit_ldarg (mb, argnum);
4709
4710                         mono_mb_emit_ldstr (mb, g_strdup (spec->data.custom_data.cookie));
4711
4712                         mono_mb_emit_byte (mb, CEE_CALL);
4713                         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, get_instance));
4714
4715                         mono_mb_emit_ldloc (mb, conv_arg);
4716                         mono_mb_emit_byte (mb, CEE_CALLVIRT);
4717                         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, marshal_native_to_managed));
4718                         mono_mb_emit_byte (mb, CEE_STIND_REF);
4719                 }
4720
4721                 mono_mb_emit_ldstr (mb, g_strdup (spec->data.custom_data.cookie));
4722
4723                 mono_mb_emit_byte (mb, CEE_CALL);
4724                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, get_instance));
4725
4726                 mono_mb_emit_ldloc (mb, conv_arg);
4727
4728                 mono_mb_emit_byte (mb, CEE_CALLVIRT);
4729                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, cleanup_native));
4730
4731                 mono_mb_patch_addr (mb, pos2, mb->pos - (pos2 + 4));
4732                 break;
4733
4734         case MARSHAL_ACTION_PUSH:
4735                 if (t->byref)
4736                         mono_mb_emit_ldloc_addr (mb, conv_arg);
4737                 else
4738                         mono_mb_emit_ldloc (mb, conv_arg);
4739                 break;
4740
4741         case MARSHAL_ACTION_CONV_RESULT:
4742                 loc1 = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
4743
4744                 mono_mb_emit_stloc (mb, 3);
4745
4746                 mono_mb_emit_ldloc (mb, 3);
4747                 mono_mb_emit_stloc (mb, loc1);
4748
4749                 /* Check for null */
4750                 mono_mb_emit_ldloc (mb, 3);
4751                 pos2 = mono_mb_emit_branch (mb, CEE_BRFALSE);
4752
4753                 mono_mb_emit_ldstr (mb, g_strdup (spec->data.custom_data.cookie));
4754
4755                 mono_mb_emit_byte (mb, CEE_CALL);
4756                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, get_instance));
4757                 mono_mb_emit_byte (mb, CEE_DUP);
4758
4759                 mono_mb_emit_ldloc (mb, 3);
4760                 mono_mb_emit_byte (mb, CEE_CALLVIRT);
4761                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, marshal_native_to_managed));
4762                 mono_mb_emit_stloc (mb, 3);
4763
4764                 mono_mb_emit_ldloc (mb, loc1);
4765                 mono_mb_emit_byte (mb, CEE_CALLVIRT);
4766                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, cleanup_native));
4767
4768                 mono_mb_patch_addr (mb, pos2, mb->pos - (pos2 + 4));
4769                 break;
4770
4771         case MARSHAL_ACTION_MANAGED_CONV_IN:
4772                 if (t->byref) {
4773                         conv_arg = 0;
4774                         break;
4775                 }
4776
4777                 conv_arg = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
4778
4779                 mono_mb_emit_byte (mb, CEE_LDNULL);
4780                 mono_mb_emit_stloc (mb, conv_arg);
4781
4782                 /* Check for null */
4783                 mono_mb_emit_ldarg (mb, argnum);
4784                 pos2 = mono_mb_emit_branch (mb, CEE_BRFALSE);
4785
4786                 mono_mb_emit_ldstr (mb, g_strdup (spec->data.custom_data.cookie));
4787                 mono_mb_emit_byte (mb, CEE_CALL);
4788                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, get_instance));
4789
4790                 mono_mb_emit_ldarg (mb, argnum);
4791
4792                 mono_mb_emit_byte (mb, CEE_CALLVIRT);
4793                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, marshal_native_to_managed));
4794                 mono_mb_emit_stloc (mb, conv_arg);
4795
4796                 mono_mb_patch_addr (mb, pos2, mb->pos - (pos2 + 4));
4797                 break;
4798
4799         case MARSHAL_ACTION_MANAGED_CONV_RESULT:
4800                 g_assert (!t->byref);
4801
4802                 loc1 = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
4803
4804                 mono_mb_emit_stloc (mb, 3);
4805
4806                 mono_mb_emit_ldloc (mb, 3);
4807                 mono_mb_emit_stloc (mb, loc1);
4808
4809                 /* Check for null */
4810                 mono_mb_emit_ldloc (mb, 3);
4811                 pos2 = mono_mb_emit_branch (mb, CEE_BRFALSE);
4812
4813                 mono_mb_emit_ldstr (mb, g_strdup (spec->data.custom_data.cookie));
4814                 mono_mb_emit_byte (mb, CEE_CALL);
4815                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, get_instance));
4816                 mono_mb_emit_byte (mb, CEE_DUP);
4817
4818                 mono_mb_emit_ldloc (mb, 3);
4819                 mono_mb_emit_byte (mb, CEE_CALLVIRT);
4820                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, marshal_managed_to_native));
4821                 mono_mb_emit_stloc (mb, 3);
4822
4823                 mono_mb_emit_ldloc (mb, loc1);
4824                 mono_mb_emit_byte (mb, CEE_CALLVIRT);
4825                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, cleanup_managed));
4826
4827                 mono_mb_patch_addr (mb, pos2, mb->pos - (pos2 + 4));
4828                 break;
4829
4830         case MARSHAL_ACTION_MANAGED_CONV_OUT:
4831                 g_assert (!t->byref);
4832
4833                 /* Check for null */
4834                 mono_mb_emit_ldloc (mb, conv_arg);
4835                 pos2 = mono_mb_emit_branch (mb, CEE_BRFALSE);
4836
4837                 /* Call CleanUpManagedData */
4838                 mono_mb_emit_ldstr (mb, g_strdup (spec->data.custom_data.cookie));
4839
4840                 mono_mb_emit_byte (mb, CEE_CALL);
4841                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, get_instance));
4842
4843                 mono_mb_emit_ldloc (mb, conv_arg);
4844                 mono_mb_emit_byte (mb, CEE_CALLVIRT);
4845                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, cleanup_managed));
4846
4847                 mono_mb_patch_addr (mb, pos2, mb->pos - (pos2 + 4));
4848                 break;
4849
4850         default:
4851                 g_assert_not_reached ();
4852         }
4853
4854         return conv_arg;
4855 }
4856
4857 static int
4858 emit_marshal_asany (EmitMarshalContext *m, int argnum, MonoType *t,
4859                                         MonoMarshalSpec *spec,
4860                                         int conv_arg, MonoType **conv_arg_type,
4861                                         MarshalAction action)
4862 {
4863         MonoMethodBuilder *mb = m->mb;
4864
4865         switch (action) {
4866         case MARSHAL_ACTION_CONV_IN: {
4867                 MonoMarshalNative encoding = mono_marshal_get_string_encoding (m->piinfo, NULL);
4868
4869                 g_assert (t->type == MONO_TYPE_OBJECT);
4870                 g_assert (!t->byref);
4871
4872                 conv_arg = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
4873                 mono_mb_emit_ldarg (mb, argnum);
4874                 mono_mb_emit_icon (mb, encoding);
4875                 mono_mb_emit_icon (mb, t->attrs);
4876                 mono_mb_emit_icall (mb, mono_marshal_asany);
4877                 mono_mb_emit_stloc (mb, conv_arg);
4878                 break;
4879         }
4880
4881         case MARSHAL_ACTION_PUSH:
4882                 mono_mb_emit_ldloc (mb, conv_arg);
4883                 break;
4884
4885         case MARSHAL_ACTION_CONV_OUT: {
4886                 MonoMarshalNative encoding = mono_marshal_get_string_encoding (m->piinfo, NULL);
4887
4888                 mono_mb_emit_ldarg (mb, argnum);
4889                 mono_mb_emit_ldloc (mb, conv_arg);
4890                 mono_mb_emit_icon (mb, encoding);
4891                 mono_mb_emit_icon (mb, t->attrs);
4892                 mono_mb_emit_icall (mb, mono_marshal_free_asany);
4893                 break;
4894         }
4895
4896         default:
4897                 g_assert_not_reached ();
4898         }
4899
4900         return conv_arg;
4901 }
4902
4903 static int
4904 emit_marshal_vtype (EmitMarshalContext *m, int argnum, MonoType *t,
4905                                         MonoMarshalSpec *spec,
4906                                         int conv_arg, MonoType **conv_arg_type,
4907                                         MarshalAction action)
4908 {
4909         MonoMethodBuilder *mb = m->mb;
4910         MonoClass *klass;
4911         int pos = 0, pos2;
4912
4913         klass = t->data.klass;
4914
4915         switch (action) {
4916         case MARSHAL_ACTION_CONV_IN:
4917                 if (((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) ||
4918                         klass->blittable || klass->enumtype)
4919                         break;
4920
4921                 conv_arg = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
4922
4923                 /* store the address of the source into local variable 0 */
4924                 if (t->byref)
4925                         mono_mb_emit_ldarg (mb, argnum);
4926                 else
4927                         mono_mb_emit_ldarg_addr (mb, argnum);
4928
4929                 mono_mb_emit_stloc (mb, 0);
4930
4931                 /* allocate space for the native struct and
4932                  * store the address into local variable 1 (dest) */
4933                 mono_mb_emit_icon (mb, mono_class_native_size (klass, NULL));
4934                 mono_mb_emit_byte (mb, CEE_PREFIX1);
4935                 mono_mb_emit_byte (mb, CEE_LOCALLOC);
4936                 mono_mb_emit_stloc (mb, conv_arg);
4937
4938                 if (t->byref) {
4939                         mono_mb_emit_ldloc (mb, 0);
4940                         mono_mb_emit_byte (mb, CEE_BRFALSE);
4941                         pos = mb->pos;
4942                         mono_mb_emit_i4 (mb, 0);
4943                 }
4944
4945                 if (!(t->byref && !(t->attrs & PARAM_ATTRIBUTE_IN) && (t->attrs & PARAM_ATTRIBUTE_OUT))) {
4946                         /* set dst_ptr */
4947                         mono_mb_emit_ldloc (mb, conv_arg);
4948                         mono_mb_emit_stloc (mb, 1);
4949
4950                         /* emit valuetype conversion code */
4951                         emit_struct_conv (mb, klass, FALSE);
4952                 }
4953
4954                 if (t->byref)
4955                         mono_mb_patch_addr (mb, pos, mb->pos - (pos + 4));
4956                 break;
4957
4958         case MARSHAL_ACTION_PUSH:
4959                 if (spec && spec->native == MONO_NATIVE_LPSTRUCT) {
4960                         /* FIXME: */
4961                         g_assert (!t->byref);
4962
4963                         /* Have to change the signature since the vtype is passed byref */
4964                         m->csig->params [argnum - m->csig->hasthis] = &mono_defaults.int_class->byval_arg;
4965
4966                         if (((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) ||
4967                                 klass->blittable || klass->enumtype)
4968                                 mono_mb_emit_ldarg_addr (mb, argnum);
4969                         else
4970                                 mono_mb_emit_ldloc (mb, conv_arg);
4971                         break;
4972                 }
4973
4974                 if (((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) ||
4975                         klass->blittable || klass->enumtype) {
4976                         mono_mb_emit_ldarg (mb, argnum);
4977                         break;
4978                 }
4979                 mono_mb_emit_ldloc (mb, conv_arg);
4980                 if (!t->byref) {
4981                         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
4982                         mono_mb_emit_byte (mb, CEE_MONO_LDNATIVEOBJ);
4983                         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, klass));
4984                 }
4985                 break;
4986
4987         case MARSHAL_ACTION_CONV_OUT:
4988                 if (((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) ||
4989                         klass->blittable || klass->enumtype)
4990                         break;
4991
4992                 if (t->byref) {
4993                         /* dst = argument */
4994                         mono_mb_emit_ldarg (mb, argnum);
4995                         mono_mb_emit_stloc (mb, 1);
4996
4997                         mono_mb_emit_ldloc (mb, 1);
4998                         mono_mb_emit_byte (mb, CEE_BRFALSE);
4999                         pos = mb->pos;
5000                         mono_mb_emit_i4 (mb, 0);
5001
5002                         if (!((t->attrs & PARAM_ATTRIBUTE_IN) && !(t->attrs & PARAM_ATTRIBUTE_OUT))) {
5003                                 /* src = tmp_locals [i] */
5004                                 mono_mb_emit_ldloc (mb, conv_arg);
5005                                 mono_mb_emit_stloc (mb, 0);
5006
5007                                 /* emit valuetype conversion code */
5008                                 emit_struct_conv (mb, klass, TRUE);
5009                         }
5010                 }
5011
5012                 emit_struct_free (mb, klass, conv_arg);
5013
5014                 if (t->byref)
5015                         mono_mb_patch_addr (mb, pos, mb->pos - (pos + 4));
5016                 break;
5017
5018         case MARSHAL_ACTION_CONV_RESULT:
5019                 if (((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) ||
5020                         klass->blittable) {
5021                         mono_mb_emit_stloc (mb, 3);
5022                         break;
5023                 }
5024                 /* load pointer to returned value type */
5025                 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
5026                 mono_mb_emit_byte (mb, CEE_MONO_VTADDR);
5027                 /* store the address of the source into local variable 0 */
5028                 mono_mb_emit_stloc (mb, 0);
5029                 /* set dst_ptr */
5030                 mono_mb_emit_ldloc_addr (mb, 3);
5031                 mono_mb_emit_stloc (mb, 1);
5032
5033                 /* emit valuetype conversion code */
5034                 emit_struct_conv (mb, klass, TRUE);
5035                 break;
5036
5037         case MARSHAL_ACTION_MANAGED_CONV_IN:
5038                 if (((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) ||
5039                         klass->blittable || klass->enumtype) {
5040                         conv_arg = 0;
5041                         break;
5042                 }
5043
5044                 conv_arg = mono_mb_add_local (mb, &klass->byval_arg);
5045
5046                 if (t->attrs & PARAM_ATTRIBUTE_OUT)
5047                         break;
5048
5049                 if (t->byref)
5050                         mono_mb_emit_ldarg (mb, argnum);
5051                 else
5052                         mono_mb_emit_ldarg_addr (mb, argnum);
5053                 mono_mb_emit_stloc (mb, 0);
5054
5055                 if (t->byref) {
5056                         mono_mb_emit_ldloc (mb, 0);
5057                         mono_mb_emit_byte (mb, CEE_BRFALSE);
5058                         pos = mb->pos;
5059                         mono_mb_emit_i4 (mb, 0);
5060                 }
5061
5062                 mono_mb_emit_ldloc_addr (mb, conv_arg);
5063                 mono_mb_emit_stloc (mb, 1);
5064
5065                 /* emit valuetype conversion code */
5066                 emit_struct_conv (mb, klass, TRUE);
5067
5068                 if (t->byref)
5069                         mono_mb_patch_addr (mb, pos, mb->pos - (pos + 4));
5070                 break;
5071
5072         case MARSHAL_ACTION_MANAGED_CONV_OUT:
5073                 if (((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) ||
5074                         klass->blittable || klass->enumtype) {
5075                         break;
5076                 }
5077
5078                 /* Check for null */
5079                 mono_mb_emit_ldarg (mb, argnum);
5080                 pos2 = mono_mb_emit_branch (mb, CEE_BRFALSE);
5081
5082                 /* Set src */
5083                 mono_mb_emit_ldloc_addr (mb, conv_arg);
5084                 mono_mb_emit_stloc (mb, 0);
5085
5086                 /* Set dest */
5087                 mono_mb_emit_ldarg (mb, argnum);
5088                 mono_mb_emit_stloc (mb, 1);
5089
5090                 /* emit valuetype conversion code */
5091                 emit_struct_conv (mb, klass, FALSE);
5092
5093                 mono_mb_patch_addr (mb, pos2, mb->pos - (pos2 + 4));
5094                 break;
5095
5096         case MARSHAL_ACTION_MANAGED_CONV_RESULT:
5097                 if (((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) ||
5098                         klass->blittable || klass->enumtype) {
5099                         mono_mb_emit_stloc (mb, 3);
5100                         m->retobj_var = 0;
5101                         break;
5102                 }
5103
5104                 /* load pointer to returned value type */
5105                 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
5106                 mono_mb_emit_byte (mb, CEE_MONO_VTADDR);
5107
5108                 /* store the address of the source into local variable 0 */
5109                 mono_mb_emit_stloc (mb, 0);
5110                 /* allocate space for the native struct and
5111                  * store the address into dst_ptr */
5112                 m->retobj_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
5113                 m->retobj_class = klass;
5114                 g_assert (m->retobj_var);
5115                 mono_mb_emit_icon (mb, mono_class_native_size (klass, NULL));
5116                 mono_mb_emit_byte (mb, CEE_CONV_I);
5117                 mono_mb_emit_icall (mb, mono_marshal_alloc);
5118                 mono_mb_emit_stloc (mb, 1);
5119                 mono_mb_emit_ldloc (mb, 1);
5120                 mono_mb_emit_stloc (mb, m->retobj_var);
5121
5122                 /* emit valuetype conversion code */
5123                 emit_struct_conv (mb, klass, FALSE);
5124                 break;
5125
5126         default:
5127                 g_assert_not_reached ();
5128         }
5129
5130         return conv_arg;
5131 }
5132
5133 static int
5134 emit_marshal_string (EmitMarshalContext *m, int argnum, MonoType *t,
5135                                          MonoMarshalSpec *spec,
5136                                          int conv_arg, MonoType **conv_arg_type,
5137                                          MarshalAction action)
5138 {
5139         MonoMethodBuilder *mb = m->mb;
5140         MonoMarshalNative encoding = mono_marshal_get_string_encoding (m->piinfo, spec);
5141         MonoMarshalConv conv = mono_marshal_get_string_to_ptr_conv (m->piinfo, spec);
5142         gboolean need_free;
5143
5144         switch (action) {
5145         case MARSHAL_ACTION_CONV_IN:
5146                 *conv_arg_type = &mono_defaults.int_class->byval_arg;
5147                 conv_arg = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
5148
5149                 if (t->byref) {
5150                         if (t->attrs & PARAM_ATTRIBUTE_OUT)
5151                                 break;
5152
5153                         mono_mb_emit_ldarg (mb, argnum);
5154                         mono_mb_emit_byte (mb, CEE_LDIND_I);
5155                 } else {
5156                         mono_mb_emit_ldarg (mb, argnum);
5157                 }
5158
5159                 if (conv == -1) {
5160                         char *msg = g_strdup_printf ("string marshalling conversion %d not implemented", encoding);
5161                         MonoException *exc = mono_get_exception_not_implemented (msg);
5162                         g_warning (msg);
5163                         g_free (msg);
5164                         mono_raise_exception (exc);
5165                 }
5166                 else
5167                         mono_mb_emit_icall (mb, conv_to_icall (conv));
5168
5169                 mono_mb_emit_stloc (mb, conv_arg);
5170                 break;
5171
5172         case MARSHAL_ACTION_CONV_OUT:
5173                 if (t->byref && (t->attrs & PARAM_ATTRIBUTE_OUT)) {
5174                         mono_mb_emit_ldarg (mb, argnum);
5175                         mono_mb_emit_ldloc (mb, conv_arg);
5176                         if (conv == MONO_MARSHAL_CONV_STR_BSTR) {
5177                                 mono_mb_emit_icall (mb, conv_to_icall (MONO_MARSHAL_CONV_BSTR_STR));
5178                                 // BSTRs always need freed
5179                                 mono_mb_emit_ldloc (mb, conv_arg);
5180                                 mono_mb_emit_icall (mb, mono_free_bstr);
5181                         }
5182                         else
5183                                 mono_mb_emit_icall (mb, conv_to_icall (MONO_MARSHAL_CONV_LPSTR_STR));
5184                         mono_mb_emit_byte (mb, CEE_STIND_REF);
5185                 } else {
5186                         if (mono_marshal_need_free (t, m->piinfo, spec)) {
5187                                 mono_mb_emit_ldloc (mb, conv_arg);
5188                                 if (conv == MONO_MARSHAL_CONV_STR_BSTR)
5189                                         mono_mb_emit_icall (mb, mono_free_bstr);
5190                                 else
5191                                         mono_mb_emit_icall (mb, mono_marshal_free);
5192                         }
5193                 }
5194                 break;
5195
5196         case MARSHAL_ACTION_PUSH:
5197                 if (t->byref)
5198                         mono_mb_emit_ldloc_addr (mb, conv_arg);
5199                 else
5200                         mono_mb_emit_ldloc (mb, conv_arg);
5201                 break;
5202
5203         case MARSHAL_ACTION_CONV_RESULT:
5204                 mono_mb_emit_stloc (mb, 0);
5205
5206                 conv = mono_marshal_get_ptr_to_string_conv (m->piinfo, spec, &need_free);
5207                 if (conv == -1) {
5208                         char *msg = g_strdup_printf ("string marshalling conversion %d not implemented", encoding);
5209                         mono_mb_emit_exception_marshal_directive (mb, msg);
5210                         break;
5211                 }
5212
5213                 mono_mb_emit_ldloc (mb, 0);
5214                 mono_mb_emit_icall (mb, conv_to_icall (conv));
5215                 mono_mb_emit_stloc (mb, 3);
5216
5217                 /* free the string */
5218                 mono_mb_emit_ldloc (mb, 0);
5219                 if (conv == MONO_MARSHAL_CONV_BSTR_STR)
5220                         mono_mb_emit_icall (mb, mono_free_bstr);
5221                 else
5222                         mono_mb_emit_icall (mb, g_free);
5223                 break;
5224
5225         case MARSHAL_ACTION_MANAGED_CONV_IN:
5226                 if (t->byref) {
5227                         conv_arg = 0;
5228                         break;
5229                 }
5230
5231                 conv_arg = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
5232                 *conv_arg_type = &mono_defaults.int_class->byval_arg;
5233
5234                 conv = mono_marshal_get_ptr_to_string_conv (m->piinfo, spec, &need_free);
5235                 if (conv == -1) {
5236                         char *msg = g_strdup_printf ("string marshalling conversion %d not implemented", encoding);
5237                         mono_mb_emit_exception_marshal_directive (mb, msg);
5238                         break;
5239                 }
5240
5241                 mono_mb_emit_ldarg (mb, argnum);
5242                 mono_mb_emit_icall (mb, conv_to_icall (conv));
5243                 mono_mb_emit_stloc (mb, conv_arg);
5244                 break;
5245
5246         case MARSHAL_ACTION_MANAGED_CONV_RESULT:
5247                 mono_mb_emit_icall (mb, conv_to_icall (MONO_MARSHAL_CONV_STR_LPSTR));
5248                 mono_mb_emit_stloc (mb, 3);
5249                 break;
5250
5251         default:
5252                 g_assert_not_reached ();
5253         }
5254
5255         return conv_arg;
5256 }
5257
5258 static int
5259 emit_marshal_object (EmitMarshalContext *m, int argnum, MonoType *t,
5260                                          MonoMarshalSpec *spec,
5261                                          int conv_arg, MonoType **conv_arg_type,
5262                                          MarshalAction action)
5263 {
5264         MonoMethodBuilder *mb = m->mb;
5265         MonoClass *klass = t->data.klass;
5266         int pos, pos2, loc;
5267
5268         if (mono_class_from_mono_type (t) == mono_defaults.object_class &&
5269                 (!spec || (spec && spec->native != MONO_NATIVE_STRUCT))) {
5270                 mono_raise_exception (mono_get_exception_not_implemented ("Marshalling of type object is not implemented"));
5271         }
5272
5273         switch (action) {
5274         case MARSHAL_ACTION_CONV_IN:
5275                 *conv_arg_type = &mono_defaults.int_class->byval_arg;
5276                 conv_arg = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
5277
5278                 m->orig_conv_args [argnum] = 0;
5279
5280                 if (spec && spec->native == MONO_NATIVE_STRUCT)
5281                 {
5282                         static MonoMethod *get_native_variant_for_object = NULL;
5283                         int local_variant;
5284                         if (!get_native_variant_for_object)
5285                                 get_native_variant_for_object = mono_class_get_method_from_name (mono_defaults.marshal_class, "GetNativeVariantForObject", 2);
5286
5287                         *conv_arg_type = &mono_defaults.variant_class->byval_arg;
5288
5289                         local_variant = mono_mb_add_local (mb, &mono_defaults.variant_class->byval_arg);
5290                         conv_arg = local_variant;
5291                         mono_mb_emit_ldarg (mb, argnum);
5292                         if (t->byref)
5293                                 mono_mb_emit_byte(mb, CEE_LDIND_REF);
5294                         mono_mb_emit_ldloc_addr (mb, local_variant);
5295                         mono_mb_emit_managed_call (mb, get_native_variant_for_object, NULL);
5296                 }
5297                 else if (klass->delegate) {
5298                         g_assert (!t->byref);
5299                         mono_mb_emit_ldarg (mb, argnum);
5300                         mono_mb_emit_icall (mb, conv_to_icall (MONO_MARSHAL_CONV_DEL_FTN));
5301                         mono_mb_emit_stloc (mb, conv_arg);
5302                 } else if (klass == mono_defaults.stringbuilder_class) {
5303                         MonoMarshalNative encoding = mono_marshal_get_string_encoding (m->piinfo, spec);
5304                         MonoMarshalConv conv = mono_marshal_get_stringbuilder_to_ptr_conv (m->piinfo, spec);
5305
5306                         g_assert (!t->byref);
5307                         mono_mb_emit_ldarg (mb, argnum);
5308
5309                         if (conv != -1)
5310                                 mono_mb_emit_icall (mb, conv_to_icall (conv));
5311                         else {
5312                                 char *msg = g_strdup_printf ("stringbuilder marshalling conversion %d not implemented", encoding);
5313                                 MonoException *exc = mono_get_exception_not_implemented (msg);
5314                                 g_warning (msg);
5315                                 g_free (msg);
5316                                 mono_raise_exception (exc);
5317                         }
5318
5319                         mono_mb_emit_stloc (mb, conv_arg);
5320                 } else if (klass->blittable) {
5321                         mono_mb_emit_ldarg (mb, argnum);
5322                         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
5323                         mono_mb_emit_byte (mb, CEE_MONO_OBJADDR);
5324                         mono_mb_emit_icon (mb, sizeof (MonoObject));
5325                         mono_mb_emit_byte (mb, CEE_ADD);
5326                         mono_mb_emit_stloc (mb, conv_arg);
5327                         break;
5328                 } else {
5329                         mono_mb_emit_byte (mb, CEE_LDNULL);
5330                         mono_mb_emit_stloc (mb, conv_arg);
5331
5332                         if (t->byref) {
5333                                 /* we dont need any conversions for out parameters */
5334                                 if (t->attrs & PARAM_ATTRIBUTE_OUT)
5335                                         break;
5336
5337                                 mono_mb_emit_ldarg (mb, argnum);
5338                                 mono_mb_emit_byte (mb, CEE_LDIND_I);
5339
5340                         } else {
5341                                 mono_mb_emit_ldarg (mb, argnum);
5342                                 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
5343                                 mono_mb_emit_byte (mb, CEE_MONO_OBJADDR);
5344                         }
5345
5346                         /* store the address of the source into local variable 0 */
5347                         mono_mb_emit_stloc (mb, 0);
5348                         mono_mb_emit_ldloc (mb, 0);
5349                         mono_mb_emit_byte (mb, CEE_BRFALSE);
5350                         pos = mb->pos;
5351                         mono_mb_emit_i4 (mb, 0);
5352
5353                         /* allocate space for the native struct and store the address */
5354                         mono_mb_emit_icon (mb, mono_class_native_size (klass, NULL));
5355                         mono_mb_emit_byte (mb, CEE_PREFIX1);
5356                         mono_mb_emit_byte (mb, CEE_LOCALLOC);
5357                         mono_mb_emit_stloc (mb, conv_arg);
5358
5359                         if (t->byref) {
5360                                 /* Need to store the original buffer so we can free it later */
5361                                 m->orig_conv_args [argnum] = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
5362                                 mono_mb_emit_ldloc (mb, conv_arg);
5363                                 mono_mb_emit_stloc (mb, m->orig_conv_args [argnum]);
5364                         }
5365
5366                         /* set the src_ptr */
5367                         mono_mb_emit_ldloc (mb, 0);
5368                         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
5369                         mono_mb_emit_byte (mb, CEE_MONO_OBJADDR);
5370                         mono_mb_emit_icon (mb, sizeof (MonoObject));
5371                         mono_mb_emit_byte (mb, CEE_ADD);
5372                         mono_mb_emit_stloc (mb, 0);
5373
5374                         /* set dst_ptr */
5375                         mono_mb_emit_ldloc (mb, conv_arg);
5376                         mono_mb_emit_stloc (mb, 1);
5377
5378                         /* emit valuetype conversion code */
5379                         emit_struct_conv (mb, klass, FALSE);
5380
5381                         mono_mb_patch_addr (mb, pos, mb->pos - (pos + 4));
5382                 }
5383                 break;
5384
5385         case MARSHAL_ACTION_CONV_OUT:
5386                 if (spec && spec->native == MONO_NATIVE_STRUCT) {
5387                         static MonoMethod *variant_clear = NULL;
5388                         static MonoMethod *get_object_for_native_variant = NULL;
5389                         if (!variant_clear)
5390                                 variant_clear = mono_class_get_method_from_name (mono_defaults.variant_class, "Clear", 0);
5391                         if (!get_object_for_native_variant)
5392                                 get_object_for_native_variant = mono_class_get_method_from_name (mono_defaults.marshal_class, "GetObjectForNativeVariant", 1);
5393                         if (t->byref) {
5394                                 mono_mb_emit_ldarg (mb, argnum);
5395                                 mono_mb_emit_ldloc_addr (mb, conv_arg);
5396                                 mono_mb_emit_managed_call (mb, get_object_for_native_variant, NULL);
5397                                 mono_mb_emit_byte (mb, CEE_STIND_REF);
5398                         }
5399
5400                         mono_mb_emit_ldloc_addr (mb, conv_arg);
5401                         mono_mb_emit_managed_call (mb, variant_clear, NULL);
5402                         break;
5403                 }
5404                 if (klass == mono_defaults.stringbuilder_class) {
5405                         gboolean need_free;
5406                         MonoMarshalNative encoding;
5407                         MonoMarshalConv conv;
5408
5409                         encoding = mono_marshal_get_string_encoding (m->piinfo, spec);
5410                         conv = mono_marshal_get_ptr_to_stringbuilder_conv (m->piinfo, spec, &need_free);
5411
5412                         g_assert (!t->byref);
5413                         g_assert (encoding != -1);
5414
5415                         mono_mb_emit_ldarg (mb, argnum);
5416                         mono_mb_emit_ldloc (mb, conv_arg);
5417
5418                         mono_mb_emit_icall (mb, conv_to_icall (conv));
5419
5420                         if (need_free) {
5421                                 mono_mb_emit_ldloc (mb, conv_arg);
5422                                 mono_mb_emit_icall (mb, mono_marshal_free);
5423                         }
5424                         break;
5425                 }
5426
5427                 if (klass->delegate)
5428                         break;
5429
5430                 if (t->byref && (t->attrs & PARAM_ATTRIBUTE_OUT)) {
5431                         /* allocate a new object */
5432                         mono_mb_emit_ldarg (mb, argnum);
5433                         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
5434                         mono_mb_emit_byte (mb, CEE_MONO_NEWOBJ);
5435                         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, t->data.klass));
5436                         mono_mb_emit_byte (mb, CEE_STIND_REF);
5437                 }
5438
5439                 /* dst = *argument */
5440                 mono_mb_emit_ldarg (mb, argnum);
5441
5442                 if (t->byref)
5443                         mono_mb_emit_byte (mb, CEE_LDIND_I);
5444
5445                 mono_mb_emit_stloc (mb, 1);
5446
5447                 mono_mb_emit_ldloc (mb, 1);
5448                 mono_mb_emit_byte (mb, CEE_BRFALSE);
5449                 pos = mb->pos;
5450                 mono_mb_emit_i4 (mb, 0);
5451
5452                 if (t->byref || (t->attrs & PARAM_ATTRIBUTE_OUT)) {
5453                         mono_mb_emit_ldloc (mb, 1);
5454                         mono_mb_emit_icon (mb, sizeof (MonoObject));
5455                         mono_mb_emit_byte (mb, CEE_ADD);
5456                         mono_mb_emit_stloc (mb, 1);
5457
5458                         /* src = tmp_locals [i] */
5459                         mono_mb_emit_ldloc (mb, conv_arg);
5460                         mono_mb_emit_stloc (mb, 0);
5461
5462                         /* emit valuetype conversion code */
5463                         emit_struct_conv (mb, t->data.klass, TRUE);
5464
5465                         /* Free the structure returned by the native code */
5466                         emit_struct_free (mb, klass, conv_arg);
5467
5468                         if (m->orig_conv_args [argnum]) {
5469                                 /*
5470                                  * If the native function changed the pointer, then free
5471                                  * the original structure plus the new pointer.
5472                                  */
5473                                 mono_mb_emit_ldloc (mb, m->orig_conv_args [argnum]);
5474                                 mono_mb_emit_ldloc (mb, conv_arg);
5475                                 mono_mb_emit_byte (mb, CEE_BEQ);
5476                                 pos2 = mb->pos;
5477                                 mono_mb_emit_i4 (mb, 0);
5478
5479                                 if (!(t->attrs & PARAM_ATTRIBUTE_OUT)) {
5480                                         g_assert (m->orig_conv_args [argnum]);
5481
5482                                         emit_struct_free (mb, klass, m->orig_conv_args [argnum]);
5483                                 }
5484
5485                                 mono_mb_emit_ldloc (mb, conv_arg);
5486                                 mono_mb_emit_icall (mb, g_free);
5487
5488                                 mono_mb_patch_addr (mb, pos2, mb->pos - (pos2 + 4));
5489                         }
5490                 }
5491                 else
5492                         /* Free the original structure passed to native code */
5493                         emit_struct_free (mb, klass, conv_arg);
5494
5495                 mono_mb_patch_addr (mb, pos, mb->pos - (pos + 4));
5496                 break;
5497
5498         case MARSHAL_ACTION_PUSH:
5499                 if (t->byref)
5500                         mono_mb_emit_ldloc_addr (mb, conv_arg);
5501                 else
5502                         mono_mb_emit_ldloc (mb, conv_arg);
5503                 break;
5504
5505         case MARSHAL_ACTION_CONV_RESULT:
5506                 if (klass->delegate) {
5507                         g_assert (!t->byref);
5508                         mono_mb_emit_stloc (mb, 0);
5509                         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
5510                         mono_mb_emit_byte (mb, CEE_MONO_CLASSCONST);
5511                         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, klass));
5512                         mono_mb_emit_ldloc (mb, 0);
5513                         mono_mb_emit_icall (mb, conv_to_icall (MONO_MARSHAL_CONV_FTN_DEL));
5514                         mono_mb_emit_stloc (mb, 3);
5515                 } else {
5516                         /* set src */
5517                         mono_mb_emit_stloc (mb, 0);
5518
5519                         /* Make a copy since emit_conv modifies local 0 */
5520                         loc = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
5521                         mono_mb_emit_ldloc (mb, 0);
5522                         mono_mb_emit_stloc (mb, loc);
5523
5524                         mono_mb_emit_byte (mb, CEE_LDNULL);
5525                         mono_mb_emit_stloc (mb, 3);
5526
5527                         mono_mb_emit_ldloc (mb, 0);
5528                         mono_mb_emit_byte (mb, CEE_BRFALSE);
5529                         pos = mb->pos;
5530                         mono_mb_emit_i4 (mb, 0);
5531
5532                         /* allocate result object */
5533
5534                         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
5535                         mono_mb_emit_byte (mb, CEE_MONO_NEWOBJ);
5536                         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, klass));
5537                         mono_mb_emit_stloc (mb, 3);
5538
5539                         /* set dst  */
5540
5541                         mono_mb_emit_ldloc (mb, 3);
5542                         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
5543                         mono_mb_emit_byte (mb, CEE_MONO_OBJADDR);
5544                         mono_mb_emit_icon (mb, sizeof (MonoObject));
5545                         mono_mb_emit_byte (mb, CEE_ADD);
5546                         mono_mb_emit_stloc (mb, 1);
5547
5548                         /* emit conversion code */
5549                         emit_struct_conv (mb, klass, TRUE);
5550
5551                         emit_struct_free (mb, klass, loc);
5552
5553                         /* Free the pointer allocated by unmanaged code */
5554                         mono_mb_emit_ldloc (mb, loc);
5555                         mono_mb_emit_icall (mb, g_free);
5556                         mono_mb_patch_addr (mb, pos, mb->pos - (pos + 4));
5557                 }
5558                 break;
5559
5560         case MARSHAL_ACTION_MANAGED_CONV_IN:
5561                 conv_arg = mono_mb_add_local (mb, &klass->byval_arg);
5562
5563                 if (klass->delegate) {
5564                         g_assert (!t->byref);
5565                         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
5566                         mono_mb_emit_byte (mb, CEE_MONO_CLASSCONST);
5567                         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, klass));
5568                         mono_mb_emit_ldarg (mb, argnum);
5569                         mono_mb_emit_icall (mb, conv_to_icall (MONO_MARSHAL_CONV_FTN_DEL));
5570                         mono_mb_emit_stloc (mb, conv_arg);
5571                         break;
5572                 }
5573
5574                 /* The class can not have an automatic layout */
5575                 if ((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_AUTO_LAYOUT) {
5576                         mono_mb_emit_auto_layout_exception (mb, klass);
5577                         break;
5578                 }
5579
5580                 if (t->attrs & PARAM_ATTRIBUTE_OUT) {
5581                         mono_mb_emit_byte (mb, CEE_LDNULL);
5582                         mono_mb_emit_stloc (mb, conv_arg);
5583                         break;
5584                 }
5585
5586                 /* Set src */
5587                 mono_mb_emit_ldarg (mb, argnum);
5588                 if (t->byref) {
5589                         int pos2;
5590
5591                         /* Check for NULL and raise an exception */
5592                         mono_mb_emit_byte (mb, CEE_BRTRUE);
5593                         pos2 = mb->pos;
5594                         mono_mb_emit_i4 (mb, 0);
5595
5596                         mono_mb_emit_exception (mb, "ArgumentNullException", NULL);
5597
5598                         mono_mb_patch_addr (mb, pos2, mb->pos - (pos2 + 4));
5599                         mono_mb_emit_ldarg (mb, argnum);
5600                         mono_mb_emit_byte (mb, CEE_LDIND_I);
5601                 }
5602
5603                 mono_mb_emit_stloc (mb, 0);
5604
5605                 mono_mb_emit_byte (mb, CEE_LDC_I4_0);
5606                 mono_mb_emit_stloc (mb, conv_arg);
5607
5608                 mono_mb_emit_ldloc (mb, 0);
5609                 mono_mb_emit_byte (mb, CEE_BRFALSE);
5610                 pos = mb->pos;
5611                 mono_mb_emit_i4 (mb, 0);
5612
5613                 /* Create and set dst */
5614                 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
5615                 mono_mb_emit_byte (mb, CEE_MONO_NEWOBJ);
5616                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, klass));
5617                 mono_mb_emit_stloc (mb, conv_arg);
5618                 mono_mb_emit_ldloc (mb, conv_arg);
5619                 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
5620                 mono_mb_emit_byte (mb, CEE_MONO_OBJADDR);
5621                 mono_mb_emit_icon (mb, sizeof (MonoObject));
5622                 mono_mb_emit_byte (mb, CEE_ADD);
5623                 mono_mb_emit_stloc (mb, 1);
5624
5625                 /* emit valuetype conversion code */
5626                 emit_struct_conv (mb, klass, TRUE);
5627
5628                 mono_mb_patch_addr (mb, pos, mb->pos - (pos + 4));
5629                 break;
5630
5631         case MARSHAL_ACTION_MANAGED_CONV_OUT:
5632                 /* Check for null */
5633                 mono_mb_emit_ldloc (mb, conv_arg);
5634                 pos = mono_mb_emit_branch (mb, CEE_BRTRUE);
5635                 mono_mb_emit_ldarg (mb, argnum);
5636                 mono_mb_emit_byte (mb, CEE_LDC_I4_0);
5637                 mono_mb_emit_byte (mb, CEE_STIND_REF);
5638                 pos2 = mono_mb_emit_branch (mb, CEE_BR);
5639
5640                 mono_mb_patch_addr (mb, pos, mb->pos - (pos + 4));
5641
5642                 /* Set src */
5643                 mono_mb_emit_ldloc (mb, conv_arg);
5644                 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
5645                 mono_mb_emit_byte (mb, CEE_MONO_OBJADDR);
5646                 mono_mb_emit_icon (mb, sizeof (MonoObject));
5647                 mono_mb_emit_byte (mb, CEE_ADD);
5648                 mono_mb_emit_stloc (mb, 0);
5649
5650                 /* Allocate and set dest */
5651                 mono_mb_emit_icon (mb, mono_class_native_size (klass, NULL));
5652                 mono_mb_emit_byte (mb, CEE_CONV_I);
5653                 mono_mb_emit_icall (mb, mono_marshal_alloc);
5654                 mono_mb_emit_stloc (mb, 1);
5655
5656                 /* Update argument pointer */
5657                 mono_mb_emit_ldarg (mb, argnum);
5658                 mono_mb_emit_ldloc (mb, 1);
5659                 mono_mb_emit_byte (mb, CEE_STIND_I);
5660
5661                 /* emit valuetype conversion code */
5662                 emit_struct_conv (mb, klass, FALSE);
5663
5664                 mono_mb_patch_addr (mb, pos2, mb->pos - (pos2 + 4));
5665                 break;
5666
5667         case MARSHAL_ACTION_MANAGED_CONV_RESULT:
5668                 if (klass->delegate) {
5669                         mono_mb_emit_icall (mb, conv_to_icall (MONO_MARSHAL_CONV_DEL_FTN));
5670                         mono_mb_emit_stloc (mb, 3);
5671                         break;
5672                 }
5673
5674                 /* The class can not have an automatic layout */
5675                 if ((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_AUTO_LAYOUT) {
5676                         mono_mb_emit_auto_layout_exception (mb, klass);
5677                         break;
5678                 }
5679
5680                 mono_mb_emit_stloc (mb, 0);
5681                 /* Check for null */
5682                 mono_mb_emit_ldloc (mb, 0);
5683                 pos = mono_mb_emit_branch (mb, CEE_BRTRUE);
5684                 mono_mb_emit_byte (mb, CEE_LDNULL);
5685                 mono_mb_emit_stloc (mb, 3);
5686                 pos2 = mono_mb_emit_branch (mb, CEE_BR);
5687
5688                 mono_mb_patch_addr (mb, pos, mb->pos - (pos + 4));
5689
5690                 /* Set src */
5691                 mono_mb_emit_ldloc (mb, 0);
5692                 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
5693                 mono_mb_emit_byte (mb, CEE_MONO_OBJADDR);
5694                 mono_mb_emit_icon (mb, sizeof (MonoObject));
5695                 mono_mb_emit_byte (mb, CEE_ADD);
5696                 mono_mb_emit_stloc (mb, 0);
5697
5698                 /* Allocate and set dest */
5699                 mono_mb_emit_icon (mb, mono_class_native_size (klass, NULL));
5700                 mono_mb_emit_byte (mb, CEE_CONV_I);
5701                 mono_mb_emit_icall (mb, mono_marshal_alloc);
5702                 mono_mb_emit_byte (mb, CEE_DUP);
5703                 mono_mb_emit_stloc (mb, 1);
5704                 mono_mb_emit_stloc (mb, 3);
5705
5706                 emit_struct_conv (mb, klass, FALSE);
5707
5708                 mono_mb_patch_addr (mb, pos2, mb->pos - (pos2 + 4));
5709                 break;
5710
5711         default:
5712                 g_assert_not_reached ();
5713         }
5714
5715         return conv_arg;
5716 }
5717
5718 static int
5719 emit_marshal_array (EmitMarshalContext *m, int argnum, MonoType *t,
5720                                         MonoMarshalSpec *spec,
5721                                         int conv_arg, MonoType **conv_arg_type,
5722                                         MarshalAction action)
5723 {
5724         MonoMethodBuilder *mb = m->mb;
5725         MonoClass *klass = mono_class_from_mono_type (t);
5726         gboolean need_convert, need_free;
5727         MonoMarshalNative encoding;
5728
5729         encoding = mono_marshal_get_string_encoding (m->piinfo, spec);
5730
5731         switch (action) {
5732         case MARSHAL_ACTION_CONV_IN:
5733                 *conv_arg_type = &mono_defaults.object_class->byval_arg;
5734                 conv_arg = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
5735
5736                 if (klass->element_class->blittable) {
5737                         mono_mb_emit_ldarg (mb, argnum);
5738                         if (t->byref)
5739                                 mono_mb_emit_byte (mb, CEE_LDIND_I);
5740                         mono_mb_emit_icall (mb, conv_to_icall (MONO_MARSHAL_CONV_ARRAY_LPARRAY));
5741                         mono_mb_emit_stloc (mb, conv_arg);
5742                 } else {
5743                         MonoClass *eklass;
5744                         guint32 label1, label2, label3;
5745                         int index_var, src_var, dest_ptr, esize;
5746                         MonoMarshalConv conv;
5747                         gboolean is_string = FALSE;
5748
5749                         dest_ptr = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
5750
5751                         eklass = klass->element_class;
5752
5753                         if (eklass == mono_defaults.string_class) {
5754                                 is_string = TRUE;
5755                                 conv = mono_marshal_get_string_to_ptr_conv (m->piinfo, spec);
5756                         }
5757                         else if (eklass == mono_defaults.stringbuilder_class) {
5758                                 is_string = TRUE;
5759                                 conv = mono_marshal_get_stringbuilder_to_ptr_conv (m->piinfo, spec);
5760                         }
5761                         else
5762                                 conv = -1;
5763
5764                         src_var = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
5765                         mono_mb_emit_ldarg (mb, argnum);
5766                         if (t->byref)
5767                                 mono_mb_emit_byte (mb, CEE_LDIND_I);
5768                         mono_mb_emit_stloc (mb, src_var);
5769
5770                         /* Check null */
5771                         mono_mb_emit_ldloc (mb, src_var);
5772                         mono_mb_emit_stloc (mb, conv_arg);
5773                         mono_mb_emit_ldloc (mb, src_var);
5774                         mono_mb_emit_byte (mb, CEE_BRFALSE);
5775                         label1 = mb->pos;
5776                         mono_mb_emit_i4 (mb, 0);
5777
5778                         if (is_string) {
5779                                 if (conv == -1) {
5780                                         char *msg = g_strdup_printf ("string/stringbuilder marshalling conversion %d not implemented", encoding);
5781                                         MonoException *exc = mono_get_exception_not_implemented (msg);
5782                                         g_warning (msg);
5783                                         g_free (msg);
5784                                         mono_raise_exception (exc);
5785                                 }
5786                         }
5787
5788                         if (is_string)
5789                                 esize = sizeof (gpointer);
5790                         else
5791                                 esize = mono_class_native_size (eklass, NULL);
5792
5793                         /* allocate space for the native struct and store the address */
5794                         mono_mb_emit_icon (mb, esize);
5795                         mono_mb_emit_ldloc (mb, src_var);
5796                         mono_mb_emit_byte (mb, CEE_LDLEN);
5797
5798                         if (eklass == mono_defaults.string_class) {
5799                                 /* Make the array bigger for the terminating null */
5800                                 mono_mb_emit_byte (mb, CEE_LDC_I4_1);
5801                                 mono_mb_emit_byte (mb, CEE_ADD);
5802                         }
5803                         mono_mb_emit_byte (mb, CEE_MUL);
5804                         mono_mb_emit_byte (mb, CEE_PREFIX1);
5805                         mono_mb_emit_byte (mb, CEE_LOCALLOC);
5806                         mono_mb_emit_stloc (mb, conv_arg);
5807
5808                         mono_mb_emit_ldloc (mb, conv_arg);
5809                         mono_mb_emit_stloc (mb, dest_ptr);
5810
5811                         /* Emit marshalling loop */
5812                         index_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
5813                         mono_mb_emit_byte (mb, CEE_LDC_I4_0);
5814                         mono_mb_emit_stloc (mb, index_var);
5815                         label2 = mb->pos;
5816                         mono_mb_emit_ldloc (mb, index_var);
5817                         mono_mb_emit_ldloc (mb, src_var);
5818                         mono_mb_emit_byte (mb, CEE_LDLEN);
5819                         mono_mb_emit_byte (mb, CEE_BGE);
5820                         label3 = mb->pos;
5821                         mono_mb_emit_i4 (mb, 0);
5822
5823                         /* Emit marshalling code */
5824
5825                         if (is_string) {
5826                                 mono_mb_emit_ldloc (mb, dest_ptr);
5827                                 mono_mb_emit_ldloc (mb, src_var);
5828                                 mono_mb_emit_ldloc (mb, index_var);
5829                                 mono_mb_emit_byte (mb, CEE_LDELEM_REF);
5830                                 mono_mb_emit_icall (mb, conv_to_icall (conv));
5831                                 mono_mb_emit_byte (mb, CEE_STIND_I);
5832                         } else {
5833                                 /* set the src_ptr */
5834                                 mono_mb_emit_ldloc (mb, src_var);
5835                                 mono_mb_emit_ldloc (mb, index_var);
5836                                 mono_mb_emit_byte (mb, CEE_LDELEMA);
5837                                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, eklass));
5838                                 mono_mb_emit_stloc (mb, 0);
5839
5840                                 /* set dst_ptr */
5841                                 mono_mb_emit_ldloc (mb, dest_ptr);
5842                                 mono_mb_emit_stloc (mb, 1);
5843
5844                                 /* emit valuetype conversion code */
5845                                 emit_struct_conv (mb, eklass, FALSE);
5846                         }
5847
5848                         mono_mb_emit_add_to_local (mb, index_var, 1);
5849                         mono_mb_emit_add_to_local (mb, dest_ptr, esize);
5850
5851                         mono_mb_emit_byte (mb, CEE_BR);
5852                         mono_mb_emit_i4 (mb, label2 - (mb->pos + 4));
5853
5854                         mono_mb_patch_addr (mb, label3, mb->pos - (label3 + 4));
5855
5856                         if (eklass == mono_defaults.string_class) {
5857                                 /* Null terminate */
5858                                 mono_mb_emit_ldloc (mb, dest_ptr);
5859                                 mono_mb_emit_byte (mb, CEE_LDC_I4_0);
5860                                 mono_mb_emit_byte (mb, CEE_STIND_REF);
5861                         }
5862
5863                         mono_mb_patch_addr (mb, label1, mb->pos - (label1 + 4));
5864                 }
5865
5866                 break;
5867
5868         case MARSHAL_ACTION_CONV_OUT:
5869                 /* Unicode character arrays are implicitly marshalled as [Out] under MS.NET */
5870                 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);
5871                 need_free = mono_marshal_need_free (&klass->element_class->byval_arg,
5872                                                                                         m->piinfo, spec);
5873
5874                 if (need_convert || need_free) {
5875                         /* FIXME: Optimize blittable case */
5876                         MonoClass *eklass;
5877                         guint32 label1, label2, label3;
5878                         int index_var, src_ptr, loc, esize;
5879
5880                         eklass = klass->element_class;
5881                         if ((eklass == mono_defaults.stringbuilder_class) || (eklass == mono_defaults.string_class))
5882                                 esize = sizeof (gpointer);
5883                         else
5884                                 esize = mono_class_native_size (eklass, NULL);
5885                         src_ptr = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
5886                         loc = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
5887
5888                         /* Check null */
5889                         mono_mb_emit_ldarg (mb, argnum);
5890                         if (t->byref)
5891                                 mono_mb_emit_byte (mb, CEE_LDIND_I);
5892                         mono_mb_emit_byte (mb, CEE_BRFALSE);
5893                         label1 = mb->pos;
5894                         mono_mb_emit_i4 (mb, 0);
5895
5896                         mono_mb_emit_ldloc (mb, conv_arg);
5897                         mono_mb_emit_stloc (mb, src_ptr);
5898
5899                         /* Emit marshalling loop */
5900                         index_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
5901                         mono_mb_emit_byte (mb, CEE_LDC_I4_0);
5902                         mono_mb_emit_stloc (mb, index_var);
5903                         label2 = mb->pos;
5904                         mono_mb_emit_ldloc (mb, index_var);
5905                         mono_mb_emit_ldarg (mb, argnum);
5906                         if (t->byref)
5907                                 mono_mb_emit_byte (mb, CEE_LDIND_REF);
5908                         mono_mb_emit_byte (mb, CEE_LDLEN);
5909                         mono_mb_emit_byte (mb, CEE_BGE);
5910                         label3 = mb->pos;
5911                         mono_mb_emit_i4 (mb, 0);
5912
5913                         /* Emit marshalling code */
5914
5915                         if (eklass == mono_defaults.stringbuilder_class) {
5916                                 gboolean need_free2;
5917                                 MonoMarshalConv conv = mono_marshal_get_ptr_to_stringbuilder_conv (m->piinfo, spec, &need_free2);
5918
5919                                 g_assert (conv != -1);
5920
5921                                 /* dest */
5922                                 mono_mb_emit_ldarg (mb, argnum);
5923                                 if (t->byref)
5924                                         mono_mb_emit_byte (mb, CEE_LDIND_I);
5925                                 mono_mb_emit_ldloc (mb, index_var);
5926                                 mono_mb_emit_byte (mb, CEE_LDELEM_REF);
5927
5928                                 /* src */
5929                                 mono_mb_emit_ldloc (mb, src_ptr);
5930                                 mono_mb_emit_byte (mb, CEE_LDIND_I);
5931
5932                                 mono_mb_emit_icall (mb, conv_to_icall (conv));
5933
5934                                 if (need_free) {
5935                                         /* src */
5936                                         mono_mb_emit_ldloc (mb, src_ptr);
5937                                         mono_mb_emit_byte (mb, CEE_LDIND_I);
5938
5939                                         mono_mb_emit_icall (mb, mono_marshal_free);
5940                                 }
5941                         }
5942                         else if (eklass == mono_defaults.string_class) {
5943                                 if (need_free) {
5944                                         /* src */
5945                                         mono_mb_emit_ldloc (mb, src_ptr);
5946                                         mono_mb_emit_byte (mb, CEE_LDIND_I);
5947
5948                                         mono_mb_emit_icall (mb, mono_marshal_free);
5949                                 }
5950                         }
5951                         else {
5952                                 if (need_convert) {
5953                                         /* set the src_ptr */
5954                                         mono_mb_emit_ldloc (mb, src_ptr);
5955                                         mono_mb_emit_stloc (mb, 0);
5956
5957                                         /* set dst_ptr */
5958                                         mono_mb_emit_ldarg (mb, argnum);
5959                                         if (t->byref)
5960                                                 mono_mb_emit_byte (mb, CEE_LDIND_I);
5961                                         mono_mb_emit_ldloc (mb, index_var);
5962                                         mono_mb_emit_byte (mb, CEE_LDELEMA);
5963                                         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, eklass));
5964                                         mono_mb_emit_stloc (mb, 1);
5965
5966                                         /* emit valuetype conversion code */
5967                                         emit_struct_conv (mb, eklass, TRUE);
5968                                 }
5969
5970                                 if (need_free) {
5971                                         mono_mb_emit_ldloc (mb, src_ptr);
5972                                         mono_mb_emit_stloc (mb, loc);
5973                                         mono_mb_emit_ldloc (mb, loc);
5974
5975                                         emit_struct_free (mb, eklass, loc);
5976                                 }
5977                         }
5978
5979                         mono_mb_emit_add_to_local (mb, index_var, 1);
5980                         mono_mb_emit_add_to_local (mb, src_ptr, esize);
5981
5982                         mono_mb_emit_byte (mb, CEE_BR);
5983                         mono_mb_emit_i4 (mb, label2 - (mb->pos + 4));
5984
5985                         mono_mb_patch_addr (mb, label1, mb->pos - (label1 + 4));
5986                         mono_mb_patch_addr (mb, label3, mb->pos - (label3 + 4));
5987                 }
5988                 break;
5989
5990         case MARSHAL_ACTION_PUSH:
5991                 if (t->byref)
5992                         mono_mb_emit_ldloc_addr (mb, conv_arg);
5993                 else
5994                         mono_mb_emit_ldloc (mb, conv_arg);
5995                 break;
5996
5997         case MARSHAL_ACTION_CONV_RESULT:
5998                 /* fixme: we need conversions here */
5999                 mono_mb_emit_stloc (mb, 3);
6000                 break;
6001
6002         case MARSHAL_ACTION_MANAGED_CONV_IN: {
6003                 MonoClass *eklass;
6004                 guint32 label1, label2, label3;
6005                 int index_var, src_ptr, loc, esize, param_num, num_elem;
6006                 MonoMarshalConv conv;
6007                 gboolean is_string = FALSE;
6008
6009                 conv_arg = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
6010                 *conv_arg_type = &mono_defaults.int_class->byval_arg;
6011
6012                 if (t->byref) {
6013                         char *msg = g_strdup ("Byref array marshalling to managed code is not implemented.");
6014                         mono_mb_emit_exception_marshal_directive (mb, msg);
6015                         return conv_arg;
6016                 }
6017                 if (spec->native != MONO_NATIVE_LPARRAY) {
6018                         char *msg = g_strdup ("Non LPArray marshalling of arrays to managed code is not implemented.");
6019                         mono_mb_emit_exception_marshal_directive (mb, msg);
6020                         return conv_arg;
6021                 }
6022
6023                 /* FIXME: t is from the method which is wrapped, not the delegate type */
6024                 /* g_assert (t->attrs & PARAM_ATTRIBUTE_IN); */
6025
6026                 param_num = spec->data.array_data.param_num;
6027                 num_elem = spec->data.array_data.num_elem;
6028                 if (spec->data.array_data.elem_mult == 0)
6029                         /* param_num is not specified */
6030                         param_num = -1;
6031
6032                 if (param_num == -1) {
6033                         if (num_elem <= 0) {
6034                                 char *msg = g_strdup ("Either SizeConst or SizeParamIndex should be specified when marshalling arrays to managed code.");
6035                                 mono_mb_emit_exception_marshal_directive (mb, msg);
6036                                 return conv_arg;
6037                         }
6038                 }
6039
6040                 /* FIXME: Optimize blittable case */
6041
6042                 eklass = klass->element_class;
6043                 if (eklass == mono_defaults.string_class) {
6044                         is_string = TRUE;
6045                         conv = mono_marshal_get_ptr_to_string_conv (m->piinfo, spec, &need_free);
6046                 }
6047                 else if (eklass == mono_defaults.stringbuilder_class) {
6048                         is_string = TRUE;
6049                         conv = mono_marshal_get_ptr_to_stringbuilder_conv (m->piinfo, spec, &need_free);
6050                 }
6051                 else
6052                         conv = -1;
6053
6054                 mono_marshal_load_type_info (eklass);
6055
6056                 if (is_string)
6057                         esize = sizeof (gpointer);
6058                 else
6059                         esize = mono_class_native_size (eklass, NULL);
6060                 src_ptr = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
6061                 loc = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
6062
6063                 mono_mb_emit_byte (mb, CEE_LDNULL);
6064                 mono_mb_emit_stloc (mb, conv_arg);
6065
6066                 /* Check param index */
6067                 if (param_num != -1) {
6068                         if (param_num >= m->sig->param_count) {
6069                                 char *msg = g_strdup ("Array size control parameter index is out of range.");
6070                                 mono_mb_emit_exception_marshal_directive (mb, msg);
6071                                 return conv_arg;
6072                         }
6073                         switch (m->sig->params [param_num]->type) {
6074                         case MONO_TYPE_I1:
6075                         case MONO_TYPE_U1:
6076                         case MONO_TYPE_I2:
6077                         case MONO_TYPE_U2:
6078                         case MONO_TYPE_I4:
6079                         case MONO_TYPE_U4:
6080                         case MONO_TYPE_I:
6081                         case MONO_TYPE_U:
6082                         case MONO_TYPE_I8:
6083                         case MONO_TYPE_U8:
6084                                 break;
6085                         default: {
6086                                 char *msg = g_strdup ("Array size control parameter must be an integral type.");
6087                                 mono_mb_emit_exception_marshal_directive (mb, msg);
6088                                 return conv_arg;
6089                         }
6090                         }
6091                 }
6092
6093                 /* Check null */
6094                 mono_mb_emit_ldarg (mb, argnum);
6095                 mono_mb_emit_byte (mb, CEE_BRFALSE);
6096                 label1 = mb->pos;
6097                 mono_mb_emit_i4 (mb, 0);
6098
6099                 mono_mb_emit_ldarg (mb, argnum);
6100                 mono_mb_emit_stloc (mb, src_ptr);
6101
6102                 /* Create managed array */
6103                 /*
6104                  * The LPArray marshalling spec says that sometimes param_num starts
6105                  * from 1, sometimes it starts from 0. But MS seems to allways start
6106                  * from 0.
6107                  */
6108
6109                 if (param_num == -1)
6110                         mono_mb_emit_icon (mb, num_elem);
6111                 else {
6112                         /* FIXME: Add the two together */
6113                         mono_mb_emit_ldarg (mb, param_num);
6114                         if (num_elem > 0) {
6115                                 mono_mb_emit_icon (mb, num_elem);
6116                                 mono_mb_emit_byte (mb, CEE_ADD);
6117                         }
6118                 }
6119
6120                 mono_mb_emit_byte (mb, CEE_NEWARR);
6121                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, eklass));
6122                 mono_mb_emit_stloc (mb, conv_arg);
6123
6124                 if (eklass->blittable) {
6125                         mono_mb_emit_ldloc (mb, conv_arg);
6126                         mono_mb_emit_byte (mb, CEE_CONV_I);
6127                         mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoArray, vector));
6128                         mono_mb_emit_byte (mb, CEE_ADD);
6129                         mono_mb_emit_ldarg (mb, argnum);
6130                         mono_mb_emit_ldloc (mb, conv_arg);
6131                         mono_mb_emit_byte (mb, CEE_LDLEN);
6132                         mono_mb_emit_icon (mb, esize);
6133                         mono_mb_emit_byte (mb, CEE_MUL);
6134                         mono_mb_emit_byte (mb, CEE_PREFIX1);
6135                         mono_mb_emit_byte (mb, CEE_CPBLK);
6136                         break;
6137                 }
6138
6139                 /* Emit marshalling loop */
6140                 index_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
6141                 mono_mb_emit_byte (mb, CEE_LDC_I4_0);
6142                 mono_mb_emit_stloc (mb, index_var);
6143                 label2 = mb->pos;
6144                 mono_mb_emit_ldloc (mb, index_var);
6145                 mono_mb_emit_ldloc (mb, conv_arg);
6146                 mono_mb_emit_byte (mb, CEE_LDLEN);
6147                 mono_mb_emit_byte (mb, CEE_BGE);
6148                 label3 = mb->pos;
6149                 mono_mb_emit_i4 (mb, 0);
6150
6151                 /* Emit marshalling code */
6152                 if (is_string) {
6153                         g_assert (conv != -1);
6154
6155                         mono_mb_emit_ldloc (mb, conv_arg);
6156                         mono_mb_emit_ldloc (mb, index_var);
6157
6158                         mono_mb_emit_ldloc (mb, src_ptr);
6159                         mono_mb_emit_byte (mb, CEE_LDIND_I);
6160
6161                         mono_mb_emit_icall (mb, conv_to_icall (conv));
6162                         mono_mb_emit_byte (mb, CEE_STELEM_REF);
6163                 }
6164                 else {
6165                         char *msg = g_strdup ("Marshalling of non-string and non-blittable arrays to managed code is not implemented.");
6166                         mono_mb_emit_exception_marshal_directive (mb, msg);
6167                         return conv_arg;
6168                 }
6169
6170                 mono_mb_emit_add_to_local (mb, index_var, 1);
6171                 mono_mb_emit_add_to_local (mb, src_ptr, esize);
6172
6173                 mono_mb_emit_byte (mb, CEE_BR);
6174                 mono_mb_emit_i4 (mb, label2 - (mb->pos + 4));
6175
6176                 mono_mb_patch_addr (mb, label1, mb->pos - (label1 + 4));
6177                 mono_mb_patch_addr (mb, label3, mb->pos - (label3 + 4));
6178
6179                 break;
6180         }
6181         case MARSHAL_ACTION_MANAGED_CONV_OUT: {
6182                 MonoClass *eklass;
6183                 guint32 label1, label2, label3;
6184                 int index_var, dest_ptr, loc, esize, param_num, num_elem;
6185                 MonoMarshalConv conv;
6186                 gboolean is_string = FALSE;
6187
6188                 /* These are already checked in CONV_IN */
6189                 g_assert (!t->byref);
6190                 g_assert (spec->native == MONO_NATIVE_LPARRAY);
6191                 g_assert (t->attrs & PARAM_ATTRIBUTE_OUT);
6192
6193                 param_num = spec->data.array_data.param_num;
6194                 num_elem = spec->data.array_data.num_elem;
6195
6196                 if (spec->data.array_data.elem_mult == 0)
6197                         /* param_num is not specified */
6198                         param_num = -1;
6199
6200                 if (param_num == -1) {
6201                         if (num_elem <= 0) {
6202                                 g_assert_not_reached ();
6203                         }
6204                 }
6205
6206                 /* FIXME: Optimize blittable case */
6207
6208                 eklass = klass->element_class;
6209                 if (eklass == mono_defaults.string_class) {
6210                         is_string = TRUE;
6211                         conv = mono_marshal_get_string_to_ptr_conv (m->piinfo, spec);
6212                 }
6213                 else if (eklass == mono_defaults.stringbuilder_class) {
6214                         is_string = TRUE;
6215                         conv = mono_marshal_get_stringbuilder_to_ptr_conv (m->piinfo, spec);
6216                 }
6217                 else
6218                         conv = -1;
6219
6220                 mono_marshal_load_type_info (eklass);
6221
6222                 if (is_string)
6223                         esize = sizeof (gpointer);
6224                 else
6225                         esize = mono_class_native_size (eklass, NULL);
6226
6227                 dest_ptr = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
6228                 loc = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
6229
6230                 /* Check null */
6231                 mono_mb_emit_ldloc (mb, conv_arg);
6232                 mono_mb_emit_byte (mb, CEE_BRFALSE);
6233                 label1 = mb->pos;
6234                 mono_mb_emit_i4 (mb, 0);
6235
6236                 mono_mb_emit_ldarg (mb, argnum);
6237                 mono_mb_emit_stloc (mb, dest_ptr);
6238
6239                 if (eklass->blittable) {
6240                         /* dest */
6241                         mono_mb_emit_ldarg (mb, argnum);
6242                         /* src */
6243                         mono_mb_emit_ldloc (mb, conv_arg);
6244                         mono_mb_emit_byte (mb, CEE_CONV_I);
6245                         mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoArray, vector));
6246                         mono_mb_emit_byte (mb, CEE_ADD);
6247                         /* length */
6248                         mono_mb_emit_ldloc (mb, conv_arg);
6249                         mono_mb_emit_byte (mb, CEE_LDLEN);
6250                         mono_mb_emit_icon (mb, esize);
6251                         mono_mb_emit_byte (mb, CEE_MUL);
6252                         mono_mb_emit_byte (mb, CEE_PREFIX1);
6253                         mono_mb_emit_byte (mb, CEE_CPBLK);
6254                         break;
6255                 }
6256
6257                 /* Emit marshalling loop */
6258                 index_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
6259                 mono_mb_emit_byte (mb, CEE_LDC_I4_0);
6260                 mono_mb_emit_stloc (mb, index_var);
6261                 label2 = mb->pos;
6262                 mono_mb_emit_ldloc (mb, index_var);
6263                 mono_mb_emit_ldloc (mb, conv_arg);
6264                 mono_mb_emit_byte (mb, CEE_LDLEN);
6265                 mono_mb_emit_byte (mb, CEE_BGE);
6266                 label3 = mb->pos;
6267                 mono_mb_emit_i4 (mb, 0);
6268
6269                 /* Emit marshalling code */
6270                 if (is_string) {
6271                         g_assert (conv != -1);
6272
6273                         /* dest */
6274                         mono_mb_emit_ldloc (mb, dest_ptr);
6275
6276                         /* src */
6277                         mono_mb_emit_ldloc (mb, conv_arg);
6278                         mono_mb_emit_ldloc (mb, index_var);
6279
6280                         mono_mb_emit_byte (mb, CEE_LDELEM_REF);
6281
6282                         mono_mb_emit_icall (mb, conv_to_icall (conv));
6283                         mono_mb_emit_byte (mb, CEE_STIND_I);
6284                 }
6285                 else {
6286                         char *msg = g_strdup ("Marshalling of non-string and non-blittable arrays to managed code is not implemented.");
6287                         mono_mb_emit_exception_marshal_directive (mb, msg);
6288                         return conv_arg;
6289                 }
6290
6291                 mono_mb_emit_add_to_local (mb, index_var, 1);
6292                 mono_mb_emit_add_to_local (mb, dest_ptr, esize);
6293
6294                 mono_mb_emit_byte (mb, CEE_BR);
6295                 mono_mb_emit_i4 (mb, label2 - (mb->pos + 4));
6296
6297                 mono_mb_patch_addr (mb, label1, mb->pos - (label1 + 4));
6298                 mono_mb_patch_addr (mb, label3, mb->pos - (label3 + 4));
6299
6300                 break;
6301         }
6302         case MARSHAL_ACTION_MANAGED_CONV_RESULT: {
6303                 MonoClass *eklass;
6304                 guint32 label1, label2, label3;
6305                 int index_var, src, dest, esize;
6306                 MonoMarshalConv conv = -1;
6307                 gboolean is_string = FALSE;
6308
6309                 g_assert (!t->byref);
6310
6311                 eklass = klass->element_class;
6312
6313                 mono_marshal_load_type_info (eklass);
6314
6315                 if (eklass == mono_defaults.string_class) {
6316                         is_string = TRUE;
6317                         conv = mono_marshal_get_string_to_ptr_conv (m->piinfo, spec);
6318                 }
6319                 else {
6320                         g_assert_not_reached ();
6321                 }
6322
6323                 if (is_string)
6324                         esize = sizeof (gpointer);
6325                 else
6326                         esize = mono_class_native_size (eklass, NULL);
6327
6328                 src = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
6329                 dest = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
6330
6331                 mono_mb_emit_stloc (mb, src);
6332                 mono_mb_emit_ldloc (mb, src);
6333                 mono_mb_emit_stloc (mb, 3);
6334
6335                 /* Check for null */
6336                 mono_mb_emit_ldloc (mb, src);
6337                 label1 = mono_mb_emit_branch (mb, CEE_BRFALSE);
6338
6339                 /* Allocate native array */
6340                 mono_mb_emit_icon (mb, esize);
6341                 mono_mb_emit_ldloc (mb, src);
6342                 mono_mb_emit_byte (mb, CEE_LDLEN);
6343
6344                 if (eklass == mono_defaults.string_class) {
6345                         /* Make the array bigger for the terminating null */
6346                         mono_mb_emit_byte (mb, CEE_LDC_I4_1);
6347                         mono_mb_emit_byte (mb, CEE_ADD);
6348                 }
6349                 mono_mb_emit_byte (mb, CEE_MUL);
6350                 mono_mb_emit_icall (mb, mono_marshal_alloc);
6351                 mono_mb_emit_stloc (mb, dest);
6352                 mono_mb_emit_ldloc (mb, dest);
6353                 mono_mb_emit_stloc (mb, 3);
6354
6355                 /* Emit marshalling loop */
6356                 index_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
6357                 mono_mb_emit_byte (mb, CEE_LDC_I4_0);
6358                 mono_mb_emit_stloc (mb, index_var);
6359                 label2 = mb->pos;
6360                 mono_mb_emit_ldloc (mb, index_var);
6361                 mono_mb_emit_ldloc (mb, src);
6362                 mono_mb_emit_byte (mb, CEE_LDLEN);
6363                 label3 = mono_mb_emit_branch (mb, CEE_BGE);
6364
6365                 /* Emit marshalling code */
6366                 if (is_string) {
6367                         g_assert (conv != -1);
6368
6369                         /* dest */
6370                         mono_mb_emit_ldloc (mb, dest);
6371
6372                         /* src */
6373                         mono_mb_emit_ldloc (mb, src);
6374                         mono_mb_emit_ldloc (mb, index_var);
6375
6376                         mono_mb_emit_byte (mb, CEE_LDELEM_REF);
6377
6378                         mono_mb_emit_icall (mb, conv_to_icall (conv));
6379                         mono_mb_emit_byte (mb, CEE_STIND_I);
6380                 }
6381                 else {
6382                         char *msg = g_strdup ("Marshalling of non-string arrays to managed code is not implemented.");
6383                         mono_mb_emit_exception_marshal_directive (mb, msg);
6384                         return conv_arg;
6385                 }
6386
6387                 mono_mb_emit_add_to_local (mb, index_var, 1);
6388                 mono_mb_emit_add_to_local (mb, dest, esize);
6389
6390                 mono_mb_emit_byte (mb, CEE_BR);
6391                 mono_mb_emit_i4 (mb, label2 - (mb->pos + 4));
6392
6393                 mono_mb_patch_addr (mb, label3, mb->pos - (label3 + 4));
6394                 mono_mb_patch_addr (mb, label1, mb->pos - (label1 + 4));
6395                 break;
6396         }
6397         default:
6398                 g_assert_not_reached ();
6399         }
6400
6401         return conv_arg;
6402 }
6403
6404 static int
6405 emit_marshal_boolean (EmitMarshalContext *m, int argnum, MonoType *t,
6406                                           MonoMarshalSpec *spec,
6407                                           int conv_arg, MonoType **conv_arg_type,
6408                                           MarshalAction action)
6409 {
6410         MonoMethodBuilder *mb = m->mb;
6411
6412         switch (action) {
6413         case MARSHAL_ACTION_CONV_IN: {
6414                 MonoType *local_type;
6415                 int variant_bool = 0;
6416                 if (!t->byref)
6417                         break;
6418                 if (spec == NULL) {
6419                         local_type = &mono_defaults.int32_class->byval_arg;
6420                 } else {
6421                         switch (spec->native) {
6422                         case MONO_NATIVE_I1:
6423                                 local_type = &mono_defaults.byte_class->byval_arg;
6424                                 break;
6425                         case MONO_NATIVE_VARIANTBOOL:
6426                                 local_type = &mono_defaults.int16_class->byval_arg;
6427                                 variant_bool = 1;
6428                                 break;
6429                         default:
6430                                 g_warning ("marshalling bool as native type %x is currently not supported", spec->native);
6431                                 local_type = &mono_defaults.int32_class->byval_arg;
6432                                 break;
6433                         }
6434                 }
6435                 *conv_arg_type = &mono_defaults.int_class->byval_arg;
6436                 conv_arg = mono_mb_add_local (mb, local_type);
6437                 mono_mb_emit_ldarg (mb, argnum);
6438                 mono_mb_emit_byte (mb, CEE_LDIND_I1);
6439                 if (variant_bool)
6440                         mono_mb_emit_byte (mb, CEE_NEG);
6441                 mono_mb_emit_stloc (mb, conv_arg);
6442                 break;
6443         }
6444
6445         case MARSHAL_ACTION_CONV_OUT:
6446                 if (!t->byref)
6447                         break;
6448                 mono_mb_emit_ldarg (mb, argnum);
6449                 mono_mb_emit_ldloc (mb, conv_arg);
6450                 if (spec != NULL && spec->native == MONO_NATIVE_VARIANTBOOL)
6451                         mono_mb_emit_byte (mb, CEE_NEG);
6452                 mono_mb_emit_byte (mb, CEE_STIND_I1);
6453                 break;
6454
6455         case MARSHAL_ACTION_PUSH:
6456                 if (t->byref)
6457                         mono_mb_emit_ldloc_addr (mb, conv_arg);
6458                 else
6459                         mono_mb_emit_ldarg (mb, argnum);
6460                 break;
6461
6462         case MARSHAL_ACTION_CONV_RESULT:
6463                 /* maybe we need to make sure that it fits within 8 bits */
6464                 mono_mb_emit_stloc (mb, 3);
6465                 break;
6466
6467         default:
6468                 g_assert_not_reached ();
6469         }
6470
6471         return conv_arg;
6472 }
6473
6474 static int
6475 emit_marshal_ptr (EmitMarshalContext *m, int argnum, MonoType *t,
6476                                   MonoMarshalSpec *spec, int conv_arg,
6477                                   MonoType **conv_arg_type, MarshalAction action)
6478 {
6479         MonoMethodBuilder *mb = m->mb;
6480
6481         switch (action) {
6482         case MARSHAL_ACTION_CONV_IN:
6483                 if (MONO_TYPE_ISSTRUCT (t->data.type)) {
6484                         char *msg = g_strdup_printf ("Can not marshal 'parameter #%d': Pointers can not reference marshaled structures. Use byref instead.", argnum + 1);
6485                         mono_mb_emit_exception_marshal_directive (m->mb, msg);
6486                 }
6487                 break;
6488
6489         case MARSHAL_ACTION_PUSH:
6490                 mono_mb_emit_ldarg (mb, argnum);
6491                 break;
6492
6493         case MARSHAL_ACTION_CONV_RESULT:
6494                 /* no conversions necessary */
6495                 mono_mb_emit_stloc (mb, 3);
6496                 break;
6497
6498         default:
6499                 break;
6500         }
6501
6502         return conv_arg;
6503 }
6504
6505 static int
6506 emit_marshal_char (EmitMarshalContext *m, int argnum, MonoType *t,
6507                                    MonoMarshalSpec *spec, int conv_arg,
6508                                    MonoType **conv_arg_type, MarshalAction action)
6509 {
6510         MonoMethodBuilder *mb = m->mb;
6511
6512         switch (action) {
6513         case MARSHAL_ACTION_PUSH:
6514                 /* fixme: dont know how to marshal that. We cant simply
6515                  * convert it to a one byte UTF8 character, because an
6516                  * unicode character may need more that one byte in UTF8 */
6517                 mono_mb_emit_ldarg (mb, argnum);
6518                 break;
6519
6520         case MARSHAL_ACTION_CONV_RESULT:
6521                 /* fixme: we need conversions here */
6522                 mono_mb_emit_stloc (mb, 3);
6523                 break;
6524
6525         default:
6526                 break;
6527         }
6528
6529         return conv_arg;
6530 }
6531
6532 static int
6533 emit_marshal_scalar (EmitMarshalContext *m, int argnum, MonoType *t,
6534                                          MonoMarshalSpec *spec, int conv_arg,
6535                                          MonoType **conv_arg_type, MarshalAction action)
6536 {
6537         MonoMethodBuilder *mb = m->mb;
6538
6539         switch (action) {
6540         case MARSHAL_ACTION_PUSH:
6541                 mono_mb_emit_ldarg (mb, argnum);
6542                 break;
6543
6544         case MARSHAL_ACTION_CONV_RESULT:
6545                 /* no conversions necessary */
6546                 mono_mb_emit_stloc (mb, 3);
6547                 break;
6548
6549         default:
6550                 break;
6551         }
6552
6553         return conv_arg;
6554 }
6555
6556 static int
6557 emit_marshal (EmitMarshalContext *m, int argnum, MonoType *t,
6558                           MonoMarshalSpec *spec, int conv_arg,
6559                           MonoType **conv_arg_type, MarshalAction action)
6560 {
6561         /* Ensure that we have marshalling info for this param */
6562         mono_marshal_load_type_info (mono_class_from_mono_type (t));
6563
6564         if (spec && spec->native == MONO_NATIVE_CUSTOM)
6565                 return emit_marshal_custom (m, argnum, t, spec, conv_arg, conv_arg_type, action);
6566
6567         if (spec && spec->native == MONO_NATIVE_ASANY)
6568                 return emit_marshal_asany (m, argnum, t, spec, conv_arg, conv_arg_type, action);
6569
6570         switch (t->type) {
6571         case MONO_TYPE_VALUETYPE:
6572                 return emit_marshal_vtype (m, argnum, t, spec, conv_arg, conv_arg_type, action);
6573         case MONO_TYPE_STRING:
6574                 return emit_marshal_string (m, argnum, t, spec, conv_arg, conv_arg_type, action);
6575         case MONO_TYPE_CLASS:
6576         case MONO_TYPE_OBJECT:
6577                 return emit_marshal_object (m, argnum, t, spec, conv_arg, conv_arg_type, action);
6578         case MONO_TYPE_ARRAY:
6579         case MONO_TYPE_SZARRAY:
6580                 return emit_marshal_array (m, argnum, t, spec, conv_arg, conv_arg_type, action);
6581         case MONO_TYPE_BOOLEAN:
6582                 return emit_marshal_boolean (m, argnum, t, spec, conv_arg, conv_arg_type, action);
6583         case MONO_TYPE_PTR:
6584                 return emit_marshal_ptr (m, argnum, t, spec, conv_arg, conv_arg_type, action);
6585         case MONO_TYPE_CHAR:
6586                 return emit_marshal_char (m, argnum, t, spec, conv_arg, conv_arg_type, action);
6587         case MONO_TYPE_I1:
6588         case MONO_TYPE_U1:
6589         case MONO_TYPE_I2:
6590         case MONO_TYPE_U2:
6591         case MONO_TYPE_I4:
6592         case MONO_TYPE_U4:
6593         case MONO_TYPE_I:
6594         case MONO_TYPE_U:
6595         case MONO_TYPE_R4:
6596         case MONO_TYPE_R8:
6597         case MONO_TYPE_I8:
6598         case MONO_TYPE_U8:
6599         case MONO_TYPE_FNPTR:
6600                 return emit_marshal_scalar (m, argnum, t, spec, conv_arg, conv_arg_type, action);
6601         }
6602
6603         return conv_arg;
6604 }
6605
6606 /**
6607  * mono_marshal_emit_native_wrapper:
6608  * @sig: The signature of the native function
6609  * @piinfo: Marshalling information
6610  * @mspecs: Marshalling information
6611  * @func: the native function to call
6612  *
6613  * generates IL code for the pinvoke wrapper, the generated code calls @func.
6614  */
6615 static void
6616 mono_marshal_emit_native_wrapper (MonoMethodBuilder *mb, MonoMethodSignature *sig, MonoMethodPInvoke *piinfo, MonoMarshalSpec **mspecs, gpointer func)
6617 {
6618         EmitMarshalContext m;
6619         MonoMethodSignature *csig;
6620         MonoClass *klass;
6621         int i, argnum, *tmp_locals;
6622         int type;
6623         static MonoMethodSignature *get_last_error_sig = NULL;
6624
6625         m.mb = mb;
6626         m.piinfo = piinfo;
6627
6628         /* we copy the signature, so that we can set pinvoke to 0 */
6629         csig = signature_dup (mb->method->klass->image, sig);
6630         csig->pinvoke = 1;
6631         m.csig = csig;
6632
6633         /* we allocate local for use with emit_struct_conv() */
6634         /* allocate local 0 (pointer) src_ptr */
6635         mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
6636         /* allocate local 1 (pointer) dst_ptr */
6637         mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
6638         /* allocate local 2 (boolean) delete_old */
6639         mono_mb_add_local (mb, &mono_defaults.boolean_class->byval_arg);
6640
6641         /* delete_old = FALSE */
6642         mono_mb_emit_icon (mb, 0);
6643         mono_mb_emit_stloc (mb, 2);
6644
6645         if (!MONO_TYPE_IS_VOID(sig->ret)) {
6646                 /* allocate local 3 to store the return value */
6647                 mono_mb_add_local (mb, sig->ret);
6648         }
6649
6650         if (mspecs [0] && mspecs [0]->native == MONO_NATIVE_CUSTOM) {
6651                 /* Return type custom marshaling */
6652                 /*
6653                  * Since we can't determine the return type of the unmanaged function,
6654                  * we assume it returns a pointer, and pass that pointer to
6655                  * MarshalNativeToManaged.
6656                  */
6657                 csig->ret = &mono_defaults.int_class->byval_arg;
6658         }
6659
6660         /* we first do all conversions */
6661         tmp_locals = alloca (sizeof (int) * sig->param_count);
6662         m.orig_conv_args = alloca (sizeof (int) * (sig->param_count + 1));
6663
6664         for (i = 0; i < sig->param_count; i ++) {
6665                 tmp_locals [i] = emit_marshal (&m, i + sig->hasthis, sig->params [i], mspecs [i + 1], 0, &csig->params [i], MARSHAL_ACTION_CONV_IN);
6666         }
6667
6668         /* push all arguments */
6669
6670         if (sig->hasthis)
6671                 mono_mb_emit_byte (mb, CEE_LDARG_0);
6672
6673         for (i = 0; i < sig->param_count; i++) {
6674                 emit_marshal (&m, i + sig->hasthis, sig->params [i], mspecs [i + 1], tmp_locals [i], NULL, MARSHAL_ACTION_PUSH);
6675         }
6676
6677         /* call the native method */
6678         mono_mb_emit_native_call (mb, csig, func);
6679
6680         /* Set LastError if needed */
6681         if (piinfo->piflags & PINVOKE_ATTRIBUTE_SUPPORTS_LAST_ERROR) {
6682                 if (!get_last_error_sig) {
6683                         get_last_error_sig = mono_metadata_signature_alloc (mono_defaults.corlib, 0);
6684                         get_last_error_sig->ret = &mono_defaults.int_class->byval_arg;
6685                         get_last_error_sig->pinvoke = 1;
6686                 }
6687
6688 #ifdef PLATFORM_WIN32
6689                 /*
6690                  * Have to call GetLastError () early and without a wrapper, since various runtime components could
6691                  * clobber its value.
6692                  */
6693                 mono_mb_emit_native_call (mb, get_last_error_sig, GetLastError);
6694                 mono_mb_emit_icall (mb, mono_marshal_set_last_error_windows);
6695 #else
6696                 mono_mb_emit_icall (mb, mono_marshal_set_last_error);
6697 #endif
6698         }
6699
6700         /* convert the result */
6701         if (!sig->ret->byref) {
6702                 MonoMarshalSpec *spec = mspecs [0];
6703                 type = sig->ret->type;
6704
6705                 if (spec && spec->native == MONO_NATIVE_CUSTOM) {
6706                         emit_marshal (&m, 0, sig->ret, spec, 0, NULL, MARSHAL_ACTION_CONV_RESULT);
6707                 } else {
6708
6709                 handle_enum:
6710                         switch (type) {
6711                         case MONO_TYPE_VOID:
6712                                 break;
6713                         case MONO_TYPE_VALUETYPE:
6714                                 klass = sig->ret->data.klass;
6715                                 if (klass->enumtype) {
6716                                         type = sig->ret->data.klass->enum_basetype->type;
6717                                         goto handle_enum;
6718                                 }
6719                                 emit_marshal (&m, 0, sig->ret, spec, 0, NULL, MARSHAL_ACTION_CONV_RESULT);
6720                                 break;
6721                         case MONO_TYPE_I1:
6722                         case MONO_TYPE_U1:
6723                         case MONO_TYPE_I2:
6724                         case MONO_TYPE_U2:
6725                         case MONO_TYPE_I4:
6726                         case MONO_TYPE_U4:
6727                         case MONO_TYPE_I:
6728                         case MONO_TYPE_U:
6729                         case MONO_TYPE_R4:
6730                         case MONO_TYPE_R8:
6731                         case MONO_TYPE_I8:
6732                         case MONO_TYPE_U8:
6733                         case MONO_TYPE_FNPTR:
6734                         case MONO_TYPE_STRING:
6735                         case MONO_TYPE_CLASS:
6736                         case MONO_TYPE_OBJECT:
6737                         case MONO_TYPE_BOOLEAN:
6738                         case MONO_TYPE_ARRAY:
6739                         case MONO_TYPE_SZARRAY:
6740                         case MONO_TYPE_CHAR:
6741                         case MONO_TYPE_PTR:
6742                                 emit_marshal (&m, 0, sig->ret, spec, 0, NULL, MARSHAL_ACTION_CONV_RESULT);
6743                                 break;
6744                         case MONO_TYPE_TYPEDBYREF:
6745                         default:
6746                                 g_warning ("return type 0x%02x unknown", sig->ret->type);
6747                                 g_assert_not_reached ();
6748                         }
6749                 }
6750         } else {
6751                 mono_mb_emit_stloc (mb, 3);
6752         }
6753
6754         /*
6755          * Need to call this after converting the result since MONO_VTADDR needs
6756          * to be adjacent to the call instruction.
6757          */
6758         emit_thread_interrupt_checkpoint (mb);
6759
6760         /* we need to convert byref arguments back and free string arrays */
6761         for (i = 0; i < sig->param_count; i++) {
6762                 MonoType *t = sig->params [i];
6763                 MonoMarshalSpec *spec = mspecs [i + 1];
6764
6765                 argnum = i + sig->hasthis;
6766
6767                 if (spec && ((spec->native == MONO_NATIVE_CUSTOM) || (spec->native == MONO_NATIVE_ASANY))) {
6768                         emit_marshal (&m, argnum, t, spec, tmp_locals [i], NULL, MARSHAL_ACTION_CONV_OUT);
6769                         continue;
6770                 }
6771
6772                 switch (t->type) {
6773                 case MONO_TYPE_STRING:
6774                 case MONO_TYPE_VALUETYPE:
6775                 case MONO_TYPE_CLASS:
6776                 case MONO_TYPE_OBJECT:
6777                 case MONO_TYPE_SZARRAY:
6778                 case MONO_TYPE_BOOLEAN:
6779                         emit_marshal (&m, argnum, t, spec, tmp_locals [i], NULL, MARSHAL_ACTION_CONV_OUT);
6780                         break;
6781                 }
6782         }
6783
6784         if (!MONO_TYPE_IS_VOID(sig->ret))
6785                 mono_mb_emit_ldloc (mb, 3);
6786
6787         mono_mb_emit_byte (mb, CEE_RET);
6788 }
6789
6790 /**
6791  * mono_marshal_get_native_wrapper:
6792  * @method: The MonoMethod to wrap.
6793  *
6794  * generates IL code for the pinvoke wrapper (the generated method
6795  * calls the unmanaged code in piinfo->addr)
6796  */
6797 MonoMethod *
6798 mono_marshal_get_native_wrapper (MonoMethod *method)
6799 {
6800         MonoMethodSignature *sig, *csig;
6801         MonoMethodPInvoke *piinfo = (MonoMethodPInvoke *) method;
6802         MonoMethodBuilder *mb;
6803         MonoMarshalSpec **mspecs;
6804         MonoMethod *res;
6805         GHashTable *cache;
6806         gboolean pinvoke = FALSE;
6807         int i;
6808         const char *exc_class = "MissingMethodException";
6809         const char *exc_arg = NULL;
6810
6811         g_assert (method != NULL);
6812         g_assert (mono_method_signature (method)->pinvoke);
6813
6814         cache = method->klass->image->native_wrapper_cache;
6815         if ((res = mono_marshal_find_in_cache (cache, method)))
6816                 return res;
6817
6818         sig = mono_method_signature (method);
6819
6820         if (!(method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) &&
6821             (method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL))
6822                 pinvoke = TRUE;
6823
6824         if (!piinfo->addr) {
6825                 if (pinvoke)
6826                         mono_lookup_pinvoke_call (method, &exc_class, &exc_arg);
6827                 else
6828                         piinfo->addr = mono_lookup_internal_call (method);
6829         }
6830
6831         mb = mono_mb_new (method->klass, method->name, MONO_WRAPPER_MANAGED_TO_NATIVE);
6832
6833         mb->method->save_lmf = 1;
6834
6835         if (!piinfo->addr) {
6836                 mono_mb_emit_exception (mb, exc_class, exc_arg);
6837                 csig = signature_dup (method->klass->image, sig);
6838                 csig->pinvoke = 0;
6839                 res = mono_mb_create_and_cache (cache, method,
6840                                                                                 mb, csig, csig->param_count + 16);
6841                 mono_mb_free (mb);
6842                 return res;
6843         }
6844
6845         /* internal calls: we simply push all arguments and call the method (no conversions) */
6846         if (method->iflags & (METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL | METHOD_IMPL_ATTRIBUTE_RUNTIME)) {
6847
6848                 /* hack - string constructors returns a value */
6849                 if (method->string_ctor) {
6850                         csig = signature_dup (method->klass->image, sig);
6851                         csig->ret = &mono_defaults.string_class->byval_arg;
6852                 } else
6853                         csig = sig;
6854
6855                 if (sig->hasthis)
6856                         mono_mb_emit_byte (mb, CEE_LDARG_0);
6857
6858                 for (i = 0; i < sig->param_count; i++)
6859                         mono_mb_emit_ldarg (mb, i + sig->hasthis);
6860
6861                 g_assert (piinfo->addr);
6862                 mono_mb_emit_native_call (mb, csig, piinfo->addr);
6863                 emit_thread_interrupt_checkpoint (mb);
6864                 mono_mb_emit_byte (mb, CEE_RET);
6865
6866                 csig = signature_dup (method->klass->image, csig);
6867                 csig->pinvoke = 0;
6868                 res = mono_mb_create_and_cache (cache, method,
6869                                                                                 mb, csig, csig->param_count + 16);
6870                 mono_mb_free (mb);
6871                 return res;
6872         }
6873
6874         g_assert (pinvoke);
6875
6876         mspecs = g_new (MonoMarshalSpec*, sig->param_count + 1);
6877         mono_method_get_marshal_info (method, mspecs);
6878
6879         mono_marshal_emit_native_wrapper (mb, sig, piinfo, mspecs, piinfo->addr);
6880
6881         csig = signature_dup (method->klass->image, sig);
6882         csig->pinvoke = 0;
6883         res = mono_mb_create_and_cache (cache, method,
6884                                                                         mb, csig, csig->param_count + 16);
6885         mono_mb_free (mb);
6886
6887         for (i = sig->param_count; i >= 0; i--)
6888                 if (mspecs [i])
6889                         mono_metadata_free_marshal_spec (mspecs [i]);
6890         g_free (mspecs);
6891
6892         /* 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)); */
6893
6894         return res;
6895 }
6896
6897 /**
6898  * mono_marshal_get_native_func_wrapper:
6899  * @sig: The signature of the function
6900  * @func: The native function to wrap
6901  *
6902  *   Returns a wrapper method around native functions, similar to the pinvoke
6903  * wrapper.
6904  */
6905 MonoMethod *
6906 mono_marshal_get_native_func_wrapper (MonoMethodSignature *sig,
6907                                                                           MonoMethodPInvoke *piinfo, MonoMarshalSpec **mspecs, gpointer func)
6908 {
6909         MonoMethodSignature *csig;
6910
6911         MonoMethodBuilder *mb;
6912         MonoMethod *res;
6913         GHashTable *cache;
6914         char *name;
6915
6916         cache = mono_defaults.corlib->native_wrapper_cache;
6917         if ((res = mono_marshal_find_in_cache (cache, func)))
6918                 return res;
6919
6920         name = g_strdup_printf ("wrapper_native_%p", func);
6921         mb = mono_mb_new (mono_defaults.object_class, name, MONO_WRAPPER_MANAGED_TO_NATIVE);
6922         mb->method->save_lmf = 1;
6923
6924         mono_marshal_emit_native_wrapper (mb, sig, piinfo, mspecs, func);
6925
6926         csig = signature_dup (mb->method->klass->image, sig);
6927         csig->pinvoke = 0;
6928         res = mono_mb_create_and_cache (cache, func,
6929                                                                         mb, csig, csig->param_count + 16);
6930         mono_mb_free (mb);
6931
6932         /* 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)); */
6933
6934         return res;
6935 }
6936
6937 /*
6938  * generates IL code to call managed methods from unmanaged code
6939  */
6940 MonoMethod *
6941 mono_marshal_get_managed_wrapper (MonoMethod *method, MonoClass *delegate_klass, MonoObject *this)
6942 {
6943         static MonoClass *UnmanagedFunctionPointerAttribute;
6944         MonoMethodSignature *sig, *csig, *invoke_sig;
6945         MonoMethodBuilder *mb;
6946         MonoMethod *res, *invoke;
6947         MonoMarshalSpec **mspecs;
6948         MonoMethodPInvoke piinfo;
6949         GHashTable *cache;
6950         int i, *tmp_locals;
6951         EmitMarshalContext m;
6952
6953         g_assert (method != NULL);
6954         g_assert (!mono_method_signature (method)->pinvoke);
6955
6956         /*
6957          * FIXME: Should cache the method+delegate type pair, since the same method
6958          * could be called with different delegates, thus different marshalling
6959          * options.
6960          */
6961         cache = method->klass->image->managed_wrapper_cache;
6962         if (!this && (res = mono_marshal_find_in_cache (cache, method)))
6963                 return res;
6964
6965         invoke = mono_class_get_method_from_name (delegate_klass, "Invoke", mono_method_signature (method)->param_count);
6966         invoke_sig = mono_method_signature (invoke);
6967
6968         mspecs = g_new0 (MonoMarshalSpec*, mono_method_signature (invoke)->param_count + 1);
6969         mono_method_get_marshal_info (invoke, mspecs);
6970
6971         sig = mono_method_signature (method);
6972
6973         mb = mono_mb_new (method->klass, method->name, MONO_WRAPPER_NATIVE_TO_MANAGED);
6974
6975         /* allocate local 0 (pointer) src_ptr */
6976         mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
6977         /* allocate local 1 (pointer) dst_ptr */
6978         mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
6979         /* allocate local 2 (boolean) delete_old */
6980         mono_mb_add_local (mb, &mono_defaults.boolean_class->byval_arg);
6981
6982         if (!MONO_TYPE_IS_VOID(sig->ret)) {
6983                 /* allocate local 3 to store the return value */
6984                 mono_mb_add_local (mb, sig->ret);
6985         }
6986
6987         mono_mb_emit_icon (mb, 0);
6988         mono_mb_emit_stloc (mb, 2);
6989
6990         /* we copy the signature, so that we can modify it */
6991         csig = signature_dup (method->klass->image, sig);
6992         csig->hasthis = 0;
6993         csig->pinvoke = 1;
6994
6995         m.mb = mb;
6996         m.sig = sig;
6997         m.piinfo = NULL;
6998         m.retobj_var = 0;
6999         m.csig = csig;
7000
7001 #ifdef PLATFORM_WIN32
7002         /*
7003          * Under windows, delegates passed to native code must use the STDCALL
7004          * calling convention.
7005          */
7006         csig->call_convention = MONO_CALL_STDCALL;
7007 #endif
7008
7009         /* Change default calling convention if needed */
7010         /* Why is this a modopt ? */
7011         if (invoke_sig->ret && invoke_sig->ret->num_mods) {
7012                 for (i = 0; i < invoke_sig->ret->num_mods; ++i) {
7013                         MonoClass *cmod_class = mono_class_get (delegate_klass->image, invoke_sig->ret->modifiers [i].token);
7014                         g_assert (cmod_class);
7015                         if ((cmod_class->image == mono_defaults.corlib) && !strcmp (cmod_class->name_space, "System.Runtime.CompilerServices")) {
7016                                 if (!strcmp (cmod_class->name, "CallConvCdecl"))
7017                                         csig->call_convention = MONO_CALL_C;
7018                                 else if (!strcmp (cmod_class->name, "CallConvStdcall"))
7019                                         csig->call_convention = MONO_CALL_STDCALL;
7020                                 else if (!strcmp (cmod_class->name, "CallConvFastcall"))
7021                                         csig->call_convention = MONO_CALL_FASTCALL;
7022                                 else if (!strcmp (cmod_class->name, "CallConvThiscall"))
7023                                         csig->call_convention = MONO_CALL_THISCALL;
7024                         }
7025                 }
7026         }
7027
7028         /* Handle the UnmanagedFunctionPointerAttribute */
7029         if (!UnmanagedFunctionPointerAttribute)
7030                 UnmanagedFunctionPointerAttribute = mono_class_from_name (mono_defaults.corlib, "System.Runtime.InteropServices", "UnmanagedFunctionPointerAttribute");
7031
7032         /* The attribute is only available in Net 2.0 */
7033         if (UnmanagedFunctionPointerAttribute) {
7034                 MonoReflectionUnmanagedFunctionPointerAttribute *attr;
7035                 MonoCustomAttrInfo *cinfo;
7036
7037                 /*
7038                  * The pinvoke attributes are stored in a real custom attribute so we have to
7039                  * construct it.
7040                  */
7041                 cinfo = mono_custom_attrs_from_class (delegate_klass);
7042                 if (cinfo) {
7043                         attr = (MonoReflectionUnmanagedFunctionPointerAttribute*)mono_custom_attrs_get_attr (cinfo, UnmanagedFunctionPointerAttribute);
7044                         if (attr) {
7045                                 memset (&piinfo, 0, sizeof (piinfo));
7046                                 m.piinfo = &piinfo;
7047                                 piinfo.piflags = (attr->call_conv << 8) | (attr->charset ? (attr->charset - 1) * 2 : 1) | attr->set_last_error;
7048
7049                                 csig->call_convention = attr->call_conv - 1;
7050                         }
7051                         if (!cinfo->cached)
7052                                 mono_custom_attrs_free (cinfo);
7053                 }
7054         }
7055
7056         /* fixme: howto handle this ? */
7057         if (sig->hasthis) {
7058                 if (this) {
7059                         mono_mb_emit_ptr (mb, this);
7060                 } else {
7061                         /* fixme: */
7062                         g_assert_not_reached ();
7063                 }
7064         }
7065
7066         /* we first do all conversions */
7067         tmp_locals = alloca (sizeof (int) * sig->param_count);
7068         for (i = 0; i < sig->param_count; i ++) {
7069                 MonoType *t = sig->params [i];
7070
7071                 switch (t->type) {
7072                 case MONO_TYPE_OBJECT:
7073                 case MONO_TYPE_CLASS:
7074                 case MONO_TYPE_VALUETYPE:
7075                 case MONO_TYPE_ARRAY:
7076                 case MONO_TYPE_SZARRAY:
7077                 case MONO_TYPE_STRING:
7078                         tmp_locals [i] = emit_marshal (&m, i, sig->params [i], mspecs [i + 1], 0, &csig->params [i], MARSHAL_ACTION_MANAGED_CONV_IN);
7079
7080                         break;
7081                 default:
7082                         tmp_locals [i] = 0;
7083                         break;
7084                 }
7085         }
7086
7087         emit_thread_interrupt_checkpoint (mb);
7088
7089         for (i = 0; i < sig->param_count; i++) {
7090                 MonoType *t = sig->params [i];
7091
7092                 if (tmp_locals [i]) {
7093                         if (t->byref)
7094                                 mono_mb_emit_ldloc_addr (mb, tmp_locals [i]);
7095                         else
7096                                 mono_mb_emit_ldloc (mb, tmp_locals [i]);
7097                 }
7098                 else
7099                         mono_mb_emit_ldarg (mb, i);
7100         }
7101
7102         mono_mb_emit_managed_call (mb, method, NULL);
7103
7104         if (mspecs [0] && mspecs [0]->native == MONO_NATIVE_CUSTOM) {
7105                 emit_marshal (&m, 0, sig->ret, mspecs [0], 0, NULL, MARSHAL_ACTION_MANAGED_CONV_RESULT);
7106         }
7107         else
7108         if (!sig->ret->byref) {
7109                 switch (sig->ret->type) {
7110                 case MONO_TYPE_VOID:
7111                         break;
7112                 case MONO_TYPE_BOOLEAN:
7113                 case MONO_TYPE_I1:
7114                 case MONO_TYPE_U1:
7115                 case MONO_TYPE_I2:
7116                 case MONO_TYPE_U2:
7117                 case MONO_TYPE_I4:
7118                 case MONO_TYPE_U4:
7119                 case MONO_TYPE_I:
7120                 case MONO_TYPE_U:
7121                 case MONO_TYPE_PTR:
7122                 case MONO_TYPE_R4:
7123                 case MONO_TYPE_R8:
7124                 case MONO_TYPE_I8:
7125                 case MONO_TYPE_U8:
7126                 case MONO_TYPE_OBJECT:
7127                         mono_mb_emit_stloc (mb, 3);
7128                         break;
7129                 case MONO_TYPE_STRING:
7130                         csig->ret = &mono_defaults.int_class->byval_arg;
7131                         emit_marshal (&m, 0, sig->ret, mspecs [0], 0, NULL, MARSHAL_ACTION_MANAGED_CONV_RESULT);
7132                         break;
7133                 case MONO_TYPE_VALUETYPE:
7134                 case MONO_TYPE_CLASS:
7135                 case MONO_TYPE_SZARRAY:
7136                         emit_marshal (&m, 0, sig->ret, mspecs [0], 0, NULL, MARSHAL_ACTION_MANAGED_CONV_RESULT);
7137                         break;
7138                 default:
7139                         g_warning ("return type 0x%02x unknown", sig->ret->type);
7140                         g_assert_not_reached ();
7141                 }
7142         } else {
7143                 mono_mb_emit_stloc (mb, 3);
7144         }
7145
7146         /* Convert byref arguments back */
7147         for (i = 0; i < sig->param_count; i ++) {
7148                 MonoType *t = sig->params [i];
7149                 MonoMarshalSpec *spec = mspecs [i + 1];
7150
7151                 if (spec && spec->native == MONO_NATIVE_CUSTOM) {
7152                         emit_marshal (&m, i, t, mspecs [i + 1], tmp_locals [i], NULL, MARSHAL_ACTION_MANAGED_CONV_OUT);
7153                 }
7154                 else if (t->byref) {
7155                         switch (t->type) {
7156                         case MONO_TYPE_CLASS:
7157                         case MONO_TYPE_VALUETYPE:
7158                                 emit_marshal (&m, i, t, mspecs [i + 1], tmp_locals [i], NULL, MARSHAL_ACTION_MANAGED_CONV_OUT);
7159                                 break;
7160                         }
7161                 }
7162                 else if (invoke_sig->params [i]->attrs & PARAM_ATTRIBUTE_OUT) {
7163                         /* The [Out] information is encoded in the delegate signature */
7164                         switch (t->type) {
7165                         case MONO_TYPE_SZARRAY:
7166                                 emit_marshal (&m, i, invoke_sig->params [i], mspecs [i + 1], tmp_locals [i], NULL, MARSHAL_ACTION_MANAGED_CONV_OUT);
7167                                 break;
7168                         default:
7169                                 g_assert_not_reached ();
7170                         }
7171                 }
7172         }
7173
7174         if (m.retobj_var) {
7175                 mono_mb_emit_ldloc (mb, m.retobj_var);
7176                 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
7177                 mono_mb_emit_byte (mb, CEE_MONO_RETOBJ);
7178                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, m.retobj_class));
7179         }
7180         else {
7181                 if (!MONO_TYPE_IS_VOID(sig->ret))
7182                         mono_mb_emit_ldloc (mb, 3);
7183                 mono_mb_emit_byte (mb, CEE_RET);
7184         }
7185
7186         if (!this)
7187                 res = mono_mb_create_and_cache (cache, method,
7188                                                                                          mb, csig, sig->param_count + 16);
7189         else {
7190                 mb->dynamic = 1;
7191                 res = mono_mb_create_method (mb, csig, sig->param_count + 16);
7192         }
7193         mono_mb_free (mb);
7194
7195         for (i = mono_method_signature (invoke)->param_count; i >= 0; i--)
7196                 if (mspecs [i])
7197                         mono_metadata_free_marshal_spec (mspecs [i]);
7198         g_free (mspecs);
7199
7200         /* 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)); */
7201
7202         return res;
7203 }
7204
7205 static MonoReflectionType *
7206 type_from_handle (MonoType *handle)
7207 {
7208         MonoDomain *domain = mono_domain_get ();
7209         MonoClass *klass = mono_class_from_mono_type (handle);
7210
7211         MONO_ARCH_SAVE_REGS;
7212
7213         mono_class_init (klass);
7214         return mono_type_get_object (domain, handle);
7215 }
7216
7217 /*
7218  * mono_marshal_get_isinst:
7219  * @klass: the type of the field
7220  *
7221  * This method generates a function which can be used to check if an object is
7222  * an instance of the given type, icluding the case where the object is a proxy.
7223  * The generated function has the following signature:
7224  * MonoObject* __isinst_wrapper_ (MonoObject *obj)
7225  */
7226 MonoMethod *
7227 mono_marshal_get_isinst (MonoClass *klass)
7228 {
7229         static MonoMethodSignature *isint_sig = NULL;
7230         GHashTable *cache;
7231         MonoMethod *res;
7232         int pos_was_ok, pos_failed, pos_end, pos_end2;
7233         char *name;
7234         MonoMethodBuilder *mb;
7235
7236         cache = klass->image->isinst_cache;
7237         if ((res = mono_marshal_find_in_cache (cache, klass)))
7238                 return res;
7239
7240         if (!isint_sig) {
7241                 isint_sig = mono_metadata_signature_alloc (mono_defaults.corlib, 1);
7242                 isint_sig->params [0] = &mono_defaults.object_class->byval_arg;
7243                 isint_sig->ret = &mono_defaults.object_class->byval_arg;
7244                 isint_sig->pinvoke = 0;
7245         }
7246
7247         name = g_strdup_printf ("__isinst_wrapper_%s", klass->name);
7248         mb = mono_mb_new (mono_defaults.object_class, name, MONO_WRAPPER_ISINST);
7249         g_free (name);
7250
7251         mb->method->save_lmf = 1;
7252
7253         /* check if the object is a proxy that needs special cast */
7254         mono_mb_emit_ldarg (mb, 0);
7255         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
7256         mono_mb_emit_byte (mb, CEE_MONO_CISINST);
7257         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, klass));
7258
7259         /* The result of MONO_ISINST can be:
7260                 0) the type check succeeded
7261                 1) the type check did not succeed
7262                 2) a CanCastTo call is needed */
7263
7264         mono_mb_emit_byte (mb, CEE_DUP);
7265         pos_was_ok = mono_mb_emit_branch (mb, CEE_BRFALSE);
7266
7267         mono_mb_emit_byte (mb, CEE_LDC_I4_2);
7268         pos_failed = mono_mb_emit_branch (mb, CEE_BNE_UN);
7269
7270         /* get the real proxy from the transparent proxy*/
7271
7272         mono_mb_emit_ldarg (mb, 0);
7273         mono_mb_emit_managed_call (mb, mono_marshal_get_proxy_cancast (klass), NULL);
7274         pos_end = mono_mb_emit_branch (mb, CEE_BR);
7275
7276         /* fail */
7277
7278         mono_mb_patch_addr (mb, pos_failed, mb->pos - (pos_failed + 4));
7279         mono_mb_emit_byte (mb, CEE_LDNULL);
7280         pos_end2 = mono_mb_emit_branch (mb, CEE_BR);
7281
7282         /* success */
7283
7284         mono_mb_patch_addr (mb, pos_was_ok, mb->pos - (pos_was_ok + 4));
7285         mono_mb_emit_byte (mb, CEE_POP);
7286         mono_mb_emit_ldarg (mb, 0);
7287
7288         /* the end */
7289
7290         mono_mb_patch_addr (mb, pos_end, mb->pos - (pos_end + 4));
7291         mono_mb_patch_addr (mb, pos_end2, mb->pos - (pos_end2 + 4));
7292         mono_mb_emit_byte (mb, CEE_RET);
7293
7294         res = mono_mb_create_and_cache (cache, klass, mb, isint_sig, isint_sig->param_count + 16);
7295         mono_mb_free (mb);
7296
7297         return res;
7298 }
7299
7300 /*
7301  * mono_marshal_get_castclass:
7302  * @klass: the type of the field
7303  *
7304  * This method generates a function which can be used to cast an object to
7305  * an instance of the given type, icluding the case where the object is a proxy.
7306  * The generated function has the following signature:
7307  * MonoObject* __castclass_wrapper_ (MonoObject *obj)
7308  */
7309 MonoMethod *
7310 mono_marshal_get_castclass (MonoClass *klass)
7311 {
7312         static MonoMethodSignature *castclass_sig = NULL;
7313         GHashTable *cache;
7314         MonoMethod *res;
7315         int pos_was_ok, pos_was_ok2;
7316         char *name;
7317         MonoMethodBuilder *mb;
7318
7319         cache = klass->image->castclass_cache;
7320         if ((res = mono_marshal_find_in_cache (cache, klass)))
7321                 return res;
7322
7323         if (!castclass_sig) {
7324                 castclass_sig = mono_metadata_signature_alloc (mono_defaults.corlib, 1);
7325                 castclass_sig->params [0] = &mono_defaults.object_class->byval_arg;
7326                 castclass_sig->ret = &mono_defaults.object_class->byval_arg;
7327                 castclass_sig->pinvoke = 0;
7328         }
7329
7330         name = g_strdup_printf ("__castclass_wrapper_%s", klass->name);
7331         mb = mono_mb_new (mono_defaults.object_class, name, MONO_WRAPPER_CASTCLASS);
7332         g_free (name);
7333
7334         mb->method->save_lmf = 1;
7335
7336         /* check if the object is a proxy that needs special cast */
7337         mono_mb_emit_ldarg (mb, 0);
7338         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
7339         mono_mb_emit_byte (mb, CEE_MONO_CCASTCLASS);
7340         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, klass));
7341
7342         /* The result of MONO_ISINST can be:
7343                 0) the cast is valid
7344                 1) cast of unknown proxy type
7345                 or an exception if the cast is is invalid
7346         */
7347
7348         pos_was_ok = mono_mb_emit_branch (mb, CEE_BRFALSE);
7349
7350         /* get the real proxy from the transparent proxy*/
7351
7352         mono_mb_emit_ldarg (mb, 0);
7353         mono_mb_emit_managed_call (mb, mono_marshal_get_proxy_cancast (klass), NULL);
7354         pos_was_ok2 = mono_mb_emit_branch (mb, CEE_BRTRUE);
7355
7356         /* fail */
7357         mono_mb_emit_exception (mb, "InvalidCastException", NULL);
7358
7359         /* success */
7360         mono_mb_patch_addr (mb, pos_was_ok, mb->pos - (pos_was_ok + 4));
7361         mono_mb_patch_addr (mb, pos_was_ok2, mb->pos - (pos_was_ok2 + 4));
7362         mono_mb_emit_ldarg (mb, 0);
7363
7364         /* the end */
7365         mono_mb_emit_byte (mb, CEE_RET);
7366
7367         res = mono_mb_create_and_cache (cache, klass, mb, castclass_sig, castclass_sig->param_count + 16);
7368         mono_mb_free (mb);
7369
7370         return res;
7371 }
7372
7373 MonoMethod *
7374 mono_marshal_get_proxy_cancast (MonoClass *klass)
7375 {
7376         static MonoMethodSignature *isint_sig = NULL;
7377         GHashTable *cache;
7378         MonoMethod *res;
7379         int pos_failed, pos_end;
7380         char *name;
7381         MonoMethod *can_cast_to;
7382         MonoMethodDesc *desc;
7383         MonoMethodBuilder *mb;
7384
7385         cache = klass->image->proxy_isinst_cache;
7386         if ((res = mono_marshal_find_in_cache (cache, klass)))
7387                 return res;
7388
7389         if (!isint_sig) {
7390                 isint_sig = mono_metadata_signature_alloc (mono_defaults.corlib, 1);
7391                 isint_sig->params [0] = &mono_defaults.object_class->byval_arg;
7392                 isint_sig->ret = &mono_defaults.object_class->byval_arg;
7393                 isint_sig->pinvoke = 0;
7394         }
7395
7396         name = g_strdup_printf ("__proxy_isinst_wrapper_%s", klass->name);
7397         mb = mono_mb_new (mono_defaults.object_class, name, MONO_WRAPPER_PROXY_ISINST);
7398         g_free (name);
7399
7400         mb->method->save_lmf = 1;
7401
7402         /* get the real proxy from the transparent proxy*/
7403         mono_mb_emit_ldarg (mb, 0);
7404         mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoTransparentProxy, rp));
7405         mono_mb_emit_byte (mb, CEE_LDIND_REF);
7406
7407         /* get the reflection type from the type handle */
7408         mono_mb_emit_ptr (mb, &klass->byval_arg);
7409         mono_mb_emit_icall (mb, type_from_handle);
7410
7411         mono_mb_emit_ldarg (mb, 0);
7412
7413         /* make the call to CanCastTo (type, ob) */
7414         desc = mono_method_desc_new ("IRemotingTypeInfo:CanCastTo", FALSE);
7415         can_cast_to = mono_method_desc_search_in_class (desc, mono_defaults.iremotingtypeinfo_class);
7416         g_assert (can_cast_to);
7417         mono_method_desc_free (desc);
7418         mono_mb_emit_byte (mb, CEE_CALLVIRT);
7419         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, can_cast_to));
7420
7421
7422         pos_failed = mono_mb_emit_branch (mb, CEE_BRFALSE);
7423
7424         /* Upgrade the proxy vtable by calling: mono_upgrade_remote_class_wrapper (type, ob)*/
7425         mono_mb_emit_ptr (mb, &klass->byval_arg);
7426         mono_mb_emit_icall (mb, type_from_handle);
7427         mono_mb_emit_ldarg (mb, 0);
7428
7429         mono_mb_emit_icall (mb, mono_upgrade_remote_class_wrapper);
7430         emit_thread_interrupt_checkpoint (mb);
7431
7432         mono_mb_emit_ldarg (mb, 0);
7433         pos_end = mono_mb_emit_branch (mb, CEE_BR);
7434
7435         /* fail */
7436
7437         mono_mb_patch_addr (mb, pos_failed, mb->pos - (pos_failed + 4));
7438         mono_mb_emit_byte (mb, CEE_LDNULL);
7439
7440         /* the end */
7441
7442         mono_mb_patch_addr (mb, pos_end, mb->pos - (pos_end + 4));
7443         mono_mb_emit_byte (mb, CEE_RET);
7444
7445         res = mono_mb_create_and_cache (cache, klass, mb, isint_sig, isint_sig->param_count + 16);
7446         mono_mb_free (mb);
7447
7448         return res;
7449 }
7450
7451 void
7452 mono_upgrade_remote_class_wrapper (MonoReflectionType *rtype, MonoTransparentProxy *tproxy)
7453 {
7454         MonoClass *klass;
7455         MonoDomain *domain = ((MonoObject*)tproxy)->vtable->domain;
7456         klass = mono_class_from_mono_type (rtype->type);
7457         mono_upgrade_remote_class (domain, (MonoObject*)tproxy, klass);
7458 }
7459
7460 /**
7461  * mono_marshal_get_struct_to_ptr:
7462  * @klass:
7463  *
7464  * generates IL code for StructureToPtr (object structure, IntPtr ptr, bool fDeleteOld)
7465  */
7466 MonoMethod *
7467 mono_marshal_get_struct_to_ptr (MonoClass *klass)
7468 {
7469         MonoMethodBuilder *mb;
7470         static MonoMethod *stoptr = NULL;
7471         MonoMethod *res;
7472
7473         g_assert (klass != NULL);
7474
7475         mono_marshal_load_type_info (klass);
7476
7477         if (klass->marshal_info->str_to_ptr)
7478                 return klass->marshal_info->str_to_ptr;
7479
7480         if (!stoptr)
7481                 stoptr = mono_class_get_method_from_name (mono_defaults.marshal_class, "StructureToPtr", 3);
7482         g_assert (stoptr);
7483
7484         mb = mono_mb_new (klass, stoptr->name, MONO_WRAPPER_UNKNOWN);
7485
7486         if (klass->blittable) {
7487                 mono_mb_emit_byte (mb, CEE_LDARG_1);
7488                 mono_mb_emit_byte (mb, CEE_LDARG_0);
7489                 mono_mb_emit_ldflda (mb, sizeof (MonoObject));
7490                 mono_mb_emit_icon (mb, mono_class_value_size (klass, NULL));
7491                 mono_mb_emit_byte (mb, CEE_PREFIX1);
7492                 mono_mb_emit_byte (mb, CEE_CPBLK);
7493         } else {
7494
7495                 /* allocate local 0 (pointer) src_ptr */
7496                 mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
7497                 /* allocate local 1 (pointer) dst_ptr */
7498                 mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
7499                 /* allocate local 2 (boolean) delete_old */
7500                 mono_mb_add_local (mb, &mono_defaults.boolean_class->byval_arg);
7501                 mono_mb_emit_byte (mb, CEE_LDARG_2);
7502                 mono_mb_emit_stloc (mb, 2);
7503
7504                 /* initialize src_ptr to point to the start of object data */
7505                 mono_mb_emit_byte (mb, CEE_LDARG_0);
7506                 mono_mb_emit_ldflda (mb, sizeof (MonoObject));
7507                 mono_mb_emit_stloc (mb, 0);
7508
7509                 /* initialize dst_ptr */
7510                 mono_mb_emit_byte (mb, CEE_LDARG_1);
7511                 mono_mb_emit_stloc (mb, 1);
7512
7513                 emit_struct_conv (mb, klass, FALSE);
7514         }
7515
7516         mono_mb_emit_byte (mb, CEE_RET);
7517
7518         res = mono_mb_create_method (mb, mono_method_signature (stoptr), 0);
7519         mono_mb_free (mb);
7520
7521         klass->marshal_info->str_to_ptr = res;
7522         return res;
7523 }
7524
7525 /**
7526  * mono_marshal_get_ptr_to_struct:
7527  * @klass:
7528  *
7529  * generates IL code for PtrToStructure (IntPtr src, object structure)
7530  */
7531 MonoMethod *
7532 mono_marshal_get_ptr_to_struct (MonoClass *klass)
7533 {
7534         MonoMethodBuilder *mb;
7535         static MonoMethodSignature *ptostr = NULL;
7536         MonoMethod *res;
7537
7538         g_assert (klass != NULL);
7539
7540         mono_marshal_load_type_info (klass);
7541
7542         if (klass->marshal_info->ptr_to_str)
7543                 return klass->marshal_info->ptr_to_str;
7544
7545         if (!ptostr)
7546                 /* Create the signature corresponding to
7547                           static void PtrToStructure (IntPtr ptr, object structure);
7548                    defined in class/corlib/System.Runtime.InteropServices/Marshal.cs */
7549                 ptostr = mono_create_icall_signature ("void ptr object");
7550
7551         mb = mono_mb_new (klass, "PtrToStructure", MONO_WRAPPER_UNKNOWN);
7552
7553         if (klass->blittable) {
7554                 mono_mb_emit_byte (mb, CEE_LDARG_1);
7555                 mono_mb_emit_ldflda (mb, sizeof (MonoObject));
7556                 mono_mb_emit_byte (mb, CEE_LDARG_0);
7557                 mono_mb_emit_icon (mb, mono_class_value_size (klass, NULL));
7558                 mono_mb_emit_byte (mb, CEE_PREFIX1);
7559                 mono_mb_emit_byte (mb, CEE_CPBLK);
7560         } else {
7561
7562                 /* allocate local 0 (pointer) src_ptr */
7563                 mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
7564                 /* allocate local 1 (pointer) dst_ptr */
7565                 mono_mb_add_local (mb, &klass->this_arg);
7566
7567                 /* initialize src_ptr to point to the start of object data */
7568                 mono_mb_emit_byte (mb, CEE_LDARG_0);
7569                 mono_mb_emit_stloc (mb, 0);
7570
7571                 /* initialize dst_ptr */
7572                 mono_mb_emit_byte (mb, CEE_LDARG_1);
7573                 mono_mb_emit_byte (mb, CEE_UNBOX);
7574                 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, klass));
7575                 mono_mb_emit_stloc (mb, 1);
7576
7577                 emit_struct_conv (mb, klass, TRUE);
7578         }
7579
7580         mono_mb_emit_byte (mb, CEE_RET);
7581
7582         res = mono_mb_create_method (mb, ptostr, 0);
7583         mono_mb_free (mb);
7584
7585         klass->marshal_info->ptr_to_str = res;
7586         return res;
7587 }
7588
7589 /*
7590  * generates IL code for the synchronized wrapper: the generated method
7591  * calls METHOD while locking 'this' or the parent type.
7592  */
7593 MonoMethod *
7594 mono_marshal_get_synchronized_wrapper (MonoMethod *method)
7595 {
7596         static MonoMethod *enter_method, *exit_method;
7597         MonoMethodSignature *sig;
7598         MonoExceptionClause *clause;
7599         MonoMethodHeader *header;
7600         MonoMethodBuilder *mb;
7601         MonoMethod *res;
7602         GHashTable *cache;
7603         int i, pos, this_local, ret_local = 0;
7604
7605         g_assert (method);
7606
7607         if (method->wrapper_type == MONO_WRAPPER_SYNCHRONIZED)
7608                 return method;
7609
7610         cache = method->klass->image->synchronized_cache;
7611         if ((res = mono_marshal_find_in_cache (cache, method)))
7612                 return res;
7613
7614         sig = signature_dup (method->klass->image, mono_method_signature (method));
7615         sig->pinvoke = 0;
7616
7617         mb = mono_mb_new (method->klass, method->name, MONO_WRAPPER_SYNCHRONIZED);
7618
7619         /* result */
7620         if (!MONO_TYPE_IS_VOID (sig->ret))
7621                 ret_local = mono_mb_add_local (mb, sig->ret);
7622
7623         /* this */
7624         this_local = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
7625
7626         mono_loader_lock ();
7627         clause = mono_mempool_alloc0 (method->klass->image->mempool, sizeof (MonoExceptionClause));
7628         mono_loader_unlock ();
7629         clause->flags = MONO_EXCEPTION_CLAUSE_FINALLY;
7630
7631         if (!enter_method) {
7632                 MonoMethodDesc *desc;
7633
7634                 desc = mono_method_desc_new ("Monitor:Enter", FALSE);
7635                 enter_method = mono_method_desc_search_in_class (desc, mono_defaults.monitor_class);
7636                 g_assert (enter_method);
7637                 mono_method_desc_free (desc);
7638                 desc = mono_method_desc_new ("Monitor:Exit", FALSE);
7639                 exit_method = mono_method_desc_search_in_class (desc, mono_defaults.monitor_class);
7640                 g_assert (exit_method);
7641                 mono_method_desc_free (desc);
7642         }
7643
7644         /* Push this or the type object */
7645         if (method->flags & METHOD_ATTRIBUTE_STATIC) {
7646                 /*
7647                  * GetTypeFromHandle isn't called as a managed method because it has
7648                  * a funky calling sequence, e.g. ldtoken+GetTypeFromHandle gets
7649                  * transformed into something else by the JIT.
7650                  */
7651                 mono_mb_emit_ptr (mb, &method->klass->byval_arg);
7652                 mono_mb_emit_icall (mb, type_from_handle);
7653         }
7654         else
7655                 mono_mb_emit_ldarg (mb, 0);
7656         mono_mb_emit_stloc (mb, this_local);
7657
7658         /* Call Monitor::Enter() */
7659         mono_mb_emit_ldloc (mb, this_local);
7660         mono_mb_emit_managed_call (mb, enter_method, NULL);
7661
7662         clause->try_offset = mb->pos;
7663
7664         /* Call the method */
7665         if (sig->hasthis)
7666                 mono_mb_emit_ldarg (mb, 0);
7667         for (i = 0; i < sig->param_count; i++)
7668                 mono_mb_emit_ldarg (mb, i + (sig->hasthis == TRUE));
7669
7670         /* this is needed to avoid recursion */
7671         mono_mb_emit_byte (mb, CEE_PREFIX1);
7672         mono_mb_emit_byte (mb, CEE_LDFTN);
7673         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, method));
7674         mono_mb_emit_calli (mb, mono_method_signature (method));
7675
7676         if (!MONO_TYPE_IS_VOID (sig->ret))
7677                 mono_mb_emit_stloc (mb, ret_local);
7678
7679         mono_mb_emit_byte (mb, CEE_LEAVE);
7680         pos = mb->pos;
7681         mono_mb_emit_i4 (mb, 0);
7682
7683         clause->try_len = mb->pos - clause->try_offset;
7684         clause->handler_offset = mb->pos;
7685
7686         /* Call Monitor::Exit() */
7687         mono_mb_emit_ldloc (mb, this_local);
7688 /*      mono_mb_emit_native_call (mb, exit_sig, mono_monitor_exit); */
7689         mono_mb_emit_managed_call (mb, exit_method, NULL);
7690         mono_mb_emit_byte (mb, CEE_ENDFINALLY);
7691
7692         clause->handler_len = mb->pos - clause->handler_offset;
7693
7694         mono_mb_patch_addr (mb, pos, mb->pos - (pos + 4));
7695         if (!MONO_TYPE_IS_VOID (sig->ret))
7696                 mono_mb_emit_ldloc (mb, ret_local);
7697         mono_mb_emit_byte (mb, CEE_RET);
7698
7699         res = mono_mb_create_and_cache (cache, method,
7700                                                                         mb, sig, sig->param_count + 16);
7701         mono_mb_free (mb);
7702
7703         header = ((MonoMethodNormal *)res)->header;
7704         header->num_clauses = 1;
7705         header->clauses = clause;
7706
7707         return res;
7708 }
7709
7710
7711 /*
7712  * the returned method calls 'method' unboxing the this argument
7713  */
7714 MonoMethod *
7715 mono_marshal_get_unbox_wrapper (MonoMethod *method)
7716 {
7717         MonoMethodSignature *sig = mono_method_signature (method);
7718         int i;
7719         MonoMethodBuilder *mb;
7720         MonoMethod *res;
7721         GHashTable *cache;
7722
7723         cache = method->klass->image->unbox_wrapper_cache;
7724         if ((res = mono_marshal_find_in_cache (cache, method)))
7725                 return res;
7726
7727         mb = mono_mb_new (method->klass, method->name, MONO_WRAPPER_UNBOX);
7728
7729         g_assert (sig->hasthis);
7730
7731         mono_mb_emit_ldarg (mb, 0);
7732         mono_mb_emit_icon (mb, sizeof (MonoObject));
7733         mono_mb_emit_byte (mb, CEE_ADD);
7734         for (i = 0; i < sig->param_count; ++i)
7735                 mono_mb_emit_ldarg (mb, i + 1);
7736         mono_mb_emit_managed_call (mb, method, NULL);
7737         mono_mb_emit_byte (mb, CEE_RET);
7738
7739         res = mono_mb_create_and_cache (cache, method,
7740                                                                                  mb, sig, sig->param_count + 16);
7741         mono_mb_free (mb);
7742
7743         /* 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)); */
7744
7745         return res;
7746 }
7747
7748 MonoMethod*
7749 mono_marshal_get_stelemref ()
7750 {
7751         static MonoMethod* ret = NULL;
7752         MonoMethodSignature *sig;
7753         MonoMethodBuilder *mb;
7754
7755         guint32 b1, b2, b3, b4;
7756         guint32 copy_pos;
7757         int aklass, vklass;
7758         int array_slot_addr;
7759
7760         if (ret)
7761                 return ret;
7762
7763         mb = mono_mb_new (mono_defaults.object_class, "stelemref", MONO_WRAPPER_STELEMREF);
7764
7765
7766         sig = mono_metadata_signature_alloc (mono_defaults.corlib, 3);
7767
7768         /* void stelemref (void* array, int idx, void* value) */
7769         sig->ret = &mono_defaults.void_class->byval_arg;
7770         sig->params [0] = &mono_defaults.object_class->byval_arg;
7771         sig->params [1] = &mono_defaults.int_class->byval_arg; /* this is a natural sized int */
7772         sig->params [2] = &mono_defaults.object_class->byval_arg;
7773
7774         aklass = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
7775         vklass = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
7776         array_slot_addr = mono_mb_add_local (mb, &mono_defaults.object_class->this_arg);
7777
7778         /*
7779         the method:
7780         <ldelema (bound check)>
7781         if (!value)
7782                 goto store;
7783
7784         aklass = array->vtable->klass->element_class;
7785         vklass = value->vtable->klass;
7786
7787         if (vklass->idepth < aklass->idepth)
7788                 goto long;
7789
7790         if (vklass->supertypes [aklass->idepth - 1] != aklass)
7791                 goto long;
7792
7793         store:
7794                 *array_slot_addr = value;
7795                 return;
7796
7797         long:
7798                 if (mono_object_isinst (value, aklass))
7799                         goto store;
7800
7801                 throw new ArrayTypeMismatchException ();
7802         */
7803
7804         /* ldelema (implicit bound check) */
7805         mono_mb_emit_ldarg (mb, 0);
7806         mono_mb_emit_ldarg (mb, 1);
7807         mono_mb_emit_byte (mb, CEE_LDELEMA);
7808         mono_mb_emit_i4 (mb, mono_mb_add_data (mb, mono_defaults.object_class));
7809         mono_mb_emit_stloc (mb, array_slot_addr);
7810
7811         /* if (!value) goto do_store */
7812         mono_mb_emit_ldarg (mb, 2);
7813         b1 = mono_mb_emit_branch (mb, CEE_BRFALSE);
7814
7815         /* aklass = array->vtable->klass->element_class */
7816         mono_mb_emit_ldarg (mb, 0);
7817         mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoObject, vtable));
7818         mono_mb_emit_byte (mb, CEE_LDIND_I);
7819         mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoVTable, klass));
7820         mono_mb_emit_byte (mb, CEE_LDIND_I);
7821         mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoClass, element_class));
7822         mono_mb_emit_byte (mb, CEE_LDIND_I);
7823         mono_mb_emit_stloc (mb, aklass);
7824
7825         /* vklass = value->vtable->klass */
7826         mono_mb_emit_ldarg (mb, 2);
7827         mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoObject, vtable));
7828         mono_mb_emit_byte (mb, CEE_LDIND_I);
7829         mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoVTable, klass));
7830         mono_mb_emit_byte (mb, CEE_LDIND_I);
7831         mono_mb_emit_stloc (mb, vklass);
7832
7833         /* if (vklass->idepth < aklass->idepth) goto failue */
7834         mono_mb_emit_ldloc (mb, vklass);
7835         mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoClass, idepth));
7836         mono_mb_emit_byte (mb, CEE_LDIND_U2);
7837
7838         mono_mb_emit_ldloc (mb, aklass);
7839         mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoClass, idepth));
7840         mono_mb_emit_byte (mb, CEE_LDIND_U2);
7841
7842         b2 = mono_mb_emit_branch (mb, CEE_BLT_UN);
7843
7844         /* if (vklass->supertypes [aklass->idepth - 1] != aklass) goto failure */
7845         mono_mb_emit_ldloc (mb, vklass);
7846         mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoClass, supertypes));
7847         mono_mb_emit_byte (mb, CEE_LDIND_I);
7848
7849         mono_mb_emit_ldloc (mb, aklass);
7850         mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoClass, idepth));
7851         mono_mb_emit_byte (mb, CEE_LDIND_U2);
7852         mono_mb_emit_icon (mb, 1);
7853         mono_mb_emit_byte (mb, CEE_SUB);
7854         mono_mb_emit_icon (mb, sizeof (void*));
7855         mono_mb_emit_byte (mb, CEE_MUL);
7856         mono_mb_emit_byte (mb, CEE_ADD);
7857         mono_mb_emit_byte (mb, CEE_LDIND_I);
7858
7859         mono_mb_emit_ldloc (mb, aklass);
7860
7861         b3 = mono_mb_emit_branch (mb, CEE_BNE_UN);
7862
7863         copy_pos = mb->pos;
7864         /* do_store */
7865         mono_mb_patch_addr (mb, b1, mb->pos - (b1 + 4));
7866         mono_mb_emit_ldloc (mb, array_slot_addr);
7867         mono_mb_emit_ldarg (mb, 2);
7868         mono_mb_emit_byte (mb, CEE_STIND_REF);
7869
7870         mono_mb_emit_byte (mb, CEE_RET);
7871
7872         /* the hard way */
7873         mono_mb_patch_addr (mb, b2, mb->pos - (b2 + 4));
7874         mono_mb_patch_addr (mb, b3, mb->pos - (b3 + 4));
7875
7876         mono_mb_emit_ldarg (mb, 2);
7877         mono_mb_emit_ldloc (mb, aklass);
7878         mono_mb_emit_icall (mb, mono_object_isinst);
7879
7880         b4 = mono_mb_emit_branch (mb, CEE_BRTRUE);
7881         mono_mb_patch_addr (mb, b4, copy_pos - (b4 + 4));
7882         mono_mb_emit_exception (mb, "ArrayTypeMismatchException", NULL);
7883
7884         mono_mb_emit_byte (mb, CEE_RET);
7885         ret = mono_mb_create_method (mb, sig, 4);
7886         mono_mb_free (mb);
7887         return ret;
7888 }
7889
7890 MonoMethod*
7891 mono_marshal_get_write_barrier (void)
7892 {
7893         static MonoMethod* ret = NULL;
7894         MonoMethodSignature *sig;
7895         MonoMethodBuilder *mb;
7896         int max_stack = 2;
7897
7898         if (ret)
7899                 return ret;
7900
7901         mb = mono_mb_new (mono_defaults.object_class, "writebarrier", MONO_WRAPPER_WRITE_BARRIER);
7902
7903         sig = mono_metadata_signature_alloc (mono_defaults.corlib, 2);
7904
7905         /* void writebarrier (MonoObject** addr, MonoObject* obj) */
7906         sig->ret = &mono_defaults.void_class->byval_arg;
7907         sig->params [0] = &mono_defaults.object_class->this_arg;
7908         sig->params [1] = &mono_defaults.object_class->byval_arg;
7909
7910         /* just the store right now: add an hook for the GC to use, maybe something
7911          * that can be used for stelemref as well
7912          * We need a write barrier variant to be used with struct copies as well, though
7913          * there are also other approaches possible, like writing a wrapper specific to
7914          * the struct or to the reference pattern in the struct...
7915          * Depending on the GC, we may want variants that take the object we store to
7916          * when it is available.
7917          */
7918         mono_mb_emit_ldarg (mb, 0);
7919         mono_mb_emit_ldarg (mb, 1);
7920         mono_mb_emit_icall (mb, mono_gc_wbarrier_generic_store);
7921         /*mono_mb_emit_byte (mb, CEE_STIND_REF);*/
7922
7923         mono_mb_emit_byte (mb, CEE_RET);
7924
7925         ret = mono_mb_create_method (mb, sig, max_stack);
7926         mono_mb_free (mb);
7927         return ret;
7928 }
7929
7930 void*
7931 mono_marshal_alloc (gulong size)
7932 {
7933         gpointer res;
7934
7935 #ifdef PLATFORM_WIN32
7936         res = CoTaskMemAlloc (size);
7937 #else
7938         res = g_try_malloc ((gulong)size);
7939         if (!res)
7940                 mono_gc_out_of_memory ((gulong)size);
7941 #endif
7942         return res;
7943 }
7944
7945 void
7946 mono_marshal_free (gpointer ptr)
7947 {
7948 #ifdef PLATFORM_WIN32
7949         CoTaskMemFree (ptr);
7950 #else
7951         g_free (ptr);
7952 #endif
7953 }
7954
7955 void
7956 mono_marshal_free_array (gpointer *ptr, int size)
7957 {
7958         int i;
7959
7960         if (!ptr)
7961                 return;
7962
7963         for (i = 0; i < size; i++)
7964                 if (ptr [i])
7965                         g_free (ptr [i]);
7966 }
7967
7968 void *
7969 mono_marshal_realloc (gpointer ptr, gpointer size)
7970 {
7971         MONO_ARCH_SAVE_REGS;
7972
7973         return g_try_realloc (ptr, (gulong)size);
7974 }
7975
7976 void *
7977 mono_marshal_string_to_utf16 (MonoString *s)
7978 {
7979         return s ? mono_string_chars (s) : NULL;
7980 }
7981
7982 /**
7983  * mono_marshal_set_last_error:
7984  *
7985  * This function is invoked to set the last error value from a P/Invoke call
7986  * which has SetLastError set.
7987  */
7988 void
7989 mono_marshal_set_last_error (void)
7990 {
7991 #ifdef WIN32
7992         TlsSetValue (last_error_tls_id, GINT_TO_POINTER (GetLastError ()));
7993 #else
7994         TlsSetValue (last_error_tls_id, GINT_TO_POINTER (errno));
7995 #endif
7996 }
7997
7998 static void
7999 mono_marshal_set_last_error_windows (int error)
8000 {
8001 #ifdef WIN32
8002         TlsSetValue (last_error_tls_id, GINT_TO_POINTER (error));
8003 #endif
8004 }
8005
8006 void
8007 ves_icall_System_Runtime_InteropServices_Marshal_copy_to_unmanaged (MonoArray *src, gint32 start_index,
8008                                                                     gpointer dest, gint32 length)
8009 {
8010         int element_size;
8011         void *source_addr;
8012
8013         MONO_ARCH_SAVE_REGS;
8014
8015         MONO_CHECK_ARG_NULL (src);
8016         MONO_CHECK_ARG_NULL (dest);
8017
8018         g_assert (src->obj.vtable->klass->rank == 1);
8019         g_assert (start_index >= 0);
8020         g_assert (length >= 0);
8021         g_assert (start_index + length <= mono_array_length (src));
8022
8023         element_size = mono_array_element_size (src->obj.vtable->klass);
8024
8025         /* no references should be involved */
8026         source_addr = mono_array_addr_with_size (src, element_size, start_index);
8027
8028         memcpy (dest, source_addr, length * element_size);
8029 }
8030
8031 void
8032 ves_icall_System_Runtime_InteropServices_Marshal_copy_from_unmanaged (gpointer src, gint32 start_index,
8033                                                                       MonoArray *dest, gint32 length)
8034 {
8035         int element_size;
8036         void *dest_addr;
8037
8038         MONO_ARCH_SAVE_REGS;
8039
8040         MONO_CHECK_ARG_NULL (src);
8041         MONO_CHECK_ARG_NULL (dest);
8042
8043         g_assert (dest->obj.vtable->klass->rank == 1);
8044         g_assert (start_index >= 0);
8045         g_assert (length >= 0);
8046         g_assert (start_index + length <= mono_array_length (dest));
8047
8048         element_size = mono_array_element_size (dest->obj.vtable->klass);
8049
8050         /* no references should be involved */
8051         dest_addr = mono_array_addr_with_size (dest, element_size, start_index);
8052
8053         memcpy (dest_addr, src, length * element_size);
8054 }
8055
8056 #if NO_UNALIGNED_ACCESS
8057 #define RETURN_UNALIGNED(type, addr) \
8058         { \
8059                 type val; \
8060                 memcpy(&val, p + offset, sizeof(val)); \
8061                 return val; \
8062         }
8063 #define WRITE_UNALIGNED(type, addr, val) \
8064         memcpy(addr, &val, sizeof(type))
8065 #else
8066 #define RETURN_UNALIGNED(type, addr) \
8067         return *(type*)(p + offset);
8068 #define WRITE_UNALIGNED(type, addr, val) \
8069         (*(type *)(addr) = (val))
8070 #endif
8071
8072 gpointer
8073 ves_icall_System_Runtime_InteropServices_Marshal_ReadIntPtr (gpointer ptr, gint32 offset)
8074 {
8075         char *p = ptr;
8076
8077         MONO_ARCH_SAVE_REGS;
8078
8079         RETURN_UNALIGNED(gpointer, p + offset);
8080 }
8081
8082 unsigned char
8083 ves_icall_System_Runtime_InteropServices_Marshal_ReadByte (gpointer ptr, gint32 offset)
8084 {
8085         char *p = ptr;
8086
8087         MONO_ARCH_SAVE_REGS;
8088
8089         return *(unsigned char*)(p + offset);
8090 }
8091
8092 gint16
8093 ves_icall_System_Runtime_InteropServices_Marshal_ReadInt16 (gpointer ptr, gint32 offset)
8094 {
8095         char *p = ptr;
8096
8097         MONO_ARCH_SAVE_REGS;
8098
8099         RETURN_UNALIGNED(gint16, p + offset);
8100 }
8101
8102 gint32
8103 ves_icall_System_Runtime_InteropServices_Marshal_ReadInt32 (gpointer ptr, gint32 offset)
8104 {
8105         char *p = ptr;
8106
8107         MONO_ARCH_SAVE_REGS;
8108
8109         RETURN_UNALIGNED(gint32, p + offset);
8110 }
8111
8112 gint64
8113 ves_icall_System_Runtime_InteropServices_Marshal_ReadInt64 (gpointer ptr, gint32 offset)
8114 {
8115         char *p = ptr;
8116
8117         MONO_ARCH_SAVE_REGS;
8118
8119         RETURN_UNALIGNED(gint64, p + offset);
8120 }
8121
8122 void
8123 ves_icall_System_Runtime_InteropServices_Marshal_WriteByte (gpointer ptr, gint32 offset, unsigned char val)
8124 {
8125         char *p = ptr;
8126
8127         MONO_ARCH_SAVE_REGS;
8128
8129         *(unsigned char*)(p + offset) = val;
8130 }
8131
8132 void
8133 ves_icall_System_Runtime_InteropServices_Marshal_WriteIntPtr (gpointer ptr, gint32 offset, gpointer val)
8134 {
8135         char *p = ptr;
8136
8137         MONO_ARCH_SAVE_REGS;
8138
8139         WRITE_UNALIGNED(gpointer, p + offset, val);
8140 }
8141
8142 void
8143 ves_icall_System_Runtime_InteropServices_Marshal_WriteInt16 (gpointer ptr, gint32 offset, gint16 val)
8144 {
8145         char *p = ptr;
8146
8147         MONO_ARCH_SAVE_REGS;
8148
8149         WRITE_UNALIGNED(gint16, p + offset, val);
8150 }
8151
8152 void
8153 ves_icall_System_Runtime_InteropServices_Marshal_WriteInt32 (gpointer ptr, gint32 offset, gint32 val)
8154 {
8155         char *p = ptr;
8156
8157         MONO_ARCH_SAVE_REGS;
8158
8159         WRITE_UNALIGNED(gint32, p + offset, val);
8160 }
8161
8162 void
8163 ves_icall_System_Runtime_InteropServices_Marshal_WriteInt64 (gpointer ptr, gint32 offset, gint64 val)
8164 {
8165         char *p = ptr;
8166
8167         MONO_ARCH_SAVE_REGS;
8168
8169         WRITE_UNALIGNED(gint64, p + offset, val);
8170 }
8171
8172 MonoString *
8173 ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringAnsi (char *ptr)
8174 {
8175         MONO_ARCH_SAVE_REGS;
8176
8177         if (ptr == NULL)
8178                 return NULL;
8179         else
8180                 return mono_string_new (mono_domain_get (), ptr);
8181 }
8182
8183 MonoString *
8184 ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringAnsi_len (char *ptr, gint32 len)
8185 {
8186         MONO_ARCH_SAVE_REGS;
8187
8188         if (ptr == NULL) {
8189                 mono_raise_exception (mono_get_exception_argument_null ("ptr"));
8190                 g_assert_not_reached ();
8191                 return NULL;
8192         } else
8193                 return mono_string_new_len (mono_domain_get (), ptr, len);
8194 }
8195
8196 MonoString *
8197 ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringUni (guint16 *ptr)
8198 {
8199         MonoDomain *domain = mono_domain_get ();
8200         int len = 0;
8201         guint16 *t = ptr;
8202
8203         MONO_ARCH_SAVE_REGS;
8204
8205         if (ptr == NULL)
8206                 return NULL;
8207
8208         while (*t++)
8209                 len++;
8210
8211         return mono_string_new_utf16 (domain, ptr, len);
8212 }
8213
8214 MonoString *
8215 ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringUni_len (guint16 *ptr, gint32 len)
8216 {
8217         MonoDomain *domain = mono_domain_get ();
8218
8219         MONO_ARCH_SAVE_REGS;
8220
8221         if (ptr == NULL) {
8222                 mono_raise_exception (mono_get_exception_argument_null ("ptr"));
8223                 g_assert_not_reached ();
8224                 return NULL;
8225         } else
8226                 return mono_string_new_utf16 (domain, ptr, len);
8227 }
8228
8229 MonoString *
8230 ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringBSTR (gpointer ptr)
8231 {
8232         MONO_ARCH_SAVE_REGS;
8233
8234         return mono_string_from_bstr(ptr);
8235 }
8236
8237 gpointer
8238 ves_icall_System_Runtime_InteropServices_Marshal_StringToBSTR (MonoString* ptr)
8239 {
8240         MONO_ARCH_SAVE_REGS;
8241
8242         return mono_string_to_bstr(ptr);
8243 }
8244
8245 void
8246 ves_icall_System_Runtime_InteropServices_Marshal_FreeBSTR (gpointer ptr)
8247 {
8248         MONO_ARCH_SAVE_REGS;
8249
8250         mono_free_bstr (ptr);
8251 }
8252
8253 guint32
8254 ves_icall_System_Runtime_InteropServices_Marshal_GetComSlotForMethodInfoInternal (MonoReflectionMethod *m)
8255 {
8256         static MonoClass *interface_type_attribute = NULL;
8257         MonoInterfaceTypeAttribute* itf_attr = NULL;
8258         MonoCustomAttrInfo *cinfo = NULL;
8259         guint32 offset = 7;
8260         MONO_ARCH_SAVE_REGS;
8261
8262         if (!interface_type_attribute)
8263                 interface_type_attribute = mono_class_from_name (mono_defaults.corlib, "System.Runtime.InteropServices", "InterfaceTypeAttribute");
8264         cinfo = mono_custom_attrs_from_class (m->method->klass);
8265         if (cinfo) {
8266                 itf_attr = (MonoInterfaceTypeAttribute*)mono_custom_attrs_get_attr (cinfo, interface_type_attribute);
8267                 if (!cinfo->cached)
8268                         mono_custom_attrs_free (cinfo);
8269         }
8270
8271         if (itf_attr && itf_attr->intType == 1)
8272                 offset = 3; /* 3 methods in IUnknown*/
8273         else
8274                 offset = 7; /* 7 methods in IDispatch*/
8275
8276         return m->method->slot + offset;
8277 }
8278
8279 guint32
8280 ves_icall_System_Runtime_InteropServices_Marshal_GetLastWin32Error (void)
8281 {
8282         MONO_ARCH_SAVE_REGS;
8283
8284         return (GPOINTER_TO_INT (TlsGetValue (last_error_tls_id)));
8285 }
8286
8287 guint32
8288 ves_icall_System_Runtime_InteropServices_Marshal_SizeOf (MonoReflectionType *rtype)
8289 {
8290         MonoClass *klass;
8291         MonoType *type;
8292         guint32 layout;
8293
8294         MONO_ARCH_SAVE_REGS;
8295
8296         MONO_CHECK_ARG_NULL (rtype);
8297
8298         type = rtype->type;
8299         klass = mono_class_from_mono_type (type);
8300         layout = (klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK);
8301
8302         if (layout == TYPE_ATTRIBUTE_AUTO_LAYOUT) {
8303                 gchar *msg;
8304                 MonoException *exc;
8305
8306                 msg = g_strdup_printf ("Type %s cannot be marshaled as an unmanaged structure.", klass->name);
8307                 exc = mono_get_exception_argument ("t", msg);
8308                 g_free (msg);
8309                 mono_raise_exception (exc);
8310         }
8311
8312
8313         return mono_class_native_size (klass, NULL);
8314 }
8315
8316 void
8317 ves_icall_System_Runtime_InteropServices_Marshal_StructureToPtr (MonoObject *obj, gpointer dst, MonoBoolean delete_old)
8318 {
8319         MonoMethod *method;
8320         gpointer pa [3];
8321
8322         MONO_ARCH_SAVE_REGS;
8323
8324         MONO_CHECK_ARG_NULL (obj);
8325         MONO_CHECK_ARG_NULL (dst);
8326
8327         method = mono_marshal_get_struct_to_ptr (obj->vtable->klass);
8328
8329         pa [0] = obj;
8330         pa [1] = &dst;
8331         pa [2] = &delete_old;
8332
8333         mono_runtime_invoke (method, NULL, pa, NULL);
8334 }
8335
8336 static void
8337 ptr_to_structure (gpointer src, MonoObject *dst)
8338 {
8339         MonoMethod *method;
8340         gpointer pa [2];
8341
8342         method = mono_marshal_get_ptr_to_struct (dst->vtable->klass);
8343
8344         pa [0] = &src;
8345         pa [1] = dst;
8346
8347         mono_runtime_invoke (method, NULL, pa, NULL);
8348 }
8349
8350 void
8351 ves_icall_System_Runtime_InteropServices_Marshal_PtrToStructure (gpointer src, MonoObject *dst)
8352 {
8353         MonoType *t;
8354
8355         MONO_ARCH_SAVE_REGS;
8356
8357         MONO_CHECK_ARG_NULL (src);
8358         MONO_CHECK_ARG_NULL (dst);
8359
8360         t = mono_type_get_underlying_type (mono_class_get_type (dst->vtable->klass));
8361
8362         if (t->type == MONO_TYPE_VALUETYPE) {
8363                 MonoException *exc;
8364                 gchar *tmp;
8365
8366                 tmp = g_strdup_printf ("Destination is a boxed value type.");
8367                 exc = mono_get_exception_argument ("dst", tmp);
8368                 g_free (tmp);
8369
8370                 mono_raise_exception (exc);
8371                 return;
8372         }
8373
8374         ptr_to_structure (src, dst);
8375 }
8376
8377 MonoObject *
8378 ves_icall_System_Runtime_InteropServices_Marshal_PtrToStructure_type (gpointer src, MonoReflectionType *type)
8379 {
8380         MonoDomain *domain = mono_domain_get ();
8381         MonoObject *res;
8382
8383         MONO_ARCH_SAVE_REGS;
8384
8385         MONO_CHECK_ARG_NULL (src);
8386         MONO_CHECK_ARG_NULL (type);
8387
8388         res = mono_object_new (domain, mono_class_from_mono_type (type->type));
8389
8390         ptr_to_structure (src, res);
8391
8392         return res;
8393 }
8394
8395 int
8396 ves_icall_System_Runtime_InteropServices_Marshal_OffsetOf (MonoReflectionType *type, MonoString *field_name)
8397 {
8398         MonoMarshalType *info;
8399         MonoClass *klass;
8400         char *fname;
8401         int match_index = -1;
8402
8403         MONO_ARCH_SAVE_REGS;
8404
8405         MONO_CHECK_ARG_NULL (type);
8406         MONO_CHECK_ARG_NULL (field_name);
8407
8408         fname = mono_string_to_utf8 (field_name);
8409         klass = mono_class_from_mono_type (type->type);
8410
8411         while (klass && match_index == -1) {
8412                 MonoClassField* field;
8413                 int i = 0;
8414                 gpointer iter = NULL;
8415                 while ((field = mono_class_get_fields (klass, &iter))) {
8416                         if (field->type->attrs & FIELD_ATTRIBUTE_STATIC)
8417                                 continue;
8418                         if (!strcmp (fname, field->name)) {
8419                                 match_index = i;
8420                                 break;
8421                         }
8422                         i ++;
8423                 }
8424
8425                 if (match_index == -1)
8426                         klass = klass->parent;
8427         }
8428
8429         g_free (fname);
8430
8431         if(match_index == -1) {
8432                 MonoException* exc;
8433                 gchar *tmp;
8434
8435                 /* Get back original class instance */
8436                 klass = mono_class_from_mono_type (type->type);
8437
8438                 tmp = g_strdup_printf ("Field passed in is not a marshaled member of the type %s", klass->name);
8439                 exc = mono_get_exception_argument ("fieldName", tmp);
8440                 g_free (tmp);
8441
8442                 mono_raise_exception ((MonoException*)exc);
8443         }
8444
8445         info = mono_marshal_load_type_info (klass);
8446         return info->fields [match_index].offset;
8447 }
8448
8449 gpointer
8450 ves_icall_System_Runtime_InteropServices_Marshal_StringToHGlobalAnsi (MonoString *string)
8451 {
8452         MONO_ARCH_SAVE_REGS;
8453
8454         return mono_string_to_utf8 (string);
8455 }
8456
8457 gpointer
8458 ves_icall_System_Runtime_InteropServices_Marshal_StringToHGlobalUni (MonoString *string)
8459 {
8460         MONO_ARCH_SAVE_REGS;
8461
8462         if (string == NULL)
8463                 return NULL;
8464         else {
8465                 gunichar2 *res = g_malloc ((mono_string_length (string) + 1) * 2);
8466                 memcpy (res, mono_string_chars (string), mono_string_length (string) * 2);
8467                 res [mono_string_length (string)] = 0;
8468                 return res;
8469         }
8470 }
8471
8472 static void
8473 mono_struct_delete_old (MonoClass *klass, char *ptr)
8474 {
8475         MonoMarshalType *info;
8476         int i;
8477
8478         info = mono_marshal_load_type_info (klass);
8479
8480         for (i = 0; i < info->num_fields; i++) {
8481                 MonoMarshalNative ntype;
8482                 MonoMarshalConv conv;
8483                 MonoType *ftype = info->fields [i].field->type;
8484                 char *cpos;
8485
8486                 if (ftype->attrs & FIELD_ATTRIBUTE_STATIC)
8487                         continue;
8488
8489                 ntype = mono_type_to_unmanaged (ftype, info->fields [i].mspec, TRUE,
8490                                                 klass->unicode, &conv);
8491
8492                 cpos = ptr + info->fields [i].offset;
8493
8494                 switch (conv) {
8495                 case MONO_MARSHAL_CONV_NONE:
8496                         if (MONO_TYPE_ISSTRUCT (ftype)) {
8497                                 mono_struct_delete_old (ftype->data.klass, cpos);
8498                                 continue;
8499                         }
8500                         break;
8501                 case MONO_MARSHAL_CONV_STR_LPWSTR:
8502                         /* We assume this field points inside a MonoString */
8503                         break;
8504                 case MONO_MARSHAL_CONV_STR_LPSTR:
8505                 case MONO_MARSHAL_CONV_STR_LPTSTR:
8506                 case MONO_MARSHAL_CONV_STR_BSTR:
8507                 case MONO_MARSHAL_CONV_STR_ANSIBSTR:
8508                 case MONO_MARSHAL_CONV_STR_TBSTR:
8509                         mono_marshal_free (*(gpointer *)cpos);
8510                         break;
8511                 default:
8512                         continue;
8513                 }
8514         }
8515 }
8516
8517 void
8518 ves_icall_System_Runtime_InteropServices_Marshal_DestroyStructure (gpointer src, MonoReflectionType *type)
8519 {
8520         MonoClass *klass;
8521
8522         MONO_ARCH_SAVE_REGS;
8523
8524         MONO_CHECK_ARG_NULL (src);
8525         MONO_CHECK_ARG_NULL (type);
8526
8527         klass = mono_class_from_mono_type (type->type);
8528
8529         mono_struct_delete_old (klass, (char *)src);
8530 }
8531
8532
8533 /* FIXME: on win32 we should probably use GlobalAlloc(). */
8534 void*
8535 ves_icall_System_Runtime_InteropServices_Marshal_AllocHGlobal (int size)
8536 {
8537         gpointer res;
8538
8539         MONO_ARCH_SAVE_REGS;
8540
8541         if ((gulong)size == 0)
8542                 /* This returns a valid pointer for size 0 on MS.NET */
8543                 size = 4;
8544
8545         res = g_try_malloc ((gulong)size);
8546         if (!res)
8547                 mono_gc_out_of_memory ((gulong)size);
8548
8549         return res;
8550 }
8551
8552 void
8553 ves_icall_System_Runtime_InteropServices_Marshal_FreeHGlobal (void *ptr)
8554 {
8555         MONO_ARCH_SAVE_REGS;
8556
8557         g_free (ptr);
8558 }
8559
8560 void*
8561 ves_icall_System_Runtime_InteropServices_Marshal_AllocCoTaskMem (int size)
8562 {
8563         MONO_ARCH_SAVE_REGS;
8564
8565 #ifdef PLATFORM_WIN32
8566         return CoTaskMemAlloc (size);
8567 #else
8568         return g_try_malloc ((gulong)size);
8569 #endif
8570 }
8571
8572 void
8573 ves_icall_System_Runtime_InteropServices_Marshal_FreeCoTaskMem (void *ptr)
8574 {
8575         MONO_ARCH_SAVE_REGS;
8576
8577 #ifdef PLATFORM_WIN32
8578         CoTaskMemFree (ptr);
8579 #else
8580         g_free (ptr);
8581 #endif
8582 }
8583
8584 void*
8585 ves_icall_System_Runtime_InteropServices_Marshal_UnsafeAddrOfPinnedArrayElement (MonoArray *arrayobj, int index)
8586 {
8587         return mono_array_addr_with_size (arrayobj, mono_array_element_size (arrayobj->obj.vtable->klass), index);
8588 }
8589
8590 MonoDelegate*
8591 ves_icall_System_Runtime_InteropServices_Marshal_GetDelegateForFunctionPointerInternal (void *ftn, MonoReflectionType *type)
8592 {
8593         return mono_ftnptr_to_delegate (mono_type_get_class (type->type), ftn);
8594 }
8595
8596 MonoMarshalType *
8597 mono_marshal_load_type_info (MonoClass* klass)
8598 {
8599         int j, count = 0;
8600         guint32 native_size = 0, min_align = 1;
8601         MonoMarshalType *info;
8602         MonoClassField* field;
8603         gpointer iter;
8604         guint32 layout;
8605
8606         g_assert (klass != NULL);
8607
8608         if (klass->marshal_info)
8609                 return klass->marshal_info;
8610
8611         if (!klass->inited)
8612                 mono_class_init (klass);
8613
8614         iter = NULL;
8615         while ((field = mono_class_get_fields (klass, &iter))) {
8616                 if (field->type->attrs & FIELD_ATTRIBUTE_STATIC)
8617                         continue;
8618                 if (mono_field_is_deleted (field))
8619                         continue;
8620                 count++;
8621         }
8622
8623         layout = klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK;
8624
8625         klass->marshal_info = info = g_malloc0 (sizeof (MonoMarshalType) + sizeof (MonoMarshalField) * count);
8626         info->num_fields = count;
8627
8628         /* Try to find a size for this type in metadata */
8629         mono_metadata_packing_from_typedef (klass->image, klass->type_token, NULL, &native_size);
8630
8631         if (klass->parent) {
8632                 int parent_size = mono_class_native_size (klass->parent, NULL);
8633
8634                 /* Add parent size to real size */
8635                 native_size += parent_size;
8636                 info->native_size = parent_size;
8637         }
8638
8639         iter = NULL;
8640         j = 0;
8641         while ((field = mono_class_get_fields (klass, &iter))) {
8642                 int size;
8643                 guint32 align;
8644
8645                 if (field->type->attrs & FIELD_ATTRIBUTE_STATIC)
8646                         continue;
8647
8648                 if (mono_field_is_deleted (field))
8649                         continue;
8650                 if (field->type->attrs & FIELD_ATTRIBUTE_HAS_FIELD_MARSHAL)
8651                         mono_metadata_field_info (klass->image, mono_metadata_token_index (mono_class_get_field_token (field)) - 1,
8652                                                   NULL, NULL, &info->fields [j].mspec);
8653
8654                 info->fields [j].field = field;
8655
8656                 if ((mono_class_num_fields (klass) == 1) && (klass->instance_size == sizeof (MonoObject)) &&
8657                         (strcmp (field->name, "$PRIVATE$") == 0)) {
8658                         /* This field is a hack inserted by MCS to empty structures */
8659                         continue;
8660                 }
8661
8662                 switch (layout) {
8663                 case TYPE_ATTRIBUTE_AUTO_LAYOUT:
8664                 case TYPE_ATTRIBUTE_SEQUENTIAL_LAYOUT:
8665                         size = mono_marshal_type_size (field->type, info->fields [j].mspec,
8666                                                        &align, TRUE, klass->unicode);
8667                         align = klass->packing_size ? MIN (klass->packing_size, align): align;
8668                         min_align = MAX (align, min_align);
8669                         info->fields [j].offset = info->native_size;
8670                         info->fields [j].offset += align - 1;
8671                         info->fields [j].offset &= ~(align - 1);
8672                         info->native_size = info->fields [j].offset + size;
8673                         break;
8674                 case TYPE_ATTRIBUTE_EXPLICIT_LAYOUT:
8675                         size = mono_marshal_type_size (field->type, info->fields [j].mspec,
8676                                                        &align, TRUE, klass->unicode);
8677                         align = klass->packing_size ? MIN (klass->packing_size, align): align;
8678                         min_align = MAX (align, min_align);
8679                         info->fields [j].offset = field->offset - sizeof (MonoObject);
8680                         info->native_size = MAX (info->native_size, info->fields [j].offset + size);
8681                         break;
8682                 }
8683                 j++;
8684         }
8685
8686         if(layout != TYPE_ATTRIBUTE_AUTO_LAYOUT) {
8687                 info->native_size = MAX (native_size, info->native_size);
8688         }
8689
8690         if (info->native_size & (min_align - 1)) {
8691                 info->native_size += min_align - 1;
8692                 info->native_size &= ~(min_align - 1);
8693         }
8694
8695         /* Update the class's blittable info, if the layouts don't match */
8696         if (info->native_size != mono_class_value_size (klass, NULL))
8697                 klass->blittable = FALSE;
8698
8699         /* If this is an array type, ensure that we have element info */
8700         if (klass->element_class) {
8701                 mono_marshal_load_type_info (klass->element_class);
8702         }
8703
8704         return klass->marshal_info;
8705 }
8706
8707 /**
8708  * mono_class_native_size:
8709  * @klass: a class
8710  *
8711  * Returns: the native size of an object instance (when marshaled
8712  * to unmanaged code)
8713  */
8714 gint32
8715 mono_class_native_size (MonoClass *klass, guint32 *align)
8716 {
8717         if (!klass->marshal_info)
8718                 mono_marshal_load_type_info (klass);
8719
8720         if (align)
8721                 *align = klass->min_align;
8722
8723         return klass->marshal_info->native_size;
8724 }
8725
8726 /*
8727  * mono_type_native_stack_size:
8728  * @t: the type to return the size it uses on the stack
8729  *
8730  * Returns: the number of bytes required to hold an instance of this
8731  * type on the native stack
8732  */
8733 int
8734 mono_type_native_stack_size (MonoType *t, guint32 *align)
8735 {
8736         guint32 tmp;
8737
8738         g_assert (t != NULL);
8739
8740         if (!align)
8741                 align = &tmp;
8742
8743         if (t->byref) {
8744                 *align = 4;
8745                 return 4;
8746         }
8747
8748         switch (t->type){
8749         case MONO_TYPE_BOOLEAN:
8750         case MONO_TYPE_CHAR:
8751         case MONO_TYPE_I1:
8752         case MONO_TYPE_U1:
8753         case MONO_TYPE_I2:
8754         case MONO_TYPE_U2:
8755         case MONO_TYPE_I4:
8756         case MONO_TYPE_U4:
8757         case MONO_TYPE_I:
8758         case MONO_TYPE_U:
8759         case MONO_TYPE_STRING:
8760         case MONO_TYPE_OBJECT:
8761         case MONO_TYPE_CLASS:
8762         case MONO_TYPE_SZARRAY:
8763         case MONO_TYPE_PTR:
8764         case MONO_TYPE_FNPTR:
8765         case MONO_TYPE_ARRAY:
8766         case MONO_TYPE_TYPEDBYREF:
8767                 *align = 4;
8768                 return 4;
8769         case MONO_TYPE_R4:
8770                 *align = 4;
8771                 return 4;
8772         case MONO_TYPE_I8:
8773         case MONO_TYPE_U8:
8774         case MONO_TYPE_R8:
8775                 *align = 4;
8776                 return 8;
8777         case MONO_TYPE_VALUETYPE: {
8778                 guint32 size;
8779
8780                 if (t->data.klass->enumtype)
8781                         return mono_type_native_stack_size (t->data.klass->enum_basetype, align);
8782                 else {
8783                         size = mono_class_native_size (t->data.klass, align);
8784                         *align = *align + 3;
8785                         *align &= ~3;
8786
8787                         size +=  3;
8788                         size &= ~3;
8789
8790                         return size;
8791                 }
8792         }
8793         default:
8794                 g_error ("type 0x%02x unknown", t->type);
8795         }
8796         return 0;
8797 }
8798
8799 /* __alignof__ returns the preferred alignment of values not the actual alignment used by
8800    the compiler so is wrong e.g. for Linux where doubles are aligned on a 4 byte boundary
8801    but __alignof__ returns 8 - using G_STRUCT_OFFSET works better */
8802 #define ALIGNMENT(type) G_STRUCT_OFFSET(struct { char c; type x; }, x)
8803
8804 gint32
8805 mono_marshal_type_size (MonoType *type, MonoMarshalSpec *mspec, guint32 *align,
8806                         gboolean as_field, gboolean unicode)
8807 {
8808         MonoMarshalNative native_type = mono_type_to_unmanaged (type, mspec, as_field, unicode, NULL);
8809         MonoClass *klass;
8810
8811         switch (native_type) {
8812         case MONO_NATIVE_BOOLEAN:
8813                 *align = 4;
8814                 return 4;
8815         case MONO_NATIVE_I1:
8816         case MONO_NATIVE_U1:
8817                 *align = 1;
8818                 return 1;
8819         case MONO_NATIVE_I2:
8820         case MONO_NATIVE_U2:
8821         case MONO_NATIVE_VARIANTBOOL:
8822                 *align = 2;
8823                 return 2;
8824         case MONO_NATIVE_I4:
8825         case MONO_NATIVE_U4:
8826         case MONO_NATIVE_ERROR:
8827                 *align = 4;
8828                 return 4;
8829         case MONO_NATIVE_I8:
8830         case MONO_NATIVE_U8:
8831                 *align = ALIGNMENT(guint64);
8832                 return 8;
8833         case MONO_NATIVE_R4:
8834                 *align = 4;
8835                 return 4;
8836         case MONO_NATIVE_R8:
8837                 *align = ALIGNMENT(double);
8838                 return 8;
8839         case MONO_NATIVE_INT:
8840         case MONO_NATIVE_UINT:
8841         case MONO_NATIVE_LPSTR:
8842         case MONO_NATIVE_LPWSTR:
8843         case MONO_NATIVE_LPTSTR:
8844         case MONO_NATIVE_BSTR:
8845         case MONO_NATIVE_ANSIBSTR:
8846         case MONO_NATIVE_TBSTR:
8847         case MONO_NATIVE_LPARRAY:
8848         case MONO_NATIVE_SAFEARRAY:
8849         case MONO_NATIVE_IUNKNOWN:
8850         case MONO_NATIVE_IDISPATCH:
8851         case MONO_NATIVE_INTERFACE:
8852         case MONO_NATIVE_ASANY:
8853         case MONO_NATIVE_FUNC:
8854         case MONO_NATIVE_LPSTRUCT:
8855                 *align = ALIGNMENT(gpointer);
8856                 return sizeof (gpointer);
8857         case MONO_NATIVE_STRUCT:
8858                 klass = mono_class_from_mono_type (type);
8859                 return mono_class_native_size (klass, align);
8860         case MONO_NATIVE_BYVALTSTR: {
8861                 int esize = unicode ? 2: 1;
8862                 g_assert (mspec);
8863                 *align = esize;
8864                 return mspec->data.array_data.num_elem * esize;
8865         }
8866         case MONO_NATIVE_BYVALARRAY: {
8867                 // FIXME: Have to consider ArraySubType
8868                 int esize;
8869                 klass = mono_class_from_mono_type (type);
8870                 if (klass->element_class == mono_defaults.char_class) {
8871                         esize = unicode ? 2 : 1;
8872                         *align = esize;
8873                 } else {
8874                         esize = mono_class_native_size (klass->element_class, align);
8875                 }
8876                 g_assert (mspec);
8877                 return mspec->data.array_data.num_elem * esize;
8878         }
8879         case MONO_NATIVE_CUSTOM:
8880                 g_assert_not_reached ();
8881                 break;
8882         case MONO_NATIVE_CURRENCY:
8883         case MONO_NATIVE_VBBYREFSTR:
8884         default:
8885                 g_error ("native type %02x not implemented", native_type);
8886                 break;
8887         }
8888         g_assert_not_reached ();
8889         return 0;
8890 }
8891
8892 gpointer
8893 mono_marshal_asany (MonoObject *o, MonoMarshalNative string_encoding, int param_attrs)
8894 {
8895         MonoType *t;
8896         MonoClass *klass;
8897
8898         if (o == NULL)
8899                 return NULL;
8900
8901         t = &o->vtable->klass->byval_arg;
8902         switch (t->type) {
8903         case MONO_TYPE_I4:
8904         case MONO_TYPE_U4:
8905         case MONO_TYPE_PTR:
8906         case MONO_TYPE_I1:
8907         case MONO_TYPE_U1:
8908         case MONO_TYPE_BOOLEAN:
8909         case MONO_TYPE_I2:
8910         case MONO_TYPE_U2:
8911         case MONO_TYPE_CHAR:
8912         case MONO_TYPE_I8:
8913         case MONO_TYPE_U8:
8914         case MONO_TYPE_R4:
8915         case MONO_TYPE_R8:
8916                 return mono_object_unbox (o);
8917                 break;
8918         case MONO_TYPE_STRING:
8919                 switch (string_encoding) {
8920                 case MONO_NATIVE_LPWSTR:
8921                         return mono_string_to_utf16 ((MonoString*)o);
8922                         break;
8923                 case MONO_NATIVE_LPSTR:
8924                         return mono_string_to_lpstr ((MonoString*)o);
8925                         break;
8926                 default:
8927                         g_warning ("marshaling conversion %d not implemented", string_encoding);
8928                         g_assert_not_reached ();
8929                 }
8930                 break;
8931         case MONO_TYPE_CLASS:
8932         case MONO_TYPE_VALUETYPE: {
8933                 MonoMethod *method;
8934                 gpointer pa [3];
8935                 gpointer res;
8936                 MonoBoolean delete_old = FALSE;
8937
8938                 klass = t->data.klass;
8939
8940                 if ((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_AUTO_LAYOUT)
8941                         break;
8942
8943                 if (klass->valuetype && (((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) ||
8944                         klass->blittable || klass->enumtype))
8945                         return mono_object_unbox (o);
8946
8947                 res = mono_marshal_alloc (mono_class_native_size (klass, NULL));
8948
8949                 if (!((param_attrs & PARAM_ATTRIBUTE_OUT) && !(param_attrs & PARAM_ATTRIBUTE_IN))) {
8950                         method = mono_marshal_get_struct_to_ptr (o->vtable->klass);
8951
8952                         pa [0] = o;
8953                         pa [1] = &res;
8954                         pa [2] = &delete_old;
8955
8956                         mono_runtime_invoke (method, NULL, pa, NULL);
8957                 }
8958
8959                 return res;
8960         }
8961         }
8962
8963         mono_raise_exception (mono_get_exception_argument ("", "No PInvoke conversion exists for value passed to Object-typed parameter."));
8964
8965         return NULL;
8966 }
8967
8968 void
8969 mono_marshal_free_asany (MonoObject *o, gpointer ptr, MonoMarshalNative string_encoding, int param_attrs)
8970 {
8971         MonoType *t;
8972         MonoClass *klass;
8973
8974         if (o == NULL)
8975                 return;
8976
8977         t = &o->vtable->klass->byval_arg;
8978         switch (t->type) {
8979         case MONO_TYPE_STRING:
8980                 switch (string_encoding) {
8981                 case MONO_NATIVE_LPWSTR:
8982                 case MONO_NATIVE_LPSTR:
8983                         mono_marshal_free (ptr);
8984                         break;
8985                 default:
8986                         g_warning ("marshaling conversion %d not implemented", string_encoding);
8987                         g_assert_not_reached ();
8988                 }
8989                 break;
8990         case MONO_TYPE_CLASS:
8991         case MONO_TYPE_VALUETYPE: {
8992                 klass = t->data.klass;
8993
8994                 if (klass->valuetype && (((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) ||
8995                                                                  klass->blittable || klass->enumtype))
8996                         break;
8997
8998                 if (param_attrs & PARAM_ATTRIBUTE_OUT) {
8999                         MonoMethod *method = mono_marshal_get_ptr_to_struct (o->vtable->klass);
9000                         gpointer pa [2];
9001
9002                         pa [0] = &ptr;
9003                         pa [1] = o;
9004
9005                         mono_runtime_invoke (method, NULL, pa, NULL);
9006                 }
9007
9008                 if (!((param_attrs & PARAM_ATTRIBUTE_OUT) && !(param_attrs & PARAM_ATTRIBUTE_IN))) {
9009                         mono_struct_delete_old (klass, ptr);
9010                 }
9011
9012                 mono_marshal_free (ptr);
9013                 break;
9014         }
9015         default:
9016                 break;
9017         }
9018 }