mono/metadata/marshal.c

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