mono/metadata/marshal.c

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