mono/metadata/object.c

   1 /*
   2  * object.c: Object creation for the Mono runtime
   3  *
   4  * Author:
   5  *   Miguel de Icaza (miguel@ximian.com)
   6  *   Paolo Molaro (lupus@ximian.com)
   7  *
   8  * Copyright 2001-2003 Ximian, Inc (http://www.ximian.com)
   9  * Copyright 2004-2011 Novell, Inc (http://www.novell.com)
  10  * Copyright 2001 Xamarin Inc (http://www.xamarin.com)
  11  * Licensed under the MIT license. See LICENSE file in the project root for full license information.
  12  */
  13 #include <config.h>
  14 #ifdef HAVE_ALLOCA_H
  15 #include <alloca.h>
  16 #endif
  17 #include <stdlib.h>
  18 #include <stdio.h>
  19 #include <string.h>
  20 #include <mono/metadata/mono-endian.h>
  21 #include <mono/metadata/tabledefs.h>
  22 #include <mono/metadata/tokentype.h>
  23 #include <mono/metadata/loader.h>
  24 #include <mono/metadata/object.h>
  25 #include <mono/metadata/gc-internals.h>
  26 #include <mono/metadata/exception.h>
  27 #include <mono/metadata/exception-internals.h>
  28 #include <mono/metadata/domain-internals.h>
  29 #include "mono/metadata/metadata-internals.h"
  30 #include "mono/metadata/class-internals.h"
  31 #include <mono/metadata/assembly.h>
  32 #include <mono/metadata/marshal.h>
  33 #include "mono/metadata/debug-helpers.h"
  34 #include "mono/metadata/marshal.h"
  35 #include <mono/metadata/threads.h>
  36 #include <mono/metadata/threads-types.h>
  37 #include <mono/metadata/environment.h>
  38 #include "mono/metadata/profiler-private.h"
  39 #include "mono/metadata/security-manager.h"
  40 #include "mono/metadata/mono-debug-debugger.h"
  41 #include <mono/metadata/gc-internals.h>
  42 #include <mono/metadata/verify-internals.h>
  43 #include <mono/metadata/reflection-internals.h>
  44 #include <mono/utils/strenc.h>
  45 #include <mono/utils/mono-counters.h>
  46 #include <mono/utils/mono-error-internals.h>
  47 #include <mono/utils/mono-memory-model.h>
  48 #include <mono/utils/checked-build.h>
  49 #include <mono/utils/mono-threads.h>
  50 #include "cominterop.h"
  51
  52 static void
  53 get_default_field_value (MonoDomain* domain, MonoClassField *field, void *value, MonoError *error);
  54
  55 static MonoString*
  56 mono_ldstr_metadata_sig (MonoDomain *domain, const char* sig, MonoError *error);
  57
  58 static void
  59 free_main_args (void);
  60
  61 static char *
  62 mono_string_to_utf8_internal (MonoMemPool *mp, MonoImage *image, MonoString *s, gboolean ignore_error, MonoError *error);
  63
  64 /* Class lazy loading functions */
  65 static GENERATE_GET_CLASS_WITH_CACHE (pointer, System.Reflection, Pointer)
  66 static GENERATE_GET_CLASS_WITH_CACHE (remoting_services, System.Runtime.Remoting, RemotingServices)
  67 static GENERATE_GET_CLASS_WITH_CACHE (unhandled_exception_event_args, System, UnhandledExceptionEventArgs)
  68 static GENERATE_GET_CLASS_WITH_CACHE (sta_thread_attribute, System, STAThreadAttribute)
  69 static GENERATE_GET_CLASS_WITH_CACHE (activation_services, System.Runtime.Remoting.Activation, ActivationServices)
  70
  71
  72 #define ldstr_lock() mono_os_mutex_lock (&ldstr_section)
  73 #define ldstr_unlock() mono_os_mutex_unlock (&ldstr_section)
  74 static mono_mutex_t ldstr_section;
  75
  76 /**
  77  * mono_runtime_object_init:
  78  * @this_obj: the object to initialize
  79  *
  80  * This function calls the zero-argument constructor (which must
  81  * exist) for the given object.
  82  */
  83 void
  84 mono_runtime_object_init (MonoObject *this_obj)
  85 {
  86         MonoError error;
  87         mono_runtime_object_init_checked (this_obj, &error);
  88         mono_error_assert_ok (&error);
  89 }
  90
  91 /**
  92  * mono_runtime_object_init_checked:
  93  * @this_obj: the object to initialize
  94  * @error: set on error.
  95  *
  96  * This function calls the zero-argument constructor (which must
  97  * exist) for the given object and returns TRUE on success, or FALSE
  98  * on error and sets @error.
  99  */
 100 gboolean
 101 mono_runtime_object_init_checked (MonoObject *this_obj, MonoError *error)
 102 {
 103         MONO_REQ_GC_UNSAFE_MODE;
 104
 105         MonoMethod *method = NULL;
 106         MonoClass *klass = this_obj->vtable->klass;
 107
 108         mono_error_init (error);
 109         method = mono_class_get_method_from_name (klass, ".ctor", 0);
 110         if (!method)
 111                 g_error ("Could not lookup zero argument constructor for class %s", mono_type_get_full_name (klass));
 112
 113         if (method->klass->valuetype)
 114                 this_obj = (MonoObject *)mono_object_unbox (this_obj);
 115
 116         mono_runtime_invoke_checked (method, this_obj, NULL, error);
 117         return is_ok (error);
 118 }
 119
 120 /* The pseudo algorithm for type initialization from the spec
 121 Note it doesn't say anything about domains - only threads.
 122
 123 2. If the type is initialized you are done.
 124 2.1. If the type is not yet initialized, try to take an
 125      initialization lock.
 126 2.2. If successful, record this thread as responsible for
 127      initializing the type and proceed to step 2.3.
 128 2.2.1. If not, see whether this thread or any thread
 129      waiting for this thread to complete already holds the lock.
 130 2.2.2. If so, return since blocking would create a deadlock.  This thread
 131      will now see an incompletely initialized state for the type,
 132      but no deadlock will arise.
 133 2.2.3  If not, block until the type is initialized then return.
 134 2.3 Initialize the parent type and then all interfaces implemented
 135     by this type.
 136 2.4 Execute the type initialization code for this type.
 137 2.5 Mark the type as initialized, release the initialization lock,
 138     awaken any threads waiting for this type to be initialized,
 139     and return.
 140
 141 */
 142
 143 typedef struct
 144 {
 145         MonoNativeThreadId initializing_tid;
 146         guint32 waiting_count;
 147         gboolean done;
 148         MonoCoopMutex initialization_section;
 149 } TypeInitializationLock;
 150
 151 /* for locking access to type_initialization_hash and blocked_thread_hash */
 152 static MonoCoopMutex type_initialization_section;
 153
 154 static inline void
 155 mono_type_initialization_lock (void)
 156 {
 157         /* The critical sections protected by this lock in mono_runtime_class_init_full () can block */
 158         mono_coop_mutex_lock (&type_initialization_section);
 159 }
 160
 161 static inline void
 162 mono_type_initialization_unlock (void)
 163 {
 164         mono_coop_mutex_unlock (&type_initialization_section);
 165 }
 166
 167 static void
 168 mono_type_init_lock (TypeInitializationLock *lock)
 169 {
 170         MONO_REQ_GC_NEUTRAL_MODE;
 171
 172         mono_coop_mutex_lock (&lock->initialization_section);
 173 }
 174
 175 static void
 176 mono_type_init_unlock (TypeInitializationLock *lock)
 177 {
 178         mono_coop_mutex_unlock (&lock->initialization_section);
 179 }
 180
 181 /* from vtable to lock */
 182 static GHashTable *type_initialization_hash;
 183
 184 /* from thread id to thread id being waited on */
 185 static GHashTable *blocked_thread_hash;
 186
 187 /* Main thread */
 188 static MonoThread *main_thread;
 189
 190 /* Functions supplied by the runtime */
 191 static MonoRuntimeCallbacks callbacks;
 192
 193 /**
 194  * mono_thread_set_main:
 195  * @thread: thread to set as the main thread
 196  *
 197  * This function can be used to instruct the runtime to treat @thread
 198  * as the main thread, ie, the thread that would normally execute the Main()
 199  * method. This basically means that at the end of @thread, the runtime will
 200  * wait for the existing foreground threads to quit and other such details.
 201  */
 202 void
 203 mono_thread_set_main (MonoThread *thread)
 204 {
 205         MONO_REQ_GC_UNSAFE_MODE;
 206
 207         static gboolean registered = FALSE;
 208
 209         if (!registered) {
 210                 MONO_GC_REGISTER_ROOT_SINGLE (main_thread, MONO_ROOT_SOURCE_THREADING, "main thread object");
 211                 registered = TRUE;
 212         }
 213
 214         main_thread = thread;
 215 }
 216
 217 MonoThread*
 218 mono_thread_get_main (void)
 219 {
 220         MONO_REQ_GC_UNSAFE_MODE;
 221
 222         return main_thread;
 223 }
 224
 225 void
 226 mono_type_initialization_init (void)
 227 {
 228         mono_coop_mutex_init_recursive (&type_initialization_section);
 229         type_initialization_hash = g_hash_table_new (NULL, NULL);
 230         blocked_thread_hash = g_hash_table_new (NULL, NULL);
 231         mono_os_mutex_init_recursive (&ldstr_section);
 232 }
 233
 234 void
 235 mono_type_initialization_cleanup (void)
 236 {
 237 #if 0
 238         /* This is causing race conditions with
 239          * mono_release_type_locks
 240          */
 241         mono_coop_mutex_destroy (&type_initialization_section);
 242         g_hash_table_destroy (type_initialization_hash);
 243         type_initialization_hash = NULL;
 244 #endif
 245         mono_os_mutex_destroy (&ldstr_section);
 246         g_hash_table_destroy (blocked_thread_hash);
 247         blocked_thread_hash = NULL;
 248
 249         free_main_args ();
 250 }
 251
 252 /**
 253  * get_type_init_exception_for_vtable:
 254  *
 255  *   Return the stored type initialization exception for VTABLE.
 256  */
 257 static MonoException*
 258 get_type_init_exception_for_vtable (MonoVTable *vtable)
 259 {
 260         MONO_REQ_GC_UNSAFE_MODE;
 261
 262         MonoError error;
 263         MonoDomain *domain = vtable->domain;
 264         MonoClass *klass = vtable->klass;
 265         MonoException *ex;
 266         gchar *full_name;
 267
 268         if (!vtable->init_failed)
 269                 g_error ("Trying to get the init exception for a non-failed vtable of class %s", mono_type_get_full_name (klass));
 270
 271         /*
 272          * If the initializing thread was rudely aborted, the exception is not stored
 273          * in the hash.
 274          */
 275         ex = NULL;
 276         mono_domain_lock (domain);
 277         if (domain->type_init_exception_hash)
 278                 ex = (MonoException *)mono_g_hash_table_lookup (domain->type_init_exception_hash, klass);
 279         mono_domain_unlock (domain);
 280
 281         if (!ex) {
 282                 if (klass->name_space && *klass->name_space)
 283                         full_name = g_strdup_printf ("%s.%s", klass->name_space, klass->name);
 284                 else
 285                         full_name = g_strdup (klass->name);
 286                 ex = mono_get_exception_type_initialization_checked (full_name, NULL, &error);
 287                 g_free (full_name);
 288                 return_val_if_nok (&error, NULL);
 289         }
 290
 291         return ex;
 292 }
 293
 294 /*
 295  * mono_runtime_class_init:
 296  * @vtable: vtable that needs to be initialized
 297  *
 298  * This routine calls the class constructor for @vtable.
 299  */
 300 void
 301 mono_runtime_class_init (MonoVTable *vtable)
 302 {
 303         MONO_REQ_GC_UNSAFE_MODE;
 304         MonoError error;
 305
 306         mono_runtime_class_init_full (vtable, &error);
 307         mono_error_assert_ok (&error);
 308 }
 309
 310 /**
 311  * mono_runtime_class_init_full:
 312  * @vtable that neeeds to be initialized
 313  * @error set on error
 314  *
 315  * returns TRUE if class constructor .cctor has been initialized successfully, or FALSE otherwise and sets @error.
 316  *
 317  */
 318 gboolean
 319 mono_runtime_class_init_full (MonoVTable *vtable, MonoError *error)
 320 {
 321         MONO_REQ_GC_UNSAFE_MODE;
 322
 323         MonoMethod *method = NULL;
 324         MonoClass *klass;
 325         gchar *full_name;
 326         MonoDomain *domain = vtable->domain;
 327         TypeInitializationLock *lock;
 328         MonoNativeThreadId tid;
 329         int do_initialization = 0;
 330         MonoDomain *last_domain = NULL;
 331
 332         mono_error_init (error);
 333
 334         if (vtable->initialized)
 335                 return TRUE;
 336
 337         klass = vtable->klass;
 338
 339         if (!klass->image->checked_module_cctor) {
 340                 mono_image_check_for_module_cctor (klass->image);
 341                 if (klass->image->has_module_cctor) {
 342                         MonoClass *module_klass;
 343                         MonoVTable *module_vtable;
 344
 345                         module_klass = mono_class_get_checked (klass->image, MONO_TOKEN_TYPE_DEF | 1, error);
 346                         if (!module_klass) {
 347                                 return FALSE;
 348                         }
 349
 350                         module_vtable = mono_class_vtable_full (vtable->domain, module_klass, error);
 351                         if (!module_vtable)
 352                                 return FALSE;
 353                         if (!mono_runtime_class_init_full (module_vtable, error))
 354                                 return FALSE;
 355                 }
 356         }
 357         method = mono_class_get_cctor (klass);
 358         if (!method) {
 359                 vtable->initialized = 1;
 360                 return TRUE;
 361         }
 362
 363         tid = mono_native_thread_id_get ();
 364
 365         mono_type_initialization_lock ();
 366         /* double check... */
 367         if (vtable->initialized) {
 368                 mono_type_initialization_unlock ();
 369                 return TRUE;
 370         }
 371         if (vtable->init_failed) {
 372                 mono_type_initialization_unlock ();
 373
 374                 /* The type initialization already failed once, rethrow the same exception */
 375                 mono_error_set_exception_instance (error, get_type_init_exception_for_vtable (vtable));
 376                 return FALSE;
 377         }
 378         lock = (TypeInitializationLock *)g_hash_table_lookup (type_initialization_hash, vtable);
 379         if (lock == NULL) {
 380                 /* This thread will get to do the initialization */
 381                 if (mono_domain_get () != domain) {
 382                         /* Transfer into the target domain */
 383                         last_domain = mono_domain_get ();
 384                         if (!mono_domain_set (domain, FALSE)) {
 385                                 vtable->initialized = 1;
 386                                 mono_type_initialization_unlock ();
 387                                 mono_error_set_exception_instance (error, mono_get_exception_appdomain_unloaded ());
 388                                 return FALSE;
 389                         }
 390                 }
 391                 lock = (TypeInitializationLock *)g_malloc (sizeof (TypeInitializationLock));
 392                 mono_coop_mutex_init_recursive (&lock->initialization_section);
 393                 lock->initializing_tid = tid;
 394                 lock->waiting_count = 1;
 395                 lock->done = FALSE;
 396                 /* grab the vtable lock while this thread still owns type_initialization_section */
 397                 /* This is why type_initialization_lock needs to enter blocking mode */
 398                 mono_type_init_lock (lock);
 399                 g_hash_table_insert (type_initialization_hash, vtable, lock);
 400                 do_initialization = 1;
 401         } else {
 402                 gpointer blocked;
 403                 TypeInitializationLock *pending_lock;
 404
 405                 if (mono_native_thread_id_equals (lock->initializing_tid, tid) || lock->done) {
 406                         mono_type_initialization_unlock ();
 407                         return TRUE;
 408                 }
 409                 /* see if the thread doing the initialization is already blocked on this thread */
 410                 blocked = GUINT_TO_POINTER (MONO_NATIVE_THREAD_ID_TO_UINT (lock->initializing_tid));
 411                 while ((pending_lock = (TypeInitializationLock*) g_hash_table_lookup (blocked_thread_hash, blocked))) {
 412                         if (mono_native_thread_id_equals (pending_lock->initializing_tid, tid)) {
 413                                 if (!pending_lock->done) {
 414                                         mono_type_initialization_unlock ();
 415                                         return TRUE;
 416                                 } else {
 417                                         /* the thread doing the initialization is blocked on this thread,
 418                                            but on a lock that has already been freed. It just hasn't got
 419                                            time to awake */
 420                                         break;
 421                                 }
 422                         }
 423                         blocked = GUINT_TO_POINTER (MONO_NATIVE_THREAD_ID_TO_UINT (pending_lock->initializing_tid));
 424                 }
 425                 ++lock->waiting_count;
 426                 /* record the fact that we are waiting on the initializing thread */
 427                 g_hash_table_insert (blocked_thread_hash, GUINT_TO_POINTER (tid), lock);
 428         }
 429         mono_type_initialization_unlock ();
 430
 431         if (do_initialization) {
 432                 MonoException *exc = NULL;
 433                 mono_runtime_try_invoke (method, NULL, NULL, (MonoObject**) &exc, error);
 434                 if (exc != NULL && mono_error_ok (error)) {
 435                         mono_error_set_exception_instance (error, exc);
 436                 }
 437
 438                 /* If the initialization failed, mark the class as unusable. */
 439                 /* Avoid infinite loops */
 440                 if (!(mono_error_ok(error) ||
 441                           (klass->image == mono_defaults.corlib &&
 442                            !strcmp (klass->name_space, "System") &&
 443                            !strcmp (klass->name, "TypeInitializationException")))) {
 444                         vtable->init_failed = 1;
 445
 446                         if (klass->name_space && *klass->name_space)
 447                                 full_name = g_strdup_printf ("%s.%s", klass->name_space, klass->name);
 448                         else
 449                                 full_name = g_strdup (klass->name);
 450
 451                         MonoException *exc_to_throw = mono_get_exception_type_initialization_checked (full_name, exc, error);
 452                         g_free (full_name);
 453                         return_val_if_nok (error, FALSE);
 454
 455                         mono_error_set_exception_instance (error, exc_to_throw);
 456
 457                         MonoException *exc_to_store = mono_error_convert_to_exception (error);
 458                         /* What we really want to do here is clone the error object and store one copy in the
 459                          * domain's exception hash and use the other one to error out here. */
 460                         mono_error_set_exception_instance (error, exc_to_store);
 461                         /*
 462                          * Store the exception object so it could be thrown on subsequent
 463                          * accesses.
 464                          */
 465                         mono_domain_lock (domain);
 466                         if (!domain->type_init_exception_hash)
 467                                 domain->type_init_exception_hash = mono_g_hash_table_new_type (mono_aligned_addr_hash, NULL, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_DOMAIN, "type initialization exceptions table");
 468                         mono_g_hash_table_insert (domain->type_init_exception_hash, klass, exc_to_store);
 469                         mono_domain_unlock (domain);
 470                 }
 471
 472                 if (last_domain)
 473                         mono_domain_set (last_domain, TRUE);
 474                 lock->done = TRUE;
 475                 mono_type_init_unlock (lock);
 476         } else {
 477                 /* this just blocks until the initializing thread is done */
 478                 mono_type_init_lock (lock);
 479                 mono_type_init_unlock (lock);
 480         }
 481
 482         mono_type_initialization_lock ();
 483         if (!mono_native_thread_id_equals (lock->initializing_tid, tid))
 484                 g_hash_table_remove (blocked_thread_hash, GUINT_TO_POINTER (tid));
 485         --lock->waiting_count;
 486         if (lock->waiting_count == 0) {
 487                 mono_coop_mutex_destroy (&lock->initialization_section);
 488                 g_hash_table_remove (type_initialization_hash, vtable);
 489                 g_free (lock);
 490         }
 491         mono_memory_barrier ();
 492         if (!vtable->init_failed)
 493                 vtable->initialized = 1;
 494         mono_type_initialization_unlock ();
 495
 496         if (vtable->init_failed) {
 497                 /* Either we were the initializing thread or we waited for the initialization */
 498                 mono_error_set_exception_instance (error, get_type_init_exception_for_vtable (vtable));
 499                 return FALSE;
 500         }
 501         return TRUE;
 502 }
 503
 504 static
 505 gboolean release_type_locks (gpointer key, gpointer value, gpointer user)
 506 {
 507         MONO_REQ_GC_NEUTRAL_MODE;
 508
 509         MonoVTable *vtable = (MonoVTable*)key;
 510
 511         TypeInitializationLock *lock = (TypeInitializationLock*) value;
 512         if (mono_native_thread_id_equals (lock->initializing_tid, MONO_UINT_TO_NATIVE_THREAD_ID (GPOINTER_TO_UINT (user))) && !lock->done) {
 513                 lock->done = TRUE;
 514                 /*
 515                  * Have to set this since it cannot be set by the normal code in
 516                  * mono_runtime_class_init (). In this case, the exception object is not stored,
 517                  * and get_type_init_exception_for_class () needs to be aware of this.
 518                  */
 519                 vtable->init_failed = 1;
 520                 mono_type_init_unlock (lock);
 521                 --lock->waiting_count;
 522                 if (lock->waiting_count == 0) {
 523                         mono_coop_mutex_destroy (&lock->initialization_section);
 524                         g_free (lock);
 525                         return TRUE;
 526                 }
 527         }
 528         return FALSE;
 529 }
 530
 531 void
 532 mono_release_type_locks (MonoInternalThread *thread)
 533 {
 534         MONO_REQ_GC_UNSAFE_MODE;
 535
 536         mono_type_initialization_lock ();
 537         g_hash_table_foreach_remove (type_initialization_hash, release_type_locks, GUINT_TO_POINTER (thread->tid));
 538         mono_type_initialization_unlock ();
 539 }
 540
 541 #ifndef DISABLE_REMOTING
 542
 543 static gpointer
 544 default_remoting_trampoline (MonoDomain *domain, MonoMethod *method, MonoRemotingTarget target)
 545 {
 546         g_error ("remoting not installed");
 547         return NULL;
 548 }
 549
 550 static MonoRemotingTrampoline arch_create_remoting_trampoline = default_remoting_trampoline;
 551 #endif
 552
 553 static gpointer
 554 default_delegate_trampoline (MonoDomain *domain, MonoClass *klass)
 555 {
 556         g_assert_not_reached ();
 557         return NULL;
 558 }
 559
 560 static MonoDelegateTrampoline arch_create_delegate_trampoline = default_delegate_trampoline;
 561 static MonoImtThunkBuilder imt_thunk_builder;
 562 static gboolean always_build_imt_thunks;
 563
 564 #if (MONO_IMT_SIZE > 32)
 565 #error "MONO_IMT_SIZE cannot be larger than 32"
 566 #endif
 567
 568 void
 569 mono_install_callbacks (MonoRuntimeCallbacks *cbs)
 570 {
 571         memcpy (&callbacks, cbs, sizeof (*cbs));
 572 }
 573
 574 MonoRuntimeCallbacks*
 575 mono_get_runtime_callbacks (void)
 576 {
 577         return &callbacks;
 578 }
 579
 580 #ifndef DISABLE_REMOTING
 581 void
 582 mono_install_remoting_trampoline (MonoRemotingTrampoline func)
 583 {
 584         arch_create_remoting_trampoline = func? func: default_remoting_trampoline;
 585 }
 586 #endif
 587
 588 void
 589 mono_install_delegate_trampoline (MonoDelegateTrampoline func)
 590 {
 591         arch_create_delegate_trampoline = func? func: default_delegate_trampoline;
 592 }
 593
 594 void
 595 mono_install_imt_thunk_builder (MonoImtThunkBuilder func) {
 596         imt_thunk_builder = func;
 597 }
 598
 599 void
 600 mono_set_always_build_imt_thunks (gboolean value)
 601 {
 602         always_build_imt_thunks = value;
 603 }
 604
 605 /**
 606  * mono_compile_method:
 607  * @method: The method to compile.
 608  *
 609  * This JIT-compiles the method, and returns the pointer to the native code
 610  * produced.
 611  */
 612 gpointer
 613 mono_compile_method (MonoMethod *method)
 614 {
 615         gpointer res;
 616         MonoError error;
 617
 618         MONO_REQ_GC_NEUTRAL_MODE
 619
 620         if (!callbacks.compile_method) {
 621                 g_error ("compile method called on uninitialized runtime");
 622                 return NULL;
 623         }
 624         res = callbacks.compile_method (method, &error);
 625         if (!mono_error_ok (&error))
 626                 mono_error_raise_exception (&error);
 627         return res;
 628 }
 629
 630 gpointer
 631 mono_runtime_create_jump_trampoline (MonoDomain *domain, MonoMethod *method, gboolean add_sync_wrapper, MonoError *error)
 632 {
 633         gpointer res;
 634
 635         MONO_REQ_GC_NEUTRAL_MODE;
 636
 637         mono_error_init (error);
 638         res = callbacks.create_jump_trampoline (domain, method, add_sync_wrapper, error);
 639         return res;
 640 }
 641
 642 gpointer
 643 mono_runtime_create_delegate_trampoline (MonoClass *klass)
 644 {
 645         MONO_REQ_GC_NEUTRAL_MODE
 646
 647         return arch_create_delegate_trampoline (mono_domain_get (), klass);
 648 }
 649
 650 static MonoFreeMethodFunc default_mono_free_method = NULL;
 651
 652 /**
 653  * mono_install_free_method:
 654  * @func: pointer to the MonoFreeMethodFunc used to release a method
 655  *
 656  * This is an internal VM routine, it is used for the engines to
 657  * register a handler to release the resources associated with a method.
 658  *
 659  * Methods are freed when no more references to the delegate that holds
 660  * them are left.
 661  */
 662 void
 663 mono_install_free_method (MonoFreeMethodFunc func)
 664 {
 665         default_mono_free_method = func;
 666 }
 667
 668 /**
 669  * mono_runtime_free_method:
 670  * @domain; domain where the method is hosted
 671  * @method: method to release
 672  *
 673  * This routine is invoked to free the resources associated with
 674  * a method that has been JIT compiled.  This is used to discard
 675  * methods that were used only temporarily (for example, used in marshalling)
 676  *
 677  */
 678 void
 679 mono_runtime_free_method (MonoDomain *domain, MonoMethod *method)
 680 {
 681         MONO_REQ_GC_NEUTRAL_MODE
 682
 683         if (default_mono_free_method != NULL)
 684                 default_mono_free_method (domain, method);
 685
 686         mono_method_clear_object (domain, method);
 687
 688         mono_free_method (method);
 689 }
 690
 691 /*
 692  * The vtables in the root appdomain are assumed to be reachable by other
 693  * roots, and we don't use typed allocation in the other domains.
 694  */
 695
 696 /* The sync block is no longer a GC pointer */
 697 #define GC_HEADER_BITMAP (0)
 698
 699 #define BITMAP_EL_SIZE (sizeof (gsize) * 8)
 700
 701 static gsize*
 702 compute_class_bitmap (MonoClass *klass, gsize *bitmap, int size, int offset, int *max_set, gboolean static_fields)
 703 {
 704         MONO_REQ_GC_NEUTRAL_MODE;
 705
 706         MonoClassField *field;
 707         MonoClass *p;
 708         guint32 pos;
 709         int max_size;
 710
 711         if (static_fields)
 712                 max_size = mono_class_data_size (klass) / sizeof (gpointer);
 713         else
 714                 max_size = klass->instance_size / sizeof (gpointer);
 715         if (max_size > size) {
 716                 g_assert (offset <= 0);
 717                 bitmap = (gsize *)g_malloc0 ((max_size + BITMAP_EL_SIZE - 1) / BITMAP_EL_SIZE * sizeof (gsize));
 718                 size = max_size;
 719         }
 720
 721 #ifdef HAVE_SGEN_GC
 722         /*An Ephemeron cannot be marked by sgen*/
 723         if (!static_fields && klass->image == mono_defaults.corlib && !strcmp ("Ephemeron", klass->name)) {
 724                 *max_set = 0;
 725                 memset (bitmap, 0, size / 8);
 726                 return bitmap;
 727         }
 728 #endif
 729
 730         for (p = klass; p != NULL; p = p->parent) {
 731                 gpointer iter = NULL;
 732                 while ((field = mono_class_get_fields (p, &iter))) {
 733                         MonoType *type;
 734
 735                         if (static_fields) {
 736                                 if (!(field->type->attrs & (FIELD_ATTRIBUTE_STATIC | FIELD_ATTRIBUTE_HAS_FIELD_RVA)))
 737                                         continue;
 738                                 if (field->type->attrs & FIELD_ATTRIBUTE_LITERAL)
 739                                         continue;
 740                         } else {
 741                                 if (field->type->attrs & (FIELD_ATTRIBUTE_STATIC | FIELD_ATTRIBUTE_HAS_FIELD_RVA))
 742                                         continue;
 743                         }
 744                         /* FIXME: should not happen, flag as type load error */
 745                         if (field->type->byref)
 746                                 break;
 747
 748                         if (static_fields && field->offset == -1)
 749                                 /* special static */
 750                                 continue;
 751
 752                         pos = field->offset / sizeof (gpointer);
 753                         pos += offset;
 754
 755                         type = mono_type_get_underlying_type (field->type);
 756                         switch (type->type) {
 757                         case MONO_TYPE_I:
 758                         case MONO_TYPE_PTR:
 759                         case MONO_TYPE_FNPTR:
 760                                 break;
 761                         /* only UIntPtr is allowed to be GC-tracked and only in mscorlib */
 762                         case MONO_TYPE_U:
 763 #ifdef HAVE_SGEN_GC
 764                                 break;
 765 #else
 766                                 if (klass->image != mono_defaults.corlib)
 767                                         break;
 768 #endif
 769                         case MONO_TYPE_STRING:
 770                         case MONO_TYPE_SZARRAY:
 771                         case MONO_TYPE_CLASS:
 772                         case MONO_TYPE_OBJECT:
 773                         case MONO_TYPE_ARRAY:
 774                                 g_assert ((field->offset % sizeof(gpointer)) == 0);
 775
 776                                 g_assert (pos < size || pos <= max_size);
 777                                 bitmap [pos / BITMAP_EL_SIZE] |= ((gsize)1) << (pos % BITMAP_EL_SIZE);
 778                                 *max_set = MAX (*max_set, pos);
 779                                 break;
 780                         case MONO_TYPE_GENERICINST:
 781                                 if (!mono_type_generic_inst_is_valuetype (type)) {
 782                                         g_assert ((field->offset % sizeof(gpointer)) == 0);
 783
 784                                         bitmap [pos / BITMAP_EL_SIZE] |= ((gsize)1) << (pos % BITMAP_EL_SIZE);
 785                                         *max_set = MAX (*max_set, pos);
 786                                         break;
 787                                 } else {
 788                                         /* fall through */
 789                                 }
 790                         case MONO_TYPE_VALUETYPE: {
 791                                 MonoClass *fclass = mono_class_from_mono_type (field->type);
 792                                 if (fclass->has_references) {
 793                                         /* remove the object header */
 794                                         compute_class_bitmap (fclass, bitmap, size, pos - (sizeof (MonoObject) / sizeof (gpointer)), max_set, FALSE);
 795                                 }
 796                                 break;
 797                         }
 798                         case MONO_TYPE_I1:
 799                         case MONO_TYPE_U1:
 800                         case MONO_TYPE_I2:
 801                         case MONO_TYPE_U2:
 802                         case MONO_TYPE_I4:
 803                         case MONO_TYPE_U4:
 804                         case MONO_TYPE_I8:
 805                         case MONO_TYPE_U8:
 806                         case MONO_TYPE_R4:
 807                         case MONO_TYPE_R8:
 808                         case MONO_TYPE_BOOLEAN:
 809                         case MONO_TYPE_CHAR:
 810                                 break;
 811                         default:
 812                                 g_error ("compute_class_bitmap: Invalid type %x for field %s:%s\n", type->type, mono_type_get_full_name (field->parent), field->name);
 813                                 break;
 814                         }
 815                 }
 816                 if (static_fields)
 817                         break;
 818         }
 819         return bitmap;
 820 }
 821
 822 /**
 823  * mono_class_compute_bitmap:
 824  *
 825  * Mono internal function to compute a bitmap of reference fields in a class.
 826  */
 827 gsize*
 828 mono_class_compute_bitmap (MonoClass *klass, gsize *bitmap, int size, int offset, int *max_set, gboolean static_fields)
 829 {
 830         MONO_REQ_GC_NEUTRAL_MODE;
 831
 832         return compute_class_bitmap (klass, bitmap, size, offset, max_set, static_fields);
 833 }
 834
 835 #if 0
 836 /*
 837  * similar to the above, but sets the bits in the bitmap for any non-ref field
 838  * and ignores static fields
 839  */
 840 static gsize*
 841 compute_class_non_ref_bitmap (MonoClass *klass, gsize *bitmap, int size, int offset)
 842 {
 843         MonoClassField *field;
 844         MonoClass *p;
 845         guint32 pos, pos2;
 846         int max_size;
 847
 848         max_size = class->instance_size / sizeof (gpointer);
 849         if (max_size >= size) {
 850                 bitmap = g_malloc0 (sizeof (gsize) * ((max_size) + 1));
 851         }
 852
 853         for (p = class; p != NULL; p = p->parent) {
 854                 gpointer iter = NULL;
 855                 while ((field = mono_class_get_fields (p, &iter))) {
 856                         MonoType *type;
 857
 858                         if (field->type->attrs & (FIELD_ATTRIBUTE_STATIC | FIELD_ATTRIBUTE_HAS_FIELD_RVA))
 859                                 continue;
 860                         /* FIXME: should not happen, flag as type load error */
 861                         if (field->type->byref)
 862                                 break;
 863
 864                         pos = field->offset / sizeof (gpointer);
 865                         pos += offset;
 866
 867                         type = mono_type_get_underlying_type (field->type);
 868                         switch (type->type) {
 869 #if SIZEOF_VOID_P == 8
 870                         case MONO_TYPE_I:
 871                         case MONO_TYPE_U:
 872                         case MONO_TYPE_PTR:
 873                         case MONO_TYPE_FNPTR:
 874 #endif
 875                         case MONO_TYPE_I8:
 876                         case MONO_TYPE_U8:
 877                         case MONO_TYPE_R8:
 878                                 if ((((field->offset + 7) / sizeof (gpointer)) + offset) != pos) {
 879                                         pos2 = ((field->offset + 7) / sizeof (gpointer)) + offset;
 880                                         bitmap [pos2 / BITMAP_EL_SIZE] |= ((gsize)1) << (pos2 % BITMAP_EL_SIZE);
 881                                 }
 882                                 /* fall through */
 883 #if SIZEOF_VOID_P == 4
 884                         case MONO_TYPE_I:
 885                         case MONO_TYPE_U:
 886                         case MONO_TYPE_PTR:
 887                         case MONO_TYPE_FNPTR:
 888 #endif
 889                         case MONO_TYPE_I4:
 890                         case MONO_TYPE_U4:
 891                         case MONO_TYPE_R4:
 892                                 if ((((field->offset + 3) / sizeof (gpointer)) + offset) != pos) {
 893                                         pos2 = ((field->offset + 3) / sizeof (gpointer)) + offset;
 894                                         bitmap [pos2 / BITMAP_EL_SIZE] |= ((gsize)1) << (pos2 % BITMAP_EL_SIZE);
 895                                 }
 896                                 /* fall through */
 897                         case MONO_TYPE_CHAR:
 898                         case MONO_TYPE_I2:
 899                         case MONO_TYPE_U2:
 900                                 if ((((field->offset + 1) / sizeof (gpointer)) + offset) != pos) {
 901                                         pos2 = ((field->offset + 1) / sizeof (gpointer)) + offset;
 902                                         bitmap [pos2 / BITMAP_EL_SIZE] |= ((gsize)1) << (pos2 % BITMAP_EL_SIZE);
 903                                 }
 904                                 /* fall through */
 905                         case MONO_TYPE_BOOLEAN:
 906                         case MONO_TYPE_I1:
 907                         case MONO_TYPE_U1:
 908                                 bitmap [pos / BITMAP_EL_SIZE] |= ((gsize)1) << (pos % BITMAP_EL_SIZE);
 909                                 break;
 910                         case MONO_TYPE_STRING:
 911                         case MONO_TYPE_SZARRAY:
 912                         case MONO_TYPE_CLASS:
 913                         case MONO_TYPE_OBJECT:
 914                         case MONO_TYPE_ARRAY:
 915                                 break;
 916                         case MONO_TYPE_GENERICINST:
 917                                 if (!mono_type_generic_inst_is_valuetype (type)) {
 918                                         break;
 919                                 } else {
 920                                         /* fall through */
 921                                 }
 922                         case MONO_TYPE_VALUETYPE: {
 923                                 MonoClass *fclass = mono_class_from_mono_type (field->type);
 924                                 /* remove the object header */
 925                                 compute_class_non_ref_bitmap (fclass, bitmap, size, pos - (sizeof (MonoObject) / sizeof (gpointer)));
 926                                 break;
 927                         }
 928                         default:
 929                                 g_assert_not_reached ();
 930                                 break;
 931                         }
 932                 }
 933         }
 934         return bitmap;
 935 }
 936
 937 /**
 938  * mono_class_insecure_overlapping:
 939  * check if a class with explicit layout has references and non-references
 940  * fields overlapping.
 941  *
 942  * Returns: TRUE if it is insecure to load the type.
 943  */
 944 gboolean
 945 mono_class_insecure_overlapping (MonoClass *klass)
 946 {
 947         int max_set = 0;
 948         gsize *bitmap;
 949         gsize default_bitmap [4] = {0};
 950         gsize *nrbitmap;
 951         gsize default_nrbitmap [4] = {0};
 952         int i, insecure = FALSE;
 953                 return FALSE;
 954
 955         bitmap = compute_class_bitmap (klass, default_bitmap, sizeof (default_bitmap) * 8, 0, &max_set, FALSE);
 956         nrbitmap = compute_class_non_ref_bitmap (klass, default_nrbitmap, sizeof (default_nrbitmap) * 8, 0);
 957
 958         for (i = 0; i <= max_set; i += sizeof (bitmap [0]) * 8) {
 959                 int idx = i % (sizeof (bitmap [0]) * 8);
 960                 if (bitmap [idx] & nrbitmap [idx]) {
 961                         insecure = TRUE;
 962                         break;
 963                 }
 964         }
 965         if (bitmap != default_bitmap)
 966                 g_free (bitmap);
 967         if (nrbitmap != default_nrbitmap)
 968                 g_free (nrbitmap);
 969         if (insecure) {
 970                 g_print ("class %s.%s in assembly %s has overlapping references\n", klass->name_space, klass->name, klass->image->name);
 971                 return FALSE;
 972         }
 973         return insecure;
 974 }
 975 #endif
 976
 977 MonoString*
 978 ves_icall_string_alloc (int length)
 979 {
 980         MonoError error;
 981         MonoString *str = mono_string_new_size_checked (mono_domain_get (), length, &error);
 982         mono_error_set_pending_exception (&error);
 983
 984         return str;
 985 }
 986
 987 void
 988 mono_class_compute_gc_descriptor (MonoClass *klass)
 989 {
 990         MONO_REQ_GC_NEUTRAL_MODE;
 991
 992         int max_set = 0;
 993         gsize *bitmap;
 994         gsize default_bitmap [4] = {0};
 995         static gboolean gcj_inited = FALSE;
 996
 997         if (!gcj_inited) {
 998                 mono_loader_lock ();
 999
1000                 mono_register_jit_icall (ves_icall_object_new_fast, "ves_icall_object_new_fast", mono_create_icall_signature ("object ptr"), FALSE);
1001                 mono_register_jit_icall (ves_icall_string_alloc, "ves_icall_string_alloc", mono_create_icall_signature ("object int"), FALSE);
1002
1003                 gcj_inited = TRUE;
1004                 mono_loader_unlock ();
1005         }
1006
1007         if (!klass->inited)
1008                 mono_class_init (klass);
1009
1010         if (klass->gc_descr_inited)
1011                 return;
1012
1013         klass->gc_descr_inited = TRUE;
1014         klass->gc_descr = MONO_GC_DESCRIPTOR_NULL;
1015
1016         bitmap = default_bitmap;
1017         if (klass == mono_defaults.string_class) {
1018                 klass->gc_descr = mono_gc_make_descr_for_string (bitmap, 2);
1019         } else if (klass->rank) {
1020                 mono_class_compute_gc_descriptor (klass->element_class);
1021                 if (MONO_TYPE_IS_REFERENCE (&klass->element_class->byval_arg)) {
1022                         gsize abm = 1;
1023                         klass->gc_descr = mono_gc_make_descr_for_array (klass->byval_arg.type == MONO_TYPE_SZARRAY, &abm, 1, sizeof (gpointer));
1024                         /*printf ("new array descriptor: 0x%x for %s.%s\n", class->gc_descr,
1025                                 class->name_space, class->name);*/
1026                 } else {
1027                         /* remove the object header */
1028                         bitmap = compute_class_bitmap (klass->element_class, default_bitmap, sizeof (default_bitmap) * 8, - (int)(sizeof (MonoObject) / sizeof (gpointer)), &max_set, FALSE);
1029                         klass->gc_descr = mono_gc_make_descr_for_array (klass->byval_arg.type == MONO_TYPE_SZARRAY, bitmap, mono_array_element_size (klass) / sizeof (gpointer), mono_array_element_size (klass));
1030                         /*printf ("new vt array descriptor: 0x%x for %s.%s\n", class->gc_descr,
1031                                 class->name_space, class->name);*/
1032                         if (bitmap != default_bitmap)
1033                                 g_free (bitmap);
1034                 }
1035         } else {
1036                 /*static int count = 0;
1037                 if (count++ > 58)
1038                         return;*/
1039                 bitmap = compute_class_bitmap (klass, default_bitmap, sizeof (default_bitmap) * 8, 0, &max_set, FALSE);
1040                 klass->gc_descr = mono_gc_make_descr_for_object (bitmap, max_set + 1, klass->instance_size);
1041                 /*
1042                 if (class->gc_descr == MONO_GC_DESCRIPTOR_NULL)
1043                         g_print ("disabling typed alloc (%d) for %s.%s\n", max_set, class->name_space, class->name);
1044                 */
1045                 /*printf ("new descriptor: %p 0x%x for %s.%s\n", class->gc_descr, bitmap [0], class->name_space, class->name);*/
1046                 if (bitmap != default_bitmap)
1047                         g_free (bitmap);
1048         }
1049 }
1050
1051 /**
1052  * field_is_special_static:
1053  * @fklass: The MonoClass to look up.
1054  * @field: The MonoClassField describing the field.
1055  *
1056  * Returns: SPECIAL_STATIC_THREAD if the field is thread static, SPECIAL_STATIC_CONTEXT if it is context static,
1057  * SPECIAL_STATIC_NONE otherwise.
1058  */
1059 static gint32
1060 field_is_special_static (MonoClass *fklass, MonoClassField *field)
1061 {
1062         MONO_REQ_GC_NEUTRAL_MODE;
1063
1064         MonoError error;
1065         MonoCustomAttrInfo *ainfo;
1066         int i;
1067         ainfo = mono_custom_attrs_from_field_checked (fklass, field, &error);
1068         mono_error_cleanup (&error); /* FIXME don't swallow the error? */
1069         if (!ainfo)
1070                 return FALSE;
1071         for (i = 0; i < ainfo->num_attrs; ++i) {
1072                 MonoClass *klass = ainfo->attrs [i].ctor->klass;
1073                 if (klass->image == mono_defaults.corlib) {
1074                         if (strcmp (klass->name, "ThreadStaticAttribute") == 0) {
1075                                 mono_custom_attrs_free (ainfo);
1076                                 return SPECIAL_STATIC_THREAD;
1077                         }
1078                         else if (strcmp (klass->name, "ContextStaticAttribute") == 0) {
1079                                 mono_custom_attrs_free (ainfo);
1080                                 return SPECIAL_STATIC_CONTEXT;
1081                         }
1082                 }
1083         }
1084         mono_custom_attrs_free (ainfo);
1085         return SPECIAL_STATIC_NONE;
1086 }
1087
1088 #define rot(x,k) (((x)<<(k)) | ((x)>>(32-(k))))
1089 #define mix(a,b,c) { \
1090         a -= c;  a ^= rot(c, 4);  c += b; \
1091         b -= a;  b ^= rot(a, 6);  a += c; \
1092         c -= b;  c ^= rot(b, 8);  b += a; \
1093         a -= c;  a ^= rot(c,16);  c += b; \
1094         b -= a;  b ^= rot(a,19);  a += c; \
1095         c -= b;  c ^= rot(b, 4);  b += a; \
1096 }
1097 #define final(a,b,c) { \
1098         c ^= b; c -= rot(b,14); \
1099         a ^= c; a -= rot(c,11); \
1100         b ^= a; b -= rot(a,25); \
1101         c ^= b; c -= rot(b,16); \
1102         a ^= c; a -= rot(c,4);  \
1103         b ^= a; b -= rot(a,14); \
1104         c ^= b; c -= rot(b,24); \
1105 }
1106
1107 /*
1108  * mono_method_get_imt_slot:
1109  *
1110  *   The IMT slot is embedded into AOTed code, so this must return the same value
1111  * for the same method across all executions. This means:
1112  * - pointers shouldn't be used as hash values.
1113  * - mono_metadata_str_hash () should be used for hashing strings.
1114  */
1115 guint32
1116 mono_method_get_imt_slot (MonoMethod *method)
1117 {
1118         MONO_REQ_GC_NEUTRAL_MODE;
1119
1120         MonoMethodSignature *sig;
1121         int hashes_count;
1122         guint32 *hashes_start, *hashes;
1123         guint32 a, b, c;
1124         int i;
1125
1126         /* This can be used to stress tests the collision code */
1127         //return 0;
1128
1129         /*
1130          * We do this to simplify generic sharing.  It will hurt
1131          * performance in cases where a class implements two different
1132          * instantiations of the same generic interface.
1133          * The code in build_imt_slots () depends on this.
1134          */
1135         if (method->is_inflated)
1136                 method = ((MonoMethodInflated*)method)->declaring;
1137
1138         sig = mono_method_signature (method);
1139         hashes_count = sig->param_count + 4;
1140         hashes_start = (guint32 *)malloc (hashes_count * sizeof (guint32));
1141         hashes = hashes_start;
1142
1143         if (! MONO_CLASS_IS_INTERFACE (method->klass)) {
1144                 g_error ("mono_method_get_imt_slot: %s.%s.%s is not an interface MonoMethod",
1145                                 method->klass->name_space, method->klass->name, method->name);
1146         }
1147
1148         /* Initialize hashes */
1149         hashes [0] = mono_metadata_str_hash (method->klass->name);
1150         hashes [1] = mono_metadata_str_hash (method->klass->name_space);
1151         hashes [2] = mono_metadata_str_hash (method->name);
1152         hashes [3] = mono_metadata_type_hash (sig->ret);
1153         for (i = 0; i < sig->param_count; i++) {
1154                 hashes [4 + i] = mono_metadata_type_hash (sig->params [i]);
1155         }
1156
1157         /* Setup internal state */
1158         a = b = c = 0xdeadbeef + (((guint32)hashes_count)<<2);
1159
1160         /* Handle most of the hashes */
1161         while (hashes_count > 3) {
1162                 a += hashes [0];
1163                 b += hashes [1];
1164                 c += hashes [2];
1165                 mix (a,b,c);
1166                 hashes_count -= 3;
1167                 hashes += 3;
1168         }
1169
1170         /* Handle the last 3 hashes (all the case statements fall through) */
1171         switch (hashes_count) {
1172         case 3 : c += hashes [2];
1173         case 2 : b += hashes [1];
1174         case 1 : a += hashes [0];
1175                 final (a,b,c);
1176         case 0: /* nothing left to add */
1177                 break;
1178         }
1179
1180         free (hashes_start);
1181         /* Report the result */
1182         return c % MONO_IMT_SIZE;
1183 }
1184 #undef rot
1185 #undef mix
1186 #undef final
1187
1188 #define DEBUG_IMT 0
1189
1190 static void
1191 add_imt_builder_entry (MonoImtBuilderEntry **imt_builder, MonoMethod *method, guint32 *imt_collisions_bitmap, int vtable_slot, int slot_num) {
1192         MONO_REQ_GC_NEUTRAL_MODE;
1193
1194         guint32 imt_slot = mono_method_get_imt_slot (method);
1195         MonoImtBuilderEntry *entry;
1196
1197         if (slot_num >= 0 && imt_slot != slot_num) {
1198                 /* we build just a single imt slot and this is not it */
1199                 return;
1200         }
1201
1202         entry = (MonoImtBuilderEntry *)g_malloc0 (sizeof (MonoImtBuilderEntry));
1203         entry->key = method;
1204         entry->value.vtable_slot = vtable_slot;
1205         entry->next = imt_builder [imt_slot];
1206         if (imt_builder [imt_slot] != NULL) {
1207                 entry->children = imt_builder [imt_slot]->children + 1;
1208                 if (entry->children == 1) {
1209                         mono_stats.imt_slots_with_collisions++;
1210                         *imt_collisions_bitmap |= (1 << imt_slot);
1211                 }
1212         } else {
1213                 entry->children = 0;
1214                 mono_stats.imt_used_slots++;
1215         }
1216         imt_builder [imt_slot] = entry;
1217 #if DEBUG_IMT
1218         {
1219         char *method_name = mono_method_full_name (method, TRUE);
1220         printf ("Added IMT slot for method (%p) %s: imt_slot = %d, vtable_slot = %d, colliding with other %d entries\n",
1221                         method, method_name, imt_slot, vtable_slot, entry->children);
1222         g_free (method_name);
1223         }
1224 #endif
1225 }
1226
1227 #if DEBUG_IMT
1228 static void
1229 print_imt_entry (const char* message, MonoImtBuilderEntry *e, int num) {
1230         if (e != NULL) {
1231                 MonoMethod *method = e->key;
1232                 printf ("  * %s [%d]: (%p) '%s.%s.%s'\n",
1233                                 message,
1234                                 num,
1235                                 method,
1236                                 method->klass->name_space,
1237                                 method->klass->name,
1238                                 method->name);
1239         } else {
1240                 printf ("  * %s: NULL\n", message);
1241         }
1242 }
1243 #endif
1244
1245 static int
1246 compare_imt_builder_entries (const void *p1, const void *p2) {
1247         MonoImtBuilderEntry *e1 = *(MonoImtBuilderEntry**) p1;
1248         MonoImtBuilderEntry *e2 = *(MonoImtBuilderEntry**) p2;
1249
1250         return (e1->key < e2->key) ? -1 : ((e1->key > e2->key) ? 1 : 0);
1251 }
1252
1253 static int
1254 imt_emit_ir (MonoImtBuilderEntry **sorted_array, int start, int end, GPtrArray *out_array)
1255 {
1256         MONO_REQ_GC_NEUTRAL_MODE;
1257
1258         int count = end - start;
1259         int chunk_start = out_array->len;
1260         if (count < 4) {
1261                 int i;
1262                 for (i = start; i < end; ++i) {
1263                         MonoIMTCheckItem *item = g_new0 (MonoIMTCheckItem, 1);
1264                         item->key = sorted_array [i]->key;
1265                         item->value = sorted_array [i]->value;
1266                         item->has_target_code = sorted_array [i]->has_target_code;
1267                         item->is_equals = TRUE;
1268                         if (i < end - 1)
1269                                 item->check_target_idx = out_array->len + 1;
1270                         else
1271                                 item->check_target_idx = 0;
1272                         g_ptr_array_add (out_array, item);
1273                 }
1274         } else {
1275                 int middle = start + count / 2;
1276                 MonoIMTCheckItem *item = g_new0 (MonoIMTCheckItem, 1);
1277
1278                 item->key = sorted_array [middle]->key;
1279                 item->is_equals = FALSE;
1280                 g_ptr_array_add (out_array, item);
1281                 imt_emit_ir (sorted_array, start, middle, out_array);
1282                 item->check_target_idx = imt_emit_ir (sorted_array, middle, end, out_array);
1283         }
1284         return chunk_start;
1285 }
1286
1287 static GPtrArray*
1288 imt_sort_slot_entries (MonoImtBuilderEntry *entries) {
1289         MONO_REQ_GC_NEUTRAL_MODE;
1290
1291         int number_of_entries = entries->children + 1;
1292         MonoImtBuilderEntry **sorted_array = (MonoImtBuilderEntry **)malloc (sizeof (MonoImtBuilderEntry*) * number_of_entries);
1293         GPtrArray *result = g_ptr_array_new ();
1294         MonoImtBuilderEntry *current_entry;
1295         int i;
1296
1297         for (current_entry = entries, i = 0; current_entry != NULL; current_entry = current_entry->next, i++) {
1298                 sorted_array [i] = current_entry;
1299         }
1300         qsort (sorted_array, number_of_entries, sizeof (MonoImtBuilderEntry*), compare_imt_builder_entries);
1301
1302         /*for (i = 0; i < number_of_entries; i++) {
1303                 print_imt_entry (" sorted array:", sorted_array [i], i);
1304         }*/
1305
1306         imt_emit_ir (sorted_array, 0, number_of_entries, result);
1307
1308         free (sorted_array);
1309         return result;
1310 }
1311
1312 static gpointer
1313 initialize_imt_slot (MonoVTable *vtable, MonoDomain *domain, MonoImtBuilderEntry *imt_builder_entry, gpointer fail_tramp)
1314 {
1315         MONO_REQ_GC_NEUTRAL_MODE;
1316
1317         if (imt_builder_entry != NULL) {
1318                 if (imt_builder_entry->children == 0 && !fail_tramp && !always_build_imt_thunks) {
1319                         /* No collision, return the vtable slot contents */
1320                         return vtable->vtable [imt_builder_entry->value.vtable_slot];
1321                 } else {
1322                         /* Collision, build the thunk */
1323                         GPtrArray *imt_ir = imt_sort_slot_entries (imt_builder_entry);
1324                         gpointer result;
1325                         int i;
1326                         result = imt_thunk_builder (vtable, domain,
1327                                 (MonoIMTCheckItem**)imt_ir->pdata, imt_ir->len, fail_tramp);
1328                         for (i = 0; i < imt_ir->len; ++i)
1329                                 g_free (g_ptr_array_index (imt_ir, i));
1330                         g_ptr_array_free (imt_ir, TRUE);
1331                         return result;
1332                 }
1333         } else {
1334                 if (fail_tramp)
1335                         return fail_tramp;
1336                 else
1337                         /* Empty slot */
1338                         return NULL;
1339         }
1340 }
1341
1342 static MonoImtBuilderEntry*
1343 get_generic_virtual_entries (MonoDomain *domain, gpointer *vtable_slot);
1344
1345 /*
1346  * LOCKING: requires the loader and domain locks.
1347  *
1348 */
1349 static void
1350 build_imt_slots (MonoClass *klass, MonoVTable *vt, MonoDomain *domain, gpointer* imt, GSList *extra_interfaces, int slot_num)
1351 {
1352         MONO_REQ_GC_NEUTRAL_MODE;
1353
1354         int i;
1355         GSList *list_item;
1356         guint32 imt_collisions_bitmap = 0;
1357         MonoImtBuilderEntry **imt_builder = (MonoImtBuilderEntry **)calloc (MONO_IMT_SIZE, sizeof (MonoImtBuilderEntry*));
1358         int method_count = 0;
1359         gboolean record_method_count_for_max_collisions = FALSE;
1360         gboolean has_generic_virtual = FALSE, has_variant_iface = FALSE;
1361
1362 #if DEBUG_IMT
1363         printf ("Building IMT for class %s.%s slot %d\n", klass->name_space, klass->name, slot_num);
1364 #endif
1365         for (i = 0; i < klass->interface_offsets_count; ++i) {
1366                 MonoClass *iface = klass->interfaces_packed [i];
1367                 int interface_offset = klass->interface_offsets_packed [i];
1368                 int method_slot_in_interface, vt_slot;
1369
1370                 if (mono_class_has_variant_generic_params (iface))
1371                         has_variant_iface = TRUE;
1372
1373                 mono_class_setup_methods (iface);
1374                 vt_slot = interface_offset;
1375                 for (method_slot_in_interface = 0; method_slot_in_interface < iface->method.count; method_slot_in_interface++) {
1376                         MonoMethod *method;
1377
1378                         if (slot_num >= 0 && iface->is_inflated) {
1379                                 /*
1380                                  * The imt slot of the method is the same as for its declaring method,
1381                                  * see the comment in mono_method_get_imt_slot (), so we can
1382                                  * avoid inflating methods which will be discarded by
1383                                  * add_imt_builder_entry anyway.
1384                                  */
1385                                 method = mono_class_get_method_by_index (iface->generic_class->container_class, method_slot_in_interface);
1386                                 if (mono_method_get_imt_slot (method) != slot_num) {
1387                                         vt_slot ++;
1388                                         continue;
1389                                 }
1390                         }
1391                         method = mono_class_get_method_by_index (iface, method_slot_in_interface);
1392                         if (method->is_generic) {
1393                                 has_generic_virtual = TRUE;
1394                                 vt_slot ++;
1395                                 continue;
1396                         }
1397
1398                         if (!(method->flags & METHOD_ATTRIBUTE_STATIC)) {
1399                                 add_imt_builder_entry (imt_builder, method, &imt_collisions_bitmap, vt_slot, slot_num);
1400                                 vt_slot ++;
1401                         }
1402                 }
1403         }
1404         if (extra_interfaces) {
1405                 int interface_offset = klass->vtable_size;
1406
1407                 for (list_item = extra_interfaces; list_item != NULL; list_item=list_item->next) {
1408                         MonoClass* iface = (MonoClass *)list_item->data;
1409                         int method_slot_in_interface;
1410                         for (method_slot_in_interface = 0; method_slot_in_interface < iface->method.count; method_slot_in_interface++) {
1411                                 MonoMethod *method = mono_class_get_method_by_index (iface, method_slot_in_interface);
1412
1413                                 if (method->is_generic)
1414                                         has_generic_virtual = TRUE;
1415                                 add_imt_builder_entry (imt_builder, method, &imt_collisions_bitmap, interface_offset + method_slot_in_interface, slot_num);
1416                         }
1417                         interface_offset += iface->method.count;
1418                 }
1419         }
1420         for (i = 0; i < MONO_IMT_SIZE; ++i) {
1421                 /* overwrite the imt slot only if we're building all the entries or if
1422                  * we're building this specific one
1423                  */
1424                 if (slot_num < 0 || i == slot_num) {
1425                         MonoImtBuilderEntry *entries = get_generic_virtual_entries (domain, &imt [i]);
1426
1427                         if (entries) {
1428                                 if (imt_builder [i]) {
1429                                         MonoImtBuilderEntry *entry;
1430
1431                                         /* Link entries with imt_builder [i] */
1432                                         for (entry = entries; entry->next; entry = entry->next) {
1433 #if DEBUG_IMT
1434                                                 MonoMethod *method = (MonoMethod*)entry->key;
1435                                                 char *method_name = mono_method_full_name (method, TRUE);
1436                                                 printf ("Added extra entry for method (%p) %s: imt_slot = %d\n", method, method_name, i);
1437                                                 g_free (method_name);
1438 #endif
1439                                         }
1440                                         entry->next = imt_builder [i];
1441                                         entries->children += imt_builder [i]->children + 1;
1442                                 }
1443                                 imt_builder [i] = entries;
1444                         }
1445
1446                         if (has_generic_virtual || has_variant_iface) {
1447                                 /*
1448                                  * There might be collisions later when the the thunk is expanded.
1449                                  */
1450                                 imt_collisions_bitmap |= (1 << i);
1451
1452                                 /*
1453                                  * The IMT thunk might be called with an instance of one of the
1454                                  * generic virtual methods, so has to fallback to the IMT trampoline.
1455                                  */
1456                                 imt [i] = initialize_imt_slot (vt, domain, imt_builder [i], callbacks.get_imt_trampoline (vt, i));
1457                         } else {
1458                                 imt [i] = initialize_imt_slot (vt, domain, imt_builder [i], NULL);
1459                         }
1460 #if DEBUG_IMT
1461                         printf ("initialize_imt_slot[%d]: %p methods %d\n", i, imt [i], imt_builder [i]->children + 1);
1462 #endif
1463                 }
1464
1465                 if (imt_builder [i] != NULL) {
1466                         int methods_in_slot = imt_builder [i]->children + 1;
1467                         if (methods_in_slot > mono_stats.imt_max_collisions_in_slot) {
1468                                 mono_stats.imt_max_collisions_in_slot = methods_in_slot;
1469                                 record_method_count_for_max_collisions = TRUE;
1470                         }
1471                         method_count += methods_in_slot;
1472                 }
1473         }
1474
1475         mono_stats.imt_number_of_methods += method_count;
1476         if (record_method_count_for_max_collisions) {
1477                 mono_stats.imt_method_count_when_max_collisions = method_count;
1478         }
1479
1480         for (i = 0; i < MONO_IMT_SIZE; i++) {
1481                 MonoImtBuilderEntry* entry = imt_builder [i];
1482                 while (entry != NULL) {
1483                         MonoImtBuilderEntry* next = entry->next;
1484                         g_free (entry);
1485                         entry = next;
1486                 }
1487         }
1488         free (imt_builder);
1489         /* we OR the bitmap since we may build just a single imt slot at a time */
1490         vt->imt_collisions_bitmap |= imt_collisions_bitmap;
1491 }
1492
1493 static void
1494 build_imt (MonoClass *klass, MonoVTable *vt, MonoDomain *domain, gpointer* imt, GSList *extra_interfaces) {
1495         MONO_REQ_GC_NEUTRAL_MODE;
1496
1497         build_imt_slots (klass, vt, domain, imt, extra_interfaces, -1);
1498 }
1499
1500 /**
1501  * mono_vtable_build_imt_slot:
1502  * @vtable: virtual object table struct
1503  * @imt_slot: slot in the IMT table
1504  *
1505  * Fill the given @imt_slot in the IMT table of @vtable with
1506  * a trampoline or a thunk for the case of collisions.
1507  * This is part of the internal mono API.
1508  *
1509  * LOCKING: Take the domain lock.
1510  */
1511 void
1512 mono_vtable_build_imt_slot (MonoVTable* vtable, int imt_slot)
1513 {
1514         MONO_REQ_GC_NEUTRAL_MODE;
1515
1516         gpointer *imt = (gpointer*)vtable;
1517         imt -= MONO_IMT_SIZE;
1518         g_assert (imt_slot >= 0 && imt_slot < MONO_IMT_SIZE);
1519
1520         /* no support for extra interfaces: the proxy objects will need
1521          * to build the complete IMT
1522          * Update and heck needs to ahppen inside the proper domain lock, as all
1523          * the changes made to a MonoVTable.
1524          */
1525         mono_loader_lock (); /*FIXME build_imt_slots requires the loader lock.*/
1526         mono_domain_lock (vtable->domain);
1527         /* we change the slot only if it wasn't changed from the generic imt trampoline already */
1528         if (!callbacks.imt_entry_inited (vtable, imt_slot))
1529                 build_imt_slots (vtable->klass, vtable, vtable->domain, imt, NULL, imt_slot);
1530         mono_domain_unlock (vtable->domain);
1531         mono_loader_unlock ();
1532 }
1533
1534
1535 /*
1536  * The first two free list entries both belong to the wait list: The
1537  * first entry is the pointer to the head of the list and the second
1538  * entry points to the last element.  That way appending and removing
1539  * the first element are both O(1) operations.
1540  */
1541 #ifdef MONO_SMALL_CONFIG
1542 #define NUM_FREE_LISTS          6
1543 #else
1544 #define NUM_FREE_LISTS          12
1545 #endif
1546 #define FIRST_FREE_LIST_SIZE    64
1547 #define MAX_WAIT_LENGTH         50
1548 #define THUNK_THRESHOLD         10
1549
1550 /*
1551  * LOCKING: The domain lock must be held.
1552  */
1553 static void
1554 init_thunk_free_lists (MonoDomain *domain)
1555 {
1556         MONO_REQ_GC_NEUTRAL_MODE;
1557
1558         if (domain->thunk_free_lists)
1559                 return;
1560         domain->thunk_free_lists = (MonoThunkFreeList **)mono_domain_alloc0 (domain, sizeof (gpointer) * NUM_FREE_LISTS);
1561 }
1562
1563 static int
1564 list_index_for_size (int item_size)
1565 {
1566         int i = 2;
1567         int size = FIRST_FREE_LIST_SIZE;
1568
1569         while (item_size > size && i < NUM_FREE_LISTS - 1) {
1570                 i++;
1571                 size <<= 1;
1572         }
1573
1574         return i;
1575 }
1576
1577 /**
1578  * mono_method_alloc_generic_virtual_thunk:
1579  * @domain: a domain
1580  * @size: size in bytes
1581  *
1582  * Allocs size bytes to be used for the code of a generic virtual
1583  * thunk.  It's either allocated from the domain's code manager or
1584  * reused from a previously invalidated piece.
1585  *
1586  * LOCKING: The domain lock must be held.
1587  */
1588 gpointer
1589 mono_method_alloc_generic_virtual_thunk (MonoDomain *domain, int size)
1590 {
1591         MONO_REQ_GC_NEUTRAL_MODE;
1592
1593         static gboolean inited = FALSE;
1594         static int generic_virtual_thunks_size = 0;
1595
1596         guint32 *p;
1597         int i;
1598         MonoThunkFreeList **l;
1599
1600         init_thunk_free_lists (domain);
1601
1602         size += sizeof (guint32);
1603         if (size < sizeof (MonoThunkFreeList))
1604                 size = sizeof (MonoThunkFreeList);
1605
1606         i = list_index_for_size (size);
1607         for (l = &domain->thunk_free_lists [i]; *l; l = &(*l)->next) {
1608                 if ((*l)->size >= size) {
1609                         MonoThunkFreeList *item = *l;
1610                         *l = item->next;
1611                         return ((guint32*)item) + 1;
1612                 }
1613         }
1614
1615         /* no suitable item found - search lists of larger sizes */
1616         while (++i < NUM_FREE_LISTS) {
1617                 MonoThunkFreeList *item = domain->thunk_free_lists [i];
1618                 if (!item)
1619                         continue;
1620                 g_assert (item->size > size);
1621                 domain->thunk_free_lists [i] = item->next;
1622                 return ((guint32*)item) + 1;
1623         }
1624
1625         /* still nothing found - allocate it */
1626         if (!inited) {
1627                 mono_counters_register ("Generic virtual thunk bytes",
1628                                 MONO_COUNTER_GENERICS | MONO_COUNTER_INT, &generic_virtual_thunks_size);
1629                 inited = TRUE;
1630         }
1631         generic_virtual_thunks_size += size;
1632
1633         p = (guint32 *)mono_domain_code_reserve (domain, size);
1634         *p = size;
1635
1636         mono_domain_lock (domain);
1637         if (!domain->generic_virtual_thunks)
1638                 domain->generic_virtual_thunks = g_hash_table_new (NULL, NULL);
1639         g_hash_table_insert (domain->generic_virtual_thunks, p, p);
1640         mono_domain_unlock (domain);
1641
1642         return p + 1;
1643 }
1644
1645 /*
1646  * LOCKING: The domain lock must be held.
1647  */
1648 static void
1649 invalidate_generic_virtual_thunk (MonoDomain *domain, gpointer code)
1650 {
1651         MONO_REQ_GC_NEUTRAL_MODE;
1652
1653         guint32 *p = (guint32 *)code;
1654         MonoThunkFreeList *l = (MonoThunkFreeList*)(p - 1);
1655         gboolean found = FALSE;
1656
1657         mono_domain_lock (domain);
1658         if (!domain->generic_virtual_thunks)
1659                 domain->generic_virtual_thunks = g_hash_table_new (NULL, NULL);
1660         if (g_hash_table_lookup (domain->generic_virtual_thunks, l))
1661                 found = TRUE;
1662         mono_domain_unlock (domain);
1663
1664         if (!found)
1665                 /* Not allocated by mono_method_alloc_generic_virtual_thunk (), i.e. AOT */
1666                 return;
1667         init_thunk_free_lists (domain);
1668
1669         while (domain->thunk_free_lists [0] && domain->thunk_free_lists [0]->length >= MAX_WAIT_LENGTH) {
1670                 MonoThunkFreeList *item = domain->thunk_free_lists [0];
1671                 int length = item->length;
1672                 int i;
1673
1674                 /* unlink the first item from the wait list */
1675                 domain->thunk_free_lists [0] = item->next;
1676                 domain->thunk_free_lists [0]->length = length - 1;
1677
1678                 i = list_index_for_size (item->size);
1679
1680                 /* put it in the free list */
1681                 item->next = domain->thunk_free_lists [i];
1682                 domain->thunk_free_lists [i] = item;
1683         }
1684
1685         l->next = NULL;
1686         if (domain->thunk_free_lists [1]) {
1687                 domain->thunk_free_lists [1] = domain->thunk_free_lists [1]->next = l;
1688                 domain->thunk_free_lists [0]->length++;
1689         } else {
1690                 g_assert (!domain->thunk_free_lists [0]);
1691
1692                 domain->thunk_free_lists [0] = domain->thunk_free_lists [1] = l;
1693                 domain->thunk_free_lists [0]->length = 1;
1694         }
1695 }
1696
1697 typedef struct _GenericVirtualCase {
1698         MonoMethod *method;
1699         gpointer code;
1700         int count;
1701         struct _GenericVirtualCase *next;
1702 } GenericVirtualCase;
1703
1704 /*
1705  * get_generic_virtual_entries:
1706  *
1707  *   Return IMT entries for the generic virtual method instances and
1708  *   variant interface methods for vtable slot
1709  * VTABLE_SLOT.
1710  */
1711 static MonoImtBuilderEntry*
1712 get_generic_virtual_entries (MonoDomain *domain, gpointer *vtable_slot)
1713 {
1714         MONO_REQ_GC_NEUTRAL_MODE;
1715
1716         GenericVirtualCase *list;
1717         MonoImtBuilderEntry *entries;
1718
1719         mono_domain_lock (domain);
1720         if (!domain->generic_virtual_cases)
1721                 domain->generic_virtual_cases = g_hash_table_new (mono_aligned_addr_hash, NULL);
1722
1723         list = (GenericVirtualCase *)g_hash_table_lookup (domain->generic_virtual_cases, vtable_slot);
1724
1725         entries = NULL;
1726         for (; list; list = list->next) {
1727                 MonoImtBuilderEntry *entry;
1728
1729                 if (list->count < THUNK_THRESHOLD)
1730                         continue;
1731
1732                 entry = g_new0 (MonoImtBuilderEntry, 1);
1733                 entry->key = list->method;
1734                 entry->value.target_code = mono_get_addr_from_ftnptr (list->code);
1735                 entry->has_target_code = 1;
1736                 if (entries)
1737                         entry->children = entries->children + 1;
1738                 entry->next = entries;
1739                 entries = entry;
1740         }
1741
1742         mono_domain_unlock (domain);
1743
1744         /* FIXME: Leaking memory ? */
1745         return entries;
1746 }
1747
1748 /**
1749  * mono_method_add_generic_virtual_invocation:
1750  * @domain: a domain
1751  * @vtable_slot: pointer to the vtable slot
1752  * @method: the inflated generic virtual method
1753  * @code: the method's code
1754  *
1755  * Registers a call via unmanaged code to a generic virtual method
1756  * instantiation or variant interface method.  If the number of calls reaches a threshold
1757  * (THUNK_THRESHOLD), the method is added to the vtable slot's generic
1758  * virtual method thunk.
1759  */
1760 void
1761 mono_method_add_generic_virtual_invocation (MonoDomain *domain, MonoVTable *vtable,
1762                                                                                         gpointer *vtable_slot,
1763                                                                                         MonoMethod *method, gpointer code)
1764 {
1765         MONO_REQ_GC_NEUTRAL_MODE;
1766
1767         static gboolean inited = FALSE;
1768         static int num_added = 0;
1769
1770         GenericVirtualCase *gvc, *list;
1771         MonoImtBuilderEntry *entries;
1772         int i;
1773         GPtrArray *sorted;
1774
1775         mono_domain_lock (domain);
1776         if (!domain->generic_virtual_cases)
1777                 domain->generic_virtual_cases = g_hash_table_new (mono_aligned_addr_hash, NULL);
1778
1779         /* Check whether the case was already added */
1780         list = (GenericVirtualCase *)g_hash_table_lookup (domain->generic_virtual_cases, vtable_slot);
1781         gvc = list;
1782         while (gvc) {
1783                 if (gvc->method == method)
1784                         break;
1785                 gvc = gvc->next;
1786         }
1787
1788         /* If not found, make a new one */
1789         if (!gvc) {
1790                 gvc = (GenericVirtualCase *)mono_domain_alloc (domain, sizeof (GenericVirtualCase));
1791                 gvc->method = method;
1792                 gvc->code = code;
1793                 gvc->count = 0;
1794                 gvc->next = (GenericVirtualCase *)g_hash_table_lookup (domain->generic_virtual_cases, vtable_slot);
1795
1796                 g_hash_table_insert (domain->generic_virtual_cases, vtable_slot, gvc);
1797
1798                 if (!inited) {
1799                         mono_counters_register ("Generic virtual cases", MONO_COUNTER_GENERICS | MONO_COUNTER_INT, &num_added);
1800                         inited = TRUE;
1801                 }
1802                 num_added++;
1803         }
1804
1805         if (++gvc->count == THUNK_THRESHOLD) {
1806                 gpointer *old_thunk = (void **)*vtable_slot;
1807                 gpointer vtable_trampoline = NULL;
1808                 gpointer imt_trampoline = NULL;
1809
1810                 if ((gpointer)vtable_slot < (gpointer)vtable) {
1811                         int displacement = (gpointer*)vtable_slot - (gpointer*)vtable;
1812                         int imt_slot = MONO_IMT_SIZE + displacement;
1813
1814                         /* Force the rebuild of the thunk at the next call */
1815                         imt_trampoline = callbacks.get_imt_trampoline (vtable, imt_slot);
1816                         *vtable_slot = imt_trampoline;
1817                 } else {
1818                         vtable_trampoline = callbacks.get_vtable_trampoline ? callbacks.get_vtable_trampoline (vtable, (gpointer*)vtable_slot - (gpointer*)vtable->vtable) : NULL;
1819
1820                         entries = get_generic_virtual_entries (domain, vtable_slot);
1821
1822                         sorted = imt_sort_slot_entries (entries);
1823
1824                         *vtable_slot = imt_thunk_builder (NULL, domain, (MonoIMTCheckItem**)sorted->pdata, sorted->len,
1825                                                                                           vtable_trampoline);
1826
1827                         while (entries) {
1828                                 MonoImtBuilderEntry *next = entries->next;
1829                                 g_free (entries);
1830                                 entries = next;
1831                         }
1832
1833                         for (i = 0; i < sorted->len; ++i)
1834                                 g_free (g_ptr_array_index (sorted, i));
1835                         g_ptr_array_free (sorted, TRUE);
1836                 }
1837
1838 #ifndef __native_client__
1839                 /* We don't re-use any thunks as there is a lot of overhead */
1840                 /* to deleting and re-using code in Native Client.          */
1841                 if (old_thunk != vtable_trampoline && old_thunk != imt_trampoline)
1842                         invalidate_generic_virtual_thunk (domain, old_thunk);
1843 #endif
1844         }
1845
1846         mono_domain_unlock (domain);
1847 }
1848
1849 static MonoVTable *mono_class_create_runtime_vtable (MonoDomain *domain, MonoClass *klass, MonoError *error);
1850
1851 /**
1852  * mono_class_vtable:
1853  * @domain: the application domain
1854  * @class: the class to initialize
1855  *
1856  * VTables are domain specific because we create domain specific code, and
1857  * they contain the domain specific static class data.
1858  * On failure, NULL is returned, and class->exception_type is set.
1859  */
1860 MonoVTable *
1861 mono_class_vtable (MonoDomain *domain, MonoClass *klass)
1862 {
1863         MonoError error;
1864         MonoVTable* vtable = mono_class_vtable_full (domain, klass, &error);
1865         mono_error_cleanup (&error);
1866         return vtable;
1867 }
1868
1869 /**
1870  * mono_class_vtable_full:
1871  * @domain: the application domain
1872  * @class: the class to initialize
1873  * @error set on failure.
1874  *
1875  * VTables are domain specific because we create domain specific code, and
1876  * they contain the domain specific static class data.
1877  */
1878 MonoVTable *
1879 mono_class_vtable_full (MonoDomain *domain, MonoClass *klass, MonoError *error)
1880 {
1881         MONO_REQ_GC_UNSAFE_MODE;
1882
1883         MonoClassRuntimeInfo *runtime_info;
1884
1885         mono_error_init (error);
1886
1887         g_assert (klass);
1888
1889         if (mono_class_has_failure (klass)) {
1890                 mono_error_set_exception_instance (error, mono_class_get_exception_for_failure (klass));
1891                 return NULL;
1892         }
1893
1894         /* this check can be inlined in jitted code, too */
1895         runtime_info = klass->runtime_info;
1896         if (runtime_info && runtime_info->max_domain >= domain->domain_id && runtime_info->domain_vtables [domain->domain_id])
1897                 return runtime_info->domain_vtables [domain->domain_id];
1898         return mono_class_create_runtime_vtable (domain, klass, error);
1899 }
1900
1901 /**
1902  * mono_class_try_get_vtable:
1903  * @domain: the application domain
1904  * @class: the class to initialize
1905  *
1906  * This function tries to get the associated vtable from @class if
1907  * it was already created.
1908  */
1909 MonoVTable *
1910 mono_class_try_get_vtable (MonoDomain *domain, MonoClass *klass)
1911 {
1912         MONO_REQ_GC_NEUTRAL_MODE;
1913
1914         MonoClassRuntimeInfo *runtime_info;
1915
1916         g_assert (klass);
1917
1918         runtime_info = klass->runtime_info;
1919         if (runtime_info && runtime_info->max_domain >= domain->domain_id && runtime_info->domain_vtables [domain->domain_id])
1920                 return runtime_info->domain_vtables [domain->domain_id];
1921         return NULL;
1922 }
1923
1924 static gpointer*
1925 alloc_vtable (MonoDomain *domain, size_t vtable_size, size_t imt_table_bytes)
1926 {
1927         MONO_REQ_GC_NEUTRAL_MODE;
1928
1929         size_t alloc_offset;
1930
1931         /*
1932          * We want the pointer to the MonoVTable aligned to 8 bytes because SGen uses three
1933          * address bits.  The IMT has an odd number of entries, however, so on 32 bits the
1934          * alignment will be off.  In that case we allocate 4 more bytes and skip over them.
1935          */
1936         if (sizeof (gpointer) == 4 && (imt_table_bytes & 7)) {
1937                 g_assert ((imt_table_bytes & 7) == 4);
1938                 vtable_size += 4;
1939                 alloc_offset = 4;
1940         } else {
1941                 alloc_offset = 0;
1942         }
1943
1944         return (gpointer*) ((char*)mono_domain_alloc0 (domain, vtable_size) + alloc_offset);
1945 }
1946
1947 static MonoVTable *
1948 mono_class_create_runtime_vtable (MonoDomain *domain, MonoClass *klass, MonoError *error)
1949 {
1950         MONO_REQ_GC_UNSAFE_MODE;
1951
1952         MonoVTable *vt;
1953         MonoClassRuntimeInfo *runtime_info, *old_info;
1954         MonoClassField *field;
1955         char *t;
1956         int i, vtable_slots;
1957         size_t imt_table_bytes;
1958         int gc_bits;
1959         guint32 vtable_size, class_size;
1960         gpointer iter;
1961         gpointer *interface_offsets;
1962
1963         mono_error_init (error);
1964
1965         mono_loader_lock (); /*FIXME mono_class_init acquires it*/
1966         mono_domain_lock (domain);
1967         runtime_info = klass->runtime_info;
1968         if (runtime_info && runtime_info->max_domain >= domain->domain_id && runtime_info->domain_vtables [domain->domain_id]) {
1969                 mono_domain_unlock (domain);
1970                 mono_loader_unlock ();
1971                 return runtime_info->domain_vtables [domain->domain_id];
1972         }
1973         if (!klass->inited || mono_class_has_failure (klass)) {
1974                 if (!mono_class_init (klass) || mono_class_has_failure (klass)) {
1975                         mono_domain_unlock (domain);
1976                         mono_loader_unlock ();
1977                         mono_error_set_exception_instance (error, mono_class_get_exception_for_failure (klass));
1978                         return NULL;
1979                 }
1980         }
1981
1982         /* Array types require that their element type be valid*/
1983         if (klass->byval_arg.type == MONO_TYPE_ARRAY || klass->byval_arg.type == MONO_TYPE_SZARRAY) {
1984                 MonoClass *element_class = klass->element_class;
1985                 if (!element_class->inited)
1986                         mono_class_init (element_class);
1987
1988                 /*mono_class_init can leave the vtable layout to be lazily done and we can't afford this here*/
1989                 if (!mono_class_has_failure (element_class) && !element_class->vtable_size)
1990                         mono_class_setup_vtable (element_class);
1991
1992                 if (mono_class_has_failure (element_class)) {
1993                         /*Can happen if element_class only got bad after mono_class_setup_vtable*/
1994                         if (!mono_class_has_failure (klass))
1995                                 mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, NULL);
1996                         mono_domain_unlock (domain);
1997                         mono_loader_unlock ();
1998                         mono_error_set_exception_instance (error, mono_class_get_exception_for_failure (klass));
1999                         return NULL;
2000                 }
2001         }
2002
2003         /*
2004          * For some classes, mono_class_init () already computed klass->vtable_size, and
2005          * that is all that is needed because of the vtable trampolines.
2006          */
2007         if (!klass->vtable_size)
2008                 mono_class_setup_vtable (klass);
2009
2010         if (klass->generic_class && !klass->vtable)
2011                 mono_class_check_vtable_constraints (klass, NULL);
2012
2013         /* Initialize klass->has_finalize */
2014         mono_class_has_finalizer (klass);
2015
2016         if (mono_class_has_failure (klass)) {
2017                 mono_domain_unlock (domain);
2018                 mono_loader_unlock ();
2019                 mono_error_set_exception_instance (error, mono_class_get_exception_for_failure (klass));
2020                 return NULL;
2021         }
2022
2023         vtable_slots = klass->vtable_size;
2024         /* we add an additional vtable slot to store the pointer to static field data only when needed */
2025         class_size = mono_class_data_size (klass);
2026         if (class_size)
2027                 vtable_slots++;
2028
2029         if (klass->interface_offsets_count) {
2030                 imt_table_bytes = sizeof (gpointer) * (MONO_IMT_SIZE);
2031                 mono_stats.imt_number_of_tables++;
2032                 mono_stats.imt_tables_size += imt_table_bytes;
2033         } else {
2034                 imt_table_bytes = 0;
2035         }
2036
2037         vtable_size = imt_table_bytes + MONO_SIZEOF_VTABLE + vtable_slots * sizeof (gpointer);
2038
2039         mono_stats.used_class_count++;
2040         mono_stats.class_vtable_size += vtable_size;
2041
2042         interface_offsets = alloc_vtable (domain, vtable_size, imt_table_bytes);
2043         vt = (MonoVTable*) ((char*)interface_offsets + imt_table_bytes);
2044         g_assert (!((gsize)vt & 7));
2045
2046         vt->klass = klass;
2047         vt->rank = klass->rank;
2048         vt->domain = domain;
2049
2050         mono_class_compute_gc_descriptor (klass);
2051                 /*
2052                  * We can't use typed allocation in the non-root domains, since the
2053                  * collector needs the GC descriptor stored in the vtable even after
2054                  * the mempool containing the vtable is destroyed when the domain is
2055                  * unloaded. An alternative might be to allocate vtables in the GC
2056                  * heap, but this does not seem to work (it leads to crashes inside
2057                  * libgc). If that approach is tried, two gc descriptors need to be
2058                  * allocated for each class: one for the root domain, and one for all
2059                  * other domains. The second descriptor should contain a bit for the
2060                  * vtable field in MonoObject, since we can no longer assume the
2061                  * vtable is reachable by other roots after the appdomain is unloaded.
2062                  */
2063 #ifdef HAVE_BOEHM_GC
2064         if (domain != mono_get_root_domain () && !mono_dont_free_domains)
2065                 vt->gc_descr = MONO_GC_DESCRIPTOR_NULL;
2066         else
2067 #endif
2068                 vt->gc_descr = klass->gc_descr;
2069
2070         gc_bits = mono_gc_get_vtable_bits (klass);
2071         g_assert (!(gc_bits & ~((1 << MONO_VTABLE_AVAILABLE_GC_BITS) - 1)));
2072
2073         vt->gc_bits = gc_bits;
2074
2075         if (class_size) {
2076                 /* we store the static field pointer at the end of the vtable: vt->vtable [class->vtable_size] */
2077                 if (klass->has_static_refs) {
2078                         MonoGCDescriptor statics_gc_descr;
2079                         int max_set = 0;
2080                         gsize default_bitmap [4] = {0};
2081                         gsize *bitmap;
2082
2083                         bitmap = compute_class_bitmap (klass, default_bitmap, sizeof (default_bitmap) * 8, 0, &max_set, TRUE);
2084                         /*g_print ("bitmap 0x%x for %s.%s (size: %d)\n", bitmap [0], klass->name_space, klass->name, class_size);*/
2085                         statics_gc_descr = mono_gc_make_descr_from_bitmap (bitmap, max_set + 1);
2086                         vt->vtable [klass->vtable_size] = mono_gc_alloc_fixed (class_size, statics_gc_descr, MONO_ROOT_SOURCE_STATIC, "managed static variables");
2087                         mono_domain_add_class_static_data (domain, klass, vt->vtable [klass->vtable_size], NULL);
2088                         if (bitmap != default_bitmap)
2089                                 g_free (bitmap);
2090                 } else {
2091                         vt->vtable [klass->vtable_size] = mono_domain_alloc0 (domain, class_size);
2092                 }
2093                 vt->has_static_fields = TRUE;
2094                 mono_stats.class_static_data_size += class_size;
2095         }
2096
2097         iter = NULL;
2098         while ((field = mono_class_get_fields (klass, &iter))) {
2099                 if (!(field->type->attrs & FIELD_ATTRIBUTE_STATIC))
2100                         continue;
2101                 if (mono_field_is_deleted (field))
2102                         continue;
2103                 if (!(field->type->attrs & FIELD_ATTRIBUTE_LITERAL)) {
2104                         gint32 special_static = klass->no_special_static_fields ? SPECIAL_STATIC_NONE : field_is_special_static (klass, field);
2105                         if (special_static != SPECIAL_STATIC_NONE) {
2106                                 guint32 size, offset;
2107                                 gint32 align;
2108                                 gsize default_bitmap [4] = {0};
2109                                 gsize *bitmap;
2110                                 int max_set = 0;
2111                                 int numbits;
2112                                 MonoClass *fclass;
2113                                 if (mono_type_is_reference (field->type)) {
2114                                         default_bitmap [0] = 1;
2115                                         numbits = 1;
2116                                         bitmap = default_bitmap;
2117                                 } else if (mono_type_is_struct (field->type)) {
2118                                         fclass = mono_class_from_mono_type (field->type);
2119                                         bitmap = compute_class_bitmap (fclass, default_bitmap, sizeof (default_bitmap) * 8, - (int)(sizeof (MonoObject) / sizeof (gpointer)), &max_set, FALSE);
2120                                         numbits = max_set + 1;
2121                                 } else {
2122                                         default_bitmap [0] = 0;
2123                                         numbits = 0;
2124                                         bitmap = default_bitmap;
2125                                 }
2126                                 size = mono_type_size (field->type, &align);
2127                                 offset = mono_alloc_special_static_data (special_static, size, align, (uintptr_t*)bitmap, numbits);
2128                                 if (!domain->special_static_fields)
2129                                         domain->special_static_fields = g_hash_table_new (NULL, NULL);
2130                                 g_hash_table_insert (domain->special_static_fields, field, GUINT_TO_POINTER (offset));
2131                                 if (bitmap != default_bitmap)
2132                                         g_free (bitmap);
2133                                 /*
2134                                  * This marks the field as special static to speed up the
2135                                  * checks in mono_field_static_get/set_value ().
2136                                  */
2137                                 field->offset = -1;
2138                                 continue;
2139                         }
2140                 }
2141                 if ((field->type->attrs & FIELD_ATTRIBUTE_HAS_FIELD_RVA)) {
2142                         MonoClass *fklass = mono_class_from_mono_type (field->type);
2143                         const char *data = mono_field_get_data (field);
2144
2145                         g_assert (!(field->type->attrs & FIELD_ATTRIBUTE_HAS_DEFAULT));
2146                         t = (char*)mono_vtable_get_static_field_data (vt) + field->offset;
2147                         /* some fields don't really have rva, they are just zeroed (bss? bug #343083) */
2148                         if (!data)
2149                                 continue;
2150                         if (fklass->valuetype) {
2151                                 memcpy (t, data, mono_class_value_size (fklass, NULL));
2152                         } else {
2153                                 /* it's a pointer type: add check */
2154                                 g_assert ((fklass->byval_arg.type == MONO_TYPE_PTR) || (fklass->byval_arg.type == MONO_TYPE_FNPTR));
2155                                 *t = *(char *)data;
2156                         }
2157                         continue;
2158                 }
2159         }
2160
2161         vt->max_interface_id = klass->max_interface_id;
2162         vt->interface_bitmap = klass->interface_bitmap;
2163
2164         //printf ("Initializing VT for class %s (interface_offsets_count = %d)\n",
2165         //              class->name, klass->interface_offsets_count);
2166
2167         /* Initialize vtable */
2168         if (callbacks.get_vtable_trampoline) {
2169                 // This also covers the AOT case
2170                 for (i = 0; i < klass->vtable_size; ++i) {
2171                         vt->vtable [i] = callbacks.get_vtable_trampoline (vt, i);
2172                 }
2173         } else {
2174                 mono_class_setup_vtable (klass);
2175
2176                 for (i = 0; i < klass->vtable_size; ++i) {
2177                         MonoMethod *cm;
2178
2179                         cm = klass->vtable [i];
2180                         if (cm) {
2181                                 vt->vtable [i] = callbacks.create_jit_trampoline (domain, cm, error);
2182                                 if (!is_ok (error)) {
2183                                         mono_domain_unlock (domain);
2184                                         mono_loader_unlock ();
2185                                         return NULL;
2186                                 }
2187                         }
2188                 }
2189         }
2190
2191         if (imt_table_bytes) {
2192                 /* Now that the vtable is full, we can actually fill up the IMT */
2193                         for (i = 0; i < MONO_IMT_SIZE; ++i)
2194                                 interface_offsets [i] = callbacks.get_imt_trampoline (vt, i);
2195         }
2196
2197         /*
2198          * FIXME: Is it ok to allocate while holding the domain/loader locks ? If not, we can release them, allocate, then
2199          * re-acquire them and check if another thread has created the vtable in the meantime.
2200          */
2201         /* Special case System.MonoType to avoid infinite recursion */
2202         if (klass != mono_defaults.monotype_class) {
2203                 vt->type = mono_type_get_object_checked (domain, &klass->byval_arg, error);
2204                 if (!is_ok (error)) {
2205                         mono_domain_unlock (domain);
2206                         mono_loader_unlock ();
2207                         return NULL;
2208                 }
2209
2210                 if (mono_object_get_class ((MonoObject *)vt->type) != mono_defaults.monotype_class)
2211                         /* This is unregistered in
2212                            unregister_vtable_reflection_type() in
2213                            domain.c. */
2214                         MONO_GC_REGISTER_ROOT_IF_MOVING(vt->type, MONO_ROOT_SOURCE_REFLECTION, "vtable reflection type");
2215         }
2216
2217         mono_vtable_set_is_remote (vt, mono_class_is_contextbound (klass));
2218
2219         /*  class_vtable_array keeps an array of created vtables
2220          */
2221         g_ptr_array_add (domain->class_vtable_array, vt);
2222         /* klass->runtime_info is protected by the loader lock, both when
2223          * it it enlarged and when it is stored info.
2224          */
2225
2226         /*
2227          * Store the vtable in klass->runtime_info.
2228          * klass->runtime_info is accessed without locking, so this do this last after the vtable has been constructed.
2229          */
2230         mono_memory_barrier ();
2231
2232         old_info = klass->runtime_info;
2233         if (old_info && old_info->max_domain >= domain->domain_id) {
2234                 /* someone already created a large enough runtime info */
2235                 old_info->domain_vtables [domain->domain_id] = vt;
2236         } else {
2237                 int new_size = domain->domain_id;
2238                 if (old_info)
2239                         new_size = MAX (new_size, old_info->max_domain);
2240                 new_size++;
2241                 /* make the new size a power of two */
2242                 i = 2;
2243                 while (new_size > i)
2244                         i <<= 1;
2245                 new_size = i;
2246                 /* this is a bounded memory retention issue: may want to
2247                  * handle it differently when we'll have a rcu-like system.
2248                  */
2249                 runtime_info = (MonoClassRuntimeInfo *)mono_image_alloc0 (klass->image, MONO_SIZEOF_CLASS_RUNTIME_INFO + new_size * sizeof (gpointer));
2250                 runtime_info->max_domain = new_size - 1;
2251                 /* copy the stuff from the older info */
2252                 if (old_info) {
2253                         memcpy (runtime_info->domain_vtables, old_info->domain_vtables, (old_info->max_domain + 1) * sizeof (gpointer));
2254                 }
2255                 runtime_info->domain_vtables [domain->domain_id] = vt;
2256                 /* keep this last*/
2257                 mono_memory_barrier ();
2258                 klass->runtime_info = runtime_info;
2259         }
2260
2261         if (klass == mono_defaults.monotype_class) {
2262                 vt->type = mono_type_get_object_checked (domain, &klass->byval_arg, error);
2263                 if (!is_ok (error)) {
2264                         mono_domain_unlock (domain);
2265                         mono_loader_unlock ();
2266                         return NULL;
2267                 }
2268
2269                 if (mono_object_get_class ((MonoObject *)vt->type) != mono_defaults.monotype_class)
2270                         /* This is unregistered in
2271                            unregister_vtable_reflection_type() in
2272                            domain.c. */
2273                         MONO_GC_REGISTER_ROOT_IF_MOVING(vt->type, MONO_ROOT_SOURCE_REFLECTION, "vtable reflection type");
2274         }
2275
2276         mono_domain_unlock (domain);
2277         mono_loader_unlock ();
2278
2279         /* make sure the parent is initialized */
2280         /*FIXME shouldn't this fail the current type?*/
2281         if (klass->parent)
2282                 mono_class_vtable_full (domain, klass->parent, error);
2283
2284         return vt;
2285 }
2286
2287 #ifndef DISABLE_REMOTING
2288 /**
2289  * mono_class_proxy_vtable:
2290  * @domain: the application domain
2291  * @remove_class: the remote class
2292  *
2293  * Creates a vtable for transparent proxies. It is basically
2294  * a copy of the real vtable of the class wrapped in @remote_class,
2295  * but all function pointers invoke the remoting functions, and
2296  * vtable->klass points to the transparent proxy class, and not to @class.
2297  */
2298 static MonoVTable *
2299 mono_class_proxy_vtable (MonoDomain *domain, MonoRemoteClass *remote_class, MonoRemotingTarget target_type)
2300 {
2301         MONO_REQ_GC_UNSAFE_MODE;
2302
2303         MonoError error;
2304         MonoVTable *vt, *pvt;
2305         int i, j, vtsize, max_interface_id, extra_interface_vtsize = 0;
2306         MonoClass *k;
2307         GSList *extra_interfaces = NULL;
2308         MonoClass *klass = remote_class->proxy_class;
2309         gpointer *interface_offsets;
2310         uint8_t *bitmap;
2311         int bsize;
2312         size_t imt_table_bytes;
2313
2314 #ifdef COMPRESSED_INTERFACE_BITMAP
2315         int bcsize;
2316 #endif
2317
2318         vt = mono_class_vtable (domain, klass);
2319         g_assert (vt); /*FIXME property handle failure*/
2320         max_interface_id = vt->max_interface_id;
2321
2322         /* Calculate vtable space for extra interfaces */
2323         for (j = 0; j < remote_class->interface_count; j++) {
2324                 MonoClass* iclass = remote_class->interfaces[j];
2325                 GPtrArray *ifaces;
2326                 int method_count;
2327
2328                 /*FIXME test for interfaces with variant generic arguments*/
2329                 if (MONO_CLASS_IMPLEMENTS_INTERFACE (klass, iclass->interface_id))
2330                         continue;       /* interface implemented by the class */
2331                 if (g_slist_find (extra_interfaces, iclass))
2332                         continue;
2333
2334                 extra_interfaces = g_slist_prepend (extra_interfaces, iclass);
2335
2336                 method_count = mono_class_num_methods (iclass);
2337
2338                 ifaces = mono_class_get_implemented_interfaces (iclass, &error);
2339                 g_assert (mono_error_ok (&error)); /*FIXME do proper error handling*/
2340                 if (ifaces) {
2341                         for (i = 0; i < ifaces->len; ++i) {
2342                                 MonoClass *ic = (MonoClass *)g_ptr_array_index (ifaces, i);
2343                                 /*FIXME test for interfaces with variant generic arguments*/
2344                                 if (MONO_CLASS_IMPLEMENTS_INTERFACE (klass, ic->interface_id))
2345                                         continue;       /* interface implemented by the class */
2346                                 if (g_slist_find (extra_interfaces, ic))
2347                                         continue;
2348                                 extra_interfaces = g_slist_prepend (extra_interfaces, ic);
2349                                 method_count += mono_class_num_methods (ic);
2350                         }
2351                         g_ptr_array_free (ifaces, TRUE);
2352                 }
2353
2354                 extra_interface_vtsize += method_count * sizeof (gpointer);
2355                 if (iclass->max_interface_id > max_interface_id) max_interface_id = iclass->max_interface_id;
2356         }
2357
2358         imt_table_bytes = sizeof (gpointer) * MONO_IMT_SIZE;
2359         mono_stats.imt_number_of_tables++;
2360         mono_stats.imt_tables_size += imt_table_bytes;
2361
2362         vtsize = imt_table_bytes + MONO_SIZEOF_VTABLE + klass->vtable_size * sizeof (gpointer);
2363
2364         mono_stats.class_vtable_size += vtsize + extra_interface_vtsize;
2365
2366         interface_offsets = alloc_vtable (domain, vtsize + extra_interface_vtsize, imt_table_bytes);
2367         pvt = (MonoVTable*) ((char*)interface_offsets + imt_table_bytes);
2368         g_assert (!((gsize)pvt & 7));
2369
2370         memcpy (pvt, vt, MONO_SIZEOF_VTABLE + klass->vtable_size * sizeof (gpointer));
2371
2372         pvt->klass = mono_defaults.transparent_proxy_class;
2373         /* we need to keep the GC descriptor for a transparent proxy or we confuse the precise GC */
2374         pvt->gc_descr = mono_defaults.transparent_proxy_class->gc_descr;
2375
2376         /* initialize vtable */
2377         mono_class_setup_vtable (klass);
2378         for (i = 0; i < klass->vtable_size; ++i) {
2379                 MonoMethod *cm;
2380
2381                 if ((cm = klass->vtable [i]))
2382                         pvt->vtable [i] = arch_create_remoting_trampoline (domain, cm, target_type);
2383                 else
2384                         pvt->vtable [i] = NULL;
2385         }
2386
2387         if (klass->flags & TYPE_ATTRIBUTE_ABSTRACT) {
2388                 /* create trampolines for abstract methods */
2389                 for (k = klass; k; k = k->parent) {
2390                         MonoMethod* m;
2391                         gpointer iter = NULL;
2392                         while ((m = mono_class_get_methods (k, &iter)))
2393                                 if (!pvt->vtable [m->slot])
2394                                         pvt->vtable [m->slot] = arch_create_remoting_trampoline (domain, m, target_type);
2395                 }
2396         }
2397
2398         pvt->max_interface_id = max_interface_id;
2399         bsize = sizeof (guint8) * (max_interface_id/8 + 1 );
2400 #ifdef COMPRESSED_INTERFACE_BITMAP
2401         bitmap = (uint8_t *)g_malloc0 (bsize);
2402 #else
2403         bitmap = (uint8_t *)mono_domain_alloc0 (domain, bsize);
2404 #endif
2405
2406         for (i = 0; i < klass->interface_offsets_count; ++i) {
2407                 int interface_id = klass->interfaces_packed [i]->interface_id;
2408                 bitmap [interface_id >> 3] |= (1 << (interface_id & 7));
2409         }
2410
2411         if (extra_interfaces) {
2412                 int slot = klass->vtable_size;
2413                 MonoClass* interf;
2414                 gpointer iter;
2415                 MonoMethod* cm;
2416                 GSList *list_item;
2417
2418                 /* Create trampolines for the methods of the interfaces */
2419                 for (list_item = extra_interfaces; list_item != NULL; list_item=list_item->next) {
2420                         interf = (MonoClass *)list_item->data;
2421
2422                         bitmap [interf->interface_id >> 3] |= (1 << (interf->interface_id & 7));
2423
2424                         iter = NULL;
2425                         j = 0;
2426                         while ((cm = mono_class_get_methods (interf, &iter)))
2427                                 pvt->vtable [slot + j++] = arch_create_remoting_trampoline (domain, cm, target_type);
2428
2429                         slot += mono_class_num_methods (interf);
2430                 }
2431         }
2432
2433         /* Now that the vtable is full, we can actually fill up the IMT */
2434         build_imt (klass, pvt, domain, interface_offsets, extra_interfaces);
2435         if (extra_interfaces) {
2436                 g_slist_free (extra_interfaces);
2437         }
2438
2439 #ifdef COMPRESSED_INTERFACE_BITMAP
2440         bcsize = mono_compress_bitmap (NULL, bitmap, bsize);
2441         pvt->interface_bitmap = mono_domain_alloc0 (domain, bcsize);
2442         mono_compress_bitmap (pvt->interface_bitmap, bitmap, bsize);
2443         g_free (bitmap);
2444 #else
2445         pvt->interface_bitmap = bitmap;
2446 #endif
2447         return pvt;
2448 }
2449
2450 #endif /* DISABLE_REMOTING */
2451
2452 /**
2453  * mono_class_field_is_special_static:
2454  *
2455  *   Returns whether @field is a thread/context static field.
2456  */
2457 gboolean
2458 mono_class_field_is_special_static (MonoClassField *field)
2459 {
2460         MONO_REQ_GC_NEUTRAL_MODE
2461
2462         if (!(field->type->attrs & FIELD_ATTRIBUTE_STATIC))
2463                 return FALSE;
2464         if (mono_field_is_deleted (field))
2465                 return FALSE;
2466         if (!(field->type->attrs & FIELD_ATTRIBUTE_LITERAL)) {
2467                 if (field_is_special_static (field->parent, field) != SPECIAL_STATIC_NONE)
2468                         return TRUE;
2469         }
2470         return FALSE;
2471 }
2472
2473 /**
2474  * mono_class_field_get_special_static_type:
2475  * @field: The MonoClassField describing the field.
2476  *
2477  * Returns: SPECIAL_STATIC_THREAD if the field is thread static, SPECIAL_STATIC_CONTEXT if it is context static,
2478  * SPECIAL_STATIC_NONE otherwise.
2479  */
2480 guint32
2481 mono_class_field_get_special_static_type (MonoClassField *field)
2482 {
2483         MONO_REQ_GC_NEUTRAL_MODE
2484
2485         if (!(field->type->attrs & FIELD_ATTRIBUTE_STATIC))
2486                 return SPECIAL_STATIC_NONE;
2487         if (mono_field_is_deleted (field))
2488                 return SPECIAL_STATIC_NONE;
2489         if (!(field->type->attrs & FIELD_ATTRIBUTE_LITERAL))
2490                 return field_is_special_static (field->parent, field);
2491         return SPECIAL_STATIC_NONE;
2492 }
2493
2494 /**
2495  * mono_class_has_special_static_fields:
2496  *
2497  *   Returns whenever @klass has any thread/context static fields.
2498  */
2499 gboolean
2500 mono_class_has_special_static_fields (MonoClass *klass)
2501 {
2502         MONO_REQ_GC_NEUTRAL_MODE
2503
2504         MonoClassField *field;
2505         gpointer iter;
2506
2507         iter = NULL;
2508         while ((field = mono_class_get_fields (klass, &iter))) {
2509                 g_assert (field->parent == klass);
2510                 if (mono_class_field_is_special_static (field))
2511                         return TRUE;
2512         }
2513
2514         return FALSE;
2515 }
2516
2517 #ifndef DISABLE_REMOTING
2518 /**
2519  * create_remote_class_key:
2520  * Creates an array of pointers that can be used as a hash key for a remote class.
2521  * The first element of the array is the number of pointers.
2522  */
2523 static gpointer*
2524 create_remote_class_key (MonoRemoteClass *remote_class, MonoClass *extra_class)
2525 {
2526         MONO_REQ_GC_NEUTRAL_MODE;
2527
2528         gpointer *key;
2529         int i, j;
2530
2531         if (remote_class == NULL) {
2532                 if (extra_class->flags & TYPE_ATTRIBUTE_INTERFACE) {
2533                         key = (void **)g_malloc (sizeof(gpointer) * 3);
2534                         key [0] = GINT_TO_POINTER (2);
2535                         key [1] = mono_defaults.marshalbyrefobject_class;
2536                         key [2] = extra_class;
2537                 } else {
2538                         key = (void **)g_malloc (sizeof(gpointer) * 2);
2539                         key [0] = GINT_TO_POINTER (1);
2540                         key [1] = extra_class;
2541                 }
2542         } else {
2543                 if (extra_class != NULL && (extra_class->flags & TYPE_ATTRIBUTE_INTERFACE)) {
2544                         key = (void **)g_malloc (sizeof(gpointer) * (remote_class->interface_count + 3));
2545                         key [0] = GINT_TO_POINTER (remote_class->interface_count + 2);
2546                         key [1] = remote_class->proxy_class;
2547
2548                         // Keep the list of interfaces sorted
2549                         for (i = 0, j = 2; i < remote_class->interface_count; i++, j++) {
2550                                 if (extra_class && remote_class->interfaces [i] > extra_class) {
2551                                         key [j++] = extra_class;
2552                                         extra_class = NULL;
2553                                 }
2554                                 key [j] = remote_class->interfaces [i];
2555                         }
2556                         if (extra_class)
2557                                 key [j] = extra_class;
2558                 } else {
2559                         // Replace the old class. The interface list is the same
2560                         key = (void **)g_malloc (sizeof(gpointer) * (remote_class->interface_count + 2));
2561                         key [0] = GINT_TO_POINTER (remote_class->interface_count + 1);
2562                         key [1] = extra_class != NULL ? extra_class : remote_class->proxy_class;
2563                         for (i = 0; i < remote_class->interface_count; i++)
2564                                 key [2 + i] = remote_class->interfaces [i];
2565                 }
2566         }
2567
2568         return key;
2569 }
2570
2571 /**
2572  * copy_remote_class_key:
2573  *
2574  *   Make a copy of KEY in the domain and return the copy.
2575  */
2576 static gpointer*
2577 copy_remote_class_key (MonoDomain *domain, gpointer *key)
2578 {
2579         MONO_REQ_GC_NEUTRAL_MODE
2580
2581         int key_size = (GPOINTER_TO_UINT (key [0]) + 1) * sizeof (gpointer);
2582         gpointer *mp_key = (gpointer *)mono_domain_alloc (domain, key_size);
2583
2584         memcpy (mp_key, key, key_size);
2585
2586         return mp_key;
2587 }
2588
2589 /**
2590  * mono_remote_class:
2591  * @domain: the application domain
2592  * @class_name: name of the remote class
2593  * @error: set on error
2594  *
2595  * Creates and initializes a MonoRemoteClass object for a remote type.
2596  *
2597  * On failure returns NULL and sets @error
2598  */
2599 MonoRemoteClass*
2600 mono_remote_class (MonoDomain *domain, MonoString *class_name, MonoClass *proxy_class, MonoError *error)
2601 {
2602         MONO_REQ_GC_UNSAFE_MODE;
2603
2604         MonoRemoteClass *rc;
2605         gpointer* key, *mp_key;
2606         char *name;
2607
2608         mono_error_init (error);
2609
2610         key = create_remote_class_key (NULL, proxy_class);
2611
2612         mono_domain_lock (domain);
2613         rc = (MonoRemoteClass *)g_hash_table_lookup (domain->proxy_vtable_hash, key);
2614
2615         if (rc) {
2616                 g_free (key);
2617                 mono_domain_unlock (domain);
2618                 return rc;
2619         }
2620
2621         name = mono_string_to_utf8_mp (domain->mp, class_name, error);
2622         if (!is_ok (error)) {
2623                 g_free (key);
2624                 mono_domain_unlock (domain);
2625                 return NULL;
2626         }
2627
2628         mp_key = copy_remote_class_key (domain, key);
2629         g_free (key);
2630         key = mp_key;
2631
2632         if (proxy_class->flags & TYPE_ATTRIBUTE_INTERFACE) {
2633                 rc = (MonoRemoteClass *)mono_domain_alloc (domain, MONO_SIZEOF_REMOTE_CLASS + sizeof(MonoClass*));
2634                 rc->interface_count = 1;
2635                 rc->interfaces [0] = proxy_class;
2636                 rc->proxy_class = mono_defaults.marshalbyrefobject_class;
2637         } else {
2638                 rc = (MonoRemoteClass *)mono_domain_alloc (domain, MONO_SIZEOF_REMOTE_CLASS);
2639                 rc->interface_count = 0;
2640                 rc->proxy_class = proxy_class;
2641         }
2642
2643         rc->default_vtable = NULL;
2644         rc->xdomain_vtable = NULL;
2645         rc->proxy_class_name = name;
2646 #ifndef DISABLE_PERFCOUNTERS
2647         mono_perfcounters->loader_bytes += mono_string_length (class_name) + 1;
2648 #endif
2649
2650         g_hash_table_insert (domain->proxy_vtable_hash, key, rc);
2651
2652         mono_domain_unlock (domain);
2653         return rc;
2654 }
2655
2656 /**
2657  * clone_remote_class:
2658  * Creates a copy of the remote_class, adding the provided class or interface
2659  */
2660 static MonoRemoteClass*
2661 clone_remote_class (MonoDomain *domain, MonoRemoteClass* remote_class, MonoClass *extra_class)
2662 {
2663         MONO_REQ_GC_NEUTRAL_MODE;
2664
2665         MonoRemoteClass *rc;
2666         gpointer* key, *mp_key;
2667
2668         key = create_remote_class_key (remote_class, extra_class);
2669         rc = (MonoRemoteClass *)g_hash_table_lookup (domain->proxy_vtable_hash, key);
2670         if (rc != NULL) {
2671                 g_free (key);
2672                 return rc;
2673         }
2674
2675         mp_key = copy_remote_class_key (domain, key);
2676         g_free (key);
2677         key = mp_key;
2678
2679         if (extra_class->flags & TYPE_ATTRIBUTE_INTERFACE) {
2680                 int i,j;
2681                 rc = (MonoRemoteClass *)mono_domain_alloc (domain, MONO_SIZEOF_REMOTE_CLASS + sizeof(MonoClass*) * (remote_class->interface_count + 1));
2682                 rc->proxy_class = remote_class->proxy_class;
2683                 rc->interface_count = remote_class->interface_count + 1;
2684
2685                 // Keep the list of interfaces sorted, since the hash key of
2686                 // the remote class depends on this
2687                 for (i = 0, j = 0; i < remote_class->interface_count; i++, j++) {
2688                         if (remote_class->interfaces [i] > extra_class && i == j)
2689                                 rc->interfaces [j++] = extra_class;
2690                         rc->interfaces [j] = remote_class->interfaces [i];
2691                 }
2692                 if (i == j)
2693                         rc->interfaces [j] = extra_class;
2694         } else {
2695                 // Replace the old class. The interface array is the same
2696                 rc = (MonoRemoteClass *)mono_domain_alloc (domain, MONO_SIZEOF_REMOTE_CLASS + sizeof(MonoClass*) * remote_class->interface_count);
2697                 rc->proxy_class = extra_class;
2698                 rc->interface_count = remote_class->interface_count;
2699                 if (rc->interface_count > 0)
2700                         memcpy (rc->interfaces, remote_class->interfaces, rc->interface_count * sizeof (MonoClass*));
2701         }
2702
2703         rc->default_vtable = NULL;
2704         rc->xdomain_vtable = NULL;
2705         rc->proxy_class_name = remote_class->proxy_class_name;
2706
2707         g_hash_table_insert (domain->proxy_vtable_hash, key, rc);
2708
2709         return rc;
2710 }
2711
2712 gpointer
2713 mono_remote_class_vtable (MonoDomain *domain, MonoRemoteClass *remote_class, MonoRealProxy *rp)
2714 {
2715         MONO_REQ_GC_UNSAFE_MODE;
2716
2717         mono_loader_lock (); /*FIXME mono_class_from_mono_type and mono_class_proxy_vtable take it*/
2718         mono_domain_lock (domain);
2719         if (rp->target_domain_id != -1) {
2720                 if (remote_class->xdomain_vtable == NULL)
2721                         remote_class->xdomain_vtable = mono_class_proxy_vtable (domain, remote_class, MONO_REMOTING_TARGET_APPDOMAIN);
2722                 mono_domain_unlock (domain);
2723                 mono_loader_unlock ();
2724                 return remote_class->xdomain_vtable;
2725         }
2726         if (remote_class->default_vtable == NULL) {
2727                 MonoType *type;
2728                 MonoClass *klass;
2729                 type = ((MonoReflectionType *)rp->class_to_proxy)->type;
2730                 klass = mono_class_from_mono_type (type);
2731 #ifndef DISABLE_COM
2732                 if ((mono_class_is_com_object (klass) || (mono_class_get_com_object_class () && klass == mono_class_get_com_object_class ())) && !mono_vtable_is_remote (mono_class_vtable (mono_domain_get (), klass)))
2733                         remote_class->default_vtable = mono_class_proxy_vtable (domain, remote_class, MONO_REMOTING_TARGET_COMINTEROP);
2734                 else
2735 #endif
2736                         remote_class->default_vtable = mono_class_proxy_vtable (domain, remote_class, MONO_REMOTING_TARGET_UNKNOWN);
2737         }
2738
2739         mono_domain_unlock (domain);
2740         mono_loader_unlock ();
2741         return remote_class->default_vtable;
2742 }
2743
2744 /**
2745  * mono_upgrade_remote_class:
2746  * @domain: the application domain
2747  * @tproxy: the proxy whose remote class has to be upgraded.
2748  * @klass: class to which the remote class can be casted.
2749  *
2750  * Updates the vtable of the remote class by adding the necessary method slots
2751  * and interface offsets so it can be safely casted to klass. klass can be a
2752  * class or an interface.
2753  */
2754 void
2755 mono_upgrade_remote_class (MonoDomain *domain, MonoObject *proxy_object, MonoClass *klass)
2756 {
2757         MONO_REQ_GC_UNSAFE_MODE;
2758
2759         MonoTransparentProxy *tproxy;
2760         MonoRemoteClass *remote_class;
2761         gboolean redo_vtable;
2762
2763         mono_loader_lock (); /*FIXME mono_remote_class_vtable requires it.*/
2764         mono_domain_lock (domain);
2765
2766         tproxy = (MonoTransparentProxy*) proxy_object;
2767         remote_class = tproxy->remote_class;
2768
2769         if (klass->flags & TYPE_ATTRIBUTE_INTERFACE) {
2770                 int i;
2771                 redo_vtable = TRUE;
2772                 for (i = 0; i < remote_class->interface_count && redo_vtable; i++)
2773                         if (remote_class->interfaces [i] == klass)
2774                                 redo_vtable = FALSE;
2775         }
2776         else {
2777                 redo_vtable = (remote_class->proxy_class != klass);
2778         }
2779
2780         if (redo_vtable) {
2781                 tproxy->remote_class = clone_remote_class (domain, remote_class, klass);
2782                 proxy_object->vtable = (MonoVTable *)mono_remote_class_vtable (domain, tproxy->remote_class, tproxy->rp);
2783         }
2784
2785         mono_domain_unlock (domain);
2786         mono_loader_unlock ();
2787 }
2788 #endif /* DISABLE_REMOTING */
2789
2790
2791 /**
2792  * mono_object_get_virtual_method:
2793  * @obj: object to operate on.
2794  * @method: method
2795  *
2796  * Retrieves the MonoMethod that would be called on obj if obj is passed as
2797  * the instance of a callvirt of method.
2798  */
2799 MonoMethod*
2800 mono_object_get_virtual_method (MonoObject *obj, MonoMethod *method)
2801 {
2802         MONO_REQ_GC_UNSAFE_MODE;
2803
2804         MonoClass *klass;
2805         MonoMethod **vtable;
2806         gboolean is_proxy = FALSE;
2807         MonoMethod *res = NULL;
2808
2809         klass = mono_object_class (obj);
2810 #ifndef DISABLE_REMOTING
2811         if (klass == mono_defaults.transparent_proxy_class) {
2812                 klass = ((MonoTransparentProxy *)obj)->remote_class->proxy_class;
2813                 is_proxy = TRUE;
2814         }
2815 #endif
2816
2817         if (!is_proxy && ((method->flags & METHOD_ATTRIBUTE_FINAL) || !(method->flags & METHOD_ATTRIBUTE_VIRTUAL)))
2818                         return method;
2819
2820         mono_class_setup_vtable (klass);
2821         vtable = klass->vtable;
2822
2823         if (method->slot == -1) {
2824                 /* method->slot might not be set for instances of generic methods */
2825                 if (method->is_inflated) {
2826                         g_assert (((MonoMethodInflated*)method)->declaring->slot != -1);
2827                         method->slot = ((MonoMethodInflated*)method)->declaring->slot;
2828                 } else {
2829                         if (!is_proxy)
2830                                 g_assert_not_reached ();
2831                 }
2832         }
2833
2834         /* check method->slot is a valid index: perform isinstance? */
2835         if (method->slot != -1) {
2836                 if (method->klass->flags & TYPE_ATTRIBUTE_INTERFACE) {
2837                         if (!is_proxy) {
2838                                 gboolean variance_used = FALSE;
2839                                 int iface_offset = mono_class_interface_offset_with_variance (klass, method->klass, &variance_used);
2840                                 g_assert (iface_offset > 0);
2841                                 res = vtable [iface_offset + method->slot];
2842                         }
2843                 } else {
2844                         res = vtable [method->slot];
2845                 }
2846     }
2847
2848 #ifndef DISABLE_REMOTING
2849         if (is_proxy) {
2850                 /* It may be an interface, abstract class method or generic method */
2851                 if (!res || mono_method_signature (res)->generic_param_count)
2852                         res = method;
2853
2854                 /* generic methods demand invoke_with_check */
2855                 if (mono_method_signature (res)->generic_param_count)
2856                         res = mono_marshal_get_remoting_invoke_with_check (res);
2857                 else {
2858 #ifndef DISABLE_COM
2859                         if (klass == mono_class_get_com_object_class () || mono_class_is_com_object (klass))
2860                                 res = mono_cominterop_get_invoke (res);
2861                         else
2862 #endif
2863                                 res = mono_marshal_get_remoting_invoke (res);
2864                 }
2865         } else
2866 #endif
2867         {
2868                 if (method->is_inflated) {
2869                         MonoError error;
2870                         /* Have to inflate the result */
2871                         res = mono_class_inflate_generic_method_checked (res, &((MonoMethodInflated*)method)->context, &error);
2872                         g_assert (mono_error_ok (&error)); /* FIXME don't swallow the error */
2873                 }
2874         }
2875
2876         g_assert (res);
2877
2878         return res;
2879 }
2880
2881 static MonoObject*
2882 do_runtime_invoke (MonoMethod *method, void *obj, void **params, MonoObject **exc, MonoError *error)
2883 {
2884         MONO_REQ_GC_UNSAFE_MODE;
2885
2886         MonoObject *result = NULL;
2887
2888         g_assert (callbacks.runtime_invoke);
2889
2890         mono_error_init (error);
2891
2892         if (mono_profiler_get_events () & MONO_PROFILE_METHOD_EVENTS)
2893                 mono_profiler_method_start_invoke (method);
2894
2895         MONO_PREPARE_RESET_BLOCKING;
2896
2897         result = callbacks.runtime_invoke (method, obj, params, exc, error);
2898
2899         MONO_FINISH_RESET_BLOCKING;
2900
2901         if (mono_profiler_get_events () & MONO_PROFILE_METHOD_EVENTS)
2902                 mono_profiler_method_end_invoke (method);
2903
2904         if (!mono_error_ok (error))
2905                 return NULL;
2906
2907         return result;
2908 }
2909
2910 /**
2911  * mono_runtime_invoke:
2912  * @method: method to invoke
2913  * @obJ: object instance
2914  * @params: arguments to the method
2915  * @exc: exception information.
2916  *
2917  * Invokes the method represented by @method on the object @obj.
2918  *
2919  * obj is the 'this' pointer, it should be NULL for static
2920  * methods, a MonoObject* for object instances and a pointer to
2921  * the value type for value types.
2922  *
2923  * The params array contains the arguments to the method with the
2924  * same convention: MonoObject* pointers for object instances and
2925  * pointers to the value type otherwise.
2926  *
2927  * From unmanaged code you'll usually use the
2928  * mono_runtime_invoke() variant.
2929  *
2930  * Note that this function doesn't handle virtual methods for
2931  * you, it will exec the exact method you pass: we still need to
2932  * expose a function to lookup the derived class implementation
2933  * of a virtual method (there are examples of this in the code,
2934  * though).
2935  *
2936  * You can pass NULL as the exc argument if you don't want to
2937  * catch exceptions, otherwise, *exc will be set to the exception
2938  * thrown, if any.  if an exception is thrown, you can't use the
2939  * MonoObject* result from the function.
2940  *
2941  * If the method returns a value type, it is boxed in an object
2942  * reference.
2943  */
2944 MonoObject*
2945 mono_runtime_invoke (MonoMethod *method, void *obj, void **params, MonoObject **exc)
2946 {
2947         MonoError error;
2948         MonoObject *res;
2949         if (exc) {
2950                 res = mono_runtime_try_invoke (method, obj, params, exc, &error);
2951                 if (*exc == NULL && !mono_error_ok(&error)) {
2952                         *exc = (MonoObject*) mono_error_convert_to_exception (&error);
2953                 } else
2954                         mono_error_cleanup (&error);
2955         } else {
2956                 res = mono_runtime_invoke_checked (method, obj, params, &error);
2957                 mono_error_raise_exception (&error);
2958         }
2959         return res;
2960 }
2961
2962 /**
2963  * mono_runtime_try_invoke:
2964  * @method: method to invoke
2965  * @obJ: object instance
2966  * @params: arguments to the method
2967  * @exc: exception information.
2968  * @error: set on error
2969  *
2970  * Invokes the method represented by @method on the object @obj.
2971  *
2972  * obj is the 'this' pointer, it should be NULL for static
2973  * methods, a MonoObject* for object instances and a pointer to
2974  * the value type for value types.
2975  *
2976  * The params array contains the arguments to the method with the
2977  * same convention: MonoObject* pointers for object instances and
2978  * pointers to the value type otherwise.
2979  *
2980  * From unmanaged code you'll usually use the
2981  * mono_runtime_invoke() variant.
2982  *
2983  * Note that this function doesn't handle virtual methods for
2984  * you, it will exec the exact method you pass: we still need to
2985  * expose a function to lookup the derived class implementation
2986  * of a virtual method (there are examples of this in the code,
2987  * though).
2988  *
2989  * For this function, you must not pass NULL as the exc argument if
2990  * you don't want to catch exceptions, use
2991  * mono_runtime_invoke_checked().  If an exception is thrown, you
2992  * can't use the MonoObject* result from the function.
2993  *
2994  * If this method cannot be invoked, @error will be set and @exc and
2995  * the return value must not be used.
2996  *
2997  * If the method returns a value type, it is boxed in an object
2998  * reference.
2999  */
3000 MonoObject*
3001 mono_runtime_try_invoke (MonoMethod *method, void *obj, void **params, MonoObject **exc, MonoError* error)
3002 {
3003         MONO_REQ_GC_UNSAFE_MODE;
3004
3005         g_assert (exc != NULL);
3006
3007         if (mono_runtime_get_no_exec ())
3008                 g_warning ("Invoking method '%s' when running in no-exec mode.\n", mono_method_full_name (method, TRUE));
3009
3010         return do_runtime_invoke (method, obj, params, exc, error);
3011 }
3012
3013 /**
3014  * mono_runtime_invoke_checked:
3015  * @method: method to invoke
3016  * @obJ: object instance
3017  * @params: arguments to the method
3018  * @error: set on error
3019  *
3020  * Invokes the method represented by @method on the object @obj.
3021  *
3022  * obj is the 'this' pointer, it should be NULL for static
3023  * methods, a MonoObject* for object instances and a pointer to
3024  * the value type for value types.
3025  *
3026  * The params array contains the arguments to the method with the
3027  * same convention: MonoObject* pointers for object instances and
3028  * pointers to the value type otherwise.
3029  *
3030  * From unmanaged code you'll usually use the
3031  * mono_runtime_invoke() variant.
3032  *
3033  * Note that this function doesn't handle virtual methods for
3034  * you, it will exec the exact method you pass: we still need to
3035  * expose a function to lookup the derived class implementation
3036  * of a virtual method (there are examples of this in the code,
3037  * though).
3038  *
3039  * If an exception is thrown, you can't use the MonoObject* result
3040  * from the function.
3041  *
3042  * If this method cannot be invoked, @error will be set.  If the
3043  * method throws an exception (and we're in coop mode) the exception
3044  * will be set in @error.
3045  *
3046  * If the method returns a value type, it is boxed in an object
3047  * reference.
3048  */
3049 MonoObject*
3050 mono_runtime_invoke_checked (MonoMethod *method, void *obj, void **params, MonoError* error)
3051 {
3052         MONO_REQ_GC_UNSAFE_MODE;
3053
3054         if (mono_runtime_get_no_exec ())
3055                 g_warning ("Invoking method '%s' when running in no-exec mode.\n", mono_method_full_name (method, TRUE));
3056
3057         return do_runtime_invoke (method, obj, params, NULL, error);
3058 }
3059
3060 /**
3061  * mono_method_get_unmanaged_thunk:
3062  * @method: method to generate a thunk for.
3063  *
3064  * Returns an unmanaged->managed thunk that can be used to call
3065  * a managed method directly from C.
3066  *
3067  * The thunk's C signature closely matches the managed signature:
3068  *
3069  * C#: public bool Equals (object obj);
3070  * C:  typedef MonoBoolean (*Equals)(MonoObject*,
3071  *             MonoObject*, MonoException**);
3072  *
3073  * The 1st ("this") parameter must not be used with static methods:
3074  *
3075  * C#: public static bool ReferenceEquals (object a, object b);
3076  * C:  typedef MonoBoolean (*ReferenceEquals)(MonoObject*, MonoObject*,
3077  *             MonoException**);
3078  *
3079  * The last argument must be a non-null pointer of a MonoException* pointer.
3080  * It has "out" semantics. After invoking the thunk, *ex will be NULL if no
3081  * exception has been thrown in managed code. Otherwise it will point
3082  * to the MonoException* caught by the thunk. In this case, the result of
3083  * the thunk is undefined:
3084  *
3085  * MonoMethod *method = ... // MonoMethod* of System.Object.Equals
3086  * MonoException *ex = NULL;
3087  * Equals func = mono_method_get_unmanaged_thunk (method);
3088  * MonoBoolean res = func (thisObj, objToCompare, &ex);
3089  * if (ex) {
3090  *    // handle exception
3091  * }
3092  *
3093  * The calling convention of the thunk matches the platform's default
3094  * convention. This means that under Windows, C declarations must
3095  * contain the __stdcall attribute:
3096  *
3097  * C:  typedef MonoBoolean (__stdcall *Equals)(MonoObject*,
3098  *             MonoObject*, MonoException**);
3099  *
3100  * LIMITATIONS
3101  *
3102  * Value type arguments and return values are treated as they were objects:
3103  *
3104  * C#: public static Rectangle Intersect (Rectangle a, Rectangle b);
3105  * C:  typedef MonoObject* (*Intersect)(MonoObject*, MonoObject*, MonoException**);
3106  *
3107  * Arguments must be properly boxed upon trunk's invocation, while return
3108  * values must be unboxed.
3109  */
3110 gpointer
3111 mono_method_get_unmanaged_thunk (MonoMethod *method)
3112 {
3113         MONO_REQ_GC_NEUTRAL_MODE;
3114         MONO_REQ_API_ENTRYPOINT;
3115
3116         gpointer res;
3117
3118         g_assert (!mono_threads_is_coop_enabled ());
3119
3120         MONO_PREPARE_RESET_BLOCKING;
3121         method = mono_marshal_get_thunk_invoke_wrapper (method);
3122         res = mono_compile_method (method);
3123         MONO_FINISH_RESET_BLOCKING;
3124
3125         return res;
3126 }
3127
3128 void
3129 mono_copy_value (MonoType *type, void *dest, void *value, int deref_pointer)
3130 {
3131         MONO_REQ_GC_UNSAFE_MODE;
3132
3133         int t;
3134         if (type->byref) {
3135                 /* object fields cannot be byref, so we don't need a
3136                    wbarrier here */
3137                 gpointer *p = (gpointer*)dest;
3138                 *p = value;
3139                 return;
3140         }
3141         t = type->type;
3142 handle_enum:
3143         switch (t) {
3144         case MONO_TYPE_BOOLEAN:
3145         case MONO_TYPE_I1:
3146         case MONO_TYPE_U1: {
3147                 guint8 *p = (guint8*)dest;
3148                 *p = value ? *(guint8*)value : 0;
3149                 return;
3150         }
3151         case MONO_TYPE_I2:
3152         case MONO_TYPE_U2:
3153         case MONO_TYPE_CHAR: {
3154                 guint16 *p = (guint16*)dest;
3155                 *p = value ? *(guint16*)value : 0;
3156                 return;
3157         }
3158 #if SIZEOF_VOID_P == 4
3159         case MONO_TYPE_I:
3160         case MONO_TYPE_U:
3161 #endif
3162         case MONO_TYPE_I4:
3163         case MONO_TYPE_U4: {
3164                 gint32 *p = (gint32*)dest;
3165                 *p = value ? *(gint32*)value : 0;
3166                 return;
3167         }
3168 #if SIZEOF_VOID_P == 8
3169         case MONO_TYPE_I:
3170         case MONO_TYPE_U:
3171 #endif
3172         case MONO_TYPE_I8:
3173         case MONO_TYPE_U8: {
3174                 gint64 *p = (gint64*)dest;
3175                 *p = value ? *(gint64*)value : 0;
3176                 return;
3177         }
3178         case MONO_TYPE_R4: {
3179                 float *p = (float*)dest;
3180                 *p = value ? *(float*)value : 0;
3181                 return;
3182         }
3183         case MONO_TYPE_R8: {
3184                 double *p = (double*)dest;
3185                 *p = value ? *(double*)value : 0;
3186                 return;
3187         }
3188         case MONO_TYPE_STRING:
3189         case MONO_TYPE_SZARRAY:
3190         case MONO_TYPE_CLASS:
3191         case MONO_TYPE_OBJECT:
3192         case MONO_TYPE_ARRAY:
3193                 mono_gc_wbarrier_generic_store (dest, deref_pointer ? *(MonoObject **)value : (MonoObject *)value);
3194                 return;
3195         case MONO_TYPE_FNPTR:
3196         case MONO_TYPE_PTR: {
3197                 gpointer *p = (gpointer*)dest;
3198                 *p = deref_pointer? *(gpointer*)value: value;
3199                 return;
3200         }
3201         case MONO_TYPE_VALUETYPE:
3202                 /* note that 't' and 'type->type' can be different */
3203                 if (type->type == MONO_TYPE_VALUETYPE && type->data.klass->enumtype) {
3204                         t = mono_class_enum_basetype (type->data.klass)->type;
3205                         goto handle_enum;
3206                 } else {
3207                         MonoClass *klass = mono_class_from_mono_type (type);
3208                         int size = mono_class_value_size (klass, NULL);
3209                         if (value == NULL)
3210                                 mono_gc_bzero_atomic (dest, size);
3211                         else
3212                                 mono_gc_wbarrier_value_copy (dest, value, 1, klass);
3213                 }
3214                 return;
3215         case MONO_TYPE_GENERICINST:
3216                 t = type->data.generic_class->container_class->byval_arg.type;
3217                 goto handle_enum;
3218         default:
3219                 g_error ("got type %x", type->type);
3220         }
3221 }
3222
3223 /**
3224  * mono_field_set_value:
3225  * @obj: Instance object
3226  * @field: MonoClassField describing the field to set
3227  * @value: The value to be set
3228  *
3229  * Sets the value of the field described by @field in the object instance @obj
3230  * to the value passed in @value.   This method should only be used for instance
3231  * fields.   For static fields, use mono_field_static_set_value.
3232  *
3233  * The value must be on the native format of the field type.
3234  */
3235 void
3236 mono_field_set_value (MonoObject *obj, MonoClassField *field, void *value)
3237 {
3238         MONO_REQ_GC_UNSAFE_MODE;
3239
3240         void *dest;
3241
3242         g_return_if_fail (!(field->type->attrs & FIELD_ATTRIBUTE_STATIC));
3243
3244         dest = (char*)obj + field->offset;
3245         mono_copy_value (field->type, dest, value, FALSE);
3246 }
3247
3248 /**
3249  * mono_field_static_set_value:
3250  * @field: MonoClassField describing the field to set
3251  * @value: The value to be set
3252  *
3253  * Sets the value of the static field described by @field
3254  * to the value passed in @value.
3255  *
3256  * The value must be on the native format of the field type.
3257  */
3258 void
3259 mono_field_static_set_value (MonoVTable *vt, MonoClassField *field, void *value)
3260 {
3261         MONO_REQ_GC_UNSAFE_MODE;
3262
3263         void *dest;
3264
3265         g_return_if_fail (field->type->attrs & FIELD_ATTRIBUTE_STATIC);
3266         /* you cant set a constant! */
3267         g_return_if_fail (!(field->type->attrs & FIELD_ATTRIBUTE_LITERAL));
3268
3269         if (field->offset == -1) {
3270                 /* Special static */
3271                 gpointer addr;
3272
3273                 mono_domain_lock (vt->domain);
3274                 addr = g_hash_table_lookup (vt->domain->special_static_fields, field);
3275                 mono_domain_unlock (vt->domain);
3276                 dest = mono_get_special_static_data (GPOINTER_TO_UINT (addr));
3277         } else {
3278                 dest = (char*)mono_vtable_get_static_field_data (vt) + field->offset;
3279         }
3280         mono_copy_value (field->type, dest, value, FALSE);
3281 }
3282
3283 /**
3284  * mono_vtable_get_static_field_data:
3285  *
3286  * Internal use function: return a pointer to the memory holding the static fields
3287  * for a class or NULL if there are no static fields.
3288  * This is exported only for use by the debugger.
3289  */
3290 void *
3291 mono_vtable_get_static_field_data (MonoVTable *vt)
3292 {
3293         MONO_REQ_GC_NEUTRAL_MODE
3294
3295         if (!vt->has_static_fields)
3296                 return NULL;
3297         return vt->vtable [vt->klass->vtable_size];
3298 }
3299
3300 static guint8*
3301 mono_field_get_addr (MonoObject *obj, MonoVTable *vt, MonoClassField *field)
3302 {
3303         MONO_REQ_GC_UNSAFE_MODE;
3304
3305         guint8 *src;
3306
3307         if (field->type->attrs & FIELD_ATTRIBUTE_STATIC) {
3308                 if (field->offset == -1) {
3309                         /* Special static */
3310                         gpointer addr;
3311
3312                         mono_domain_lock (vt->domain);
3313                         addr = g_hash_table_lookup (vt->domain->special_static_fields, field);
3314                         mono_domain_unlock (vt->domain);
3315                         src = (guint8 *)mono_get_special_static_data (GPOINTER_TO_UINT (addr));
3316                 } else {
3317                         src = (guint8*)mono_vtable_get_static_field_data (vt) + field->offset;
3318                 }
3319         } else {
3320                 src = (guint8*)obj + field->offset;
3321         }
3322
3323         return src;
3324 }
3325
3326 /**
3327  * mono_field_get_value:
3328  * @obj: Object instance
3329  * @field: MonoClassField describing the field to fetch information from
3330  * @value: pointer to the location where the value will be stored
3331  *
3332  * Use this routine to get the value of the field @field in the object
3333  * passed.
3334  *
3335  * The pointer provided by value must be of the field type, for reference
3336  * types this is a MonoObject*, for value types its the actual pointer to
3337  * the value type.
3338  *
3339  * For example:
3340  *     int i;
3341  *     mono_field_get_value (obj, int_field, &i);
3342  */
3343 void
3344 mono_field_get_value (MonoObject *obj, MonoClassField *field, void *value)
3345 {
3346         MONO_REQ_GC_UNSAFE_MODE;
3347
3348         void *src;
3349
3350         g_assert (obj);
3351
3352         g_return_if_fail (!(field->type->attrs & FIELD_ATTRIBUTE_STATIC));
3353
3354         src = (char*)obj + field->offset;
3355         mono_copy_value (field->type, value, src, TRUE);
3356 }
3357
3358 /**
3359  * mono_field_get_value_object:
3360  * @domain: domain where the object will be created (if boxing)
3361  * @field: MonoClassField describing the field to fetch information from
3362  * @obj: The object instance for the field.
3363  *
3364  * Returns: a new MonoObject with the value from the given field.  If the
3365  * field represents a value type, the value is boxed.
3366  *
3367  */
3368 MonoObject *
3369 mono_field_get_value_object (MonoDomain *domain, MonoClassField *field, MonoObject *obj)
3370 {
3371         MonoError error;
3372         MonoObject* result = mono_field_get_value_object_checked (domain, field, obj, &error);
3373         mono_error_assert_ok (&error);
3374         return result;
3375 }
3376
3377 /**
3378  * mono_field_get_value_object_checked:
3379  * @domain: domain where the object will be created (if boxing)
3380  * @field: MonoClassField describing the field to fetch information from
3381  * @obj: The object instance for the field.
3382  * @error: Set on error.
3383  *
3384  * Returns: a new MonoObject with the value from the given field.  If the
3385  * field represents a value type, the value is boxed.  On error returns NULL and sets @error.
3386  *
3387  */
3388 MonoObject *
3389 mono_field_get_value_object_checked (MonoDomain *domain, MonoClassField *field, MonoObject *obj, MonoError *error)
3390 {
3391         MONO_REQ_GC_UNSAFE_MODE;
3392
3393         mono_error_init (error);
3394
3395         MonoObject *o;
3396         MonoClass *klass;
3397         MonoVTable *vtable = NULL;
3398         gchar *v;
3399         gboolean is_static = FALSE;
3400         gboolean is_ref = FALSE;
3401         gboolean is_literal = FALSE;
3402         gboolean is_ptr = FALSE;
3403         MonoType *type = mono_field_get_type_checked (field, error);
3404
3405         return_val_if_nok (error, NULL);
3406
3407         switch (type->type) {
3408         case MONO_TYPE_STRING:
3409         case MONO_TYPE_OBJECT:
3410         case MONO_TYPE_CLASS:
3411         case MONO_TYPE_ARRAY:
3412         case MONO_TYPE_SZARRAY:
3413                 is_ref = TRUE;
3414                 break;
3415         case MONO_TYPE_U1:
3416         case MONO_TYPE_I1:
3417         case MONO_TYPE_BOOLEAN:
3418         case MONO_TYPE_U2:
3419         case MONO_TYPE_I2:
3420         case MONO_TYPE_CHAR:
3421         case MONO_TYPE_U:
3422         case MONO_TYPE_I:
3423         case MONO_TYPE_U4:
3424         case MONO_TYPE_I4:
3425         case MONO_TYPE_R4:
3426         case MONO_TYPE_U8:
3427         case MONO_TYPE_I8:
3428         case MONO_TYPE_R8:
3429         case MONO_TYPE_VALUETYPE:
3430                 is_ref = type->byref;
3431                 break;
3432         case MONO_TYPE_GENERICINST:
3433                 is_ref = !mono_type_generic_inst_is_valuetype (type);
3434                 break;
3435         case MONO_TYPE_PTR:
3436                 is_ptr = TRUE;
3437                 break;
3438         default:
3439                 g_error ("type 0x%x not handled in "
3440                          "mono_field_get_value_object", type->type);
3441                 return NULL;
3442         }
3443
3444         if (type->attrs & FIELD_ATTRIBUTE_LITERAL)
3445                 is_literal = TRUE;
3446
3447         if (type->attrs & FIELD_ATTRIBUTE_STATIC) {
3448                 is_static = TRUE;
3449
3450                 if (!is_literal) {
3451                         vtable = mono_class_vtable_full (domain, field->parent, error);
3452                         return_val_if_nok (error, NULL);
3453
3454                         if (!vtable->initialized) {
3455                                 mono_runtime_class_init_full (vtable, error);
3456                                 return_val_if_nok (error, NULL);
3457                         }
3458                 }
3459         } else {
3460                 g_assert (obj);
3461         }
3462
3463         if (is_ref) {
3464                 if (is_literal) {
3465                         get_default_field_value (domain, field, &o, error);
3466                         return_val_if_nok (error, NULL);
3467                 } else if (is_static) {
3468                         mono_field_static_get_value_checked (vtable, field, &o, error);
3469                         return_val_if_nok (error, NULL);
3470                 } else {
3471                         mono_field_get_value (obj, field, &o);
3472                 }
3473                 return o;
3474         }
3475
3476         if (is_ptr) {
3477                 static MonoMethod *m;
3478                 gpointer args [2];
3479                 gpointer *ptr;
3480                 gpointer v;
3481
3482                 if (!m) {
3483                         MonoClass *ptr_klass = mono_class_get_pointer_class ();
3484                         m = mono_class_get_method_from_name_flags (ptr_klass, "Box", 2, METHOD_ATTRIBUTE_STATIC);
3485                         g_assert (m);
3486                 }
3487
3488                 v = &ptr;
3489                 if (is_literal) {
3490                         get_default_field_value (domain, field, v, error);
3491                         return_val_if_nok (error, NULL);
3492                 } else if (is_static) {
3493                         mono_field_static_get_value_checked (vtable, field, v, error);
3494                         return_val_if_nok (error, NULL);
3495                 } else {
3496                         mono_field_get_value (obj, field, v);
3497                 }
3498
3499                 /* MONO_TYPE_PTR is passed by value to runtime_invoke () */
3500                 args [0] = ptr ? *ptr : NULL;
3501                 args [1] = mono_type_get_object_checked (mono_domain_get (), type, error);
3502                 return_val_if_nok (error, NULL);
3503
3504                 o = mono_runtime_invoke_checked (m, NULL, args, error);
3505                 return_val_if_nok (error, NULL);
3506
3507                 return o;
3508         }
3509
3510         /* boxed value type */
3511         klass = mono_class_from_mono_type (type);
3512
3513         if (mono_class_is_nullable (klass))
3514                 return mono_nullable_box (mono_field_get_addr (obj, vtable, field), klass, error);
3515
3516         o = mono_object_new_checked (domain, klass, error);
3517         return_val_if_nok (error, NULL);
3518         v = ((gchar *) o) + sizeof (MonoObject);
3519
3520         if (is_literal) {
3521                 get_default_field_value (domain, field, v, error);
3522                 return_val_if_nok (error, NULL);
3523         } else if (is_static) {
3524                 mono_field_static_get_value_checked (vtable, field, v, error);
3525                 return_val_if_nok (error, NULL);
3526         } else {
3527                 mono_field_get_value (obj, field, v);
3528         }
3529
3530         return o;
3531 }
3532
3533 int
3534 mono_get_constant_value_from_blob (MonoDomain* domain, MonoTypeEnum type, const char *blob, void *value, MonoError *error)
3535 {
3536         MONO_REQ_GC_UNSAFE_MODE;
3537
3538         mono_error_init (error);
3539         int retval = 0;
3540         const char *p = blob;
3541         mono_metadata_decode_blob_size (p, &p);
3542
3543         switch (type) {
3544         case MONO_TYPE_BOOLEAN:
3545         case MONO_TYPE_U1:
3546         case MONO_TYPE_I1:
3547                 *(guint8 *) value = *p;
3548                 break;
3549         case MONO_TYPE_CHAR:
3550         case MONO_TYPE_U2:
3551         case MONO_TYPE_I2:
3552                 *(guint16*) value = read16 (p);
3553                 break;
3554         case MONO_TYPE_U4:
3555         case MONO_TYPE_I4:
3556                 *(guint32*) value = read32 (p);
3557                 break;
3558         case MONO_TYPE_U8:
3559         case MONO_TYPE_I8:
3560                 *(guint64*) value = read64 (p);
3561                 break;
3562         case MONO_TYPE_R4:
3563                 readr4 (p, (float*) value);
3564                 break;
3565         case MONO_TYPE_R8:
3566                 readr8 (p, (double*) value);
3567                 break;
3568         case MONO_TYPE_STRING:
3569                 *(gpointer*) value = mono_ldstr_metadata_sig (domain, blob, error);
3570                 break;
3571         case MONO_TYPE_CLASS:
3572                 *(gpointer*) value = NULL;
3573                 break;
3574         default:
3575                 retval = -1;
3576                 g_warning ("type 0x%02x should not be in constant table", type);
3577         }
3578         return retval;
3579 }
3580
3581 static void
3582 get_default_field_value (MonoDomain* domain, MonoClassField *field, void *value, MonoError *error)
3583 {
3584         MONO_REQ_GC_NEUTRAL_MODE;
3585
3586         MonoTypeEnum def_type;
3587         const char* data;
3588
3589         mono_error_init (error);
3590
3591         data = mono_class_get_field_default_value (field, &def_type);
3592         mono_get_constant_value_from_blob (domain, def_type, data, value, error);
3593 }
3594
3595 void
3596 mono_field_static_get_value_for_thread (MonoInternalThread *thread, MonoVTable *vt, MonoClassField *field, void *value, MonoError *error)
3597 {
3598         MONO_REQ_GC_UNSAFE_MODE;
3599
3600         void *src;
3601
3602         mono_error_init (error);
3603
3604         g_return_if_fail (field->type->attrs & FIELD_ATTRIBUTE_STATIC);
3605
3606         if (field->type->attrs & FIELD_ATTRIBUTE_LITERAL) {
3607                 get_default_field_value (vt->domain, field, value, error);
3608                 return;
3609         }
3610
3611         if (field->offset == -1) {
3612                 /* Special static */
3613                 gpointer addr = g_hash_table_lookup (vt->domain->special_static_fields, field);
3614                 src = mono_get_special_static_data_for_thread (thread, GPOINTER_TO_UINT (addr));
3615         } else {
3616                 src = (char*)mono_vtable_get_static_field_data (vt) + field->offset;
3617         }
3618         mono_copy_value (field->type, value, src, TRUE);
3619 }
3620
3621 /**
3622  * mono_field_static_get_value:
3623  * @vt: vtable to the object
3624  * @field: MonoClassField describing the field to fetch information from
3625  * @value: where the value is returned
3626  *
3627  * Use this routine to get the value of the static field @field value.
3628  *
3629  * The pointer provided by value must be of the field type, for reference
3630  * types this is a MonoObject*, for value types its the actual pointer to
3631  * the value type.
3632  *
3633  * For example:
3634  *     int i;
3635  *     mono_field_static_get_value (vt, int_field, &i);
3636  */
3637 void
3638 mono_field_static_get_value (MonoVTable *vt, MonoClassField *field, void *value)
3639 {
3640         MONO_REQ_GC_NEUTRAL_MODE;
3641
3642         MonoError error;
3643         mono_field_static_get_value_checked (vt, field, value, &error);
3644         mono_error_cleanup (&error);
3645 }
3646
3647 /**
3648  * mono_field_static_get_value_checked:
3649  * @vt: vtable to the object
3650  * @field: MonoClassField describing the field to fetch information from
3651  * @value: where the value is returned
3652  * @error: set on error
3653  *
3654  * Use this routine to get the value of the static field @field value.
3655  *
3656  * The pointer provided by value must be of the field type, for reference
3657  * types this is a MonoObject*, for value types its the actual pointer to
3658  * the value type.
3659  *
3660  * For example:
3661  *     int i;
3662  *     mono_field_static_get_value_checked (vt, int_field, &i, error);
3663  *     if (!is_ok (error)) { ... }
3664  *
3665  * On failure sets @error.
3666  */
3667 void
3668 mono_field_static_get_value_checked (MonoVTable *vt, MonoClassField *field, void *value, MonoError *error)
3669 {
3670         MONO_REQ_GC_NEUTRAL_MODE;
3671
3672         mono_field_static_get_value_for_thread (mono_thread_internal_current (), vt, field, value, error);
3673 }
3674
3675 /**
3676  * mono_property_set_value:
3677  * @prop: MonoProperty to set
3678  * @obj: instance object on which to act
3679  * @params: parameters to pass to the propery
3680  * @exc: optional exception
3681  *
3682  * Invokes the property's set method with the given arguments on the
3683  * object instance obj (or NULL for static properties).
3684  *
3685  * You can pass NULL as the exc argument if you don't want to
3686  * catch exceptions, otherwise, *exc will be set to the exception
3687  * thrown, if any.  if an exception is thrown, you can't use the
3688  * MonoObject* result from the function.
3689  */
3690 void
3691 mono_property_set_value (MonoProperty *prop, void *obj, void **params, MonoObject **exc)
3692 {
3693         MONO_REQ_GC_UNSAFE_MODE;
3694
3695         MonoError error;
3696         do_runtime_invoke (prop->set, obj, params, exc, &error);
3697         if (exc && *exc == NULL && !mono_error_ok (&error)) {
3698                 *exc = (MonoObject*) mono_error_convert_to_exception (&error);
3699         } else {
3700                 mono_error_cleanup (&error);
3701         }
3702 }
3703
3704 /**
3705  * mono_property_set_value_checked:
3706  * @prop: MonoProperty to set
3707  * @obj: instance object on which to act
3708  * @params: parameters to pass to the propery
3709  * @error: set on error
3710  *
3711  * Invokes the property's set method with the given arguments on the
3712  * object instance obj (or NULL for static properties).
3713  *
3714  * Returns: TRUE on success.  On failure returns FALSE and sets @error.
3715  * If an exception is thrown, it will be caught and returned via @error.
3716  */
3717 gboolean
3718 mono_property_set_value_checked (MonoProperty *prop, void *obj, void **params, MonoError *error)
3719 {
3720         MONO_REQ_GC_UNSAFE_MODE;
3721
3722         MonoObject *exc;
3723
3724         mono_error_init (error);
3725         do_runtime_invoke (prop->set, obj, params, &exc, error);
3726         if (exc != NULL && is_ok (error))
3727                 mono_error_set_exception_instance (error, (MonoException*)exc);
3728         return is_ok (error);
3729 }
3730
3731 /**
3732  * mono_property_get_value:
3733  * @prop: MonoProperty to fetch
3734  * @obj: instance object on which to act
3735  * @params: parameters to pass to the propery
3736  * @exc: optional exception
3737  *
3738  * Invokes the property's get method with the given arguments on the
3739  * object instance obj (or NULL for static properties).
3740  *
3741  * You can pass NULL as the exc argument if you don't want to
3742  * catch exceptions, otherwise, *exc will be set to the exception
3743  * thrown, if any.  if an exception is thrown, you can't use the
3744  * MonoObject* result from the function.
3745  *
3746  * Returns: the value from invoking the get method on the property.
3747  */
3748 MonoObject*
3749 mono_property_get_value (MonoProperty *prop, void *obj, void **params, MonoObject **exc)
3750 {
3751         MONO_REQ_GC_UNSAFE_MODE;
3752
3753         MonoError error;
3754         MonoObject *val = do_runtime_invoke (prop->get, obj, params, exc, &error);
3755         if (exc && *exc == NULL && !mono_error_ok (&error)) {
3756                 *exc = (MonoObject*) mono_error_convert_to_exception (&error);
3757         } else {
3758                 mono_error_cleanup (&error); /* FIXME don't raise here */
3759         }
3760
3761         return val;
3762 }
3763
3764 /**
3765  * mono_property_get_value_checked:
3766  * @prop: MonoProperty to fetch
3767  * @obj: instance object on which to act
3768  * @params: parameters to pass to the propery
3769  * @error: set on error
3770  *
3771  * Invokes the property's get method with the given arguments on the
3772  * object instance obj (or NULL for static properties).
3773  *
3774  * If an exception is thrown, you can't use the
3775  * MonoObject* result from the function.  The exception will be propagated via @error.
3776  *
3777  * Returns: the value from invoking the get method on the property. On
3778  * failure returns NULL and sets @error.
3779  */
3780 MonoObject*
3781 mono_property_get_value_checked (MonoProperty *prop, void *obj, void **params, MonoError *error)
3782 {
3783         MONO_REQ_GC_UNSAFE_MODE;
3784
3785         MonoObject *exc;
3786         MonoObject *val = do_runtime_invoke (prop->get, obj, params, &exc, error);
3787         if (exc != NULL && !is_ok (error))
3788                 mono_error_set_exception_instance (error, (MonoException*) exc);
3789         if (!is_ok (error))
3790                 val = NULL;
3791         return val;
3792 }
3793
3794
3795 /*
3796  * mono_nullable_init:
3797  * @buf: The nullable structure to initialize.
3798  * @value: the value to initialize from
3799  * @klass: the type for the object
3800  *
3801  * Initialize the nullable structure pointed to by @buf from @value which
3802  * should be a boxed value type.   The size of @buf should be able to hold
3803  * as much data as the @klass->instance_size (which is the number of bytes
3804  * that will be copies).
3805  *
3806  * Since Nullables have variable structure, we can not define a C
3807  * structure for them.
3808  */
3809 void
3810 mono_nullable_init (guint8 *buf, MonoObject *value, MonoClass *klass)
3811 {
3812         MONO_REQ_GC_UNSAFE_MODE;
3813
3814         MonoClass *param_class = klass->cast_class;
3815
3816         mono_class_setup_fields_locking (klass);
3817         g_assert (klass->fields_inited);
3818
3819         g_assert (mono_class_from_mono_type (klass->fields [0].type) == param_class);
3820         g_assert (mono_class_from_mono_type (klass->fields [1].type) == mono_defaults.boolean_class);
3821
3822         *(guint8*)(buf + klass->fields [1].offset - sizeof (MonoObject)) = value ? 1 : 0;
3823         if (value) {
3824                 if (param_class->has_references)
3825                         mono_gc_wbarrier_value_copy (buf + klass->fields [0].offset - sizeof (MonoObject), mono_object_unbox (value), 1, param_class);
3826                 else
3827                         mono_gc_memmove_atomic (buf + klass->fields [0].offset - sizeof (MonoObject), mono_object_unbox (value), mono_class_value_size (param_class, NULL));
3828         } else {
3829                 mono_gc_bzero_atomic (buf + klass->fields [0].offset - sizeof (MonoObject), mono_class_value_size (param_class, NULL));
3830         }
3831 }
3832
3833 /**
3834  * mono_nullable_box:
3835  * @buf: The buffer representing the data to be boxed
3836  * @klass: the type to box it as.
3837  * @error: set on oerr
3838  *
3839  * Creates a boxed vtype or NULL from the Nullable structure pointed to by
3840  * @buf.  On failure returns NULL and sets @error
3841  */
3842 MonoObject*
3843 mono_nullable_box (guint8 *buf, MonoClass *klass, MonoError *error)
3844 {
3845         MONO_REQ_GC_UNSAFE_MODE;
3846
3847         mono_error_init (error);
3848         MonoClass *param_class = klass->cast_class;
3849
3850         mono_class_setup_fields_locking (klass);
3851         g_assert (klass->fields_inited);
3852
3853         g_assert (mono_class_from_mono_type (klass->fields [0].type) == param_class);
3854         g_assert (mono_class_from_mono_type (klass->fields [1].type) == mono_defaults.boolean_class);
3855
3856         if (*(guint8*)(buf + klass->fields [1].offset - sizeof (MonoObject))) {
3857                 MonoObject *o = mono_object_new_checked (mono_domain_get (), param_class, error);
3858                 return_val_if_nok (error, NULL);
3859                 if (param_class->has_references)
3860                         mono_gc_wbarrier_value_copy (mono_object_unbox (o), buf + klass->fields [0].offset - sizeof (MonoObject), 1, param_class);
3861                 else
3862                         mono_gc_memmove_atomic (mono_object_unbox (o), buf + klass->fields [0].offset - sizeof (MonoObject), mono_class_value_size (param_class, NULL));
3863                 return o;
3864         }
3865         else
3866                 return NULL;
3867 }
3868
3869 /**
3870  * mono_get_delegate_invoke:
3871  * @klass: The delegate class
3872  *
3873  * Returns: the MonoMethod for the "Invoke" method in the delegate klass or NULL if @klass is a broken delegate type
3874  */
3875 MonoMethod *
3876 mono_get_delegate_invoke (MonoClass *klass)
3877 {
3878         MONO_REQ_GC_NEUTRAL_MODE;
3879
3880         MonoMethod *im;
3881
3882         /* This is called at runtime, so avoid the slower search in metadata */
3883         mono_class_setup_methods (klass);
3884         if (mono_class_has_failure (klass))
3885                 return NULL;
3886         im = mono_class_get_method_from_name (klass, "Invoke", -1);
3887         return im;
3888 }
3889
3890 /**
3891  * mono_get_delegate_begin_invoke:
3892  * @klass: The delegate class
3893  *
3894  * Returns: the MonoMethod for the "BeginInvoke" method in the delegate klass or NULL if @klass is a broken delegate type
3895  */
3896 MonoMethod *
3897 mono_get_delegate_begin_invoke (MonoClass *klass)
3898 {
3899         MONO_REQ_GC_NEUTRAL_MODE;
3900
3901         MonoMethod *im;
3902
3903         /* This is called at runtime, so avoid the slower search in metadata */
3904         mono_class_setup_methods (klass);
3905         if (mono_class_has_failure (klass))
3906                 return NULL;
3907         im = mono_class_get_method_from_name (klass, "BeginInvoke", -1);
3908         return im;
3909 }
3910
3911 /**
3912  * mono_get_delegate_end_invoke:
3913  * @klass: The delegate class
3914  *
3915  * Returns: the MonoMethod for the "EndInvoke" method in the delegate klass or NULL if @klass is a broken delegate type
3916  */
3917 MonoMethod *
3918 mono_get_delegate_end_invoke (MonoClass *klass)
3919 {
3920         MONO_REQ_GC_NEUTRAL_MODE;
3921
3922         MonoMethod *im;
3923
3924         /* This is called at runtime, so avoid the slower search in metadata */
3925         mono_class_setup_methods (klass);
3926         if (mono_class_has_failure (klass))
3927                 return NULL;
3928         im = mono_class_get_method_from_name (klass, "EndInvoke", -1);
3929         return im;
3930 }
3931
3932 /**
3933  * mono_runtime_delegate_invoke:
3934  * @delegate: pointer to a delegate object.
3935  * @params: parameters for the delegate.
3936  * @exc: Pointer to the exception result.
3937  *
3938  * Invokes the delegate method @delegate with the parameters provided.
3939  *
3940  * You can pass NULL as the exc argument if you don't want to
3941  * catch exceptions, otherwise, *exc will be set to the exception
3942  * thrown, if any.  if an exception is thrown, you can't use the
3943  * MonoObject* result from the function.
3944  */
3945 MonoObject*
3946 mono_runtime_delegate_invoke (MonoObject *delegate, void **params, MonoObject **exc)
3947 {
3948         MONO_REQ_GC_UNSAFE_MODE;
3949
3950         MonoError error;
3951         MonoMethod *im;
3952         MonoClass *klass = delegate->vtable->klass;
3953         MonoObject *o;
3954
3955         im = mono_get_delegate_invoke (klass);
3956         if (!im)
3957                 g_error ("Could not lookup delegate invoke method for delegate %s", mono_type_get_full_name (klass));
3958
3959         if (exc) {
3960                 o = mono_runtime_try_invoke (im, delegate, params, exc, &error);
3961                 if (*exc == NULL && !mono_error_ok (&error))
3962                         *exc = (MonoObject*) mono_error_convert_to_exception (&error);
3963                 else
3964                         mono_error_cleanup (&error);
3965         } else {
3966                 o = mono_runtime_invoke_checked (im, delegate, params, &error);
3967                 mono_error_raise_exception (&error); /* FIXME don't raise here */
3968         }
3969
3970         return o;
3971 }
3972
3973 static char **main_args = NULL;
3974 static int num_main_args = 0;
3975
3976 /**
3977  * mono_runtime_get_main_args:
3978  *
3979  * Returns: a MonoArray with the arguments passed to the main program
3980  */
3981 MonoArray*
3982 mono_runtime_get_main_args (void)
3983 {
3984         MONO_REQ_GC_UNSAFE_MODE;
3985         MonoError error;
3986         MonoArray *result = mono_runtime_get_main_args_checked (&error);
3987         mono_error_assert_ok (&error);
3988         return result;
3989 }
3990
3991 /**
3992  * mono_runtime_get_main_args:
3993  * @error: set on error
3994  *
3995  * Returns: a MonoArray with the arguments passed to the main
3996  * program. On failure returns NULL and sets @error.
3997  */
3998 MonoArray*
3999 mono_runtime_get_main_args_checked (MonoError *error)
4000 {
4001         MonoArray *res;
4002         int i;
4003         MonoDomain *domain = mono_domain_get ();
4004
4005         mono_error_init (error);
4006
4007         res = (MonoArray*)mono_array_new_checked (domain, mono_defaults.string_class, num_main_args, error);
4008         return_val_if_nok (error, NULL);
4009
4010         for (i = 0; i < num_main_args; ++i)
4011                 mono_array_setref (res, i, mono_string_new (domain, main_args [i]));
4012
4013         return res;
4014 }
4015
4016 static void
4017 free_main_args (void)
4018 {
4019         MONO_REQ_GC_NEUTRAL_MODE;
4020
4021         int i;
4022
4023         for (i = 0; i < num_main_args; ++i)
4024                 g_free (main_args [i]);
4025         g_free (main_args);
4026         num_main_args = 0;
4027         main_args = NULL;
4028 }
4029
4030 /**
4031  * mono_runtime_set_main_args:
4032  * @argc: number of arguments from the command line
4033  * @argv: array of strings from the command line
4034  *
4035  * Set the command line arguments from an embedding application that doesn't otherwise call
4036  * mono_runtime_run_main ().
4037  */
4038 int
4039 mono_runtime_set_main_args (int argc, char* argv[])
4040 {
4041         MONO_REQ_GC_NEUTRAL_MODE;
4042
4043         int i;
4044
4045         free_main_args ();
4046         main_args = g_new0 (char*, argc);
4047         num_main_args = argc;
4048
4049         for (i = 0; i < argc; ++i) {
4050                 gchar *utf8_arg;
4051
4052                 utf8_arg = mono_utf8_from_external (argv[i]);
4053                 if (utf8_arg == NULL) {
4054                         g_print ("\nCannot determine the text encoding for argument %d (%s).\n", i, argv [i]);
4055                         g_print ("Please add the correct encoding to MONO_EXTERNAL_ENCODINGS and try again.\n");
4056                         exit (-1);
4057                 }
4058
4059                 main_args [i] = utf8_arg;
4060         }
4061
4062         return 0;
4063 }
4064
4065 /**
4066  * mono_runtime_run_main:
4067  * @method: the method to start the application with (usually Main)
4068  * @argc: number of arguments from the command line
4069  * @argv: array of strings from the command line
4070  * @exc: excetption results
4071  *
4072  * Execute a standard Main() method (argc/argv contains the
4073  * executable name). This method also sets the command line argument value
4074  * needed by System.Environment.
4075  *
4076  *
4077  */
4078 int
4079 mono_runtime_run_main (MonoMethod *method, int argc, char* argv[],
4080                        MonoObject **exc)
4081 {
4082         MONO_REQ_GC_UNSAFE_MODE;
4083
4084         MonoError error;
4085         int i;
4086         MonoArray *args = NULL;
4087         MonoDomain *domain = mono_domain_get ();
4088         gchar *utf8_fullpath;
4089         MonoMethodSignature *sig;
4090
4091         g_assert (method != NULL);
4092
4093         mono_thread_set_main (mono_thread_current ());
4094
4095         main_args = g_new0 (char*, argc);
4096         num_main_args = argc;
4097
4098         if (!g_path_is_absolute (argv [0])) {
4099                 gchar *basename = g_path_get_basename (argv [0]);
4100                 gchar *fullpath = g_build_filename (method->klass->image->assembly->basedir,
4101                                                     basename,
4102                                                     NULL);
4103
4104                 utf8_fullpath = mono_utf8_from_external (fullpath);
4105                 if(utf8_fullpath == NULL) {
4106                         /* Printing the arg text will cause glib to
4107                          * whinge about "Invalid UTF-8", but at least
4108                          * its relevant, and shows the problem text
4109                          * string.
4110                          */
4111                         g_print ("\nCannot determine the text encoding for the assembly location: %s\n", fullpath);
4112                         g_print ("Please add the correct encoding to MONO_EXTERNAL_ENCODINGS and try again.\n");
4113                         exit (-1);
4114                 }
4115
4116                 g_free (fullpath);
4117                 g_free (basename);
4118         } else {
4119                 utf8_fullpath = mono_utf8_from_external (argv[0]);
4120                 if(utf8_fullpath == NULL) {
4121                         g_print ("\nCannot determine the text encoding for the assembly location: %s\n", argv[0]);
4122                         g_print ("Please add the correct encoding to MONO_EXTERNAL_ENCODINGS and try again.\n");
4123                         exit (-1);
4124                 }
4125         }
4126
4127         main_args [0] = utf8_fullpath;
4128
4129         for (i = 1; i < argc; ++i) {
4130                 gchar *utf8_arg;
4131
4132                 utf8_arg=mono_utf8_from_external (argv[i]);
4133                 if(utf8_arg==NULL) {
4134                         /* Ditto the comment about Invalid UTF-8 here */
4135                         g_print ("\nCannot determine the text encoding for argument %d (%s).\n", i, argv[i]);
4136                         g_print ("Please add the correct encoding to MONO_EXTERNAL_ENCODINGS and try again.\n");
4137                         exit (-1);
4138                 }
4139
4140                 main_args [i] = utf8_arg;
4141         }
4142         argc--;
4143         argv++;
4144
4145         sig = mono_method_signature (method);
4146         if (!sig) {
4147                 g_print ("Unable to load Main method.\n");
4148                 exit (-1);
4149         }
4150
4151         if (sig->param_count) {
4152                 args = (MonoArray*)mono_array_new_checked (domain, mono_defaults.string_class, argc, &error);
4153                 mono_error_assert_ok (&error);
4154                 for (i = 0; i < argc; ++i) {
4155                         /* The encodings should all work, given that
4156                          * we've checked all these args for the
4157                          * main_args array.
4158                          */
4159                         gchar *str = mono_utf8_from_external (argv [i]);
4160                         MonoString *arg = mono_string_new (domain, str);
4161                         mono_array_setref (args, i, arg);
4162                         g_free (str);
4163                 }
4164         } else {
4165                 args = (MonoArray*)mono_array_new_checked (domain, mono_defaults.string_class, 0, &error);
4166                 mono_error_assert_ok (&error);
4167         }
4168
4169         mono_assembly_set_main (method->klass->image->assembly);
4170
4171         return mono_runtime_exec_main (method, args, exc);
4172 }
4173
4174 static MonoObject*
4175 serialize_object (MonoObject *obj, gboolean *failure, MonoObject **exc)
4176 {
4177         static MonoMethod *serialize_method;
4178
4179         MonoError error;
4180         void *params [1];
4181         MonoObject *array;
4182
4183         if (!serialize_method) {
4184                 MonoClass *klass = mono_class_get_remoting_services_class ();
4185                 serialize_method = mono_class_get_method_from_name (klass, "SerializeCallData", -1);
4186         }
4187
4188         if (!serialize_method) {
4189                 *failure = TRUE;
4190                 return NULL;
4191         }
4192
4193         g_assert (!mono_class_is_marshalbyref (mono_object_class (obj)));
4194
4195         params [0] = obj;
4196         *exc = NULL;
4197
4198         array = mono_runtime_try_invoke (serialize_method, NULL, params, exc, &error);
4199         if (*exc == NULL && !mono_error_ok (&error))
4200                 *exc = (MonoObject*) mono_error_convert_to_exception (&error); /* FIXME convert serialize_object to MonoError */
4201         else
4202                 mono_error_cleanup (&error);
4203
4204         if (*exc)
4205                 *failure = TRUE;
4206
4207         return array;
4208 }
4209
4210 static MonoObject*
4211 deserialize_object (MonoObject *obj, gboolean *failure, MonoObject **exc)
4212 {
4213         MONO_REQ_GC_UNSAFE_MODE;
4214
4215         static MonoMethod *deserialize_method;
4216
4217         MonoError error;
4218         void *params [1];
4219         MonoObject *result;
4220
4221         if (!deserialize_method) {
4222                 MonoClass *klass = mono_class_get_remoting_services_class ();
4223                 deserialize_method = mono_class_get_method_from_name (klass, "DeserializeCallData", -1);
4224         }
4225         if (!deserialize_method) {
4226                 *failure = TRUE;
4227                 return NULL;
4228         }
4229
4230         params [0] = obj;
4231         *exc = NULL;
4232
4233         result = mono_runtime_try_invoke (deserialize_method, NULL, params, exc, &error);
4234         if (*exc == NULL && !mono_error_ok (&error))
4235                 *exc = (MonoObject*) mono_error_convert_to_exception (&error); /* FIXME convert deserialize_object to MonoError */
4236         else
4237                 mono_error_cleanup (&error);
4238
4239         if (*exc)
4240                 *failure = TRUE;
4241
4242         return result;
4243 }
4244
4245 #ifndef DISABLE_REMOTING
4246 static MonoObject*
4247 make_transparent_proxy (MonoObject *obj, MonoError *error)
4248 {
4249         MONO_REQ_GC_UNSAFE_MODE;
4250
4251         static MonoMethod *get_proxy_method;
4252
4253         MonoDomain *domain = mono_domain_get ();
4254         MonoRealProxy *real_proxy;
4255         MonoReflectionType *reflection_type;
4256         MonoTransparentProxy *transparent_proxy;
4257
4258         mono_error_init (error);
4259
4260         if (!get_proxy_method)
4261                 get_proxy_method = mono_class_get_method_from_name (mono_defaults.real_proxy_class, "GetTransparentProxy", 0);
4262
4263         g_assert (mono_class_is_marshalbyref (obj->vtable->klass));
4264
4265         real_proxy = (MonoRealProxy*) mono_object_new_checked (domain, mono_defaults.real_proxy_class, error);
4266         return_val_if_nok (error, NULL);
4267         reflection_type = mono_type_get_object_checked (domain, &obj->vtable->klass->byval_arg, error);
4268         return_val_if_nok (error, NULL);
4269
4270         MONO_OBJECT_SETREF (real_proxy, class_to_proxy, reflection_type);
4271         MONO_OBJECT_SETREF (real_proxy, unwrapped_server, obj);
4272
4273         MonoObject *exc = NULL;
4274
4275         transparent_proxy = (MonoTransparentProxy*) mono_runtime_try_invoke (get_proxy_method, real_proxy, NULL, &exc, error);
4276         if (exc != NULL && is_ok (error))
4277                 mono_error_set_exception_instance (error, (MonoException*)exc);
4278
4279         return (MonoObject*) transparent_proxy;
4280 }
4281 #endif /* DISABLE_REMOTING */
4282
4283 /**
4284  * mono_object_xdomain_representation
4285  * @obj: an object
4286  * @target_domain: a domain
4287  * @error: set on error.
4288  *
4289  * Creates a representation of obj in the domain target_domain.  This
4290  * is either a copy of obj arrived through via serialization and
4291  * deserialization or a proxy, depending on whether the object is
4292  * serializable or marshal by ref.  obj must not be in target_domain.
4293  *
4294  * If the object cannot be represented in target_domain, NULL is
4295  * returned and @error is set appropriately.
4296  */
4297 MonoObject*
4298 mono_object_xdomain_representation (MonoObject *obj, MonoDomain *target_domain, MonoError *error)
4299 {
4300         MONO_REQ_GC_UNSAFE_MODE;
4301
4302         mono_error_init (error);
4303         MonoObject *deserialized = NULL;
4304
4305 #ifndef DISABLE_REMOTING
4306         if (mono_class_is_marshalbyref (mono_object_class (obj))) {
4307                 deserialized = make_transparent_proxy (obj, error);
4308         }
4309         else
4310 #endif
4311         {
4312                 gboolean failure = FALSE;
4313                 MonoDomain *domain = mono_domain_get ();
4314                 MonoObject *serialized;
4315                 MonoObject *exc = NULL;
4316
4317                 mono_domain_set_internal_with_options (mono_object_domain (obj), FALSE);
4318                 serialized = serialize_object (obj, &failure, &exc);
4319                 mono_domain_set_internal_with_options (target_domain, FALSE);
4320                 if (!failure)
4321                         deserialized = deserialize_object (serialized, &failure, &exc);
4322                 if (domain != target_domain)
4323                         mono_domain_set_internal_with_options (domain, FALSE);
4324                 if (failure)
4325                         mono_error_set_exception_instance (error, (MonoException*)exc);
4326         }
4327
4328         return deserialized;
4329 }
4330
4331 /* Used in call_unhandled_exception_delegate */
4332 static MonoObject *
4333 create_unhandled_exception_eventargs (MonoObject *exc)
4334 {
4335         MONO_REQ_GC_UNSAFE_MODE;
4336
4337         MonoError error;
4338         MonoClass *klass;
4339         gpointer args [2];
4340         MonoMethod *method = NULL;
4341         MonoBoolean is_terminating = TRUE;
4342         MonoObject *obj;
4343
4344         klass = mono_class_get_unhandled_exception_event_args_class ();
4345         mono_class_init (klass);
4346
4347         /* UnhandledExceptionEventArgs only has 1 public ctor with 2 args */
4348         method = mono_class_get_method_from_name_flags (klass, ".ctor", 2, METHOD_ATTRIBUTE_PUBLIC);
4349         g_assert (method);
4350
4351         args [0] = exc;
4352         args [1] = &is_terminating;
4353
4354         obj = mono_object_new_checked (mono_domain_get (), klass, &error);
4355         mono_error_raise_exception (&error); /* FIXME don't raise here */
4356
4357         mono_runtime_invoke_checked (method, obj, args, &error);
4358         mono_error_raise_exception (&error); /* FIXME don't raise here */
4359
4360         return obj;
4361 }
4362
4363 /* Used in mono_unhandled_exception */
4364 static void
4365 call_unhandled_exception_delegate (MonoDomain *domain, MonoObject *delegate, MonoObject *exc) {
4366         MONO_REQ_GC_UNSAFE_MODE;
4367
4368         MonoObject *e = NULL;
4369         gpointer pa [2];
4370         MonoDomain *current_domain = mono_domain_get ();
4371
4372         if (domain != current_domain)
4373                 mono_domain_set_internal_with_options (domain, FALSE);
4374
4375         g_assert (domain == mono_object_domain (domain->domain));
4376
4377         if (mono_object_domain (exc) != domain) {
4378                 MonoError error;
4379
4380                 exc = mono_object_xdomain_representation (exc, domain, &error);
4381                 if (!exc) {
4382                         if (!is_ok (&error)) {
4383                                 MonoError inner_error;
4384                                 MonoException *serialization_exc = mono_error_convert_to_exception (&error);
4385                                 exc = mono_object_xdomain_representation ((MonoObject*)serialization_exc, domain, &inner_error);
4386                                 mono_error_assert_ok (&inner_error);
4387                         } else {
4388                                 exc = (MonoObject*) mono_exception_from_name_msg (mono_get_corlib (),
4389                                                 "System.Runtime.Serialization", "SerializationException",
4390                                                 "Could not serialize unhandled exception.");
4391                         }
4392                 }
4393         }
4394         g_assert (mono_object_domain (exc) == domain);
4395
4396         pa [0] = domain->domain;
4397         pa [1] = create_unhandled_exception_eventargs (exc);
4398         mono_runtime_delegate_invoke (delegate, pa, &e);
4399
4400         if (domain != current_domain)
4401                 mono_domain_set_internal_with_options (current_domain, FALSE);
4402
4403         if (e) {
4404                 MonoError error;
4405                 gchar *msg = mono_string_to_utf8_checked (((MonoException *) e)->message, &error);
4406                 if (!mono_error_ok (&error)) {
4407                         g_warning ("Exception inside UnhandledException handler with invalid message (Invalid characters)\n");
4408                         mono_error_cleanup (&error);
4409                 } else {
4410                         g_warning ("exception inside UnhandledException handler: %s\n", msg);
4411                         g_free (msg);
4412                 }
4413         }
4414 }
4415
4416 static MonoRuntimeUnhandledExceptionPolicy runtime_unhandled_exception_policy = MONO_UNHANDLED_POLICY_CURRENT;
4417
4418 /**
4419  * mono_runtime_unhandled_exception_policy_set:
4420  * @policy: the new policy
4421  *
4422  * This is a VM internal routine.
4423  *
4424  * Sets the runtime policy for handling unhandled exceptions.
4425  */
4426 void
4427 mono_runtime_unhandled_exception_policy_set (MonoRuntimeUnhandledExceptionPolicy policy) {
4428         runtime_unhandled_exception_policy = policy;
4429 }
4430
4431 /**
4432  * mono_runtime_unhandled_exception_policy_get:
4433  *
4434  * This is a VM internal routine.
4435  *
4436  * Gets the runtime policy for handling unhandled exceptions.
4437  */
4438 MonoRuntimeUnhandledExceptionPolicy
4439 mono_runtime_unhandled_exception_policy_get (void) {
4440         return runtime_unhandled_exception_policy;
4441 }
4442
4443 /**
4444  * mono_unhandled_exception:
4445  * @exc: exception thrown
4446  *
4447  * This is a VM internal routine.
4448  *
4449  * We call this function when we detect an unhandled exception
4450  * in the default domain.
4451  *
4452  * It invokes the * UnhandledException event in AppDomain or prints
4453  * a warning to the console
4454  */
4455 void
4456 mono_unhandled_exception (MonoObject *exc)
4457 {
4458         MONO_REQ_GC_UNSAFE_MODE;
4459
4460         MonoError error;
4461         MonoClassField *field;
4462         MonoDomain *current_domain, *root_domain;
4463         MonoObject *current_appdomain_delegate = NULL, *root_appdomain_delegate = NULL;
4464
4465         if (mono_class_has_parent (exc->vtable->klass, mono_defaults.threadabortexception_class))
4466                 return;
4467
4468         field = mono_class_get_field_from_name (mono_defaults.appdomain_class, "UnhandledException");
4469         g_assert (field);
4470
4471         current_domain = mono_domain_get ();
4472         root_domain = mono_get_root_domain ();
4473
4474         root_appdomain_delegate = mono_field_get_value_object_checked (root_domain, field, (MonoObject*) root_domain->domain, &error);
4475         mono_error_raise_exception (&error); /* FIXME don't raise here */
4476         if (current_domain != root_domain) {
4477                 current_appdomain_delegate = mono_field_get_value_object_checked (current_domain, field, (MonoObject*) current_domain->domain, &error);
4478                 mono_error_raise_exception (&error); /* FIXME don't raise here */
4479         }
4480
4481         if (!current_appdomain_delegate && !root_appdomain_delegate) {
4482                 mono_print_unhandled_exception (exc);
4483         } else {
4484                 if (root_appdomain_delegate)
4485                         call_unhandled_exception_delegate (root_domain, root_appdomain_delegate, exc);
4486                 if (current_appdomain_delegate)
4487                         call_unhandled_exception_delegate (current_domain, current_appdomain_delegate, exc);
4488         }
4489
4490         /* set exitcode only if we will abort the process */
4491         if ((main_thread && mono_thread_internal_current () == main_thread->internal_thread)
4492                  || mono_runtime_unhandled_exception_policy_get () == MONO_UNHANDLED_POLICY_CURRENT)
4493         {
4494                 mono_environment_exitcode_set (1);
4495         }
4496 }
4497
4498 /**
4499  * mono_runtime_exec_managed_code:
4500  * @domain: Application domain
4501  * @main_func: function to invoke from the execution thread
4502  * @main_args: parameter to the main_func
4503  *
4504  * Launch a new thread to execute a function
4505  *
4506  * main_func is called back from the thread with main_args as the
4507  * parameter.  The callback function is expected to start Main()
4508  * eventually.  This function then waits for all managed threads to
4509  * finish.
4510  * It is not necesseray anymore to execute managed code in a subthread,
4511  * so this function should not be used anymore by default: just
4512  * execute the code and then call mono_thread_manage ().
4513  */
4514 void
4515 mono_runtime_exec_managed_code (MonoDomain *domain,
4516                                 MonoMainThreadFunc main_func,
4517                                 gpointer main_args)
4518 {
4519         MonoError error;
4520         mono_thread_create_checked (domain, main_func, main_args, &error);
4521         mono_error_assert_ok (&error);
4522
4523         mono_thread_manage ();
4524 }
4525
4526 /*
4527  * Execute a standard Main() method (args doesn't contain the
4528  * executable name).
4529  */
4530 int
4531 mono_runtime_exec_main (MonoMethod *method, MonoArray *args, MonoObject **exc)
4532 {
4533         MONO_REQ_GC_UNSAFE_MODE;
4534
4535         MonoError error;
4536         MonoDomain *domain;
4537         gpointer pa [1];
4538         int rval;
4539         MonoCustomAttrInfo* cinfo;
4540         gboolean has_stathread_attribute;
4541         MonoInternalThread* thread = mono_thread_internal_current ();
4542
4543         g_assert (args);
4544
4545         pa [0] = args;
4546
4547         domain = mono_object_domain (args);
4548         if (!domain->entry_assembly) {
4549                 gchar *str;
4550                 MonoAssembly *assembly;
4551
4552                 assembly = method->klass->image->assembly;
4553                 domain->entry_assembly = assembly;
4554                 /* Domains created from another domain already have application_base and configuration_file set */
4555                 if (domain->setup->application_base == NULL) {
4556                         MONO_OBJECT_SETREF (domain->setup, application_base, mono_string_new (domain, assembly->basedir));
4557                 }
4558
4559                 if (domain->setup->configuration_file == NULL) {
4560                         str = g_strconcat (assembly->image->name, ".config", NULL);
4561                         MONO_OBJECT_SETREF (domain->setup, configuration_file, mono_string_new (domain, str));
4562                         g_free (str);
4563                         mono_domain_set_options_from_config (domain);
4564                 }
4565         }
4566
4567         cinfo = mono_custom_attrs_from_method_checked (method, &error);
4568         mono_error_cleanup (&error); /* FIXME warn here? */
4569         if (cinfo) {
4570                 has_stathread_attribute = mono_custom_attrs_has_attr (cinfo, mono_class_get_sta_thread_attribute_class ());
4571                 if (!cinfo->cached)
4572                         mono_custom_attrs_free (cinfo);
4573         } else {
4574                 has_stathread_attribute = FALSE;
4575         }
4576         if (has_stathread_attribute) {
4577                 thread->apartment_state = ThreadApartmentState_STA;
4578         } else {
4579                 thread->apartment_state = ThreadApartmentState_MTA;
4580         }
4581         mono_thread_init_apartment_state ();
4582
4583         /* FIXME: check signature of method */
4584         if (mono_method_signature (method)->ret->type == MONO_TYPE_I4) {
4585                 MonoObject *res;
4586                 if (exc) {
4587                         res = mono_runtime_try_invoke (method, NULL, pa, exc, &error);
4588                         if (*exc == NULL && !mono_error_ok (&error))
4589                                 *exc = (MonoObject*) mono_error_convert_to_exception (&error);
4590                         else
4591                                 mono_error_cleanup (&error);
4592                 } else {
4593                         res = mono_runtime_invoke_checked (method, NULL, pa, &error);
4594                         mono_error_raise_exception (&error); /* FIXME don't raise here */
4595                 }
4596
4597                 if (!exc || !*exc)
4598                         rval = *(guint32 *)((char *)res + sizeof (MonoObject));
4599                 else
4600                         rval = -1;
4601
4602                 mono_environment_exitcode_set (rval);
4603         } else {
4604                 if (exc) {
4605                         mono_runtime_try_invoke (method, NULL, pa, exc, &error);
4606                         if (*exc == NULL && !mono_error_ok (&error))
4607                                 *exc = (MonoObject*) mono_error_convert_to_exception (&error);
4608                         else
4609                                 mono_error_cleanup (&error);
4610                 } else {
4611                         mono_runtime_invoke_checked (method, NULL, pa, &error);
4612                         mono_error_raise_exception (&error); /* FIXME don't raise here */
4613                 }
4614
4615                 if (!exc || !*exc)
4616                         rval = 0;
4617                 else {
4618                         /* If the return type of Main is void, only
4619                          * set the exitcode if an exception was thrown
4620                          * (we don't want to blow away an
4621                          * explicitly-set exit code)
4622                          */
4623                         rval = -1;
4624                         mono_environment_exitcode_set (rval);
4625                 }
4626         }
4627
4628         return rval;
4629 }
4630
4631 /**
4632  * mono_runtime_invoke_array:
4633  * @method: method to invoke
4634  * @obJ: object instance
4635  * @params: arguments to the method
4636  * @exc: exception information.
4637  *
4638  * Invokes the method represented by @method on the object @obj.
4639  *
4640  * obj is the 'this' pointer, it should be NULL for static
4641  * methods, a MonoObject* for object instances and a pointer to
4642  * the value type for value types.
4643  *
4644  * The params array contains the arguments to the method with the
4645  * same convention: MonoObject* pointers for object instances and
4646  * pointers to the value type otherwise. The _invoke_array
4647  * variant takes a C# object[] as the params argument (MonoArray
4648  * *params): in this case the value types are boxed inside the
4649  * respective reference representation.
4650  *
4651  * From unmanaged code you'll usually use the
4652  * mono_runtime_invoke_checked() variant.
4653  *
4654  * Note that this function doesn't handle virtual methods for
4655  * you, it will exec the exact method you pass: we still need to
4656  * expose a function to lookup the derived class implementation
4657  * of a virtual method (there are examples of this in the code,
4658  * though).
4659  *
4660  * You can pass NULL as the exc argument if you don't want to
4661  * catch exceptions, otherwise, *exc will be set to the exception
4662  * thrown, if any.  if an exception is thrown, you can't use the
4663  * MonoObject* result from the function.
4664  *
4665  * If the method returns a value type, it is boxed in an object
4666  * reference.
4667  */
4668 MonoObject*
4669 mono_runtime_invoke_array (MonoMethod *method, void *obj, MonoArray *params,
4670                            MonoObject **exc)
4671 {
4672         MONO_REQ_GC_UNSAFE_MODE;
4673
4674         MonoError error;
4675         MonoMethodSignature *sig = mono_method_signature (method);
4676         gpointer *pa = NULL;
4677         MonoObject *res;
4678         int i;
4679         gboolean has_byref_nullables = FALSE;
4680
4681         if (NULL != params) {
4682                 pa = (void **)alloca (sizeof (gpointer) * mono_array_length (params));
4683                 for (i = 0; i < mono_array_length (params); i++) {
4684                         MonoType *t = sig->params [i];
4685
4686                 again:
4687                         switch (t->type) {
4688                         case MONO_TYPE_U1:
4689                         case MONO_TYPE_I1:
4690                         case MONO_TYPE_BOOLEAN:
4691                         case MONO_TYPE_U2:
4692                         case MONO_TYPE_I2:
4693                         case MONO_TYPE_CHAR:
4694                         case MONO_TYPE_U:
4695                         case MONO_TYPE_I:
4696                         case MONO_TYPE_U4:
4697                         case MONO_TYPE_I4:
4698                         case MONO_TYPE_U8:
4699                         case MONO_TYPE_I8:
4700                         case MONO_TYPE_R4:
4701                         case MONO_TYPE_R8:
4702                         case MONO_TYPE_VALUETYPE:
4703                                 if (t->type == MONO_TYPE_VALUETYPE && mono_class_is_nullable (mono_class_from_mono_type (sig->params [i]))) {
4704                                         /* The runtime invoke wrapper needs the original boxed vtype, it does handle byref values as well. */
4705                                         pa [i] = mono_array_get (params, MonoObject*, i);
4706                                         if (t->byref)
4707                                                 has_byref_nullables = TRUE;
4708                                 } else {
4709                                         /* MS seems to create the objects if a null is passed in */
4710                                         if (!mono_array_get (params, MonoObject*, i)) {
4711                                                 MonoObject *o = mono_object_new_checked (mono_domain_get (), mono_class_from_mono_type (sig->params [i]), &error);
4712                                                 mono_error_raise_exception (&error); /* FIXME don't raise here */
4713                                                 mono_array_setref (params, i, o);
4714                                         }
4715
4716                                         if (t->byref) {
4717                                                 /*
4718                                                  * We can't pass the unboxed vtype byref to the callee, since
4719                                                  * that would mean the callee would be able to modify boxed
4720                                                  * primitive types. So we (and MS) make a copy of the boxed
4721                                                  * object, pass that to the callee, and replace the original
4722                                                  * boxed object in the arg array with the copy.
4723                                                  */
4724                                                 MonoObject *orig = mono_array_get (params, MonoObject*, i);
4725                                                 MonoObject *copy = mono_value_box_checked (mono_domain_get (), orig->vtable->klass, mono_object_unbox (orig), &error);
4726                                                 mono_error_raise_exception (&error); /* FIXME don't raise here */
4727                                                 mono_array_setref (params, i, copy);
4728                                         }
4729
4730                                         pa [i] = mono_object_unbox (mono_array_get (params, MonoObject*, i));
4731                                 }
4732                                 break;
4733                         case MONO_TYPE_STRING:
4734                         case MONO_TYPE_OBJECT:
4735                         case MONO_TYPE_CLASS:
4736                         case MONO_TYPE_ARRAY:
4737                         case MONO_TYPE_SZARRAY:
4738                                 if (t->byref)
4739                                         pa [i] = mono_array_addr (params, MonoObject*, i);
4740                                         // FIXME: I need to check this code path
4741                                 else
4742                                         pa [i] = mono_array_get (params, MonoObject*, i);
4743                                 break;
4744                         case MONO_TYPE_GENERICINST:
4745                                 if (t->byref)
4746                                         t = &t->data.generic_class->container_class->this_arg;
4747                                 else
4748                                         t = &t->data.generic_class->container_class->byval_arg;
4749                                 goto again;
4750                         case MONO_TYPE_PTR: {
4751                                 MonoObject *arg;
4752
4753                                 /* The argument should be an IntPtr */
4754                                 arg = mono_array_get (params, MonoObject*, i);
4755                                 if (arg == NULL) {
4756                                         pa [i] = NULL;
4757                                 } else {
4758                                         g_assert (arg->vtable->klass == mono_defaults.int_class);
4759                                         pa [i] = ((MonoIntPtr*)arg)->m_value;
4760                                 }
4761                                 break;
4762                         }
4763                         default:
4764                                 g_error ("type 0x%x not handled in mono_runtime_invoke_array", sig->params [i]->type);
4765                         }
4766                 }
4767         }
4768
4769         if (!strcmp (method->name, ".ctor") && method->klass != mono_defaults.string_class) {
4770                 void *o = obj;
4771
4772                 if (mono_class_is_nullable (method->klass)) {
4773                         /* Need to create a boxed vtype instead */
4774                         g_assert (!obj);
4775
4776                         if (!params)
4777                                 return NULL;
4778                         else {
4779                                 MonoObject *result = mono_value_box_checked (mono_domain_get (), method->klass->cast_class, pa [0], &error);
4780                                 mono_error_raise_exception (&error); /* FIXME don't raise here */
4781                                 return result;
4782                         }
4783                 }
4784
4785                 if (!obj) {
4786                         obj = mono_object_new_checked (mono_domain_get (), method->klass, &error);
4787                         g_assert (obj && mono_error_ok (&error)); /*maybe we should raise a TLE instead?*/ /* FIXME don't swallow error */
4788 #ifndef DISABLE_REMOTING
4789                         if (mono_object_class(obj) == mono_defaults.transparent_proxy_class) {
4790                                 method = mono_marshal_get_remoting_invoke (method->slot == -1 ? method : method->klass->vtable [method->slot]);
4791                         }
4792 #endif
4793                         if (method->klass->valuetype)
4794                                 o = (MonoObject *)mono_object_unbox ((MonoObject *)obj);
4795                         else
4796                                 o = obj;
4797                 } else if (method->klass->valuetype) {
4798                         obj = mono_value_box_checked (mono_domain_get (), method->klass, obj, &error);
4799                         mono_error_raise_exception (&error); /* FIXME don't raise here */
4800                 }
4801
4802                 if (exc) {
4803                         mono_runtime_try_invoke (method, o, pa, exc, &error);
4804                         if (*exc == NULL && !mono_error_ok (&error))
4805                                 *exc = (MonoObject*) mono_error_convert_to_exception (&error);
4806                         else
4807                                 mono_error_cleanup (&error);
4808                 } else {
4809                         mono_runtime_invoke_checked (method, o, pa, &error);
4810                         mono_error_raise_exception (&error); /* FIXME don't raise here */
4811                 }
4812
4813                 return (MonoObject *)obj;
4814         } else {
4815                 if (mono_class_is_nullable (method->klass)) {
4816                         MonoObject *nullable;
4817
4818                         /* Convert the unboxed vtype into a Nullable structure */
4819                         nullable = mono_object_new_checked (mono_domain_get (), method->klass, &error);
4820                         mono_error_raise_exception (&error); /* FIXME don't raise here */
4821
4822                         MonoObject *boxed = mono_value_box_checked (mono_domain_get (), method->klass->cast_class, obj, &error);
4823                         mono_error_raise_exception (&error); /* FIXME don't raise here */
4824                         mono_nullable_init ((guint8 *)mono_object_unbox (nullable), boxed, method->klass);
4825                         obj = mono_object_unbox (nullable);
4826                 }
4827
4828                 /* obj must be already unboxed if needed */
4829                 if (exc) {
4830                         res = mono_runtime_try_invoke (method, obj, pa, exc, &error);
4831                         if (*exc == NULL && !mono_error_ok (&error))
4832                                 *exc = (MonoObject*) mono_error_convert_to_exception (&error);
4833                         else
4834                                 mono_error_cleanup (&error);
4835                 } else {
4836                         res = mono_runtime_invoke_checked (method, obj, pa, &error);
4837                         mono_error_raise_exception (&error); /* FIXME don't raise here */
4838                 }
4839
4840                 if (sig->ret->type == MONO_TYPE_PTR) {
4841                         MonoClass *pointer_class;
4842                         static MonoMethod *box_method;
4843                         void *box_args [2];
4844                         MonoObject *box_exc;
4845
4846                         /*
4847                          * The runtime-invoke wrapper returns a boxed IntPtr, need to
4848                          * convert it to a Pointer object.
4849                          */
4850                         pointer_class = mono_class_get_pointer_class ();
4851                         if (!box_method)
4852                                 box_method = mono_class_get_method_from_name (pointer_class, "Box", -1);
4853
4854                         g_assert (res->vtable->klass == mono_defaults.int_class);
4855                         box_args [0] = ((MonoIntPtr*)res)->m_value;
4856                         box_args [1] = mono_type_get_object_checked (mono_domain_get (), sig->ret, &error);
4857                         mono_error_raise_exception (&error); /* FIXME don't raise here */
4858
4859                         res = mono_runtime_try_invoke (box_method, NULL, box_args, &box_exc, &error);
4860                         g_assert (box_exc == NULL);
4861                         mono_error_assert_ok (&error);
4862                 }
4863
4864                 if (has_byref_nullables) {
4865                         /*
4866                          * The runtime invoke wrapper already converted byref nullables back,
4867                          * and stored them in pa, we just need to copy them back to the
4868                          * managed array.
4869                          */
4870                         for (i = 0; i < mono_array_length (params); i++) {
4871                                 MonoType *t = sig->params [i];
4872
4873                                 if (t->byref && t->type == MONO_TYPE_GENERICINST && mono_class_is_nullable (mono_class_from_mono_type (t)))
4874                                         mono_array_setref (params, i, pa [i]);
4875                         }
4876                 }
4877
4878                 return res;
4879         }
4880 }
4881
4882 /**
4883  * mono_object_new:
4884  * @klass: the class of the object that we want to create
4885  *
4886  * Returns: a newly created object whose definition is
4887  * looked up using @klass.   This will not invoke any constructors,
4888  * so the consumer of this routine has to invoke any constructors on
4889  * its own to initialize the object.
4890  *
4891  * It returns NULL on failure.
4892  */
4893 MonoObject *
4894 mono_object_new (MonoDomain *domain, MonoClass *klass)
4895 {
4896         MONO_REQ_GC_UNSAFE_MODE;
4897
4898         MonoError error;
4899
4900         MonoObject * result = mono_object_new_checked (domain, klass, &error);
4901
4902         mono_error_cleanup (&error);
4903         return result;
4904 }
4905
4906 MonoObject *
4907 ves_icall_object_new (MonoDomain *domain, MonoClass *klass)
4908 {
4909         MONO_REQ_GC_UNSAFE_MODE;
4910
4911         MonoError error;
4912
4913         MonoObject * result = mono_object_new_checked (domain, klass, &error);
4914
4915         mono_error_set_pending_exception (&error);
4916         return result;
4917 }
4918
4919 /**
4920  * mono_object_new_checked:
4921  * @klass: the class of the object that we want to create
4922  * @error: set on error
4923  *
4924  * Returns: a newly created object whose definition is
4925  * looked up using @klass.   This will not invoke any constructors,
4926  * so the consumer of this routine has to invoke any constructors on
4927  * its own to initialize the object.
4928  *
4929  * It returns NULL on failure and sets @error.
4930  */
4931 MonoObject *
4932 mono_object_new_checked (MonoDomain *domain, MonoClass *klass, MonoError *error)
4933 {
4934         MONO_REQ_GC_UNSAFE_MODE;
4935
4936         MonoVTable *vtable;
4937
4938         vtable = mono_class_vtable (domain, klass);
4939         g_assert (vtable); /* FIXME don't swallow the error */
4940
4941         MonoObject *o = mono_object_new_specific_checked (vtable, error);
4942         return o;
4943 }
4944
4945 /**
4946  * mono_object_new_pinned:
4947  *
4948  *   Same as mono_object_new, but the returned object will be pinned.
4949  * For SGEN, these objects will only be freed at appdomain unload.
4950  */
4951 MonoObject *
4952 mono_object_new_pinned (MonoDomain *domain, MonoClass *klass, MonoError *error)
4953 {
4954         MONO_REQ_GC_UNSAFE_MODE;
4955
4956         MonoVTable *vtable;
4957
4958         mono_error_init (error);
4959
4960         vtable = mono_class_vtable (domain, klass);
4961         g_assert (vtable); /* FIXME don't swallow the error */
4962
4963         MonoObject *o = (MonoObject *)mono_gc_alloc_pinned_obj (vtable, mono_class_instance_size (klass));
4964
4965         if (G_UNLIKELY (!o))
4966                 mono_error_set_out_of_memory (error, "Could not allocate %i bytes", mono_class_instance_size (klass));
4967         else if (G_UNLIKELY (vtable->klass->has_finalize))
4968                 mono_object_register_finalizer (o, error);
4969
4970         return o;
4971 }
4972
4973 /**
4974  * mono_object_new_specific:
4975  * @vtable: the vtable of the object that we want to create
4976  *
4977  * Returns: A newly created object with class and domain specified
4978  * by @vtable
4979  */
4980 MonoObject *
4981 mono_object_new_specific (MonoVTable *vtable)
4982 {
4983         MonoError error;
4984         MonoObject *o = mono_object_new_specific_checked (vtable, &error);
4985         mono_error_cleanup (&error);
4986
4987         return o;
4988 }
4989
4990 MonoObject *
4991 mono_object_new_specific_checked (MonoVTable *vtable, MonoError *error)
4992 {
4993         MONO_REQ_GC_UNSAFE_MODE;
4994
4995         MonoObject *o;
4996
4997         mono_error_init (error);
4998
4999         /* check for is_com_object for COM Interop */
5000         if (mono_vtable_is_remote (vtable) || mono_class_is_com_object (vtable->klass))
5001         {
5002                 gpointer pa [1];
5003                 MonoMethod *im = vtable->domain->create_proxy_for_type_method;
5004
5005                 if (im == NULL) {
5006                         MonoClass *klass = mono_class_get_activation_services_class ();
5007
5008                         if (!klass->inited)
5009                                 mono_class_init (klass);
5010
5011                         im = mono_class_get_method_from_name (klass, "CreateProxyForType", 1);
5012                         if (!im) {
5013                                 mono_error_set_not_supported (error, "Linked away.");
5014                                 return NULL;
5015                         }
5016                         vtable->domain->create_proxy_for_type_method = im;
5017                 }
5018
5019                 pa [0] = mono_type_get_object_checked (mono_domain_get (), &vtable->klass->byval_arg, error);
5020                 if (!mono_error_ok (error))
5021                         return NULL;
5022
5023                 o = mono_runtime_invoke_checked (im, NULL, pa, error);
5024                 if (!mono_error_ok (error))
5025                         return NULL;
5026
5027                 if (o != NULL)
5028                         return o;
5029         }
5030
5031         return mono_object_new_alloc_specific_checked (vtable, error);
5032 }
5033
5034 MonoObject *
5035 ves_icall_object_new_specific (MonoVTable *vtable)
5036 {
5037         MonoError error;
5038         MonoObject *o = mono_object_new_specific_checked (vtable, &error);
5039         mono_error_set_pending_exception (&error);
5040
5041         return o;
5042 }
5043
5044 /**
5045  * mono_object_new_alloc_specific:
5046  * @vtable: virtual table for the object.
5047  *
5048  * This function allocates a new `MonoObject` with the type derived
5049  * from the @vtable information.   If the class of this object has a
5050  * finalizer, then the object will be tracked for finalization.
5051  *
5052  * This method might raise an exception on errors.  Use the
5053  * `mono_object_new_fast_checked` method if you want to manually raise
5054  * the exception.
5055  *
5056  * Returns: the allocated object.
5057  */
5058 MonoObject *
5059 mono_object_new_alloc_specific (MonoVTable *vtable)
5060 {
5061         MonoError error;
5062         MonoObject *o = mono_object_new_alloc_specific_checked (vtable, &error);
5063         mono_error_cleanup (&error);
5064
5065         return o;
5066 }
5067
5068 /**
5069  * mono_object_new_alloc_specific_checked:
5070  * @vtable: virtual table for the object.
5071  * @error: holds the error return value.
5072  *
5073  * This function allocates a new `MonoObject` with the type derived
5074  * from the @vtable information. If the class of this object has a
5075  * finalizer, then the object will be tracked for finalization.
5076  *
5077  * If there is not enough memory, the @error parameter will be set
5078  * and will contain a user-visible message with the amount of bytes
5079  * that were requested.
5080  *
5081  * Returns: the allocated object, or NULL if there is not enough memory
5082  *
5083  */
5084 MonoObject *
5085 mono_object_new_alloc_specific_checked (MonoVTable *vtable, MonoError *error)
5086 {
5087         MONO_REQ_GC_UNSAFE_MODE;
5088
5089         MonoObject *o;
5090
5091         mono_error_init (error);
5092
5093         o = (MonoObject *)mono_gc_alloc_obj (vtable, vtable->klass->instance_size);
5094
5095         if (G_UNLIKELY (!o))
5096                 mono_error_set_out_of_memory (error, "Could not allocate %i bytes", vtable->klass->instance_size);
5097         else if (G_UNLIKELY (vtable->klass->has_finalize))
5098                 mono_object_register_finalizer (o, error);
5099
5100         return o;
5101 }
5102
5103 /**
5104  * mono_object_new_fast:
5105  * @vtable: virtual table for the object.
5106  *
5107  * This function allocates a new `MonoObject` with the type derived
5108  * from the @vtable information.   The returned object is not tracked
5109  * for finalization.   If your object implements a finalizer, you should
5110  * use `mono_object_new_alloc_specific` instead.
5111  *
5112  * This method might raise an exception on errors.  Use the
5113  * `mono_object_new_fast_checked` method if you want to manually raise
5114  * the exception.
5115  *
5116  * Returns: the allocated object.
5117  */
5118 MonoObject*
5119 mono_object_new_fast (MonoVTable *vtable)
5120 {
5121         MonoError error;
5122         MonoObject *o = mono_object_new_fast_checked (vtable, &error);
5123         mono_error_cleanup (&error);
5124
5125         return o;
5126 }
5127
5128 /**
5129  * mono_object_new_fast_checked:
5130  * @vtable: virtual table for the object.
5131  * @error: holds the error return value.
5132  *
5133  * This function allocates a new `MonoObject` with the type derived
5134  * from the @vtable information. The returned object is not tracked
5135  * for finalization.   If your object implements a finalizer, you should
5136  * use `mono_object_new_alloc_specific_checked` instead.
5137  *
5138  * If there is not enough memory, the @error parameter will be set
5139  * and will contain a user-visible message with the amount of bytes
5140  * that were requested.
5141  *
5142  * Returns: the allocated object, or NULL if there is not enough memory
5143  *
5144  */
5145 MonoObject*
5146 mono_object_new_fast_checked (MonoVTable *vtable, MonoError *error)
5147 {
5148         MONO_REQ_GC_UNSAFE_MODE;
5149
5150         MonoObject *o;
5151
5152         mono_error_init (error);
5153
5154         o = mono_gc_alloc_obj (vtable, vtable->klass->instance_size);
5155
5156         if (G_UNLIKELY (!o))
5157                 mono_error_set_out_of_memory (error, "Could not allocate %i bytes", vtable->klass->instance_size);
5158
5159         return o;
5160 }
5161
5162 MonoObject *
5163 ves_icall_object_new_fast (MonoVTable *vtable)
5164 {
5165         MonoError error;
5166         MonoObject *o = mono_object_new_fast_checked (vtable, &error);
5167         mono_error_set_pending_exception (&error);
5168
5169         return o;
5170 }
5171
5172 MonoObject*
5173 mono_object_new_mature (MonoVTable *vtable, MonoError *error)
5174 {
5175         MONO_REQ_GC_UNSAFE_MODE;
5176
5177         MonoObject *o;
5178
5179         mono_error_init (error);
5180
5181         o = mono_gc_alloc_mature (vtable, vtable->klass->instance_size);
5182
5183         if (G_UNLIKELY (!o))
5184                 mono_error_set_out_of_memory (error, "Could not allocate %i bytes", vtable->klass->instance_size);
5185         else if (G_UNLIKELY (vtable->klass->has_finalize))
5186                 mono_object_register_finalizer (o, error);
5187
5188         return o;
5189 }
5190
5191 /**
5192  * mono_class_get_allocation_ftn:
5193  * @vtable: vtable
5194  * @for_box: the object will be used for boxing
5195  * @pass_size_in_words:
5196  *
5197  * Return the allocation function appropriate for the given class.
5198  */
5199
5200 void*
5201 mono_class_get_allocation_ftn (MonoVTable *vtable, gboolean for_box, gboolean *pass_size_in_words)
5202 {
5203         MONO_REQ_GC_NEUTRAL_MODE;
5204
5205         *pass_size_in_words = FALSE;
5206
5207         if (mono_class_has_finalizer (vtable->klass) || mono_class_is_marshalbyref (vtable->klass) || (mono_profiler_get_events () & MONO_PROFILE_ALLOCATIONS))
5208                 return ves_icall_object_new_specific;
5209
5210         if (vtable->gc_descr != MONO_GC_DESCRIPTOR_NULL) {
5211
5212                 return ves_icall_object_new_fast;
5213
5214                 /*
5215                  * FIXME: This is actually slower than ves_icall_object_new_fast, because
5216                  * of the overhead of parameter passing.
5217                  */
5218                 /*
5219                 *pass_size_in_words = TRUE;
5220 #ifdef GC_REDIRECT_TO_LOCAL
5221                 return GC_local_gcj_fast_malloc;
5222 #else
5223                 return GC_gcj_fast_malloc;
5224 #endif
5225                 */
5226         }
5227
5228         return ves_icall_object_new_specific;
5229 }
5230
5231 /**
5232  * mono_object_new_from_token:
5233  * @image: Context where the type_token is hosted
5234  * @token: a token of the type that we want to create
5235  *
5236  * Returns: A newly created object whose definition is
5237  * looked up using @token in the @image image
5238  */
5239 MonoObject *
5240 mono_object_new_from_token  (MonoDomain *domain, MonoImage *image, guint32 token)
5241 {
5242         MONO_REQ_GC_UNSAFE_MODE;
5243
5244         MonoError error;
5245         MonoObject *result;
5246         MonoClass *klass;
5247
5248         klass = mono_class_get_checked (image, token, &error);
5249         mono_error_assert_ok (&error);
5250
5251         result = mono_object_new_checked (domain, klass, &error);
5252
5253         mono_error_cleanup (&error);
5254         return result;
5255
5256 }
5257
5258
5259 /**
5260  * mono_object_clone:
5261  * @obj: the object to clone
5262  *
5263  * Returns: A newly created object who is a shallow copy of @obj
5264  */
5265 MonoObject *
5266 mono_object_clone (MonoObject *obj)
5267 {
5268         MonoError error;
5269         MonoObject *o = mono_object_clone_checked (obj, &error);
5270         mono_error_cleanup (&error);
5271
5272         return o;
5273 }
5274
5275 MonoObject *
5276 mono_object_clone_checked (MonoObject *obj, MonoError *error)
5277 {
5278         MONO_REQ_GC_UNSAFE_MODE;
5279
5280         MonoObject *o;
5281         int size;
5282
5283         mono_error_init (error);
5284
5285         size = obj->vtable->klass->instance_size;
5286
5287         if (obj->vtable->klass->rank)
5288                 return (MonoObject*)mono_array_clone_checked ((MonoArray*)obj, error);
5289
5290         o = (MonoObject *)mono_gc_alloc_obj (obj->vtable, size);
5291
5292         if (G_UNLIKELY (!o)) {
5293                 mono_error_set_out_of_memory (error, "Could not allocate %i bytes", size);
5294                 return NULL;
5295         }
5296
5297         /* If the object doesn't contain references this will do a simple memmove. */
5298         mono_gc_wbarrier_object_copy (o, obj);
5299
5300         if (obj->vtable->klass->has_finalize)
5301                 mono_object_register_finalizer (o, error);
5302         return o;
5303 }
5304
5305 /**
5306  * mono_array_full_copy:
5307  * @src: source array to copy
5308  * @dest: destination array
5309  *
5310  * Copies the content of one array to another with exactly the same type and size.
5311  */
5312 void
5313 mono_array_full_copy (MonoArray *src, MonoArray *dest)
5314 {
5315         MONO_REQ_GC_UNSAFE_MODE;
5316
5317         uintptr_t size;
5318         MonoClass *klass = src->obj.vtable->klass;
5319
5320         g_assert (klass == dest->obj.vtable->klass);
5321
5322         size = mono_array_length (src);
5323         g_assert (size == mono_array_length (dest));
5324         size *= mono_array_element_size (klass);
5325 #ifdef HAVE_SGEN_GC
5326         if (klass->element_class->valuetype) {
5327                 if (klass->element_class->has_references)
5328                         mono_value_copy_array (dest, 0, mono_array_addr_with_size_fast (src, 0, 0), mono_array_length (src));
5329                 else
5330                         mono_gc_memmove_atomic (&dest->vector, &src->vector, size);
5331         } else {
5332                 mono_array_memcpy_refs (dest, 0, src, 0, mono_array_length (src));
5333         }
5334 #else
5335         mono_gc_memmove_atomic (&dest->vector, &src->vector, size);
5336 #endif
5337 }
5338
5339 /**
5340  * mono_array_clone_in_domain:
5341  * @domain: the domain in which the array will be cloned into
5342  * @array: the array to clone
5343  * @error: set on error
5344  *
5345  * This routine returns a copy of the array that is hosted on the
5346  * specified MonoDomain.  On failure returns NULL and sets @error.
5347  */
5348 MonoArray*
5349 mono_array_clone_in_domain (MonoDomain *domain, MonoArray *array, MonoError *error)
5350 {
5351         MONO_REQ_GC_UNSAFE_MODE;
5352
5353         MonoArray *o;
5354         uintptr_t size, i;
5355         uintptr_t *sizes;
5356         MonoClass *klass = array->obj.vtable->klass;
5357
5358         mono_error_init (error);
5359
5360         if (array->bounds == NULL) {
5361                 size = mono_array_length (array);
5362                 o = mono_array_new_full_checked (domain, klass, &size, NULL, error);
5363                 return_val_if_nok (error, NULL);
5364
5365                 size *= mono_array_element_size (klass);
5366 #ifdef HAVE_SGEN_GC
5367                 if (klass->element_class->valuetype) {
5368                         if (klass->element_class->has_references)
5369                                 mono_value_copy_array (o, 0, mono_array_addr_with_size_fast (array, 0, 0), mono_array_length (array));
5370                         else
5371                                 mono_gc_memmove_atomic (&o->vector, &array->vector, size);
5372                 } else {
5373                         mono_array_memcpy_refs (o, 0, array, 0, mono_array_length (array));
5374                 }
5375 #else
5376                 mono_gc_memmove_atomic (&o->vector, &array->vector, size);
5377 #endif
5378                 return o;
5379         }
5380
5381         sizes = (uintptr_t *)alloca (klass->rank * sizeof(intptr_t) * 2);
5382         size = mono_array_element_size (klass);
5383         for (i = 0; i < klass->rank; ++i) {
5384                 sizes [i] = array->bounds [i].length;
5385                 size *= array->bounds [i].length;
5386                 sizes [i + klass->rank] = array->bounds [i].lower_bound;
5387         }
5388         o = mono_array_new_full_checked (domain, klass, sizes, (intptr_t*)sizes + klass->rank, error);
5389         return_val_if_nok (error, NULL);
5390 #ifdef HAVE_SGEN_GC
5391         if (klass->element_class->valuetype) {
5392                 if (klass->element_class->has_references)
5393                         mono_value_copy_array (o, 0, mono_array_addr_with_size_fast (array, 0, 0), mono_array_length (array));
5394                 else
5395                         mono_gc_memmove_atomic (&o->vector, &array->vector, size);
5396         } else {
5397                 mono_array_memcpy_refs (o, 0, array, 0, mono_array_length (array));
5398         }
5399 #else
5400         mono_gc_memmove_atomic (&o->vector, &array->vector, size);
5401 #endif
5402
5403         return o;
5404 }
5405
5406 /**
5407  * mono_array_clone:
5408  * @array: the array to clone
5409  *
5410  * Returns: A newly created array who is a shallow copy of @array
5411  */
5412 MonoArray*
5413 mono_array_clone (MonoArray *array)
5414 {
5415         MONO_REQ_GC_UNSAFE_MODE;
5416
5417         MonoError error;
5418         MonoArray *result = mono_array_clone_checked (array, &error);
5419         mono_error_cleanup (&error);
5420         return result;
5421 }
5422
5423 /**
5424  * mono_array_clone_checked:
5425  * @array: the array to clone
5426  * @error: set on error
5427  *
5428  * Returns: A newly created array who is a shallow copy of @array.  On
5429  * failure returns NULL and sets @error.
5430  */
5431 MonoArray*
5432 mono_array_clone_checked (MonoArray *array, MonoError *error)
5433 {
5434
5435         MONO_REQ_GC_UNSAFE_MODE;
5436         return mono_array_clone_in_domain (((MonoObject *)array)->vtable->domain, array, error);
5437 }
5438
5439 /* helper macros to check for overflow when calculating the size of arrays */
5440 #ifdef MONO_BIG_ARRAYS
5441 #define MYGUINT64_MAX 0x0000FFFFFFFFFFFFUL
5442 #define MYGUINT_MAX MYGUINT64_MAX
5443 #define CHECK_ADD_OVERFLOW_UN(a,b) \
5444             (G_UNLIKELY ((guint64)(MYGUINT64_MAX) - (guint64)(b) < (guint64)(a)))
5445 #define CHECK_MUL_OVERFLOW_UN(a,b) \
5446             (G_UNLIKELY (((guint64)(a) > 0) && ((guint64)(b) > 0) &&    \
5447                                          ((guint64)(b) > ((MYGUINT64_MAX) / (guint64)(a)))))
5448 #else
5449 #define MYGUINT32_MAX 4294967295U
5450 #define MYGUINT_MAX MYGUINT32_MAX
5451 #define CHECK_ADD_OVERFLOW_UN(a,b) \
5452             (G_UNLIKELY ((guint32)(MYGUINT32_MAX) - (guint32)(b) < (guint32)(a)))
5453 #define CHECK_MUL_OVERFLOW_UN(a,b) \
5454             (G_UNLIKELY (((guint32)(a) > 0) && ((guint32)(b) > 0) &&                    \
5455                                          ((guint32)(b) > ((MYGUINT32_MAX) / (guint32)(a)))))
5456 #endif
5457
5458 gboolean
5459 mono_array_calc_byte_len (MonoClass *klass, uintptr_t len, uintptr_t *res)
5460 {
5461         MONO_REQ_GC_NEUTRAL_MODE;
5462
5463         uintptr_t byte_len;
5464
5465         byte_len = mono_array_element_size (klass);
5466         if (CHECK_MUL_OVERFLOW_UN (byte_len, len))
5467                 return FALSE;
5468         byte_len *= len;
5469         if (CHECK_ADD_OVERFLOW_UN (byte_len, MONO_SIZEOF_MONO_ARRAY))
5470                 return FALSE;
5471         byte_len += MONO_SIZEOF_MONO_ARRAY;
5472
5473         *res = byte_len;
5474
5475         return TRUE;
5476 }
5477
5478 /**
5479  * mono_array_new_full:
5480  * @domain: domain where the object is created
5481  * @array_class: array class
5482  * @lengths: lengths for each dimension in the array
5483  * @lower_bounds: lower bounds for each dimension in the array (may be NULL)
5484  *
5485  * This routine creates a new array objects with the given dimensions,
5486  * lower bounds and type.
5487  */
5488 MonoArray*
5489 mono_array_new_full (MonoDomain *domain, MonoClass *array_class, uintptr_t *lengths, intptr_t *lower_bounds)
5490 {
5491         MonoError error;
5492         MonoArray *array = mono_array_new_full_checked (domain, array_class, lengths, lower_bounds, &error);
5493         mono_error_cleanup (&error);
5494
5495         return array;
5496 }
5497
5498 MonoArray*
5499 mono_array_new_full_checked (MonoDomain *domain, MonoClass *array_class, uintptr_t *lengths, intptr_t *lower_bounds, MonoError *error)
5500 {
5501         MONO_REQ_GC_UNSAFE_MODE;
5502
5503         uintptr_t byte_len = 0, len, bounds_size;
5504         MonoObject *o;
5505         MonoArray *array;
5506         MonoArrayBounds *bounds;
5507         MonoVTable *vtable;
5508         int i;
5509
5510         mono_error_init (error);
5511
5512         if (!array_class->inited)
5513                 mono_class_init (array_class);
5514
5515         len = 1;
5516
5517         /* A single dimensional array with a 0 lower bound is the same as an szarray */
5518         if (array_class->rank == 1 && ((array_class->byval_arg.type == MONO_TYPE_SZARRAY) || (lower_bounds && lower_bounds [0] == 0))) {
5519                 len = lengths [0];
5520                 if (len > MONO_ARRAY_MAX_INDEX) {
5521                         mono_error_set_generic_error (error, "System", "OverflowException", "");
5522                         return NULL;
5523                 }
5524                 bounds_size = 0;
5525         } else {
5526                 bounds_size = sizeof (MonoArrayBounds) * array_class->rank;
5527
5528                 for (i = 0; i < array_class->rank; ++i) {
5529                         if (lengths [i] > MONO_ARRAY_MAX_INDEX) {
5530                                 mono_error_set_generic_error (error, "System", "OverflowException", "");
5531                                 return NULL;
5532                         }
5533                         if (CHECK_MUL_OVERFLOW_UN (len, lengths [i])) {
5534                                 mono_error_set_out_of_memory (error, "Could not allocate %i bytes", MONO_ARRAY_MAX_SIZE);
5535                                 return NULL;
5536                         }
5537                         len *= lengths [i];
5538                 }
5539         }
5540
5541         if (!mono_array_calc_byte_len (array_class, len, &byte_len)) {
5542                 mono_error_set_out_of_memory (error, "Could not allocate %i bytes", MONO_ARRAY_MAX_SIZE);
5543                 return NULL;
5544         }
5545
5546         if (bounds_size) {
5547                 /* align */
5548                 if (CHECK_ADD_OVERFLOW_UN (byte_len, 3)) {
5549                         mono_error_set_out_of_memory (error, "Could not allocate %i bytes", MONO_ARRAY_MAX_SIZE);
5550                         return NULL;
5551                 }
5552                 byte_len = (byte_len + 3) & ~3;
5553                 if (CHECK_ADD_OVERFLOW_UN (byte_len, bounds_size)) {
5554                         mono_error_set_out_of_memory (error, "Could not allocate %i bytes", MONO_ARRAY_MAX_SIZE);
5555                         return NULL;
5556                 }
5557                 byte_len += bounds_size;
5558         }
5559         /*
5560          * Following three lines almost taken from mono_object_new ():
5561          * they need to be kept in sync.
5562          */
5563         vtable = mono_class_vtable_full (domain, array_class, error);
5564         return_val_if_nok (error, NULL);
5565
5566         if (bounds_size)
5567                 o = (MonoObject *)mono_gc_alloc_array (vtable, byte_len, len, bounds_size);
5568         else
5569                 o = (MonoObject *)mono_gc_alloc_vector (vtable, byte_len, len);
5570
5571         if (G_UNLIKELY (!o)) {
5572                 mono_error_set_out_of_memory (error, "Could not allocate %i bytes", byte_len);
5573                 return NULL;
5574         }
5575
5576         array = (MonoArray*)o;
5577
5578         bounds = array->bounds;
5579
5580         if (bounds_size) {
5581                 for (i = 0; i < array_class->rank; ++i) {
5582                         bounds [i].length = lengths [i];
5583                         if (lower_bounds)
5584                                 bounds [i].lower_bound = lower_bounds [i];
5585                 }
5586         }
5587
5588         return array;
5589 }
5590
5591 /**
5592  * mono_array_new:
5593  * @domain: domain where the object is created
5594  * @eclass: element class
5595  * @n: number of array elements
5596  *
5597  * This routine creates a new szarray with @n elements of type @eclass.
5598  */
5599 MonoArray *
5600 mono_array_new (MonoDomain *domain, MonoClass *eclass, uintptr_t n)
5601 {
5602         MONO_REQ_GC_UNSAFE_MODE;
5603
5604         MonoError error;
5605         MonoArray *result = mono_array_new_checked (domain, eclass, n, &error);
5606         mono_error_cleanup (&error);
5607         return result;
5608 }
5609
5610 /**
5611  * mono_array_new_checked:
5612  * @domain: domain where the object is created
5613  * @eclass: element class
5614  * @n: number of array elements
5615  * @error: set on error
5616  *
5617  * This routine creates a new szarray with @n elements of type @eclass.
5618  * On failure returns NULL and sets @error.
5619  */
5620 MonoArray *
5621 mono_array_new_checked (MonoDomain *domain, MonoClass *eclass, uintptr_t n, MonoError *error)
5622 {
5623         MonoClass *ac;
5624
5625         mono_error_init (error);
5626
5627         ac = mono_array_class_get (eclass, 1);
5628         g_assert (ac);
5629
5630         MonoVTable *vtable = mono_class_vtable_full (domain, ac, error);
5631         return_val_if_nok (error, NULL);
5632
5633         return mono_array_new_specific_checked (vtable, n, error);
5634 }
5635
5636 MonoArray*
5637 ves_icall_array_new (MonoDomain *domain, MonoClass *eclass, uintptr_t n)
5638 {
5639         MonoError error;
5640         MonoArray *arr = mono_array_new_checked (domain, eclass, n, &error);
5641         mono_error_set_pending_exception (&error);
5642
5643         return arr;
5644 }
5645
5646 /**
5647  * mono_array_new_specific:
5648  * @vtable: a vtable in the appropriate domain for an initialized class
5649  * @n: number of array elements
5650  *
5651  * This routine is a fast alternative to mono_array_new() for code which
5652  * can be sure about the domain it operates in.
5653  */
5654 MonoArray *
5655 mono_array_new_specific (MonoVTable *vtable, uintptr_t n)
5656 {
5657         MonoError error;
5658         MonoArray *arr = mono_array_new_specific_checked (vtable, n, &error);
5659         mono_error_cleanup (&error);
5660
5661         return arr;
5662 }
5663
5664 MonoArray*
5665 mono_array_new_specific_checked (MonoVTable *vtable, uintptr_t n, MonoError *error)
5666 {
5667         MONO_REQ_GC_UNSAFE_MODE;
5668
5669         MonoObject *o;
5670         uintptr_t byte_len;
5671
5672         mono_error_init (error);
5673
5674         if (G_UNLIKELY (n > MONO_ARRAY_MAX_INDEX)) {
5675                 mono_error_set_generic_error (error, "System", "OverflowException", "");
5676                 return NULL;
5677         }
5678
5679         if (!mono_array_calc_byte_len (vtable->klass, n, &byte_len)) {
5680                 mono_error_set_out_of_memory (error, "Could not allocate %i bytes", MONO_ARRAY_MAX_SIZE);
5681                 return NULL;
5682         }
5683         o = (MonoObject *)mono_gc_alloc_vector (vtable, byte_len, n);
5684
5685         if (G_UNLIKELY (!o)) {
5686                 mono_error_set_out_of_memory (error, "Could not allocate %i bytes", byte_len);
5687                 return NULL;
5688         }
5689
5690         return (MonoArray*)o;
5691 }
5692
5693 MonoArray*
5694 ves_icall_array_new_specific (MonoVTable *vtable, uintptr_t n)
5695 {
5696         MonoError error;
5697         MonoArray *arr = mono_array_new_specific_checked (vtable, n, &error);
5698         mono_error_set_pending_exception (&error);
5699
5700         return arr;
5701 }
5702
5703 /**
5704  * mono_string_new_utf16:
5705  * @text: a pointer to an utf16 string
5706  * @len: the length of the string
5707  *
5708  * Returns: A newly created string object which contains @text.
5709  */
5710 MonoString *
5711 mono_string_new_utf16 (MonoDomain *domain, const guint16 *text, gint32 len)
5712 {
5713         MONO_REQ_GC_UNSAFE_MODE;
5714
5715         MonoError error;
5716         MonoString *res = NULL;
5717         res = mono_string_new_utf16_checked (domain, text, len, &error);
5718         mono_error_cleanup (&error);
5719
5720         return res;
5721 }
5722
5723 /**
5724  * mono_string_new_utf16_checked:
5725  * @text: a pointer to an utf16 string
5726  * @len: the length of the string
5727  * @error: written on error.
5728  *
5729  * Returns: A newly created string object which contains @text.
5730  * On error, returns NULL and sets @error.
5731  */
5732 MonoString *
5733 mono_string_new_utf16_checked (MonoDomain *domain, const guint16 *text, gint32 len, MonoError *error)
5734 {
5735         MONO_REQ_GC_UNSAFE_MODE;
5736
5737         MonoString *s;
5738
5739         mono_error_init (error);
5740
5741         s = mono_string_new_size_checked (domain, len, error);
5742         if (s != NULL)
5743                 memcpy (mono_string_chars (s), text, len * 2);
5744
5745         return s;
5746 }
5747
5748 /**
5749  * mono_string_new_utf32:
5750  * @text: a pointer to an utf32 string
5751  * @len: the length of the string
5752  * @error: set on failure.
5753  *
5754  * Returns: A newly created string object which contains @text. On failure returns NULL and sets @error.
5755  */
5756 static MonoString *
5757 mono_string_new_utf32_checked (MonoDomain *domain, const mono_unichar4 *text, gint32 len, MonoError *error)
5758 {
5759         MONO_REQ_GC_UNSAFE_MODE;
5760
5761         MonoString *s;
5762         mono_unichar2 *utf16_output = NULL;
5763         gint32 utf16_len = 0;
5764         GError *gerror = NULL;
5765         glong items_written;
5766
5767         mono_error_init (error);
5768         utf16_output = g_ucs4_to_utf16 (text, len, NULL, &items_written, &gerror);
5769
5770         if (gerror)
5771                 g_error_free (gerror);
5772
5773         while (utf16_output [utf16_len]) utf16_len++;
5774
5775         s = mono_string_new_size_checked (domain, utf16_len, error);
5776         return_val_if_nok (error, NULL);
5777
5778         memcpy (mono_string_chars (s), utf16_output, utf16_len * 2);
5779
5780         g_free (utf16_output);
5781
5782         return s;
5783 }
5784
5785 /**
5786  * mono_string_new_utf32:
5787  * @text: a pointer to an utf32 string
5788  * @len: the length of the string
5789  *
5790  * Returns: A newly created string object which contains @text.
5791  */
5792 MonoString *
5793 mono_string_new_utf32 (MonoDomain *domain, const mono_unichar4 *text, gint32 len)
5794 {
5795         MonoError error;
5796         MonoString *result = mono_string_new_utf32_checked (domain, text, len, &error);
5797         mono_error_cleanup (&error);
5798         return result;
5799 }
5800
5801 /**
5802  * mono_string_new_size:
5803  * @text: a pointer to an utf16 string
5804  * @len: the length of the string
5805  *
5806  * Returns: A newly created string object of @len
5807  */
5808 MonoString *
5809 mono_string_new_size (MonoDomain *domain, gint32 len)
5810 {
5811         MonoError error;
5812         MonoString *str = mono_string_new_size_checked (domain, len, &error);
5813         mono_error_cleanup (&error);
5814
5815         return str;
5816 }
5817
5818 MonoString *
5819 mono_string_new_size_checked (MonoDomain *domain, gint32 len, MonoError *error)
5820 {
5821         MONO_REQ_GC_UNSAFE_MODE;
5822
5823         MonoString *s;
5824         MonoVTable *vtable;
5825         size_t size;
5826
5827         mono_error_init (error);
5828
5829         /* check for overflow */
5830         if (len < 0 || len > ((SIZE_MAX - G_STRUCT_OFFSET (MonoString, chars) - 8) / 2)) {
5831                 mono_error_set_out_of_memory (error, "Could not allocate %i bytes", -1);
5832                 return NULL;
5833         }
5834
5835         size = (G_STRUCT_OFFSET (MonoString, chars) + (((size_t)len + 1) * 2));
5836         g_assert (size > 0);
5837
5838         vtable = mono_class_vtable (domain, mono_defaults.string_class);
5839         g_assert (vtable);
5840
5841         s = (MonoString *)mono_gc_alloc_string (vtable, size, len);
5842
5843         if (G_UNLIKELY (!s)) {
5844                 mono_error_set_out_of_memory (error, "Could not allocate %i bytes", size);
5845                 return NULL;
5846         }
5847
5848         return s;
5849 }
5850
5851 /**
5852  * mono_string_new_len:
5853  * @text: a pointer to an utf8 string
5854  * @length: number of bytes in @text to consider
5855  *
5856  * Returns: A newly created string object which contains @text.
5857  */
5858 MonoString*
5859 mono_string_new_len (MonoDomain *domain, const char *text, guint length)
5860 {
5861         MONO_REQ_GC_UNSAFE_MODE;
5862
5863         MonoError error;
5864         MonoString *result = mono_string_new_len_checked (domain, text, length, &error);
5865         mono_error_cleanup (&error);
5866         return result;
5867 }
5868
5869 /**
5870  * mono_string_new_len_checked:
5871  * @text: a pointer to an utf8 string
5872  * @length: number of bytes in @text to consider
5873  * @error: set on error
5874  *
5875  * Returns: A newly created string object which contains @text. On
5876  * failure returns NULL and sets @error.
5877  */
5878 MonoString*
5879 mono_string_new_len_checked (MonoDomain *domain, const char *text, guint length, MonoError *error)
5880 {
5881         MONO_REQ_GC_UNSAFE_MODE;
5882
5883         mono_error_init (error);
5884
5885         GError *eg_error = NULL;
5886         MonoString *o = NULL;
5887         guint16 *ut = NULL;
5888         glong items_written;
5889
5890         ut = eg_utf8_to_utf16_with_nuls (text, length, NULL, &items_written, &eg_error);
5891
5892         if (!eg_error)
5893                 o = mono_string_new_utf16_checked (domain, ut, items_written, error);
5894         else
5895                 g_error_free (eg_error);
5896
5897         g_free (ut);
5898
5899         return o;
5900 }
5901
5902 /**
5903  * mono_string_new:
5904  * @text: a pointer to an utf8 string
5905  *
5906  * Returns: A newly created string object which contains @text.
5907  *
5908  * This function asserts if it cannot allocate a new string.
5909  *
5910  * @deprecated Use mono_string_new_checked in new code.
5911  */
5912 MonoString*
5913 mono_string_new (MonoDomain *domain, const char *text)
5914 {
5915         MonoError error;
5916         MonoString *res = NULL;
5917         res = mono_string_new_checked (domain, text, &error);
5918         mono_error_assert_ok (&error);
5919         return res;
5920 }
5921
5922 /**
5923  * mono_string_new_checked:
5924  * @text: a pointer to an utf8 string
5925  * @merror: set on error
5926  *
5927  * Returns: A newly created string object which contains @text.
5928  * On error returns NULL and sets @merror.
5929  */
5930 MonoString*
5931 mono_string_new_checked (MonoDomain *domain, const char *text, MonoError *error)
5932 {
5933         MONO_REQ_GC_UNSAFE_MODE;
5934
5935     GError *eg_error = NULL;
5936     MonoString *o = NULL;
5937     guint16 *ut;
5938     glong items_written;
5939     int l;
5940
5941     mono_error_init (error);
5942
5943     l = strlen (text);
5944
5945     ut = g_utf8_to_utf16 (text, l, NULL, &items_written, &eg_error);
5946
5947     if (!eg_error)
5948             o = mono_string_new_utf16_checked (domain, ut, items_written, error);
5949     else
5950         g_error_free (eg_error);
5951
5952     g_free (ut);
5953
5954 /*FIXME g_utf8_get_char, g_utf8_next_char and g_utf8_validate are not part of eglib.*/
5955 #if 0
5956         gunichar2 *str;
5957         const gchar *end;
5958         int len;
5959         MonoString *o = NULL;
5960
5961         if (!g_utf8_validate (text, -1, &end)) {
5962                 mono_error_set_argument (error, "text", "Not a valid utf8 string");
5963                 goto leave;
5964         }
5965
5966         len = g_utf8_strlen (text, -1);
5967         o = mono_string_new_size_checked (domain, len, error);
5968         if (!o)
5969                 goto leave;
5970         str = mono_string_chars (o);
5971
5972         while (text < end) {
5973                 *str++ = g_utf8_get_char (text);
5974                 text = g_utf8_next_char (text);
5975         }
5976
5977 leave:
5978 #endif
5979         return o;
5980 }
5981
5982 /**
5983  * mono_string_new_wrapper:
5984  * @text: pointer to utf8 characters.
5985  *
5986  * Helper function to create a string object from @text in the current domain.
5987  */
5988 MonoString*
5989 mono_string_new_wrapper (const char *text)
5990 {
5991         MONO_REQ_GC_UNSAFE_MODE;
5992
5993         MonoDomain *domain = mono_domain_get ();
5994
5995         if (text)
5996                 return mono_string_new (domain, text);
5997
5998         return NULL;
5999 }
6000
6001 /**
6002  * mono_value_box:
6003  * @class: the class of the value
6004  * @value: a pointer to the unboxed data
6005  *
6006  * Returns: A newly created object which contains @value.
6007  */
6008 MonoObject *
6009 mono_value_box (MonoDomain *domain, MonoClass *klass, gpointer value)
6010 {
6011         MonoError error;
6012         MonoObject *result = mono_value_box_checked (domain, klass, value, &error);
6013         mono_error_cleanup (&error);
6014         return result;
6015 }
6016
6017 /**
6018  * mono_value_box_checked:
6019  * @domain: the domain of the new object
6020  * @class: the class of the value
6021  * @value: a pointer to the unboxed data
6022  * @error: set on error
6023  *
6024  * Returns: A newly created object which contains @value. On failure
6025  * returns NULL and sets @error.
6026  */
6027 MonoObject *
6028 mono_value_box_checked (MonoDomain *domain, MonoClass *klass, gpointer value, MonoError *error)
6029 {
6030         MONO_REQ_GC_UNSAFE_MODE;
6031         MonoObject *res;
6032         int size;
6033         MonoVTable *vtable;
6034
6035         mono_error_init (error);
6036
6037         g_assert (klass->valuetype);
6038         if (mono_class_is_nullable (klass))
6039                 return mono_nullable_box ((guint8 *)value, klass, error);
6040
6041         vtable = mono_class_vtable (domain, klass);
6042         if (!vtable)
6043                 return NULL;
6044         size = mono_class_instance_size (klass);
6045         res = mono_object_new_alloc_specific_checked (vtable, error);
6046         return_val_if_nok (error, NULL);
6047
6048         size = size - sizeof (MonoObject);
6049
6050 #ifdef HAVE_SGEN_GC
6051         g_assert (size == mono_class_value_size (klass, NULL));
6052         mono_gc_wbarrier_value_copy ((char *)res + sizeof (MonoObject), value, 1, klass);
6053 #else
6054 #if NO_UNALIGNED_ACCESS
6055         mono_gc_memmove_atomic ((char *)res + sizeof (MonoObject), value, size);
6056 #else
6057         switch (size) {
6058         case 1:
6059                 *((guint8 *) res + sizeof (MonoObject)) = *(guint8 *) value;
6060                 break;
6061         case 2:
6062                 *(guint16 *)((guint8 *) res + sizeof (MonoObject)) = *(guint16 *) value;
6063                 break;
6064         case 4:
6065                 *(guint32 *)((guint8 *) res + sizeof (MonoObject)) = *(guint32 *) value;
6066                 break;
6067         case 8:
6068                 *(guint64 *)((guint8 *) res + sizeof (MonoObject)) = *(guint64 *) value;
6069                 break;
6070         default:
6071                 mono_gc_memmove_atomic ((char *)res + sizeof (MonoObject), value, size);
6072         }
6073 #endif
6074 #endif
6075         if (klass->has_finalize) {
6076                 mono_object_register_finalizer (res, error);
6077                 return_val_if_nok (error, NULL);
6078         }
6079         return res;
6080 }
6081
6082 /**
6083  * mono_value_copy:
6084  * @dest: destination pointer
6085  * @src: source pointer
6086  * @klass: a valuetype class
6087  *
6088  * Copy a valuetype from @src to @dest. This function must be used
6089  * when @klass contains references fields.
6090  */
6091 void
6092 mono_value_copy (gpointer dest, gpointer src, MonoClass *klass)
6093 {
6094         MONO_REQ_GC_UNSAFE_MODE;
6095
6096         mono_gc_wbarrier_value_copy (dest, src, 1, klass);
6097 }
6098
6099 /**
6100  * mono_value_copy_array:
6101  * @dest: destination array
6102  * @dest_idx: index in the @dest array
6103  * @src: source pointer
6104  * @count: number of items
6105  *
6106  * Copy @count valuetype items from @src to the array @dest at index @dest_idx.
6107  * This function must be used when @klass contains references fields.
6108  * Overlap is handled.
6109  */
6110 void
6111 mono_value_copy_array (MonoArray *dest, int dest_idx, gpointer src, int count)
6112 {
6113         MONO_REQ_GC_UNSAFE_MODE;
6114
6115         int size = mono_array_element_size (dest->obj.vtable->klass);
6116         char *d = mono_array_addr_with_size_fast (dest, size, dest_idx);
6117         g_assert (size == mono_class_value_size (mono_object_class (dest)->element_class, NULL));
6118         mono_gc_wbarrier_value_copy (d, src, count, mono_object_class (dest)->element_class);
6119 }
6120
6121 /**
6122  * mono_object_get_domain:
6123  * @obj: object to query
6124  *
6125  * Returns: the MonoDomain where the object is hosted
6126  */
6127 MonoDomain*
6128 mono_object_get_domain (MonoObject *obj)
6129 {
6130         MONO_REQ_GC_UNSAFE_MODE;
6131
6132         return mono_object_domain (obj);
6133 }
6134
6135 /**
6136  * mono_object_get_class:
6137  * @obj: object to query
6138  *
6139  * Use this function to obtain the `MonoClass*` for a given `MonoObject`.
6140  *
6141  * Returns: the MonoClass of the object.
6142  */
6143 MonoClass*
6144 mono_object_get_class (MonoObject *obj)
6145 {
6146         MONO_REQ_GC_UNSAFE_MODE;
6147
6148         return mono_object_class (obj);
6149 }
6150 /**
6151  * mono_object_get_size:
6152  * @o: object to query
6153  *
6154  * Returns: the size, in bytes, of @o
6155  */
6156 guint
6157 mono_object_get_size (MonoObject* o)
6158 {
6159         MONO_REQ_GC_UNSAFE_MODE;
6160
6161         MonoClass* klass = mono_object_class (o);
6162         if (klass == mono_defaults.string_class) {
6163                 return sizeof (MonoString) + 2 * mono_string_length ((MonoString*) o) + 2;
6164         } else if (o->vtable->rank) {
6165                 MonoArray *array = (MonoArray*)o;
6166                 size_t size = MONO_SIZEOF_MONO_ARRAY + mono_array_element_size (klass) * mono_array_length (array);
6167                 if (array->bounds) {
6168                         size += 3;
6169                         size &= ~3;
6170                         size += sizeof (MonoArrayBounds) * o->vtable->rank;
6171                 }
6172                 return size;
6173         } else {
6174                 return mono_class_instance_size (klass);
6175         }
6176 }
6177
6178 /**
6179  * mono_object_unbox:
6180  * @obj: object to unbox
6181  *
6182  * Returns: a pointer to the start of the valuetype boxed in this
6183  * object.
6184  *
6185  * This method will assert if the object passed is not a valuetype.
6186  */
6187 gpointer
6188 mono_object_unbox (MonoObject *obj)
6189 {
6190         MONO_REQ_GC_UNSAFE_MODE;
6191
6192         /* add assert for valuetypes? */
6193         g_assert (obj->vtable->klass->valuetype);
6194         return ((char*)obj) + sizeof (MonoObject);
6195 }
6196
6197 /**
6198  * mono_object_isinst:
6199  * @obj: an object
6200  * @klass: a pointer to a class
6201  *
6202  * Returns: @obj if @obj is derived from @klass or NULL otherwise.
6203  */
6204 MonoObject *
6205 mono_object_isinst (MonoObject *obj, MonoClass *klass)
6206 {
6207         MONO_REQ_GC_UNSAFE_MODE;
6208
6209         MonoError error;
6210         MonoObject *result = mono_object_isinst_checked (obj, klass, &error);
6211         mono_error_cleanup (&error);
6212         return result;
6213 }
6214
6215
6216 /**
6217  * mono_object_isinst_checked:
6218  * @obj: an object
6219  * @klass: a pointer to a class
6220  * @error: set on error
6221  *
6222  * Returns: @obj if @obj is derived from @klass or NULL if it isn't.
6223  * On failure returns NULL and sets @error.
6224  */
6225 MonoObject *
6226 mono_object_isinst_checked (MonoObject *obj, MonoClass *klass, MonoError *error)
6227 {
6228         MONO_REQ_GC_UNSAFE_MODE;
6229
6230         mono_error_init (error);
6231
6232         MonoObject *result = NULL;
6233
6234         if (!klass->inited)
6235                 mono_class_init (klass);
6236
6237         if (mono_class_is_marshalbyref (klass) || (klass->flags & TYPE_ATTRIBUTE_INTERFACE)) {
6238                 result = mono_object_isinst_mbyref_checked (obj, klass, error);
6239                 return result;
6240         }
6241
6242         if (!obj)
6243                 return NULL;
6244
6245         return mono_class_is_assignable_from (klass, obj->vtable->klass) ? obj : NULL;
6246 }
6247
6248 MonoObject *
6249 mono_object_isinst_mbyref (MonoObject *obj, MonoClass *klass)
6250 {
6251         MONO_REQ_GC_UNSAFE_MODE;
6252
6253         MonoError error;
6254         MonoObject *result = mono_object_isinst_mbyref_checked (obj, klass, &error);
6255         mono_error_cleanup (&error); /* FIXME better API that doesn't swallow the error */
6256         return result;
6257 }
6258
6259 MonoObject *
6260 mono_object_isinst_mbyref_checked (MonoObject *obj, MonoClass *klass, MonoError *error)
6261 {
6262         MONO_REQ_GC_UNSAFE_MODE;
6263
6264         MonoVTable *vt;
6265
6266         mono_error_init (error);
6267
6268         if (!obj)
6269                 return NULL;
6270
6271         vt = obj->vtable;
6272
6273         if (klass->flags & TYPE_ATTRIBUTE_INTERFACE) {
6274                 if (MONO_VTABLE_IMPLEMENTS_INTERFACE (vt, klass->interface_id)) {
6275                         return obj;
6276                 }
6277
6278                 /*If the above check fails we are in the slow path of possibly raising an exception. So it's ok to it this way.*/
6279                 if (mono_class_has_variant_generic_params (klass) && mono_class_is_assignable_from (klass, obj->vtable->klass))
6280                         return obj;
6281         } else {
6282                 MonoClass *oklass = vt->klass;
6283                 if (mono_class_is_transparent_proxy (oklass))
6284                         oklass = ((MonoTransparentProxy *)obj)->remote_class->proxy_class;
6285
6286                 mono_class_setup_supertypes (klass);
6287                 if ((oklass->idepth >= klass->idepth) && (oklass->supertypes [klass->idepth - 1] == klass))
6288                         return obj;
6289         }
6290 #ifndef DISABLE_REMOTING
6291         if (vt->klass == mono_defaults.transparent_proxy_class && ((MonoTransparentProxy *)obj)->custom_type_info)
6292         {
6293                 MonoDomain *domain = mono_domain_get ();
6294                 MonoObject *res;
6295                 MonoObject *rp = (MonoObject *)((MonoTransparentProxy *)obj)->rp;
6296                 MonoClass *rpklass = mono_defaults.iremotingtypeinfo_class;
6297                 MonoMethod *im = NULL;
6298                 gpointer pa [2];
6299
6300                 im = mono_class_get_method_from_name (rpklass, "CanCastTo", -1);
6301                 if (!im) {
6302                         mono_error_set_not_supported (error, "Linked away.");
6303                         return NULL;
6304                 }
6305                 im = mono_object_get_virtual_method (rp, im);
6306                 g_assert (im);
6307
6308                 pa [0] = mono_type_get_object_checked (domain, &klass->byval_arg, error);
6309                 return_val_if_nok (error, NULL);
6310                 pa [1] = obj;
6311
6312                 res = mono_runtime_invoke_checked (im, rp, pa, error);
6313                 return_val_if_nok (error, NULL);
6314
6315                 if (*(MonoBoolean *) mono_object_unbox(res)) {
6316                         /* Update the vtable of the remote type, so it can safely cast to this new type */
6317                         mono_upgrade_remote_class (domain, obj, klass);
6318                         return obj;
6319                 }
6320         }
6321 #endif /* DISABLE_REMOTING */
6322         return NULL;
6323 }
6324
6325 /**
6326  * mono_object_castclass_mbyref:
6327  * @obj: an object
6328  * @klass: a pointer to a class
6329  *
6330  * Returns: @obj if @obj is derived from @klass, returns NULL otherwise.
6331  */
6332 MonoObject *
6333 mono_object_castclass_mbyref (MonoObject *obj, MonoClass *klass)
6334 {
6335         MONO_REQ_GC_UNSAFE_MODE;
6336         MonoError error;
6337
6338         if (!obj) return NULL;
6339         if (mono_object_isinst_mbyref_checked (obj, klass, &error)) return obj;
6340         mono_error_cleanup (&error);
6341         return NULL;
6342 }
6343
6344 typedef struct {
6345         MonoDomain *orig_domain;
6346         MonoString *ins;
6347         MonoString *res;
6348 } LDStrInfo;
6349
6350 static void
6351 str_lookup (MonoDomain *domain, gpointer user_data)
6352 {
6353         MONO_REQ_GC_UNSAFE_MODE;
6354
6355         LDStrInfo *info = (LDStrInfo *)user_data;
6356         if (info->res || domain == info->orig_domain)
6357                 return;
6358         info->res = (MonoString *)mono_g_hash_table_lookup (domain->ldstr_table, info->ins);
6359 }
6360
6361 static MonoString*
6362 mono_string_get_pinned (MonoString *str, MonoError *error)
6363 {
6364         MONO_REQ_GC_UNSAFE_MODE;
6365
6366         mono_error_init (error);
6367
6368         /* We only need to make a pinned version of a string if this is a moving GC */
6369         if (!mono_gc_is_moving ())
6370                 return str;
6371         int size;
6372         MonoString *news;
6373         size = sizeof (MonoString) + 2 * (mono_string_length (str) + 1);
6374         news = (MonoString *)mono_gc_alloc_pinned_obj (((MonoObject*)str)->vtable, size);
6375         if (news) {
6376                 memcpy (mono_string_chars (news), mono_string_chars (str), mono_string_length (str) * 2);
6377                 news->length = mono_string_length (str);
6378         } else {
6379                 mono_error_set_out_of_memory (error, "Could not allocate %i bytes", size);
6380         }
6381         return news;
6382 }
6383
6384 static MonoString*
6385 mono_string_is_interned_lookup (MonoString *str, int insert, MonoError *error)
6386 {
6387         MONO_REQ_GC_UNSAFE_MODE;
6388
6389         MonoGHashTable *ldstr_table;
6390         MonoString *s, *res;
6391         MonoDomain *domain;
6392
6393         mono_error_init (error);
6394
6395         domain = ((MonoObject *)str)->vtable->domain;
6396         ldstr_table = domain->ldstr_table;
6397         ldstr_lock ();
6398         res = (MonoString *)mono_g_hash_table_lookup (ldstr_table, str);
6399         if (res) {
6400                 ldstr_unlock ();
6401                 return res;
6402         }
6403         if (insert) {
6404                 /* Allocate outside the lock */
6405                 ldstr_unlock ();
6406                 s = mono_string_get_pinned (str, error);
6407                 return_val_if_nok (error, NULL);
6408                 if (s) {
6409                         ldstr_lock ();
6410                         res = (MonoString *)mono_g_hash_table_lookup (ldstr_table, str);
6411                         if (res) {
6412                                 ldstr_unlock ();
6413                                 return res;
6414                         }
6415                         mono_g_hash_table_insert (ldstr_table, s, s);
6416                         ldstr_unlock ();
6417                 }
6418                 return s;
6419         } else {
6420                 LDStrInfo ldstr_info;
6421                 ldstr_info.orig_domain = domain;
6422                 ldstr_info.ins = str;
6423                 ldstr_info.res = NULL;
6424
6425                 mono_domain_foreach (str_lookup, &ldstr_info);
6426                 if (ldstr_info.res) {
6427                         /*
6428                          * the string was already interned in some other domain:
6429                          * intern it in the current one as well.
6430                          */
6431                         mono_g_hash_table_insert (ldstr_table, str, str);
6432                         ldstr_unlock ();
6433                         return str;
6434                 }
6435         }
6436         ldstr_unlock ();
6437         return NULL;
6438 }
6439
6440 /**
6441  * mono_string_is_interned:
6442  * @o: String to probe
6443  *
6444  * Returns whether the string has been interned.
6445  */
6446 MonoString*
6447 mono_string_is_interned (MonoString *o)
6448 {
6449         MonoError error;
6450         MonoString *result = mono_string_is_interned_lookup (o, FALSE, &error);
6451         /* This function does not fail. */
6452         mono_error_assert_ok (&error);
6453         return result;
6454 }
6455
6456 /**
6457  * mono_string_intern:
6458  * @o: String to intern
6459  *
6460  * Interns the string passed.
6461  * Returns: The interned string.
6462  */
6463 MonoString*
6464 mono_string_intern (MonoString *str)
6465 {
6466         MonoError error;
6467         MonoString *result = mono_string_intern_checked (str, &error);
6468         mono_error_assert_ok (&error);
6469         return result;
6470 }
6471
6472 /**
6473  * mono_string_intern_checked:
6474  * @o: String to intern
6475  * @error: set on error.
6476  *
6477  * Interns the string passed.
6478  * Returns: The interned string.  On failure returns NULL and sets @error
6479  */
6480 MonoString*
6481 mono_string_intern_checked (MonoString *str, MonoError *error)
6482 {
6483         MONO_REQ_GC_UNSAFE_MODE;
6484
6485         mono_error_init (error);
6486
6487         return mono_string_is_interned_lookup (str, TRUE, error);
6488 }
6489
6490 /**
6491  * mono_ldstr:
6492  * @domain: the domain where the string will be used.
6493  * @image: a metadata context
6494  * @idx: index into the user string table.
6495  *
6496  * Implementation for the ldstr opcode.
6497  * Returns: a loaded string from the @image/@idx combination.
6498  */
6499 MonoString*
6500 mono_ldstr (MonoDomain *domain, MonoImage *image, guint32 idx)
6501 {
6502         MONO_REQ_GC_UNSAFE_MODE;
6503         MonoError error;
6504
6505         if (image->dynamic) {
6506                 MonoString *str = (MonoString *)mono_lookup_dynamic_token (image, MONO_TOKEN_STRING | idx, NULL, &error);
6507                 mono_error_raise_exception (&error); /* FIXME don't raise here */
6508                 return str;
6509         } else {
6510                 if (!mono_verifier_verify_string_signature (image, idx, NULL))
6511                         return NULL; /*FIXME we should probably be raising an exception here*/
6512                 MonoString *str = mono_ldstr_metadata_sig (domain, mono_metadata_user_string (image, idx), &error);
6513                 mono_error_raise_exception (&error); /* FIXME don't raise here */
6514                 return str;
6515         }
6516 }
6517
6518 /**
6519  * mono_ldstr_metadata_sig
6520  * @domain: the domain for the string
6521  * @sig: the signature of a metadata string
6522  * @error: set on error
6523  *
6524  * Returns: a MonoString for a string stored in the metadata. On
6525  * failure returns NULL and sets @error.
6526  */
6527 static MonoString*
6528 mono_ldstr_metadata_sig (MonoDomain *domain, const char* sig, MonoError *error)
6529 {
6530         MONO_REQ_GC_UNSAFE_MODE;
6531
6532         mono_error_init (error);
6533         const char *str = sig;
6534         MonoString *o, *interned;
6535         size_t len2;
6536
6537         len2 = mono_metadata_decode_blob_size (str, &str);
6538         len2 >>= 1;
6539
6540         o = mono_string_new_utf16_checked (domain, (guint16*)str, len2, error);
6541         return_val_if_nok (error, NULL);
6542 #if G_BYTE_ORDER != G_LITTLE_ENDIAN
6543         {
6544                 int i;
6545                 guint16 *p2 = (guint16*)mono_string_chars (o);
6546                 for (i = 0; i < len2; ++i) {
6547                         *p2 = GUINT16_FROM_LE (*p2);
6548                         ++p2;
6549                 }
6550         }
6551 #endif
6552         ldstr_lock ();
6553         interned = (MonoString *)mono_g_hash_table_lookup (domain->ldstr_table, o);
6554         ldstr_unlock ();
6555         if (interned)
6556                 return interned; /* o will get garbage collected */
6557
6558         o = mono_string_get_pinned (o, error);
6559         if (o) {
6560                 ldstr_lock ();
6561                 interned = (MonoString *)mono_g_hash_table_lookup (domain->ldstr_table, o);
6562                 if (!interned) {
6563                         mono_g_hash_table_insert (domain->ldstr_table, o, o);
6564                         interned = o;
6565                 }
6566                 ldstr_unlock ();
6567         }
6568
6569         return interned;
6570 }
6571
6572 /**
6573  * mono_string_to_utf8:
6574  * @s: a System.String
6575  *
6576  * Returns the UTF8 representation for @s.
6577  * The resulting buffer needs to be freed with mono_free().
6578  *
6579  * @deprecated Use mono_string_to_utf8_checked to avoid having an exception arbritraly raised.
6580  */
6581 char *
6582 mono_string_to_utf8 (MonoString *s)
6583 {
6584         MONO_REQ_GC_UNSAFE_MODE;
6585
6586         MonoError error;
6587         char *result = mono_string_to_utf8_checked (s, &error);
6588
6589         if (!mono_error_ok (&error))
6590                 mono_error_raise_exception (&error);
6591         return result;
6592 }
6593
6594 /**
6595  * mono_string_to_utf8_checked:
6596  * @s: a System.String
6597  * @error: a MonoError.
6598  *
6599  * Converts a MonoString to its UTF8 representation. May fail; check
6600  * @error to determine whether the conversion was successful.
6601  * The resulting buffer should be freed with mono_free().
6602  */
6603 char *
6604 mono_string_to_utf8_checked (MonoString *s, MonoError *error)
6605 {
6606         MONO_REQ_GC_UNSAFE_MODE;
6607
6608         long written = 0;
6609         char *as;
6610         GError *gerror = NULL;
6611
6612         mono_error_init (error);
6613
6614         if (s == NULL)
6615                 return NULL;
6616
6617         if (!s->length)
6618                 return g_strdup ("");
6619
6620         as = g_utf16_to_utf8 (mono_string_chars (s), s->length, NULL, &written, &gerror);
6621         if (gerror) {
6622                 mono_error_set_argument (error, "string", "%s", gerror->message);
6623                 g_error_free (gerror);
6624                 return NULL;
6625         }
6626         /* g_utf16_to_utf8  may not be able to complete the convertion (e.g. NULL values were found, #335488) */
6627         if (s->length > written) {
6628                 /* allocate the total length and copy the part of the string that has been converted */
6629                 char *as2 = (char *)g_malloc0 (s->length);
6630                 memcpy (as2, as, written);
6631                 g_free (as);
6632                 as = as2;
6633         }
6634
6635         return as;
6636 }
6637
6638 /**
6639  * mono_string_to_utf8_ignore:
6640  * @s: a MonoString
6641  *
6642  * Converts a MonoString to its UTF8 representation. Will ignore
6643  * invalid surrogate pairs.
6644  * The resulting buffer should be freed with mono_free().
6645  *
6646  */
6647 char *
6648 mono_string_to_utf8_ignore (MonoString *s)
6649 {
6650         MONO_REQ_GC_UNSAFE_MODE;
6651
6652         long written = 0;
6653         char *as;
6654
6655         if (s == NULL)
6656                 return NULL;
6657
6658         if (!s->length)
6659                 return g_strdup ("");
6660
6661         as = g_utf16_to_utf8 (mono_string_chars (s), s->length, NULL, &written, NULL);
6662
6663         /* g_utf16_to_utf8  may not be able to complete the convertion (e.g. NULL values were found, #335488) */
6664         if (s->length > written) {
6665                 /* allocate the total length and copy the part of the string that has been converted */
6666                 char *as2 = (char *)g_malloc0 (s->length);
6667                 memcpy (as2, as, written);
6668                 g_free (as);
6669                 as = as2;
6670         }
6671
6672         return as;
6673 }
6674
6675 /**
6676  * mono_string_to_utf8_image_ignore:
6677  * @s: a System.String
6678  *
6679  * Same as mono_string_to_utf8_ignore, but allocate the string from the image mempool.
6680  */
6681 char *
6682 mono_string_to_utf8_image_ignore (MonoImage *image, MonoString *s)
6683 {
6684         MONO_REQ_GC_UNSAFE_MODE;
6685
6686         return mono_string_to_utf8_internal (NULL, image, s, TRUE, NULL);
6687 }
6688
6689 /**
6690  * mono_string_to_utf8_mp_ignore:
6691  * @s: a System.String
6692  *
6693  * Same as mono_string_to_utf8_ignore, but allocate the string from a mempool.
6694  */
6695 char *
6696 mono_string_to_utf8_mp_ignore (MonoMemPool *mp, MonoString *s)
6697 {
6698         MONO_REQ_GC_UNSAFE_MODE;
6699
6700         return mono_string_to_utf8_internal (mp, NULL, s, TRUE, NULL);
6701 }
6702
6703
6704 /**
6705  * mono_string_to_utf16:
6706  * @s: a MonoString
6707  *
6708  * Return an null-terminated array of the utf-16 chars
6709  * contained in @s. The result must be freed with g_free().
6710  * This is a temporary helper until our string implementation
6711  * is reworked to always include the null terminating char.
6712  */
6713 mono_unichar2*
6714 mono_string_to_utf16 (MonoString *s)
6715 {
6716         MONO_REQ_GC_UNSAFE_MODE;
6717
6718         char *as;
6719
6720         if (s == NULL)
6721                 return NULL;
6722
6723         as = (char *)g_malloc ((s->length * 2) + 2);
6724         as [(s->length * 2)] = '\0';
6725         as [(s->length * 2) + 1] = '\0';
6726
6727         if (!s->length) {
6728                 return (gunichar2 *)(as);
6729         }
6730
6731         memcpy (as, mono_string_chars(s), s->length * 2);
6732         return (gunichar2 *)(as);
6733 }
6734
6735 /**
6736  * mono_string_to_utf32:
6737  * @s: a MonoString
6738  *
6739  * Return an null-terminated array of the UTF-32 (UCS-4) chars
6740  * contained in @s. The result must be freed with g_free().
6741  */
6742 mono_unichar4*
6743 mono_string_to_utf32 (MonoString *s)
6744 {
6745         MONO_REQ_GC_UNSAFE_MODE;
6746
6747         mono_unichar4 *utf32_output = NULL;
6748         GError *error = NULL;
6749         glong items_written;
6750
6751         if (s == NULL)
6752                 return NULL;
6753
6754         utf32_output = g_utf16_to_ucs4 (s->chars, s->length, NULL, &items_written, &error);
6755
6756         if (error)
6757                 g_error_free (error);
6758
6759         return utf32_output;
6760 }
6761
6762 /**
6763  * mono_string_from_utf16:
6764  * @data: the UTF16 string (LPWSTR) to convert
6765  *
6766  * Converts a NULL terminated UTF16 string (LPWSTR) to a MonoString.
6767  *
6768  * Returns: a MonoString.
6769  */
6770 MonoString *
6771 mono_string_from_utf16 (gunichar2 *data)
6772 {
6773         MONO_REQ_GC_UNSAFE_MODE;
6774
6775         MonoError error;
6776         MonoString *res = NULL;
6777         MonoDomain *domain = mono_domain_get ();
6778         int len = 0;
6779
6780         if (!data)
6781                 return NULL;
6782
6783         while (data [len]) len++;
6784
6785         res = mono_string_new_utf16_checked (domain, data, len, &error);
6786         mono_error_raise_exception (&error); /* FIXME don't raise here */
6787         return res;
6788 }
6789
6790 /**
6791  * mono_string_from_utf32:
6792  * @data: the UTF32 string (LPWSTR) to convert
6793  *
6794  * Converts a UTF32 (UCS-4)to a MonoString.
6795  *
6796  * Returns: a MonoString.
6797  */
6798 MonoString *
6799 mono_string_from_utf32 (mono_unichar4 *data)
6800 {
6801         MONO_REQ_GC_UNSAFE_MODE;
6802
6803         MonoString* result = NULL;
6804         mono_unichar2 *utf16_output = NULL;
6805         GError *error = NULL;
6806         glong items_written;
6807         int len = 0;
6808
6809         if (!data)
6810                 return NULL;
6811
6812         while (data [len]) len++;
6813
6814         utf16_output = g_ucs4_to_utf16 (data, len, NULL, &items_written, &error);
6815
6816         if (error)
6817                 g_error_free (error);
6818
6819         result = mono_string_from_utf16 (utf16_output);
6820         g_free (utf16_output);
6821         return result;
6822 }
6823
6824 static char *
6825 mono_string_to_utf8_internal (MonoMemPool *mp, MonoImage *image, MonoString *s, gboolean ignore_error, MonoError *error)
6826 {
6827         MONO_REQ_GC_UNSAFE_MODE;
6828
6829         char *r;
6830         char *mp_s;
6831         int len;
6832
6833         if (ignore_error) {
6834                 r = mono_string_to_utf8_ignore (s);
6835         } else {
6836                 r = mono_string_to_utf8_checked (s, error);
6837                 if (!mono_error_ok (error))
6838                         return NULL;
6839         }
6840
6841         if (!mp && !image)
6842                 return r;
6843
6844         len = strlen (r) + 1;
6845         if (mp)
6846                 mp_s = (char *)mono_mempool_alloc (mp, len);
6847         else
6848                 mp_s = (char *)mono_image_alloc (image, len);
6849
6850         memcpy (mp_s, r, len);
6851
6852         g_free (r);
6853
6854         return mp_s;
6855 }
6856
6857 /**
6858  * mono_string_to_utf8_image:
6859  * @s: a System.String
6860  *
6861  * Same as mono_string_to_utf8, but allocate the string from the image mempool.
6862  */
6863 char *
6864 mono_string_to_utf8_image (MonoImage *image, MonoString *s, MonoError *error)
6865 {
6866         MONO_REQ_GC_UNSAFE_MODE;
6867
6868         return mono_string_to_utf8_internal (NULL, image, s, FALSE, error);
6869 }
6870
6871 /**
6872  * mono_string_to_utf8_mp:
6873  * @s: a System.String
6874  *
6875  * Same as mono_string_to_utf8, but allocate the string from a mempool.
6876  */
6877 char *
6878 mono_string_to_utf8_mp (MonoMemPool *mp, MonoString *s, MonoError *error)
6879 {
6880         MONO_REQ_GC_UNSAFE_MODE;
6881
6882         return mono_string_to_utf8_internal (mp, NULL, s, FALSE, error);
6883 }
6884
6885
6886 static MonoRuntimeExceptionHandlingCallbacks eh_callbacks;
6887
6888 void
6889 mono_install_eh_callbacks (MonoRuntimeExceptionHandlingCallbacks *cbs)
6890 {
6891         eh_callbacks = *cbs;
6892 }
6893
6894 MonoRuntimeExceptionHandlingCallbacks *
6895 mono_get_eh_callbacks (void)
6896 {
6897         return &eh_callbacks;
6898 }
6899
6900 /**
6901  * mono_raise_exception:
6902  * @ex: exception object
6903  *
6904  * Signal the runtime that the exception @ex has been raised in unmanaged code.
6905  */
6906 void
6907 mono_raise_exception (MonoException *ex)
6908 {
6909         MONO_REQ_GC_UNSAFE_MODE;
6910
6911         /*
6912          * NOTE: Do NOT annotate this function with G_GNUC_NORETURN, since
6913          * that will cause gcc to omit the function epilog, causing problems when
6914          * the JIT tries to walk the stack, since the return address on the stack
6915          * will point into the next function in the executable, not this one.
6916          */
6917         eh_callbacks.mono_raise_exception (ex);
6918 }
6919
6920 void
6921 mono_raise_exception_with_context (MonoException *ex, MonoContext *ctx)
6922 {
6923         MONO_REQ_GC_UNSAFE_MODE;
6924
6925         eh_callbacks.mono_raise_exception_with_ctx (ex, ctx);
6926 }
6927
6928 /**
6929  * mono_wait_handle_new:
6930  * @domain: Domain where the object will be created
6931  * @handle: Handle for the wait handle
6932  * @error: set on error.
6933  *
6934  * Returns: A new MonoWaitHandle created in the given domain for the
6935  * given handle.  On failure returns NULL and sets @rror.
6936  */
6937 MonoWaitHandle *
6938 mono_wait_handle_new (MonoDomain *domain, HANDLE handle, MonoError *error)
6939 {
6940         MONO_REQ_GC_UNSAFE_MODE;
6941
6942         MonoWaitHandle *res;
6943         gpointer params [1];
6944         static MonoMethod *handle_set;
6945
6946         mono_error_init (error);
6947         res = (MonoWaitHandle *)mono_object_new_checked (domain, mono_defaults.manualresetevent_class, error);
6948         return_val_if_nok (error, NULL);
6949
6950         /* Even though this method is virtual, it's safe to invoke directly, since the object type matches.  */
6951         if (!handle_set)
6952                 handle_set = mono_class_get_property_from_name (mono_defaults.manualresetevent_class, "Handle")->set;
6953
6954         params [0] = &handle;
6955
6956         mono_runtime_invoke_checked (handle_set, res, params, error);
6957         return res;
6958 }
6959
6960 HANDLE
6961 mono_wait_handle_get_handle (MonoWaitHandle *handle)
6962 {
6963         MONO_REQ_GC_UNSAFE_MODE;
6964
6965         static MonoClassField *f_safe_handle = NULL;
6966         MonoSafeHandle *sh;
6967
6968         if (!f_safe_handle) {
6969                 f_safe_handle = mono_class_get_field_from_name (mono_defaults.manualresetevent_class, "safeWaitHandle");
6970                 g_assert (f_safe_handle);
6971         }
6972
6973         mono_field_get_value ((MonoObject*)handle, f_safe_handle, &sh);
6974         return sh->handle;
6975 }
6976
6977
6978 static MonoObject*
6979 mono_runtime_capture_context (MonoDomain *domain)
6980 {
6981         MONO_REQ_GC_UNSAFE_MODE;
6982
6983         RuntimeInvokeFunction runtime_invoke;
6984
6985         if (!domain->capture_context_runtime_invoke || !domain->capture_context_method) {
6986                 MonoMethod *method = mono_get_context_capture_method ();
6987                 MonoMethod *wrapper;
6988                 if (!method)
6989                         return NULL;
6990                 wrapper = mono_marshal_get_runtime_invoke (method, FALSE);
6991                 domain->capture_context_runtime_invoke = mono_compile_method (wrapper);
6992                 domain->capture_context_method = mono_compile_method (method);
6993         }
6994
6995         runtime_invoke = (RuntimeInvokeFunction)domain->capture_context_runtime_invoke;
6996
6997         return runtime_invoke (NULL, NULL, NULL, domain->capture_context_method);
6998 }
6999 /**
7000  * mono_async_result_new:
7001  * @domain:domain where the object will be created.
7002  * @handle: wait handle.
7003  * @state: state to pass to AsyncResult
7004  * @data: C closure data.
7005  *
7006  * Creates a new MonoAsyncResult (AsyncResult C# class) in the given domain.
7007  * If the handle is not null, the handle is initialized to a MonOWaitHandle.
7008  *
7009  */
7010 MonoAsyncResult *
7011 mono_async_result_new (MonoDomain *domain, HANDLE handle, MonoObject *state, gpointer data, MonoObject *object_data)
7012 {
7013         MONO_REQ_GC_UNSAFE_MODE;
7014
7015         MonoError error;
7016         MonoAsyncResult *res = (MonoAsyncResult *)mono_object_new_checked (domain, mono_defaults.asyncresult_class, &error);
7017         mono_error_raise_exception (&error); /* FIXME don't raise here */
7018         MonoObject *context = mono_runtime_capture_context (domain);
7019         /* we must capture the execution context from the original thread */
7020         if (context) {
7021                 MONO_OBJECT_SETREF (res, execution_context, context);
7022                 /* note: result may be null if the flow is suppressed */
7023         }
7024
7025         res->data = (void **)data;
7026         MONO_OBJECT_SETREF (res, object_data, object_data);
7027         MONO_OBJECT_SETREF (res, async_state, state);
7028         MonoWaitHandle *wait_handle = mono_wait_handle_new (domain, handle, &error);
7029         mono_error_raise_exception (&error); /* FIXME don't raise here */
7030         if (handle != NULL)
7031                 MONO_OBJECT_SETREF (res, handle, (MonoObject *) wait_handle);
7032
7033         res->sync_completed = FALSE;
7034         res->completed = FALSE;
7035
7036         return res;
7037 }
7038
7039 MonoObject *
7040 ves_icall_System_Runtime_Remoting_Messaging_AsyncResult_Invoke (MonoAsyncResult *ares)
7041 {
7042         MONO_REQ_GC_UNSAFE_MODE;
7043
7044         MonoError error;
7045         MonoAsyncCall *ac;
7046         MonoObject *res;
7047
7048         g_assert (ares);
7049         g_assert (ares->async_delegate);
7050
7051         ac = (MonoAsyncCall*) ares->object_data;
7052         if (!ac) {
7053                 res = mono_runtime_delegate_invoke (ares->async_delegate, (void**) &ares->async_state, NULL);
7054         } else {
7055                 gpointer wait_event = NULL;
7056
7057                 ac->msg->exc = NULL;
7058                 res = mono_message_invoke (ares->async_delegate, ac->msg, &ac->msg->exc, &ac->out_args);
7059                 MONO_OBJECT_SETREF (ac, res, res);
7060
7061                 mono_monitor_enter ((MonoObject*) ares);
7062                 ares->completed = 1;
7063                 if (ares->handle)
7064                         wait_event = mono_wait_handle_get_handle ((MonoWaitHandle*) ares->handle);
7065                 mono_monitor_exit ((MonoObject*) ares);
7066
7067                 if (wait_event != NULL)
7068                         SetEvent (wait_event);
7069
7070                 if (ac->cb_method) {
7071                         mono_runtime_invoke_checked (ac->cb_method, ac->cb_target, (gpointer*) &ares, &error);
7072                         if (mono_error_set_pending_exception (&error))
7073                                 return NULL;
7074                 }
7075         }
7076
7077         return res;
7078 }
7079
7080 void
7081 mono_message_init (MonoDomain *domain,
7082                    MonoMethodMessage *this_obj,
7083                    MonoReflectionMethod *method,
7084                    MonoArray *out_args)
7085 {
7086         MONO_REQ_GC_UNSAFE_MODE;
7087
7088         static MonoClass *object_array_klass;
7089         static MonoClass *byte_array_klass;
7090         static MonoClass *string_array_klass;
7091         MonoError error;
7092         MonoMethodSignature *sig = mono_method_signature (method->method);
7093         MonoString *name;
7094         MonoArray *arr;
7095         int i, j;
7096         char **names;
7097         guint8 arg_type;
7098
7099         if (!object_array_klass) {
7100                 MonoClass *klass;
7101
7102                 klass = mono_array_class_get (mono_defaults.byte_class, 1);
7103                 g_assert (klass);
7104                 byte_array_klass = klass;
7105
7106                 klass = mono_array_class_get (mono_defaults.string_class, 1);
7107                 g_assert (klass);
7108                 string_array_klass = klass;
7109
7110                 klass = mono_array_class_get (mono_defaults.object_class, 1);
7111                 g_assert (klass);
7112
7113                 mono_atomic_store_release (&object_array_klass, klass);
7114         }
7115
7116         MONO_OBJECT_SETREF (this_obj, method, method);
7117
7118         arr = mono_array_new_specific_checked (mono_class_vtable (domain, object_array_klass), sig->param_count, &error);
7119         mono_error_raise_exception (&error); /* FIXME don't raise here */
7120
7121         MONO_OBJECT_SETREF (this_obj, args, arr);
7122
7123         arr = mono_array_new_specific_checked (mono_class_vtable (domain, byte_array_klass), sig->param_count, &error);
7124         mono_error_raise_exception (&error); /* FIXME don't raise here */
7125
7126         MONO_OBJECT_SETREF (this_obj, arg_types, arr);
7127
7128         this_obj->async_result = NULL;
7129         this_obj->call_type = CallType_Sync;
7130
7131         names = g_new (char *, sig->param_count);
7132         mono_method_get_param_names (method->method, (const char **) names);
7133
7134         arr = mono_array_new_specific_checked (mono_class_vtable (domain, string_array_klass), sig->param_count, &error);
7135         mono_error_raise_exception (&error); /* FIXME don't raise here */
7136
7137         MONO_OBJECT_SETREF (this_obj, names, arr);
7138
7139         for (i = 0; i < sig->param_count; i++) {
7140                 name = mono_string_new (domain, names [i]);
7141                 mono_array_setref (this_obj->names, i, name);
7142         }
7143
7144         g_free (names);
7145         for (i = 0, j = 0; i < sig->param_count; i++) {
7146                 if (sig->params [i]->byref) {
7147                         if (out_args) {
7148                                 MonoObject* arg = (MonoObject *)mono_array_get (out_args, gpointer, j);
7149                                 mono_array_setref (this_obj->args, i, arg);
7150                                 j++;
7151                         }
7152                         arg_type = 2;
7153                         if (!(sig->params [i]->attrs & PARAM_ATTRIBUTE_OUT))
7154                                 arg_type |= 1;
7155                 } else {
7156                         arg_type = 1;
7157                         if (sig->params [i]->attrs & PARAM_ATTRIBUTE_OUT)
7158                                 arg_type |= 4;
7159                 }
7160                 mono_array_set (this_obj->arg_types, guint8, i, arg_type);
7161         }
7162 }
7163
7164 #ifndef DISABLE_REMOTING
7165 /**
7166  * mono_remoting_invoke:
7167  * @real_proxy: pointer to a RealProxy object
7168  * @msg: The MonoMethodMessage to execute
7169  * @exc: used to store exceptions
7170  * @out_args: used to store output arguments
7171  *
7172  * This is used to call RealProxy::Invoke(). RealProxy::Invoke() returns an
7173  * IMessage interface and it is not trivial to extract results from there. So
7174  * we call an helper method PrivateInvoke instead of calling
7175  * RealProxy::Invoke() directly.
7176  *
7177  * Returns: the result object.
7178  */
7179 MonoObject *
7180 mono_remoting_invoke (MonoObject *real_proxy, MonoMethodMessage *msg, MonoObject **exc, MonoArray **out_args, MonoError *error)
7181 {
7182         MONO_REQ_GC_UNSAFE_MODE;
7183
7184         MonoObject *o;
7185         MonoMethod *im = real_proxy->vtable->domain->private_invoke_method;
7186         gpointer pa [4];
7187
7188         g_assert (exc);
7189
7190         mono_error_init (error);
7191
7192         /*static MonoObject *(*invoke) (gpointer, gpointer, MonoObject **, MonoArray **) = NULL;*/
7193
7194         if (!im) {
7195                 im = mono_class_get_method_from_name (mono_defaults.real_proxy_class, "PrivateInvoke", 4);
7196                 if (!im) {
7197                         mono_error_set_not_supported (error, "Linked away.");
7198                         return NULL;
7199                 }
7200                 real_proxy->vtable->domain->private_invoke_method = im;
7201         }
7202
7203         pa [0] = real_proxy;
7204         pa [1] = msg;
7205         pa [2] = exc;
7206         pa [3] = out_args;
7207
7208         o = mono_runtime_try_invoke (im, NULL, pa, exc, error);
7209         return_val_if_nok (error, NULL);
7210
7211         return o;
7212 }
7213 #endif
7214
7215 MonoObject *
7216 mono_message_invoke (MonoObject *target, MonoMethodMessage *msg,
7217                      MonoObject **exc, MonoArray **out_args)
7218 {
7219         MONO_REQ_GC_UNSAFE_MODE;
7220
7221         static MonoClass *object_array_klass;
7222         MonoError error;
7223         MonoDomain *domain;
7224         MonoMethod *method;
7225         MonoMethodSignature *sig;
7226         MonoObject *ret;
7227         MonoArray *arr;
7228         int i, j, outarg_count = 0;
7229
7230 #ifndef DISABLE_REMOTING
7231         if (target && mono_object_is_transparent_proxy (target)) {
7232                 MonoTransparentProxy* tp = (MonoTransparentProxy *)target;
7233                 if (mono_class_is_contextbound (tp->remote_class->proxy_class) && tp->rp->context == (MonoObject *) mono_context_get ()) {
7234                         target = tp->rp->unwrapped_server;
7235                 } else {
7236                         ret = mono_remoting_invoke ((MonoObject *)tp->rp, msg, exc, out_args, &error);
7237                         mono_error_raise_exception (&error); /* FIXME don't raise here */
7238
7239                         return ret;
7240                 }
7241         }
7242 #endif
7243
7244         domain = mono_domain_get ();
7245         method = msg->method->method;
7246         sig = mono_method_signature (method);
7247
7248         for (i = 0; i < sig->param_count; i++) {
7249                 if (sig->params [i]->byref)
7250                         outarg_count++;
7251         }
7252
7253         if (!object_array_klass) {
7254                 MonoClass *klass;
7255
7256                 klass = mono_array_class_get (mono_defaults.object_class, 1);
7257                 g_assert (klass);
7258
7259                 mono_memory_barrier ();
7260                 object_array_klass = klass;
7261         }
7262
7263         arr = mono_array_new_specific_checked (mono_class_vtable (domain, object_array_klass), outarg_count, &error);
7264         mono_error_raise_exception (&error); /* FIXME don't raise here */
7265
7266         mono_gc_wbarrier_generic_store (out_args, (MonoObject*) arr);
7267         *exc = NULL;
7268
7269         ret = mono_runtime_invoke_array (method, method->klass->valuetype? mono_object_unbox (target): target, msg->args, exc);
7270
7271         for (i = 0, j = 0; i < sig->param_count; i++) {
7272                 if (sig->params [i]->byref) {
7273                         MonoObject* arg;
7274                         arg = (MonoObject *)mono_array_get (msg->args, gpointer, i);
7275                         mono_array_setref (*out_args, j, arg);
7276                         j++;
7277                 }
7278         }
7279
7280         return ret;
7281 }
7282
7283 /**
7284  * mono_object_to_string:
7285  * @obj: The object
7286  * @exc: Any exception thrown by ToString (). May be NULL.
7287  *
7288  * Returns: the result of calling ToString () on an object.
7289  */
7290 MonoString *
7291 mono_object_to_string (MonoObject *obj, MonoObject **exc)
7292 {
7293         MONO_REQ_GC_UNSAFE_MODE;
7294
7295         static MonoMethod *to_string = NULL;
7296         MonoError error;
7297         MonoMethod *method;
7298         MonoString *s;
7299         void *target = obj;
7300
7301         g_assert (obj);
7302
7303         if (!to_string)
7304                 to_string = mono_class_get_method_from_name_flags (mono_get_object_class (), "ToString", 0, METHOD_ATTRIBUTE_VIRTUAL | METHOD_ATTRIBUTE_PUBLIC);
7305
7306         method = mono_object_get_virtual_method (obj, to_string);
7307
7308         // Unbox value type if needed
7309         if (mono_class_is_valuetype (mono_method_get_class (method))) {
7310                 target = mono_object_unbox (obj);
7311         }
7312
7313         if (exc) {
7314                 s = (MonoString *) mono_runtime_try_invoke (method, target, NULL, exc, &error);
7315                 if (*exc == NULL && !mono_error_ok (&error))
7316                         *exc = (MonoObject*) mono_error_convert_to_exception (&error);
7317                 else
7318                         mono_error_cleanup (&error);
7319         } else {
7320                 s = (MonoString *) mono_runtime_invoke_checked (method, target, NULL, &error);
7321                 mono_error_raise_exception (&error); /* FIXME don't raise here */
7322         }
7323
7324         return s;
7325 }
7326
7327 /**
7328  * mono_print_unhandled_exception:
7329  * @exc: The exception
7330  *
7331  * Prints the unhandled exception.
7332  */
7333 void
7334 mono_print_unhandled_exception (MonoObject *exc)
7335 {
7336         MONO_REQ_GC_UNSAFE_MODE;
7337
7338         MonoString * str;
7339         char *message = (char*)"";
7340         gboolean free_message = FALSE;
7341         MonoError error;
7342
7343         if (exc == (MonoObject*)mono_object_domain (exc)->out_of_memory_ex) {
7344                 message = g_strdup ("OutOfMemoryException");
7345                 free_message = TRUE;
7346         } else if (exc == (MonoObject*)mono_object_domain (exc)->stack_overflow_ex) {
7347                 message = g_strdup ("StackOverflowException"); //if we OVF, we can't expect to have stack space to JIT Exception::ToString.
7348                 free_message = TRUE;
7349         } else {
7350
7351                 if (((MonoException*)exc)->native_trace_ips) {
7352                         message = mono_exception_get_native_backtrace ((MonoException*)exc);
7353                         free_message = TRUE;
7354                 } else {
7355                         MonoObject *other_exc = NULL;
7356                         str = mono_object_to_string (exc, &other_exc);
7357                         if (other_exc) {
7358                                 char *original_backtrace = mono_exception_get_managed_backtrace ((MonoException*)exc);
7359                                 char *nested_backtrace = mono_exception_get_managed_backtrace ((MonoException*)other_exc);
7360
7361                                 message = g_strdup_printf ("Nested exception detected.\nOriginal Exception: %s\nNested exception:%s\n",
7362                                         original_backtrace, nested_backtrace);
7363
7364                                 g_free (original_backtrace);
7365                                 g_free (nested_backtrace);
7366                                 free_message = TRUE;
7367                         } else if (str) {
7368                                 message = mono_string_to_utf8_checked (str, &error);
7369                                 if (!mono_error_ok (&error)) {
7370                                         mono_error_cleanup (&error);
7371                                         message = (char *) "";
7372                                 } else {
7373                                         free_message = TRUE;
7374                                 }
7375                         }
7376                 }
7377         }
7378
7379         /*
7380          * g_printerr ("\nUnhandled Exception: %s.%s: %s\n", exc->vtable->klass->name_space,
7381          *         exc->vtable->klass->name, message);
7382          */
7383         g_printerr ("\nUnhandled Exception:\n%s\n", message);
7384
7385         if (free_message)
7386                 g_free (message);
7387 }
7388
7389 /**
7390  * mono_delegate_ctor:
7391  * @this: pointer to an uninitialized delegate object
7392  * @target: target object
7393  * @addr: pointer to native code
7394  * @method: method
7395  *
7396  * Initialize a delegate and sets a specific method, not the one
7397  * associated with addr.  This is useful when sharing generic code.
7398  * In that case addr will most probably not be associated with the
7399  * correct instantiation of the method.
7400  */
7401 void
7402 mono_delegate_ctor_with_method (MonoObject *this_obj, MonoObject *target, gpointer addr, MonoMethod *method)
7403 {
7404         MONO_REQ_GC_UNSAFE_MODE;
7405
7406         MonoDelegate *delegate = (MonoDelegate *)this_obj;
7407
7408         g_assert (this_obj);
7409         g_assert (addr);
7410
7411         g_assert (mono_class_has_parent (mono_object_class (this_obj), mono_defaults.multicastdelegate_class));
7412
7413         if (method)
7414                 delegate->method = method;
7415
7416         mono_stats.delegate_creations++;
7417
7418 #ifndef DISABLE_REMOTING
7419         if (target && target->vtable->klass == mono_defaults.transparent_proxy_class) {
7420                 g_assert (method);
7421                 method = mono_marshal_get_remoting_invoke (method);
7422                 delegate->method_ptr = mono_compile_method (method);
7423                 MONO_OBJECT_SETREF (delegate, target, target);
7424         } else
7425 #endif
7426         {
7427                 delegate->method_ptr = addr;
7428                 MONO_OBJECT_SETREF (delegate, target, target);
7429         }
7430
7431         delegate->invoke_impl = arch_create_delegate_trampoline (delegate->object.vtable->domain, delegate->object.vtable->klass);
7432         if (callbacks.init_delegate)
7433                 callbacks.init_delegate (delegate);
7434 }
7435
7436 /**
7437  * mono_delegate_ctor:
7438  * @this: pointer to an uninitialized delegate object
7439  * @target: target object
7440  * @addr: pointer to native code
7441  *
7442  * This is used to initialize a delegate.
7443  */
7444 void
7445 mono_delegate_ctor (MonoObject *this_obj, MonoObject *target, gpointer addr)
7446 {
7447         MONO_REQ_GC_UNSAFE_MODE;
7448
7449         MonoDomain *domain = mono_domain_get ();
7450         MonoJitInfo *ji;
7451         MonoMethod *method = NULL;
7452
7453         g_assert (addr);
7454
7455         ji = mono_jit_info_table_find (domain, (char *)mono_get_addr_from_ftnptr (addr));
7456         /* Shared code */
7457         if (!ji && domain != mono_get_root_domain ())
7458                 ji = mono_jit_info_table_find (mono_get_root_domain (), (char *)mono_get_addr_from_ftnptr (addr));
7459         if (ji) {
7460                 method = mono_jit_info_get_method (ji);
7461                 g_assert (!method->klass->generic_container);
7462         }
7463
7464         mono_delegate_ctor_with_method (this_obj, target, addr, method);
7465 }
7466
7467 /**
7468  * mono_method_call_message_new:
7469  * @method: method to encapsulate
7470  * @params: parameters to the method
7471  * @invoke: optional, delegate invoke.
7472  * @cb: async callback delegate.
7473  * @state: state passed to the async callback.
7474  *
7475  * Translates arguments pointers into a MonoMethodMessage.
7476  */
7477 MonoMethodMessage *
7478 mono_method_call_message_new (MonoMethod *method, gpointer *params, MonoMethod *invoke,
7479                               MonoDelegate **cb, MonoObject **state)
7480 {
7481         MONO_REQ_GC_UNSAFE_MODE;
7482
7483         MonoError error;
7484
7485         MonoDomain *domain = mono_domain_get ();
7486         MonoMethodSignature *sig = mono_method_signature (method);
7487         MonoMethodMessage *msg;
7488         int i, count;
7489
7490         msg = (MonoMethodMessage *)mono_object_new_checked (domain, mono_defaults.mono_method_message_class, &error);
7491         mono_error_raise_exception (&error); /* FIXME don't raise here */
7492
7493         if (invoke) {
7494                 MonoReflectionMethod *rm = mono_method_get_object_checked (domain, invoke, NULL, &error);
7495                 mono_error_raise_exception (&error); /* FIXME don't raise here */
7496                 mono_message_init (domain, msg, rm, NULL);
7497                 count =  sig->param_count - 2;
7498         } else {
7499                 MonoReflectionMethod *rm = mono_method_get_object_checked (domain, method, NULL, &error);
7500                 mono_error_raise_exception (&error); /* FIXME don't raise here */
7501                 mono_message_init (domain, msg, rm, NULL);
7502                 count =  sig->param_count;
7503         }
7504
7505         for (i = 0; i < count; i++) {
7506                 gpointer vpos;
7507                 MonoClass *klass;
7508                 MonoObject *arg;
7509
7510                 if (sig->params [i]->byref)
7511                         vpos = *((gpointer *)params [i]);
7512                 else
7513                         vpos = params [i];
7514
7515                 klass = mono_class_from_mono_type (sig->params [i]);
7516
7517                 if (klass->valuetype) {
7518                         arg = mono_value_box_checked (domain, klass, vpos, &error);
7519                         mono_error_raise_exception (&error); /* FIXME don't raise here */
7520                 } else
7521                         arg = *((MonoObject **)vpos);
7522
7523                 mono_array_setref (msg->args, i, arg);
7524         }
7525
7526         if (cb != NULL && state != NULL) {
7527                 *cb = *((MonoDelegate **)params [i]);
7528                 i++;
7529                 *state = *((MonoObject **)params [i]);
7530         }
7531
7532         return msg;
7533 }
7534
7535 /**
7536  * mono_method_return_message_restore:
7537  *
7538  * Restore results from message based processing back to arguments pointers
7539  */
7540 void
7541 mono_method_return_message_restore (MonoMethod *method, gpointer *params, MonoArray *out_args, MonoError *error)
7542 {
7543         MONO_REQ_GC_UNSAFE_MODE;
7544
7545         mono_error_init (error);
7546
7547         MonoMethodSignature *sig = mono_method_signature (method);
7548         int i, j, type, size, out_len;
7549
7550         if (out_args == NULL)
7551                 return;
7552         out_len = mono_array_length (out_args);
7553         if (out_len == 0)
7554                 return;
7555
7556         for (i = 0, j = 0; i < sig->param_count; i++) {
7557                 MonoType *pt = sig->params [i];
7558
7559                 if (pt->byref) {
7560                         char *arg;
7561                         if (j >= out_len) {
7562                                 mono_error_set_execution_engine (error, "The proxy call returned an incorrect number of output arguments");
7563                                 return;
7564                         }
7565
7566                         arg = (char *)mono_array_get (out_args, gpointer, j);
7567                         type = pt->type;
7568
7569                         g_assert (type != MONO_TYPE_VOID);
7570
7571                         if (MONO_TYPE_IS_REFERENCE (pt)) {
7572                                 mono_gc_wbarrier_generic_store (*((MonoObject ***)params [i]), (MonoObject *)arg);
7573                         } else {
7574                                 if (arg) {
7575                                         MonoClass *klass = ((MonoObject*)arg)->vtable->klass;
7576                                         size = mono_class_value_size (klass, NULL);
7577                                         if (klass->has_references)
7578                                                 mono_gc_wbarrier_value_copy (*((gpointer *)params [i]), arg + sizeof (MonoObject), 1, klass);
7579                                         else
7580                                                 mono_gc_memmove_atomic (*((gpointer *)params [i]), arg + sizeof (MonoObject), size);
7581                                 } else {
7582                                         size = mono_class_value_size (mono_class_from_mono_type (pt), NULL);
7583                                         mono_gc_bzero_atomic (*((gpointer *)params [i]), size);
7584                                 }
7585                         }
7586
7587                         j++;
7588                 }
7589         }
7590 }
7591
7592 #ifndef DISABLE_REMOTING
7593
7594 /**
7595  * mono_load_remote_field:
7596  * @this: pointer to an object
7597  * @klass: klass of the object containing @field
7598  * @field: the field to load
7599  * @res: a storage to store the result
7600  *
7601  * This method is called by the runtime on attempts to load fields of
7602  * transparent proxy objects. @this points to such TP, @klass is the class of
7603  * the object containing @field. @res is a storage location which can be
7604  * used to store the result.
7605  *
7606  * Returns: an address pointing to the value of field.
7607  */
7608 gpointer
7609 mono_load_remote_field (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, gpointer *res)
7610 {
7611         MonoError error;
7612         gpointer result = mono_load_remote_field_checked (this_obj, klass, field, res, &error);
7613         mono_error_cleanup (&error);
7614         return result;
7615 }
7616
7617 /**
7618  * mono_load_remote_field_checked:
7619  * @this: pointer to an object
7620  * @klass: klass of the object containing @field
7621  * @field: the field to load
7622  * @res: a storage to store the result
7623  * @error: set on error
7624  *
7625  * This method is called by the runtime on attempts to load fields of
7626  * transparent proxy objects. @this points to such TP, @klass is the class of
7627  * the object containing @field. @res is a storage location which can be
7628  * used to store the result.
7629  *
7630  * Returns: an address pointing to the value of field.  On failure returns NULL and sets @error.
7631  */
7632 gpointer
7633 mono_load_remote_field_checked (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, gpointer *res, MonoError *error)
7634 {
7635         MONO_REQ_GC_UNSAFE_MODE;
7636
7637         static MonoMethod *getter = NULL;
7638
7639         mono_error_init (error);
7640
7641         MonoDomain *domain = mono_domain_get ();
7642         MonoTransparentProxy *tp = (MonoTransparentProxy *) this_obj;
7643         MonoClass *field_class;
7644         MonoMethodMessage *msg;
7645         MonoArray *out_args;
7646         MonoObject *exc;
7647         char* full_name;
7648
7649         g_assert (mono_object_is_transparent_proxy (this_obj));
7650         g_assert (res != NULL);
7651
7652         if (mono_class_is_contextbound (tp->remote_class->proxy_class) && tp->rp->context == (MonoObject *) mono_context_get ()) {
7653                 mono_field_get_value (tp->rp->unwrapped_server, field, res);
7654                 return res;
7655         }
7656
7657         if (!getter) {
7658                 getter = mono_class_get_method_from_name (mono_defaults.object_class, "FieldGetter", -1);
7659                 if (!getter) {
7660                         mono_error_set_not_supported (error, "Linked away.");
7661                         return NULL;
7662                 }
7663         }
7664
7665         field_class = mono_class_from_mono_type (field->type);
7666
7667         msg = (MonoMethodMessage *)mono_object_new_checked (domain, mono_defaults.mono_method_message_class, error);
7668         return_val_if_nok (error, NULL);
7669         out_args = mono_array_new_checked (domain, mono_defaults.object_class, 1, error);
7670         return_val_if_nok (error, NULL);
7671         MonoReflectionMethod *rm = mono_method_get_object_checked (domain, getter, NULL, error);
7672         return_val_if_nok (error, NULL);
7673         mono_message_init (domain, msg, rm, out_args);
7674
7675         full_name = mono_type_get_full_name (klass);
7676         mono_array_setref (msg->args, 0, mono_string_new (domain, full_name));
7677         mono_array_setref (msg->args, 1, mono_string_new (domain, mono_field_get_name (field)));
7678         g_free (full_name);
7679
7680         mono_remoting_invoke ((MonoObject *)(tp->rp), msg, &exc, &out_args, error);
7681         return_val_if_nok (error, NULL);
7682
7683         if (exc) {
7684                 mono_error_set_exception_instance (error, (MonoException *)exc);
7685                 return NULL;
7686         }
7687
7688         if (mono_array_length (out_args) == 0)
7689                 return NULL;
7690
7691         mono_gc_wbarrier_generic_store (res, mono_array_get (out_args, MonoObject *, 0));
7692
7693         if (field_class->valuetype) {
7694                 return ((char *)*res) + sizeof (MonoObject);
7695         } else
7696                 return res;
7697 }
7698
7699 /**
7700  * mono_load_remote_field_new:
7701  * @this:
7702  * @klass:
7703  * @field:
7704  *
7705  * Missing documentation.
7706  */
7707 MonoObject *
7708 mono_load_remote_field_new (MonoObject *this_obj, MonoClass *klass, MonoClassField *field)
7709 {
7710         MonoError error;
7711
7712         MonoObject *result = mono_load_remote_field_new_checked (this_obj, klass, field, &error);
7713         mono_error_cleanup (&error);
7714         return result;
7715 }
7716
7717 /**
7718  * mono_load_remote_field_new_icall:
7719  * @this: pointer to an object
7720  * @klass: klass of the object containing @field
7721  * @field: the field to load
7722  *
7723  * This method is called by the runtime on attempts to load fields of
7724  * transparent proxy objects. @this points to such TP, @klass is the class of
7725  * the object containing @field.
7726  *
7727  * Returns: a freshly allocated object containing the value of the
7728  * field.  On failure returns NULL and throws an exception.
7729  */
7730 MonoObject *
7731 mono_load_remote_field_new_icall (MonoObject *this_obj, MonoClass *klass, MonoClassField *field)
7732 {
7733         MonoError error;
7734         MonoObject *result = mono_load_remote_field_new_checked (this_obj, klass, field, &error);
7735         mono_error_set_pending_exception (&error);
7736         return result;
7737 }
7738
7739 /**
7740  * mono_load_remote_field_new_checked:
7741  * @this: pointer to an object
7742  * @klass: klass of the object containing @field
7743  * @field: the field to load
7744  * @error: set on error.
7745  *
7746  * This method is called by the runtime on attempts to load fields of
7747  * transparent proxy objects. @this points to such TP, @klass is the class of
7748  * the object containing @field.
7749  *
7750  * Returns: a freshly allocated object containing the value of the field.  On failure returns NULL and sets @error.
7751  */
7752 MonoObject *
7753 mono_load_remote_field_new_checked (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, MonoError *error)
7754 {
7755         MONO_REQ_GC_UNSAFE_MODE;
7756
7757         mono_error_init (error);
7758
7759         static MonoMethod *getter = NULL;
7760         MonoDomain *domain = mono_domain_get ();
7761         MonoTransparentProxy *tp = (MonoTransparentProxy *) this_obj;
7762         MonoClass *field_class;
7763         MonoMethodMessage *msg;
7764         MonoArray *out_args;
7765         MonoObject *exc, *res;
7766         char* full_name;
7767
7768         g_assert (mono_object_is_transparent_proxy (this_obj));
7769
7770         field_class = mono_class_from_mono_type (field->type);
7771
7772         if (mono_class_is_contextbound (tp->remote_class->proxy_class) && tp->rp->context == (MonoObject *) mono_context_get ()) {
7773                 gpointer val;
7774                 if (field_class->valuetype) {
7775                         res = mono_object_new_checked (domain, field_class, error);
7776                         return_val_if_nok (error, NULL);
7777                         val = ((gchar *) res) + sizeof (MonoObject);
7778                 } else {
7779                         val = &res;
7780                 }
7781                 mono_field_get_value (tp->rp->unwrapped_server, field, val);
7782                 return res;
7783         }
7784
7785         if (!getter) {
7786                 getter = mono_class_get_method_from_name (mono_defaults.object_class, "FieldGetter", -1);
7787                 if (!getter) {
7788                         mono_error_set_not_supported (error, "Linked away.");
7789                         return NULL;
7790                 }
7791         }
7792
7793         msg = (MonoMethodMessage *)mono_object_new_checked (domain, mono_defaults.mono_method_message_class, error);
7794         return_val_if_nok (error, NULL);
7795         out_args = mono_array_new_checked (domain, mono_defaults.object_class, 1, error);
7796         return_val_if_nok (error, NULL);
7797
7798         MonoReflectionMethod *rm = mono_method_get_object_checked (domain, getter, NULL, error);
7799         return_val_if_nok (error, NULL);
7800         mono_message_init (domain, msg, rm, out_args);
7801
7802         full_name = mono_type_get_full_name (klass);
7803         mono_array_setref (msg->args, 0, mono_string_new (domain, full_name));
7804         mono_array_setref (msg->args, 1, mono_string_new (domain, mono_field_get_name (field)));
7805         g_free (full_name);
7806
7807         mono_remoting_invoke ((MonoObject *)(tp->rp), msg, &exc, &out_args, error);
7808         return_val_if_nok (error, NULL);
7809
7810         if (exc) {
7811                 mono_error_set_exception_instance (error, (MonoException *)exc);
7812                 return NULL;
7813         }
7814
7815         if (mono_array_length (out_args) == 0)
7816                 res = NULL;
7817         else
7818                 res = mono_array_get (out_args, MonoObject *, 0);
7819
7820         return res;
7821 }
7822
7823 /**
7824  * mono_store_remote_field:
7825  * @this_obj: pointer to an object
7826  * @klass: klass of the object containing @field
7827  * @field: the field to load
7828  * @val: the value/object to store
7829  *
7830  * This method is called by the runtime on attempts to store fields of
7831  * transparent proxy objects. @this_obj points to such TP, @klass is the class of
7832  * the object containing @field. @val is the new value to store in @field.
7833  */
7834 void
7835 mono_store_remote_field (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, gpointer val)
7836 {
7837         MonoError error;
7838         (void) mono_store_remote_field_checked (this_obj, klass, field, val, &error);
7839         mono_error_cleanup (&error);
7840 }
7841
7842 /**
7843  * mono_store_remote_field_checked:
7844  * @this_obj: pointer to an object
7845  * @klass: klass of the object containing @field
7846  * @field: the field to load
7847  * @val: the value/object to store
7848  * @error: set on error
7849  *
7850  * This method is called by the runtime on attempts to store fields of
7851  * transparent proxy objects. @this_obj points to such TP, @klass is the class of
7852  * the object containing @field. @val is the new value to store in @field.
7853  *
7854  * Returns: on success returns TRUE, on failure returns FALSE and sets @error.
7855  */
7856 gboolean
7857 mono_store_remote_field_checked (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, gpointer val, MonoError *error)
7858 {
7859
7860         MONO_REQ_GC_UNSAFE_MODE;
7861
7862         static MonoMethod *setter = NULL;
7863
7864         MonoDomain *domain = mono_domain_get ();
7865         MonoTransparentProxy *tp = (MonoTransparentProxy *) this_obj;
7866         MonoClass *field_class;
7867         MonoMethodMessage *msg;
7868         MonoArray *out_args;
7869         MonoObject *exc;
7870         MonoObject *arg;
7871         char* full_name;
7872
7873         mono_error_init (error);
7874
7875         g_assert (mono_object_is_transparent_proxy (this_obj));
7876
7877         field_class = mono_class_from_mono_type (field->type);
7878
7879         if (mono_class_is_contextbound (tp->remote_class->proxy_class) && tp->rp->context == (MonoObject *) mono_context_get ()) {
7880                 if (field_class->valuetype) mono_field_set_value (tp->rp->unwrapped_server, field, val);
7881                 else mono_field_set_value (tp->rp->unwrapped_server, field, *((MonoObject **)val));
7882                 return TRUE;
7883         }
7884
7885         if (!setter) {
7886                 setter = mono_class_get_method_from_name (mono_defaults.object_class, "FieldSetter", -1);
7887                 if (!setter) {
7888                         mono_error_set_not_supported (error, "Linked away.");
7889                         return FALSE;
7890                 }
7891         }
7892
7893         if (field_class->valuetype) {
7894                 arg = mono_value_box_checked (domain, field_class, val, error);
7895                 return_val_if_nok (error, FALSE);
7896         } else
7897                 arg = *((MonoObject **)val);
7898
7899
7900         msg = (MonoMethodMessage *)mono_object_new_checked (domain, mono_defaults.mono_method_message_class, error);
7901         return_val_if_nok (error, FALSE);
7902         MonoReflectionMethod *rm = mono_method_get_object_checked (domain, setter, NULL, error);
7903         return_val_if_nok (error, FALSE);
7904         mono_message_init (domain, msg, rm, NULL);
7905
7906         full_name = mono_type_get_full_name (klass);
7907         mono_array_setref (msg->args, 0, mono_string_new (domain, full_name));
7908         mono_array_setref (msg->args, 1, mono_string_new (domain, mono_field_get_name (field)));
7909         mono_array_setref (msg->args, 2, arg);
7910         g_free (full_name);
7911
7912         mono_remoting_invoke ((MonoObject *)(tp->rp), msg, &exc, &out_args, error);
7913         return_val_if_nok (error, FALSE);
7914
7915         if (exc) {
7916                 mono_error_set_exception_instance (error, (MonoException *)exc);
7917                 return FALSE;
7918         }
7919         return TRUE;
7920 }
7921
7922 /**
7923  * mono_store_remote_field_new:
7924  * @this_obj:
7925  * @klass:
7926  * @field:
7927  * @arg:
7928  *
7929  * Missing documentation
7930  */
7931 void
7932 mono_store_remote_field_new (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, MonoObject *arg)
7933 {
7934         MonoError error;
7935         (void) mono_store_remote_field_new_checked (this_obj, klass, field, arg, &error);
7936         mono_error_cleanup (&error);
7937 }
7938
7939 /**
7940  * mono_store_remote_field_new_icall:
7941  * @this_obj:
7942  * @klass:
7943  * @field:
7944  * @arg:
7945  *
7946  * Missing documentation
7947  */
7948 void
7949 mono_store_remote_field_new_icall (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, MonoObject *arg)
7950 {
7951         MonoError error;
7952         (void) mono_store_remote_field_new_checked (this_obj, klass, field, arg, &error);
7953         mono_error_set_pending_exception (&error);
7954 }
7955
7956 /**
7957  * mono_store_remote_field_new_checked:
7958  * @this_obj:
7959  * @klass:
7960  * @field:
7961  * @arg:
7962  * @error:
7963  *
7964  * Missing documentation
7965  */
7966 gboolean
7967 mono_store_remote_field_new_checked (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, MonoObject *arg, MonoError *error)
7968 {
7969         MONO_REQ_GC_UNSAFE_MODE;
7970
7971         static MonoMethod *setter = NULL;
7972         MonoDomain *domain = mono_domain_get ();
7973         MonoTransparentProxy *tp = (MonoTransparentProxy *) this_obj;
7974         MonoClass *field_class;
7975         MonoMethodMessage *msg;
7976         MonoArray *out_args;
7977         MonoObject *exc;
7978         char* full_name;
7979
7980         mono_error_init (error);
7981
7982         g_assert (mono_object_is_transparent_proxy (this_obj));
7983
7984         field_class = mono_class_from_mono_type (field->type);
7985
7986         if (mono_class_is_contextbound (tp->remote_class->proxy_class) && tp->rp->context == (MonoObject *) mono_context_get ()) {
7987                 if (field_class->valuetype) mono_field_set_value (tp->rp->unwrapped_server, field, ((gchar *) arg) + sizeof (MonoObject));
7988                 else mono_field_set_value (tp->rp->unwrapped_server, field, arg);
7989                 return TRUE;
7990         }
7991
7992         if (!setter) {
7993                 setter = mono_class_get_method_from_name (mono_defaults.object_class, "FieldSetter", -1);
7994                 if (!setter) {
7995                         mono_error_set_not_supported (error, "Linked away.");
7996                         return FALSE;
7997                 }
7998         }
7999
8000         msg = (MonoMethodMessage *)mono_object_new_checked (domain, mono_defaults.mono_method_message_class, error);
8001         return_val_if_nok (error, FALSE);
8002         MonoReflectionMethod *rm = mono_method_get_object_checked (domain, setter, NULL, error);
8003         return_val_if_nok (error, FALSE);
8004         mono_message_init (domain, msg, rm, NULL);
8005
8006         full_name = mono_type_get_full_name (klass);
8007         mono_array_setref (msg->args, 0, mono_string_new (domain, full_name));
8008         mono_array_setref (msg->args, 1, mono_string_new (domain, mono_field_get_name (field)));
8009         mono_array_setref (msg->args, 2, arg);
8010         g_free (full_name);
8011
8012         mono_remoting_invoke ((MonoObject *)(tp->rp), msg, &exc, &out_args, error);
8013         return_val_if_nok (error, FALSE);
8014
8015         if (exc) {
8016                 mono_error_set_exception_instance (error, (MonoException *)exc);
8017                 return FALSE;
8018         }
8019         return TRUE;
8020 }
8021 #endif
8022
8023 /*
8024  * mono_create_ftnptr:
8025  *
8026  *   Given a function address, create a function descriptor for it.
8027  * This is only needed on some platforms.
8028  */
8029 gpointer
8030 mono_create_ftnptr (MonoDomain *domain, gpointer addr)
8031 {
8032         return callbacks.create_ftnptr (domain, addr);
8033 }
8034
8035 /*
8036  * mono_get_addr_from_ftnptr:
8037  *
8038  *   Given a pointer to a function descriptor, return the function address.
8039  * This is only needed on some platforms.
8040  */
8041 gpointer
8042 mono_get_addr_from_ftnptr (gpointer descr)
8043 {
8044         return callbacks.get_addr_from_ftnptr (descr);
8045 }
8046
8047 /**
8048  * mono_string_chars:
8049  * @s: a MonoString
8050  *
8051  * Returns a pointer to the UCS16 characters stored in the MonoString
8052  */
8053 gunichar2 *
8054 mono_string_chars (MonoString *s)
8055 {
8056         // MONO_REQ_GC_UNSAFE_MODE; //FIXME too much trouble for now
8057
8058         return s->chars;
8059 }
8060
8061 /**
8062  * mono_string_length:
8063  * @s: MonoString
8064  *
8065  * Returns the lenght in characters of the string
8066  */
8067 int
8068 mono_string_length (MonoString *s)
8069 {
8070         MONO_REQ_GC_UNSAFE_MODE;
8071
8072         return s->length;
8073 }
8074
8075 /**
8076  * mono_array_length:
8077  * @array: a MonoArray*
8078  *
8079  * Returns the total number of elements in the array. This works for
8080  * both vectors and multidimensional arrays.
8081  */
8082 uintptr_t
8083 mono_array_length (MonoArray *array)
8084 {
8085         MONO_REQ_GC_UNSAFE_MODE;
8086
8087         return array->max_length;
8088 }
8089
8090 /**
8091  * mono_array_addr_with_size:
8092  * @array: a MonoArray*
8093  * @size: size of the array elements
8094  * @idx: index into the array
8095  *
8096  * Use this function to obtain the address for the @idx item on the
8097  * @array containing elements of size @size.
8098  *
8099  * This method performs no bounds checking or type checking.
8100  *
8101  * Returns the address of the @idx element in the array.
8102  */
8103 char*
8104 mono_array_addr_with_size (MonoArray *array, int size, uintptr_t idx)
8105 {
8106         MONO_REQ_GC_UNSAFE_MODE;
8107
8108         return ((char*)(array)->vector) + size * idx;
8109 }
8110
8111
8112 MonoArray *
8113 mono_glist_to_array (GList *list, MonoClass *eclass, MonoError *error)
8114 {
8115         MonoDomain *domain = mono_domain_get ();
8116         MonoArray *res;
8117         int len, i;
8118
8119         mono_error_init (error);
8120         if (!list)
8121                 return NULL;
8122
8123         len = g_list_length (list);
8124         res = mono_array_new_checked (domain, eclass, len, error);
8125         return_val_if_nok (error, NULL);
8126
8127         for (i = 0; list; list = list->next, i++)
8128                 mono_array_set (res, gpointer, i, list->data);
8129
8130         return res;
8131 }
8132
8133 #if NEVER_DEFINED
8134 /*
8135  * The following section is purely to declare prototypes and
8136  * document the API, as these C files are processed by our
8137  * tool
8138  */
8139
8140 /**
8141  * mono_array_set:
8142  * @array: array to alter
8143  * @element_type: A C type name, this macro will use the sizeof(type) to determine the element size
8144  * @index: index into the array
8145  * @value: value to set
8146  *
8147  * Value Type version: This sets the @index's element of the @array
8148  * with elements of size sizeof(type) to the provided @value.
8149  *
8150  * This macro does not attempt to perform type checking or bounds checking.
8151  *
8152  * Use this to set value types in a `MonoArray`.
8153  */
8154 void mono_array_set(MonoArray *array, Type element_type, uintptr_t index, Value value)
8155 {
8156 }
8157
8158 /**
8159  * mono_array_setref:
8160  * @array: array to alter
8161  * @index: index into the array
8162  * @value: value to set
8163  *
8164  * Reference Type version: This sets the @index's element of the
8165  * @array with elements of size sizeof(type) to the provided @value.
8166  *
8167  * This macro does not attempt to perform type checking or bounds checking.
8168  *
8169  * Use this to reference types in a `MonoArray`.
8170  */
8171 void mono_array_setref(MonoArray *array, uintptr_t index, MonoObject *object)
8172 {
8173 }
8174
8175 /**
8176  * mono_array_get:
8177  * @array: array on which to operate on
8178  * @element_type: C element type (example: MonoString *, int, MonoObject *)
8179  * @index: index into the array
8180  *
8181  * Use this macro to retrieve the @index element of an @array and
8182  * extract the value assuming that the elements of the array match
8183  * the provided type value.
8184  *
8185  * This method can be used with both arrays holding value types and
8186  * reference types.   For reference types, the @type parameter should
8187  * be a `MonoObject*` or any subclass of it, like `MonoString*`.
8188  *
8189  * This macro does not attempt to perform type checking or bounds checking.
8190  *
8191  * Returns: The element at the @index position in the @array.
8192  */
8193 Type mono_array_get (MonoArray *array, Type element_type, uintptr_t index)
8194 {
8195 }
8196 #endif
8197