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