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);
  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         MONO_PREPARE_RESET_BLOCKING;
3119         method = mono_marshal_get_thunk_invoke_wrapper (method);
3120         res = mono_compile_method (method);
3121         MONO_FINISH_RESET_BLOCKING;
3122
3123         return res;
3124 }
3125
3126 void
3127 mono_copy_value (MonoType *type, void *dest, void *value, int deref_pointer)
3128 {
3129         MONO_REQ_GC_UNSAFE_MODE;
3130
3131         int t;
3132         if (type->byref) {
3133                 /* object fields cannot be byref, so we don't need a
3134                    wbarrier here */
3135                 gpointer *p = (gpointer*)dest;
3136                 *p = value;
3137                 return;
3138         }
3139         t = type->type;
3140 handle_enum:
3141         switch (t) {
3142         case MONO_TYPE_BOOLEAN:
3143         case MONO_TYPE_I1:
3144         case MONO_TYPE_U1: {
3145                 guint8 *p = (guint8*)dest;
3146                 *p = value ? *(guint8*)value : 0;
3147                 return;
3148         }
3149         case MONO_TYPE_I2:
3150         case MONO_TYPE_U2:
3151         case MONO_TYPE_CHAR: {
3152                 guint16 *p = (guint16*)dest;
3153                 *p = value ? *(guint16*)value : 0;
3154                 return;
3155         }
3156 #if SIZEOF_VOID_P == 4
3157         case MONO_TYPE_I:
3158         case MONO_TYPE_U:
3159 #endif
3160         case MONO_TYPE_I4:
3161         case MONO_TYPE_U4: {
3162                 gint32 *p = (gint32*)dest;
3163                 *p = value ? *(gint32*)value : 0;
3164                 return;
3165         }
3166 #if SIZEOF_VOID_P == 8
3167         case MONO_TYPE_I:
3168         case MONO_TYPE_U:
3169 #endif
3170         case MONO_TYPE_I8:
3171         case MONO_TYPE_U8: {
3172                 gint64 *p = (gint64*)dest;
3173                 *p = value ? *(gint64*)value : 0;
3174                 return;
3175         }
3176         case MONO_TYPE_R4: {
3177                 float *p = (float*)dest;
3178                 *p = value ? *(float*)value : 0;
3179                 return;
3180         }
3181         case MONO_TYPE_R8: {
3182                 double *p = (double*)dest;
3183                 *p = value ? *(double*)value : 0;
3184                 return;
3185         }
3186         case MONO_TYPE_STRING:
3187         case MONO_TYPE_SZARRAY:
3188         case MONO_TYPE_CLASS:
3189         case MONO_TYPE_OBJECT:
3190         case MONO_TYPE_ARRAY:
3191                 mono_gc_wbarrier_generic_store (dest, deref_pointer ? *(MonoObject **)value : (MonoObject *)value);
3192                 return;
3193         case MONO_TYPE_FNPTR:
3194         case MONO_TYPE_PTR: {
3195                 gpointer *p = (gpointer*)dest;
3196                 *p = deref_pointer? *(gpointer*)value: value;
3197                 return;
3198         }
3199         case MONO_TYPE_VALUETYPE:
3200                 /* note that 't' and 'type->type' can be different */
3201                 if (type->type == MONO_TYPE_VALUETYPE && type->data.klass->enumtype) {
3202                         t = mono_class_enum_basetype (type->data.klass)->type;
3203                         goto handle_enum;
3204                 } else {
3205                         MonoClass *klass = mono_class_from_mono_type (type);
3206                         int size = mono_class_value_size (klass, NULL);
3207                         if (value == NULL)
3208                                 mono_gc_bzero_atomic (dest, size);
3209                         else
3210                                 mono_gc_wbarrier_value_copy (dest, value, 1, klass);
3211                 }
3212                 return;
3213         case MONO_TYPE_GENERICINST:
3214                 t = type->data.generic_class->container_class->byval_arg.type;
3215                 goto handle_enum;
3216         default:
3217                 g_error ("got type %x", type->type);
3218         }
3219 }
3220
3221 /**
3222  * mono_field_set_value:
3223  * @obj: Instance object
3224  * @field: MonoClassField describing the field to set
3225  * @value: The value to be set
3226  *
3227  * Sets the value of the field described by @field in the object instance @obj
3228  * to the value passed in @value.   This method should only be used for instance
3229  * fields.   For static fields, use mono_field_static_set_value.
3230  *
3231  * The value must be on the native format of the field type.
3232  */
3233 void
3234 mono_field_set_value (MonoObject *obj, MonoClassField *field, void *value)
3235 {
3236         MONO_REQ_GC_UNSAFE_MODE;
3237
3238         void *dest;
3239
3240         g_return_if_fail (!(field->type->attrs & FIELD_ATTRIBUTE_STATIC));
3241
3242         dest = (char*)obj + field->offset;
3243         mono_copy_value (field->type, dest, value, FALSE);
3244 }
3245
3246 /**
3247  * mono_field_static_set_value:
3248  * @field: MonoClassField describing the field to set
3249  * @value: The value to be set
3250  *
3251  * Sets the value of the static field described by @field
3252  * to the value passed in @value.
3253  *
3254  * The value must be on the native format of the field type.
3255  */
3256 void
3257 mono_field_static_set_value (MonoVTable *vt, MonoClassField *field, void *value)
3258 {
3259         MONO_REQ_GC_UNSAFE_MODE;
3260
3261         void *dest;
3262
3263         g_return_if_fail (field->type->attrs & FIELD_ATTRIBUTE_STATIC);
3264         /* you cant set a constant! */
3265         g_return_if_fail (!(field->type->attrs & FIELD_ATTRIBUTE_LITERAL));
3266
3267         if (field->offset == -1) {
3268                 /* Special static */
3269                 gpointer addr;
3270
3271                 mono_domain_lock (vt->domain);
3272                 addr = g_hash_table_lookup (vt->domain->special_static_fields, field);
3273                 mono_domain_unlock (vt->domain);
3274                 dest = mono_get_special_static_data (GPOINTER_TO_UINT (addr));
3275         } else {
3276                 dest = (char*)mono_vtable_get_static_field_data (vt) + field->offset;
3277         }
3278         mono_copy_value (field->type, dest, value, FALSE);
3279 }
3280
3281 /**
3282  * mono_vtable_get_static_field_data:
3283  *
3284  * Internal use function: return a pointer to the memory holding the static fields
3285  * for a class or NULL if there are no static fields.
3286  * This is exported only for use by the debugger.
3287  */
3288 void *
3289 mono_vtable_get_static_field_data (MonoVTable *vt)
3290 {
3291         MONO_REQ_GC_NEUTRAL_MODE
3292
3293         if (!vt->has_static_fields)
3294                 return NULL;
3295         return vt->vtable [vt->klass->vtable_size];
3296 }
3297
3298 static guint8*
3299 mono_field_get_addr (MonoObject *obj, MonoVTable *vt, MonoClassField *field)
3300 {
3301         MONO_REQ_GC_UNSAFE_MODE;
3302
3303         guint8 *src;
3304
3305         if (field->type->attrs & FIELD_ATTRIBUTE_STATIC) {
3306                 if (field->offset == -1) {
3307                         /* Special static */
3308                         gpointer addr;
3309
3310                         mono_domain_lock (vt->domain);
3311                         addr = g_hash_table_lookup (vt->domain->special_static_fields, field);
3312                         mono_domain_unlock (vt->domain);
3313                         src = (guint8 *)mono_get_special_static_data (GPOINTER_TO_UINT (addr));
3314                 } else {
3315                         src = (guint8*)mono_vtable_get_static_field_data (vt) + field->offset;
3316                 }
3317         } else {
3318                 src = (guint8*)obj + field->offset;
3319         }
3320
3321         return src;
3322 }
3323
3324 /**
3325  * mono_field_get_value:
3326  * @obj: Object instance
3327  * @field: MonoClassField describing the field to fetch information from
3328  * @value: pointer to the location where the value will be stored
3329  *
3330  * Use this routine to get the value of the field @field in the object
3331  * passed.
3332  *
3333  * The pointer provided by value must be of the field type, for reference
3334  * types this is a MonoObject*, for value types its the actual pointer to
3335  * the value type.
3336  *
3337  * For example:
3338  *     int i;
3339  *     mono_field_get_value (obj, int_field, &i);
3340  */
3341 void
3342 mono_field_get_value (MonoObject *obj, MonoClassField *field, void *value)
3343 {
3344         MONO_REQ_GC_UNSAFE_MODE;
3345
3346         void *src;
3347
3348         g_assert (obj);
3349
3350         g_return_if_fail (!(field->type->attrs & FIELD_ATTRIBUTE_STATIC));
3351
3352         src = (char*)obj + field->offset;
3353         mono_copy_value (field->type, value, src, TRUE);
3354 }
3355
3356 /**
3357  * mono_field_get_value_object:
3358  * @domain: domain where the object will be created (if boxing)
3359  * @field: MonoClassField describing the field to fetch information from
3360  * @obj: The object instance for the field.
3361  *
3362  * Returns: a new MonoObject with the value from the given field.  If the
3363  * field represents a value type, the value is boxed.
3364  *
3365  */
3366 MonoObject *
3367 mono_field_get_value_object (MonoDomain *domain, MonoClassField *field, MonoObject *obj)
3368 {
3369         MonoError error;
3370         MonoObject* result = mono_field_get_value_object_checked (domain, field, obj, &error);
3371         mono_error_assert_ok (&error);
3372         return result;
3373 }
3374
3375 /**
3376  * mono_field_get_value_object_checked:
3377  * @domain: domain where the object will be created (if boxing)
3378  * @field: MonoClassField describing the field to fetch information from
3379  * @obj: The object instance for the field.
3380  * @error: Set on error.
3381  *
3382  * Returns: a new MonoObject with the value from the given field.  If the
3383  * field represents a value type, the value is boxed.  On error returns NULL and sets @error.
3384  *
3385  */
3386 MonoObject *
3387 mono_field_get_value_object_checked (MonoDomain *domain, MonoClassField *field, MonoObject *obj, MonoError *error)
3388 {
3389         MONO_REQ_GC_UNSAFE_MODE;
3390
3391         mono_error_init (error);
3392
3393         MonoObject *o;
3394         MonoClass *klass;
3395         MonoVTable *vtable = NULL;
3396         gchar *v;
3397         gboolean is_static = FALSE;
3398         gboolean is_ref = FALSE;
3399         gboolean is_literal = FALSE;
3400         gboolean is_ptr = FALSE;
3401         MonoType *type = mono_field_get_type_checked (field, error);
3402
3403         return_val_if_nok (error, NULL);
3404
3405         switch (type->type) {
3406         case MONO_TYPE_STRING:
3407         case MONO_TYPE_OBJECT:
3408         case MONO_TYPE_CLASS:
3409         case MONO_TYPE_ARRAY:
3410         case MONO_TYPE_SZARRAY:
3411                 is_ref = TRUE;
3412                 break;
3413         case MONO_TYPE_U1:
3414         case MONO_TYPE_I1:
3415         case MONO_TYPE_BOOLEAN:
3416         case MONO_TYPE_U2:
3417         case MONO_TYPE_I2:
3418         case MONO_TYPE_CHAR:
3419         case MONO_TYPE_U:
3420         case MONO_TYPE_I:
3421         case MONO_TYPE_U4:
3422         case MONO_TYPE_I4:
3423         case MONO_TYPE_R4:
3424         case MONO_TYPE_U8:
3425         case MONO_TYPE_I8:
3426         case MONO_TYPE_R8:
3427         case MONO_TYPE_VALUETYPE:
3428                 is_ref = type->byref;
3429                 break;
3430         case MONO_TYPE_GENERICINST:
3431                 is_ref = !mono_type_generic_inst_is_valuetype (type);
3432                 break;
3433         case MONO_TYPE_PTR:
3434                 is_ptr = TRUE;
3435                 break;
3436         default:
3437                 g_error ("type 0x%x not handled in "
3438                          "mono_field_get_value_object", type->type);
3439                 return NULL;
3440         }
3441
3442         if (type->attrs & FIELD_ATTRIBUTE_LITERAL)
3443                 is_literal = TRUE;
3444
3445         if (type->attrs & FIELD_ATTRIBUTE_STATIC) {
3446                 is_static = TRUE;
3447
3448                 if (!is_literal) {
3449                         vtable = mono_class_vtable_full (domain, field->parent, error);
3450                         return_val_if_nok (error, NULL);
3451
3452                         if (!vtable->initialized) {
3453                                 mono_runtime_class_init_full (vtable, error);
3454                                 return_val_if_nok (error, NULL);
3455                         }
3456                 }
3457         } else {
3458                 g_assert (obj);
3459         }
3460
3461         if (is_ref) {
3462                 if (is_literal) {
3463                         get_default_field_value (domain, field, &o);
3464                 } else if (is_static) {
3465                         mono_field_static_get_value (vtable, field, &o);
3466                 } else {
3467                         mono_field_get_value (obj, field, &o);
3468                 }
3469                 return o;
3470         }
3471
3472         if (is_ptr) {
3473                 static MonoMethod *m;
3474                 gpointer args [2];
3475                 gpointer *ptr;
3476                 gpointer v;
3477
3478                 if (!m) {
3479                         MonoClass *ptr_klass = mono_class_get_pointer_class ();
3480                         m = mono_class_get_method_from_name_flags (ptr_klass, "Box", 2, METHOD_ATTRIBUTE_STATIC);
3481                         g_assert (m);
3482                 }
3483
3484                 v = &ptr;
3485                 if (is_literal) {
3486                         get_default_field_value (domain, field, v);
3487                 } else if (is_static) {
3488                         mono_field_static_get_value (vtable, field, v);
3489                 } else {
3490                         mono_field_get_value (obj, field, v);
3491                 }
3492
3493                 /* MONO_TYPE_PTR is passed by value to runtime_invoke () */
3494                 args [0] = ptr ? *ptr : NULL;
3495                 args [1] = mono_type_get_object_checked (mono_domain_get (), type, error);
3496                 return_val_if_nok (error, NULL);
3497
3498                 o = mono_runtime_invoke_checked (m, NULL, args, error);
3499                 return_val_if_nok (error, NULL);
3500
3501                 return o;
3502         }
3503
3504         /* boxed value type */
3505         klass = mono_class_from_mono_type (type);
3506
3507         if (mono_class_is_nullable (klass))
3508                 return mono_nullable_box (mono_field_get_addr (obj, vtable, field), klass, error);
3509
3510         o = mono_object_new_checked (domain, klass, error);
3511         return_val_if_nok (error, NULL);
3512         v = ((gchar *) o) + sizeof (MonoObject);
3513
3514         if (is_literal) {
3515                 get_default_field_value (domain, field, v);
3516         } else if (is_static) {
3517                 mono_field_static_get_value (vtable, field, v);
3518         } else {
3519                 mono_field_get_value (obj, field, v);
3520         }
3521
3522         return o;
3523 }
3524
3525 int
3526 mono_get_constant_value_from_blob (MonoDomain* domain, MonoTypeEnum type, const char *blob, void *value)
3527 {
3528         MONO_REQ_GC_UNSAFE_MODE;
3529
3530         MonoError error;
3531         int retval = 0;
3532         const char *p = blob;
3533         mono_metadata_decode_blob_size (p, &p);
3534
3535         switch (type) {
3536         case MONO_TYPE_BOOLEAN:
3537         case MONO_TYPE_U1:
3538         case MONO_TYPE_I1:
3539                 *(guint8 *) value = *p;
3540                 break;
3541         case MONO_TYPE_CHAR:
3542         case MONO_TYPE_U2:
3543         case MONO_TYPE_I2:
3544                 *(guint16*) value = read16 (p);
3545                 break;
3546         case MONO_TYPE_U4:
3547         case MONO_TYPE_I4:
3548                 *(guint32*) value = read32 (p);
3549                 break;
3550         case MONO_TYPE_U8:
3551         case MONO_TYPE_I8:
3552                 *(guint64*) value = read64 (p);
3553                 break;
3554         case MONO_TYPE_R4:
3555                 readr4 (p, (float*) value);
3556                 break;
3557         case MONO_TYPE_R8:
3558                 readr8 (p, (double*) value);
3559                 break;
3560         case MONO_TYPE_STRING:
3561                 *(gpointer*) value = mono_ldstr_metadata_sig (domain, blob, &error);
3562                 mono_error_raise_exception (&error); /* FIXME don't raise here */
3563                 break;
3564         case MONO_TYPE_CLASS:
3565                 *(gpointer*) value = NULL;
3566                 break;
3567         default:
3568                 retval = -1;
3569                 g_warning ("type 0x%02x should not be in constant table", type);
3570         }
3571         return retval;
3572 }
3573
3574 static void
3575 get_default_field_value (MonoDomain* domain, MonoClassField *field, void *value)
3576 {
3577         MONO_REQ_GC_NEUTRAL_MODE;
3578
3579         MonoTypeEnum def_type;
3580         const char* data;
3581
3582         data = mono_class_get_field_default_value (field, &def_type);
3583         mono_get_constant_value_from_blob (domain, def_type, data, value);
3584 }
3585
3586 void
3587 mono_field_static_get_value_for_thread (MonoInternalThread *thread, MonoVTable *vt, MonoClassField *field, void *value)
3588 {
3589         MONO_REQ_GC_UNSAFE_MODE;
3590
3591         void *src;
3592
3593         g_return_if_fail (field->type->attrs & FIELD_ATTRIBUTE_STATIC);
3594
3595         if (field->type->attrs & FIELD_ATTRIBUTE_LITERAL) {
3596                 get_default_field_value (vt->domain, field, value);
3597                 return;
3598         }
3599
3600         if (field->offset == -1) {
3601                 /* Special static */
3602                 gpointer addr = g_hash_table_lookup (vt->domain->special_static_fields, field);
3603                 src = mono_get_special_static_data_for_thread (thread, GPOINTER_TO_UINT (addr));
3604         } else {
3605                 src = (char*)mono_vtable_get_static_field_data (vt) + field->offset;
3606         }
3607         mono_copy_value (field->type, value, src, TRUE);
3608 }
3609
3610 /**
3611  * mono_field_static_get_value:
3612  * @vt: vtable to the object
3613  * @field: MonoClassField describing the field to fetch information from
3614  * @value: where the value is returned
3615  *
3616  * Use this routine to get the value of the static field @field value.
3617  *
3618  * The pointer provided by value must be of the field type, for reference
3619  * types this is a MonoObject*, for value types its the actual pointer to
3620  * the value type.
3621  *
3622  * For example:
3623  *     int i;
3624  *     mono_field_static_get_value (vt, int_field, &i);
3625  */
3626 void
3627 mono_field_static_get_value (MonoVTable *vt, MonoClassField *field, void *value)
3628 {
3629         MONO_REQ_GC_NEUTRAL_MODE;
3630
3631         mono_field_static_get_value_for_thread (mono_thread_internal_current (), vt, field, value);
3632 }
3633
3634 /**
3635  * mono_property_set_value:
3636  * @prop: MonoProperty to set
3637  * @obj: instance object on which to act
3638  * @params: parameters to pass to the propery
3639  * @exc: optional exception
3640  *
3641  * Invokes the property's set method with the given arguments on the
3642  * object instance obj (or NULL for static properties).
3643  *
3644  * You can pass NULL as the exc argument if you don't want to
3645  * catch exceptions, otherwise, *exc will be set to the exception
3646  * thrown, if any.  if an exception is thrown, you can't use the
3647  * MonoObject* result from the function.
3648  */
3649 void
3650 mono_property_set_value (MonoProperty *prop, void *obj, void **params, MonoObject **exc)
3651 {
3652         MONO_REQ_GC_UNSAFE_MODE;
3653
3654         MonoError error;
3655         do_runtime_invoke (prop->set, obj, params, exc, &error);
3656         if (exc && *exc == NULL && !mono_error_ok (&error)) {
3657                 *exc = (MonoObject*) mono_error_convert_to_exception (&error);
3658         } else {
3659                 mono_error_cleanup (&error);
3660         }
3661 }
3662
3663 /**
3664  * mono_property_set_value_checked:
3665  * @prop: MonoProperty to set
3666  * @obj: instance object on which to act
3667  * @params: parameters to pass to the propery
3668  * @error: set on error
3669  *
3670  * Invokes the property's set method with the given arguments on the
3671  * object instance obj (or NULL for static properties).
3672  *
3673  * Returns: TRUE on success.  On failure returns FALSE and sets @error.
3674  * If an exception is thrown, it will be caught and returned via @error.
3675  */
3676 gboolean
3677 mono_property_set_value_checked (MonoProperty *prop, void *obj, void **params, MonoError *error)
3678 {
3679         MONO_REQ_GC_UNSAFE_MODE;
3680
3681         MonoObject *exc;
3682
3683         mono_error_init (error);
3684         do_runtime_invoke (prop->set, obj, params, &exc, error);
3685         if (exc != NULL && is_ok (error))
3686                 mono_error_set_exception_instance (error, (MonoException*)exc);
3687         return is_ok (error);
3688 }
3689
3690 /**
3691  * mono_property_get_value:
3692  * @prop: MonoProperty to fetch
3693  * @obj: instance object on which to act
3694  * @params: parameters to pass to the propery
3695  * @exc: optional exception
3696  *
3697  * Invokes the property's get method with the given arguments on the
3698  * object instance obj (or NULL for static properties).
3699  *
3700  * You can pass NULL as the exc argument if you don't want to
3701  * catch exceptions, otherwise, *exc will be set to the exception
3702  * thrown, if any.  if an exception is thrown, you can't use the
3703  * MonoObject* result from the function.
3704  *
3705  * Returns: the value from invoking the get method on the property.
3706  */
3707 MonoObject*
3708 mono_property_get_value (MonoProperty *prop, void *obj, void **params, MonoObject **exc)
3709 {
3710         MONO_REQ_GC_UNSAFE_MODE;
3711
3712         MonoError error;
3713         MonoObject *val = do_runtime_invoke (prop->get, obj, params, exc, &error);
3714         if (exc && *exc == NULL && !mono_error_ok (&error)) {
3715                 *exc = (MonoObject*) mono_error_convert_to_exception (&error);
3716         } else {
3717                 mono_error_cleanup (&error); /* FIXME don't raise here */
3718         }
3719
3720         return val;
3721 }
3722
3723 /**
3724  * mono_property_get_value_checked:
3725  * @prop: MonoProperty to fetch
3726  * @obj: instance object on which to act
3727  * @params: parameters to pass to the propery
3728  * @error: set on error
3729  *
3730  * Invokes the property's get method with the given arguments on the
3731  * object instance obj (or NULL for static properties).
3732  *
3733  * If an exception is thrown, you can't use the
3734  * MonoObject* result from the function.  The exception will be propagated via @error.
3735  *
3736  * Returns: the value from invoking the get method on the property. On
3737  * failure returns NULL and sets @error.
3738  */
3739 MonoObject*
3740 mono_property_get_value_checked (MonoProperty *prop, void *obj, void **params, MonoError *error)
3741 {
3742         MONO_REQ_GC_UNSAFE_MODE;
3743
3744         MonoObject *exc;
3745         MonoObject *val = do_runtime_invoke (prop->get, obj, params, &exc, error);
3746         if (exc != NULL && !is_ok (error))
3747                 mono_error_set_exception_instance (error, (MonoException*) exc);
3748         if (!is_ok (error))
3749                 val = NULL;
3750         return val;
3751 }
3752
3753
3754 /*
3755  * mono_nullable_init:
3756  * @buf: The nullable structure to initialize.
3757  * @value: the value to initialize from
3758  * @klass: the type for the object
3759  *
3760  * Initialize the nullable structure pointed to by @buf from @value which
3761  * should be a boxed value type.   The size of @buf should be able to hold
3762  * as much data as the @klass->instance_size (which is the number of bytes
3763  * that will be copies).
3764  *
3765  * Since Nullables have variable structure, we can not define a C
3766  * structure for them.
3767  */
3768 void
3769 mono_nullable_init (guint8 *buf, MonoObject *value, MonoClass *klass)
3770 {
3771         MONO_REQ_GC_UNSAFE_MODE;
3772
3773         MonoClass *param_class = klass->cast_class;
3774
3775         mono_class_setup_fields_locking (klass);
3776         g_assert (klass->fields_inited);
3777
3778         g_assert (mono_class_from_mono_type (klass->fields [0].type) == param_class);
3779         g_assert (mono_class_from_mono_type (klass->fields [1].type) == mono_defaults.boolean_class);
3780
3781         *(guint8*)(buf + klass->fields [1].offset - sizeof (MonoObject)) = value ? 1 : 0;
3782         if (value) {
3783                 if (param_class->has_references)
3784                         mono_gc_wbarrier_value_copy (buf + klass->fields [0].offset - sizeof (MonoObject), mono_object_unbox (value), 1, param_class);
3785                 else
3786                         mono_gc_memmove_atomic (buf + klass->fields [0].offset - sizeof (MonoObject), mono_object_unbox (value), mono_class_value_size (param_class, NULL));
3787         } else {
3788                 mono_gc_bzero_atomic (buf + klass->fields [0].offset - sizeof (MonoObject), mono_class_value_size (param_class, NULL));
3789         }
3790 }
3791
3792 /**
3793  * mono_nullable_box:
3794  * @buf: The buffer representing the data to be boxed
3795  * @klass: the type to box it as.
3796  * @error: set on oerr
3797  *
3798  * Creates a boxed vtype or NULL from the Nullable structure pointed to by
3799  * @buf.  On failure returns NULL and sets @error
3800  */
3801 MonoObject*
3802 mono_nullable_box (guint8 *buf, MonoClass *klass, MonoError *error)
3803 {
3804         MONO_REQ_GC_UNSAFE_MODE;
3805
3806         mono_error_init (error);
3807         MonoClass *param_class = klass->cast_class;
3808
3809         mono_class_setup_fields_locking (klass);
3810         g_assert (klass->fields_inited);
3811
3812         g_assert (mono_class_from_mono_type (klass->fields [0].type) == param_class);
3813         g_assert (mono_class_from_mono_type (klass->fields [1].type) == mono_defaults.boolean_class);
3814
3815         if (*(guint8*)(buf + klass->fields [1].offset - sizeof (MonoObject))) {
3816                 MonoObject *o = mono_object_new_checked (mono_domain_get (), param_class, error);
3817                 return_val_if_nok (error, NULL);
3818                 if (param_class->has_references)
3819                         mono_gc_wbarrier_value_copy (mono_object_unbox (o), buf + klass->fields [0].offset - sizeof (MonoObject), 1, param_class);
3820                 else
3821                         mono_gc_memmove_atomic (mono_object_unbox (o), buf + klass->fields [0].offset - sizeof (MonoObject), mono_class_value_size (param_class, NULL));
3822                 return o;
3823         }
3824         else
3825                 return NULL;
3826 }
3827
3828 /**
3829  * mono_get_delegate_invoke:
3830  * @klass: The delegate class
3831  *
3832  * Returns: the MonoMethod for the "Invoke" method in the delegate klass or NULL if @klass is a broken delegate type
3833  */
3834 MonoMethod *
3835 mono_get_delegate_invoke (MonoClass *klass)
3836 {
3837         MONO_REQ_GC_NEUTRAL_MODE;
3838
3839         MonoMethod *im;
3840
3841         /* This is called at runtime, so avoid the slower search in metadata */
3842         mono_class_setup_methods (klass);
3843         if (mono_class_has_failure (klass))
3844                 return NULL;
3845         im = mono_class_get_method_from_name (klass, "Invoke", -1);
3846         return im;
3847 }
3848
3849 /**
3850  * mono_get_delegate_begin_invoke:
3851  * @klass: The delegate class
3852  *
3853  * Returns: the MonoMethod for the "BeginInvoke" method in the delegate klass or NULL if @klass is a broken delegate type
3854  */
3855 MonoMethod *
3856 mono_get_delegate_begin_invoke (MonoClass *klass)
3857 {
3858         MONO_REQ_GC_NEUTRAL_MODE;
3859
3860         MonoMethod *im;
3861
3862         /* This is called at runtime, so avoid the slower search in metadata */
3863         mono_class_setup_methods (klass);
3864         if (mono_class_has_failure (klass))
3865                 return NULL;
3866         im = mono_class_get_method_from_name (klass, "BeginInvoke", -1);
3867         return im;
3868 }
3869
3870 /**
3871  * mono_get_delegate_end_invoke:
3872  * @klass: The delegate class
3873  *
3874  * Returns: the MonoMethod for the "EndInvoke" method in the delegate klass or NULL if @klass is a broken delegate type
3875  */
3876 MonoMethod *
3877 mono_get_delegate_end_invoke (MonoClass *klass)
3878 {
3879         MONO_REQ_GC_NEUTRAL_MODE;
3880
3881         MonoMethod *im;
3882
3883         /* This is called at runtime, so avoid the slower search in metadata */
3884         mono_class_setup_methods (klass);
3885         if (mono_class_has_failure (klass))
3886                 return NULL;
3887         im = mono_class_get_method_from_name (klass, "EndInvoke", -1);
3888         return im;
3889 }
3890
3891 /**
3892  * mono_runtime_delegate_invoke:
3893  * @delegate: pointer to a delegate object.
3894  * @params: parameters for the delegate.
3895  * @exc: Pointer to the exception result.
3896  *
3897  * Invokes the delegate method @delegate with the parameters provided.
3898  *
3899  * You can pass NULL as the exc argument if you don't want to
3900  * catch exceptions, otherwise, *exc will be set to the exception
3901  * thrown, if any.  if an exception is thrown, you can't use the
3902  * MonoObject* result from the function.
3903  */
3904 MonoObject*
3905 mono_runtime_delegate_invoke (MonoObject *delegate, void **params, MonoObject **exc)
3906 {
3907         MONO_REQ_GC_UNSAFE_MODE;
3908
3909         MonoError error;
3910         MonoMethod *im;
3911         MonoClass *klass = delegate->vtable->klass;
3912         MonoObject *o;
3913
3914         im = mono_get_delegate_invoke (klass);
3915         if (!im)
3916                 g_error ("Could not lookup delegate invoke method for delegate %s", mono_type_get_full_name (klass));
3917
3918         if (exc) {
3919                 o = mono_runtime_try_invoke (im, delegate, params, exc, &error);
3920                 if (*exc == NULL && !mono_error_ok (&error))
3921                         *exc = (MonoObject*) mono_error_convert_to_exception (&error);
3922                 else
3923                         mono_error_cleanup (&error);
3924         } else {
3925                 o = mono_runtime_invoke_checked (im, delegate, params, &error);
3926                 mono_error_raise_exception (&error); /* FIXME don't raise here */
3927         }
3928
3929         return o;
3930 }
3931
3932 static char **main_args = NULL;
3933 static int num_main_args = 0;
3934
3935 /**
3936  * mono_runtime_get_main_args:
3937  *
3938  * Returns: a MonoArray with the arguments passed to the main program
3939  */
3940 MonoArray*
3941 mono_runtime_get_main_args (void)
3942 {
3943         MONO_REQ_GC_UNSAFE_MODE;
3944         MonoError error;
3945         MonoArray *result = mono_runtime_get_main_args_checked (&error);
3946         mono_error_assert_ok (&error);
3947         return result;
3948 }
3949
3950 /**
3951  * mono_runtime_get_main_args:
3952  * @error: set on error
3953  *
3954  * Returns: a MonoArray with the arguments passed to the main
3955  * program. On failure returns NULL and sets @error.
3956  */
3957 MonoArray*
3958 mono_runtime_get_main_args_checked (MonoError *error)
3959 {
3960         MonoArray *res;
3961         int i;
3962         MonoDomain *domain = mono_domain_get ();
3963
3964         mono_error_init (error);
3965
3966         res = (MonoArray*)mono_array_new_checked (domain, mono_defaults.string_class, num_main_args, error);
3967         return_val_if_nok (error, NULL);
3968
3969         for (i = 0; i < num_main_args; ++i)
3970                 mono_array_setref (res, i, mono_string_new (domain, main_args [i]));
3971
3972         return res;
3973 }
3974
3975 static void
3976 free_main_args (void)
3977 {
3978         MONO_REQ_GC_NEUTRAL_MODE;
3979
3980         int i;
3981
3982         for (i = 0; i < num_main_args; ++i)
3983                 g_free (main_args [i]);
3984         g_free (main_args);
3985         num_main_args = 0;
3986         main_args = NULL;
3987 }
3988
3989 /**
3990  * mono_runtime_set_main_args:
3991  * @argc: number of arguments from the command line
3992  * @argv: array of strings from the command line
3993  *
3994  * Set the command line arguments from an embedding application that doesn't otherwise call
3995  * mono_runtime_run_main ().
3996  */
3997 int
3998 mono_runtime_set_main_args (int argc, char* argv[])
3999 {
4000         MONO_REQ_GC_NEUTRAL_MODE;
4001
4002         int i;
4003
4004         free_main_args ();
4005         main_args = g_new0 (char*, argc);
4006         num_main_args = argc;
4007
4008         for (i = 0; i < argc; ++i) {
4009                 gchar *utf8_arg;
4010
4011                 utf8_arg = mono_utf8_from_external (argv[i]);
4012                 if (utf8_arg == NULL) {
4013                         g_print ("\nCannot determine the text encoding for argument %d (%s).\n", i, argv [i]);
4014                         g_print ("Please add the correct encoding to MONO_EXTERNAL_ENCODINGS and try again.\n");
4015                         exit (-1);
4016                 }
4017
4018                 main_args [i] = utf8_arg;
4019         }
4020
4021         return 0;
4022 }
4023
4024 /**
4025  * mono_runtime_run_main:
4026  * @method: the method to start the application with (usually Main)
4027  * @argc: number of arguments from the command line
4028  * @argv: array of strings from the command line
4029  * @exc: excetption results
4030  *
4031  * Execute a standard Main() method (argc/argv contains the
4032  * executable name). This method also sets the command line argument value
4033  * needed by System.Environment.
4034  *
4035  *
4036  */
4037 int
4038 mono_runtime_run_main (MonoMethod *method, int argc, char* argv[],
4039                        MonoObject **exc)
4040 {
4041         MONO_REQ_GC_UNSAFE_MODE;
4042
4043         MonoError error;
4044         int i;
4045         MonoArray *args = NULL;
4046         MonoDomain *domain = mono_domain_get ();
4047         gchar *utf8_fullpath;
4048         MonoMethodSignature *sig;
4049
4050         g_assert (method != NULL);
4051
4052         mono_thread_set_main (mono_thread_current ());
4053
4054         main_args = g_new0 (char*, argc);
4055         num_main_args = argc;
4056
4057         if (!g_path_is_absolute (argv [0])) {
4058                 gchar *basename = g_path_get_basename (argv [0]);
4059                 gchar *fullpath = g_build_filename (method->klass->image->assembly->basedir,
4060                                                     basename,
4061                                                     NULL);
4062
4063                 utf8_fullpath = mono_utf8_from_external (fullpath);
4064                 if(utf8_fullpath == NULL) {
4065                         /* Printing the arg text will cause glib to
4066                          * whinge about "Invalid UTF-8", but at least
4067                          * its relevant, and shows the problem text
4068                          * string.
4069                          */
4070                         g_print ("\nCannot determine the text encoding for the assembly location: %s\n", fullpath);
4071                         g_print ("Please add the correct encoding to MONO_EXTERNAL_ENCODINGS and try again.\n");
4072                         exit (-1);
4073                 }
4074
4075                 g_free (fullpath);
4076                 g_free (basename);
4077         } else {
4078                 utf8_fullpath = mono_utf8_from_external (argv[0]);
4079                 if(utf8_fullpath == NULL) {
4080                         g_print ("\nCannot determine the text encoding for the assembly location: %s\n", argv[0]);
4081                         g_print ("Please add the correct encoding to MONO_EXTERNAL_ENCODINGS and try again.\n");
4082                         exit (-1);
4083                 }
4084         }
4085
4086         main_args [0] = utf8_fullpath;
4087
4088         for (i = 1; i < argc; ++i) {
4089                 gchar *utf8_arg;
4090
4091                 utf8_arg=mono_utf8_from_external (argv[i]);
4092                 if(utf8_arg==NULL) {
4093                         /* Ditto the comment about Invalid UTF-8 here */
4094                         g_print ("\nCannot determine the text encoding for argument %d (%s).\n", i, argv[i]);
4095                         g_print ("Please add the correct encoding to MONO_EXTERNAL_ENCODINGS and try again.\n");
4096                         exit (-1);
4097                 }
4098
4099                 main_args [i] = utf8_arg;
4100         }
4101         argc--;
4102         argv++;
4103
4104         sig = mono_method_signature (method);
4105         if (!sig) {
4106                 g_print ("Unable to load Main method.\n");
4107                 exit (-1);
4108         }
4109
4110         if (sig->param_count) {
4111                 args = (MonoArray*)mono_array_new_checked (domain, mono_defaults.string_class, argc, &error);
4112                 mono_error_assert_ok (&error);
4113                 for (i = 0; i < argc; ++i) {
4114                         /* The encodings should all work, given that
4115                          * we've checked all these args for the
4116                          * main_args array.
4117                          */
4118                         gchar *str = mono_utf8_from_external (argv [i]);
4119                         MonoString *arg = mono_string_new (domain, str);
4120                         mono_array_setref (args, i, arg);
4121                         g_free (str);
4122                 }
4123         } else {
4124                 args = (MonoArray*)mono_array_new_checked (domain, mono_defaults.string_class, 0, &error);
4125                 mono_error_assert_ok (&error);
4126         }
4127
4128         mono_assembly_set_main (method->klass->image->assembly);
4129
4130         return mono_runtime_exec_main (method, args, exc);
4131 }
4132
4133 static MonoObject*
4134 serialize_object (MonoObject *obj, gboolean *failure, MonoObject **exc)
4135 {
4136         static MonoMethod *serialize_method;
4137
4138         MonoError error;
4139         void *params [1];
4140         MonoObject *array;
4141
4142         if (!serialize_method) {
4143                 MonoClass *klass = mono_class_get_remoting_services_class ();
4144                 serialize_method = mono_class_get_method_from_name (klass, "SerializeCallData", -1);
4145         }
4146
4147         if (!serialize_method) {
4148                 *failure = TRUE;
4149                 return NULL;
4150         }
4151
4152         g_assert (!mono_class_is_marshalbyref (mono_object_class (obj)));
4153
4154         params [0] = obj;
4155         *exc = NULL;
4156
4157         array = mono_runtime_try_invoke (serialize_method, NULL, params, exc, &error);
4158         if (*exc == NULL && !mono_error_ok (&error))
4159                 *exc = (MonoObject*) mono_error_convert_to_exception (&error); /* FIXME convert serialize_object to MonoError */
4160         else
4161                 mono_error_cleanup (&error);
4162
4163         if (*exc)
4164                 *failure = TRUE;
4165
4166         return array;
4167 }
4168
4169 static MonoObject*
4170 deserialize_object (MonoObject *obj, gboolean *failure, MonoObject **exc)
4171 {
4172         MONO_REQ_GC_UNSAFE_MODE;
4173
4174         static MonoMethod *deserialize_method;
4175
4176         MonoError error;
4177         void *params [1];
4178         MonoObject *result;
4179
4180         if (!deserialize_method) {
4181                 MonoClass *klass = mono_class_get_remoting_services_class ();
4182                 deserialize_method = mono_class_get_method_from_name (klass, "DeserializeCallData", -1);
4183         }
4184         if (!deserialize_method) {
4185                 *failure = TRUE;
4186                 return NULL;
4187         }
4188
4189         params [0] = obj;
4190         *exc = NULL;
4191
4192         result = mono_runtime_try_invoke (deserialize_method, NULL, params, exc, &error);
4193         if (*exc == NULL && !mono_error_ok (&error))
4194                 *exc = (MonoObject*) mono_error_convert_to_exception (&error); /* FIXME convert deserialize_object to MonoError */
4195         else
4196                 mono_error_cleanup (&error);
4197
4198         if (*exc)
4199                 *failure = TRUE;
4200
4201         return result;
4202 }
4203
4204 #ifndef DISABLE_REMOTING
4205 static MonoObject*
4206 make_transparent_proxy (MonoObject *obj, MonoError *error)
4207 {
4208         MONO_REQ_GC_UNSAFE_MODE;
4209
4210         static MonoMethod *get_proxy_method;
4211
4212         MonoDomain *domain = mono_domain_get ();
4213         MonoRealProxy *real_proxy;
4214         MonoReflectionType *reflection_type;
4215         MonoTransparentProxy *transparent_proxy;
4216
4217         mono_error_init (error);
4218
4219         if (!get_proxy_method)
4220                 get_proxy_method = mono_class_get_method_from_name (mono_defaults.real_proxy_class, "GetTransparentProxy", 0);
4221
4222         g_assert (mono_class_is_marshalbyref (obj->vtable->klass));
4223
4224         real_proxy = (MonoRealProxy*) mono_object_new_checked (domain, mono_defaults.real_proxy_class, error);
4225         return_val_if_nok (error, NULL);
4226         reflection_type = mono_type_get_object_checked (domain, &obj->vtable->klass->byval_arg, error);
4227         return_val_if_nok (error, NULL);
4228
4229         MONO_OBJECT_SETREF (real_proxy, class_to_proxy, reflection_type);
4230         MONO_OBJECT_SETREF (real_proxy, unwrapped_server, obj);
4231
4232         MonoObject *exc = NULL;
4233
4234         transparent_proxy = (MonoTransparentProxy*) mono_runtime_try_invoke (get_proxy_method, real_proxy, NULL, &exc, error);
4235         if (exc != NULL && is_ok (error))
4236                 mono_error_set_exception_instance (error, (MonoException*)exc);
4237
4238         return (MonoObject*) transparent_proxy;
4239 }
4240 #endif /* DISABLE_REMOTING */
4241
4242 /**
4243  * mono_object_xdomain_representation
4244  * @obj: an object
4245  * @target_domain: a domain
4246  * @error: set on error.
4247  *
4248  * Creates a representation of obj in the domain target_domain.  This
4249  * is either a copy of obj arrived through via serialization and
4250  * deserialization or a proxy, depending on whether the object is
4251  * serializable or marshal by ref.  obj must not be in target_domain.
4252  *
4253  * If the object cannot be represented in target_domain, NULL is
4254  * returned and @error is set appropriately.
4255  */
4256 MonoObject*
4257 mono_object_xdomain_representation (MonoObject *obj, MonoDomain *target_domain, MonoError *error)
4258 {
4259         MONO_REQ_GC_UNSAFE_MODE;
4260
4261         mono_error_init (error);
4262         MonoObject *deserialized = NULL;
4263
4264 #ifndef DISABLE_REMOTING
4265         if (mono_class_is_marshalbyref (mono_object_class (obj))) {
4266                 deserialized = make_transparent_proxy (obj, error);
4267         }
4268         else
4269 #endif
4270         {
4271                 gboolean failure = FALSE;
4272                 MonoDomain *domain = mono_domain_get ();
4273                 MonoObject *serialized;
4274                 MonoObject *exc = NULL;
4275
4276                 mono_domain_set_internal_with_options (mono_object_domain (obj), FALSE);
4277                 serialized = serialize_object (obj, &failure, &exc);
4278                 mono_domain_set_internal_with_options (target_domain, FALSE);
4279                 if (!failure)
4280                         deserialized = deserialize_object (serialized, &failure, &exc);
4281                 if (domain != target_domain)
4282                         mono_domain_set_internal_with_options (domain, FALSE);
4283                 if (failure)
4284                         mono_error_set_exception_instance (error, (MonoException*)exc);
4285         }
4286
4287         return deserialized;
4288 }
4289
4290 /* Used in call_unhandled_exception_delegate */
4291 static MonoObject *
4292 create_unhandled_exception_eventargs (MonoObject *exc)
4293 {
4294         MONO_REQ_GC_UNSAFE_MODE;
4295
4296         MonoError error;
4297         MonoClass *klass;
4298         gpointer args [2];
4299         MonoMethod *method = NULL;
4300         MonoBoolean is_terminating = TRUE;
4301         MonoObject *obj;
4302
4303         klass = mono_class_get_unhandled_exception_event_args_class ();
4304         mono_class_init (klass);
4305
4306         /* UnhandledExceptionEventArgs only has 1 public ctor with 2 args */
4307         method = mono_class_get_method_from_name_flags (klass, ".ctor", 2, METHOD_ATTRIBUTE_PUBLIC);
4308         g_assert (method);
4309
4310         args [0] = exc;
4311         args [1] = &is_terminating;
4312
4313         obj = mono_object_new_checked (mono_domain_get (), klass, &error);
4314         mono_error_raise_exception (&error); /* FIXME don't raise here */
4315
4316         mono_runtime_invoke_checked (method, obj, args, &error);
4317         mono_error_raise_exception (&error); /* FIXME don't raise here */
4318
4319         return obj;
4320 }
4321
4322 /* Used in mono_unhandled_exception */
4323 static void
4324 call_unhandled_exception_delegate (MonoDomain *domain, MonoObject *delegate, MonoObject *exc) {
4325         MONO_REQ_GC_UNSAFE_MODE;
4326
4327         MonoObject *e = NULL;
4328         gpointer pa [2];
4329         MonoDomain *current_domain = mono_domain_get ();
4330
4331         if (domain != current_domain)
4332                 mono_domain_set_internal_with_options (domain, FALSE);
4333
4334         g_assert (domain == mono_object_domain (domain->domain));
4335
4336         if (mono_object_domain (exc) != domain) {
4337                 MonoError error;
4338
4339                 exc = mono_object_xdomain_representation (exc, domain, &error);
4340                 if (!exc) {
4341                         if (!is_ok (&error)) {
4342                                 MonoError inner_error;
4343                                 MonoException *serialization_exc = mono_error_convert_to_exception (&error);
4344                                 exc = mono_object_xdomain_representation ((MonoObject*)serialization_exc, domain, &inner_error);
4345                                 mono_error_assert_ok (&inner_error);
4346                         } else {
4347                                 exc = (MonoObject*) mono_exception_from_name_msg (mono_get_corlib (),
4348                                                 "System.Runtime.Serialization", "SerializationException",
4349                                                 "Could not serialize unhandled exception.");
4350                         }
4351                 }
4352         }
4353         g_assert (mono_object_domain (exc) == domain);
4354
4355         pa [0] = domain->domain;
4356         pa [1] = create_unhandled_exception_eventargs (exc);
4357         mono_runtime_delegate_invoke (delegate, pa, &e);
4358
4359         if (domain != current_domain)
4360                 mono_domain_set_internal_with_options (current_domain, FALSE);
4361
4362         if (e) {
4363                 MonoError error;
4364                 gchar *msg = mono_string_to_utf8_checked (((MonoException *) e)->message, &error);
4365                 if (!mono_error_ok (&error)) {
4366                         g_warning ("Exception inside UnhandledException handler with invalid message (Invalid characters)\n");
4367                         mono_error_cleanup (&error);
4368                 } else {
4369                         g_warning ("exception inside UnhandledException handler: %s\n", msg);
4370                         g_free (msg);
4371                 }
4372         }
4373 }
4374
4375 static MonoRuntimeUnhandledExceptionPolicy runtime_unhandled_exception_policy = MONO_UNHANDLED_POLICY_CURRENT;
4376
4377 /**
4378  * mono_runtime_unhandled_exception_policy_set:
4379  * @policy: the new policy
4380  *
4381  * This is a VM internal routine.
4382  *
4383  * Sets the runtime policy for handling unhandled exceptions.
4384  */
4385 void
4386 mono_runtime_unhandled_exception_policy_set (MonoRuntimeUnhandledExceptionPolicy policy) {
4387         runtime_unhandled_exception_policy = policy;
4388 }
4389
4390 /**
4391  * mono_runtime_unhandled_exception_policy_get:
4392  *
4393  * This is a VM internal routine.
4394  *
4395  * Gets the runtime policy for handling unhandled exceptions.
4396  */
4397 MonoRuntimeUnhandledExceptionPolicy
4398 mono_runtime_unhandled_exception_policy_get (void) {
4399         return runtime_unhandled_exception_policy;
4400 }
4401
4402 /**
4403  * mono_unhandled_exception:
4404  * @exc: exception thrown
4405  *
4406  * This is a VM internal routine.
4407  *
4408  * We call this function when we detect an unhandled exception
4409  * in the default domain.
4410  *
4411  * It invokes the * UnhandledException event in AppDomain or prints
4412  * a warning to the console
4413  */
4414 void
4415 mono_unhandled_exception (MonoObject *exc)
4416 {
4417         MONO_REQ_GC_UNSAFE_MODE;
4418
4419         MonoError error;
4420         MonoClassField *field;
4421         MonoDomain *current_domain, *root_domain;
4422         MonoObject *current_appdomain_delegate = NULL, *root_appdomain_delegate = NULL;
4423
4424         if (mono_class_has_parent (exc->vtable->klass, mono_defaults.threadabortexception_class))
4425                 return;
4426
4427         field = mono_class_get_field_from_name (mono_defaults.appdomain_class, "UnhandledException");
4428         g_assert (field);
4429
4430         current_domain = mono_domain_get ();
4431         root_domain = mono_get_root_domain ();
4432
4433         root_appdomain_delegate = mono_field_get_value_object_checked (root_domain, field, (MonoObject*) root_domain->domain, &error);
4434         mono_error_raise_exception (&error); /* FIXME don't raise here */
4435         if (current_domain != root_domain) {
4436                 current_appdomain_delegate = mono_field_get_value_object_checked (current_domain, field, (MonoObject*) current_domain->domain, &error);
4437                 mono_error_raise_exception (&error); /* FIXME don't raise here */
4438         }
4439
4440         if (!current_appdomain_delegate && !root_appdomain_delegate) {
4441                 mono_print_unhandled_exception (exc);
4442         } else {
4443                 if (root_appdomain_delegate)
4444                         call_unhandled_exception_delegate (root_domain, root_appdomain_delegate, exc);
4445                 if (current_appdomain_delegate)
4446                         call_unhandled_exception_delegate (current_domain, current_appdomain_delegate, exc);
4447         }
4448
4449         /* set exitcode only if we will abort the process */
4450         if ((main_thread && mono_thread_internal_current () == main_thread->internal_thread)
4451                  || mono_runtime_unhandled_exception_policy_get () == MONO_UNHANDLED_POLICY_CURRENT)
4452         {
4453                 mono_environment_exitcode_set (1);
4454         }
4455 }
4456
4457 /**
4458  * mono_runtime_exec_managed_code:
4459  * @domain: Application domain
4460  * @main_func: function to invoke from the execution thread
4461  * @main_args: parameter to the main_func
4462  *
4463  * Launch a new thread to execute a function
4464  *
4465  * main_func is called back from the thread with main_args as the
4466  * parameter.  The callback function is expected to start Main()
4467  * eventually.  This function then waits for all managed threads to
4468  * finish.
4469  * It is not necesseray anymore to execute managed code in a subthread,
4470  * so this function should not be used anymore by default: just
4471  * execute the code and then call mono_thread_manage ().
4472  */
4473 void
4474 mono_runtime_exec_managed_code (MonoDomain *domain,
4475                                 MonoMainThreadFunc main_func,
4476                                 gpointer main_args)
4477 {
4478         MonoError error;
4479         mono_thread_create_checked (domain, main_func, main_args, &error);
4480         mono_error_assert_ok (&error);
4481
4482         mono_thread_manage ();
4483 }
4484
4485 /*
4486  * Execute a standard Main() method (args doesn't contain the
4487  * executable name).
4488  */
4489 int
4490 mono_runtime_exec_main (MonoMethod *method, MonoArray *args, MonoObject **exc)
4491 {
4492         MONO_REQ_GC_UNSAFE_MODE;
4493
4494         MonoError error;
4495         MonoDomain *domain;
4496         gpointer pa [1];
4497         int rval;
4498         MonoCustomAttrInfo* cinfo;
4499         gboolean has_stathread_attribute;
4500         MonoInternalThread* thread = mono_thread_internal_current ();
4501
4502         g_assert (args);
4503
4504         pa [0] = args;
4505
4506         domain = mono_object_domain (args);
4507         if (!domain->entry_assembly) {
4508                 gchar *str;
4509                 MonoAssembly *assembly;
4510
4511                 assembly = method->klass->image->assembly;
4512                 domain->entry_assembly = assembly;
4513                 /* Domains created from another domain already have application_base and configuration_file set */
4514                 if (domain->setup->application_base == NULL) {
4515                         MONO_OBJECT_SETREF (domain->setup, application_base, mono_string_new (domain, assembly->basedir));
4516                 }
4517
4518                 if (domain->setup->configuration_file == NULL) {
4519                         str = g_strconcat (assembly->image->name, ".config", NULL);
4520                         MONO_OBJECT_SETREF (domain->setup, configuration_file, mono_string_new (domain, str));
4521                         g_free (str);
4522                         mono_domain_set_options_from_config (domain);
4523                 }
4524         }
4525
4526         cinfo = mono_custom_attrs_from_method_checked (method, &error);
4527         mono_error_cleanup (&error); /* FIXME warn here? */
4528         if (cinfo) {
4529                 has_stathread_attribute = mono_custom_attrs_has_attr (cinfo, mono_class_get_sta_thread_attribute_class ());
4530                 if (!cinfo->cached)
4531                         mono_custom_attrs_free (cinfo);
4532         } else {
4533                 has_stathread_attribute = FALSE;
4534         }
4535         if (has_stathread_attribute) {
4536                 thread->apartment_state = ThreadApartmentState_STA;
4537         } else {
4538                 thread->apartment_state = ThreadApartmentState_MTA;
4539         }
4540         mono_thread_init_apartment_state ();
4541
4542         /* FIXME: check signature of method */
4543         if (mono_method_signature (method)->ret->type == MONO_TYPE_I4) {
4544                 MonoObject *res;
4545                 if (exc) {
4546                         res = mono_runtime_try_invoke (method, NULL, pa, exc, &error);
4547                         if (*exc == NULL && !mono_error_ok (&error))
4548                                 *exc = (MonoObject*) mono_error_convert_to_exception (&error);
4549                         else
4550                                 mono_error_cleanup (&error);
4551                 } else {
4552                         res = mono_runtime_invoke_checked (method, NULL, pa, &error);
4553                         mono_error_raise_exception (&error); /* FIXME don't raise here */
4554                 }
4555
4556                 if (!exc || !*exc)
4557                         rval = *(guint32 *)((char *)res + sizeof (MonoObject));
4558                 else
4559                         rval = -1;
4560
4561                 mono_environment_exitcode_set (rval);
4562         } else {
4563                 if (exc) {
4564                         mono_runtime_try_invoke (method, NULL, pa, exc, &error);
4565                         if (*exc == NULL && !mono_error_ok (&error))
4566                                 *exc = (MonoObject*) mono_error_convert_to_exception (&error);
4567                         else
4568                                 mono_error_cleanup (&error);
4569                 } else {
4570                         mono_runtime_invoke_checked (method, NULL, pa, &error);
4571                         mono_error_raise_exception (&error); /* FIXME don't raise here */
4572                 }
4573
4574                 if (!exc || !*exc)
4575                         rval = 0;
4576                 else {
4577                         /* If the return type of Main is void, only
4578                          * set the exitcode if an exception was thrown
4579                          * (we don't want to blow away an
4580                          * explicitly-set exit code)
4581                          */
4582                         rval = -1;
4583                         mono_environment_exitcode_set (rval);
4584                 }
4585         }
4586
4587         return rval;
4588 }
4589
4590 /**
4591  * mono_runtime_invoke_array:
4592  * @method: method to invoke
4593  * @obJ: object instance
4594  * @params: arguments to the method
4595  * @exc: exception information.
4596  *
4597  * Invokes the method represented by @method on the object @obj.
4598  *
4599  * obj is the 'this' pointer, it should be NULL for static
4600  * methods, a MonoObject* for object instances and a pointer to
4601  * the value type for value types.
4602  *
4603  * The params array contains the arguments to the method with the
4604  * same convention: MonoObject* pointers for object instances and
4605  * pointers to the value type otherwise. The _invoke_array
4606  * variant takes a C# object[] as the params argument (MonoArray
4607  * *params): in this case the value types are boxed inside the
4608  * respective reference representation.
4609  *
4610  * From unmanaged code you'll usually use the
4611  * mono_runtime_invoke_checked() variant.
4612  *
4613  * Note that this function doesn't handle virtual methods for
4614  * you, it will exec the exact method you pass: we still need to
4615  * expose a function to lookup the derived class implementation
4616  * of a virtual method (there are examples of this in the code,
4617  * though).
4618  *
4619  * You can pass NULL as the exc argument if you don't want to
4620  * catch exceptions, otherwise, *exc will be set to the exception
4621  * thrown, if any.  if an exception is thrown, you can't use the
4622  * MonoObject* result from the function.
4623  *
4624  * If the method returns a value type, it is boxed in an object
4625  * reference.
4626  */
4627 MonoObject*
4628 mono_runtime_invoke_array (MonoMethod *method, void *obj, MonoArray *params,
4629                            MonoObject **exc)
4630 {
4631         MONO_REQ_GC_UNSAFE_MODE;
4632
4633         MonoError error;
4634         MonoMethodSignature *sig = mono_method_signature (method);
4635         gpointer *pa = NULL;
4636         MonoObject *res;
4637         int i;
4638         gboolean has_byref_nullables = FALSE;
4639
4640         if (NULL != params) {
4641                 pa = (void **)alloca (sizeof (gpointer) * mono_array_length (params));
4642                 for (i = 0; i < mono_array_length (params); i++) {
4643                         MonoType *t = sig->params [i];
4644
4645                 again:
4646                         switch (t->type) {
4647                         case MONO_TYPE_U1:
4648                         case MONO_TYPE_I1:
4649                         case MONO_TYPE_BOOLEAN:
4650                         case MONO_TYPE_U2:
4651                         case MONO_TYPE_I2:
4652                         case MONO_TYPE_CHAR:
4653                         case MONO_TYPE_U:
4654                         case MONO_TYPE_I:
4655                         case MONO_TYPE_U4:
4656                         case MONO_TYPE_I4:
4657                         case MONO_TYPE_U8:
4658                         case MONO_TYPE_I8:
4659                         case MONO_TYPE_R4:
4660                         case MONO_TYPE_R8:
4661                         case MONO_TYPE_VALUETYPE:
4662                                 if (t->type == MONO_TYPE_VALUETYPE && mono_class_is_nullable (mono_class_from_mono_type (sig->params [i]))) {
4663                                         /* The runtime invoke wrapper needs the original boxed vtype, it does handle byref values as well. */
4664                                         pa [i] = mono_array_get (params, MonoObject*, i);
4665                                         if (t->byref)
4666                                                 has_byref_nullables = TRUE;
4667                                 } else {
4668                                         /* MS seems to create the objects if a null is passed in */
4669                                         if (!mono_array_get (params, MonoObject*, i)) {
4670                                                 MonoObject *o = mono_object_new_checked (mono_domain_get (), mono_class_from_mono_type (sig->params [i]), &error);
4671                                                 mono_error_raise_exception (&error); /* FIXME don't raise here */
4672                                                 mono_array_setref (params, i, o);
4673                                         }
4674
4675                                         if (t->byref) {
4676                                                 /*
4677                                                  * We can't pass the unboxed vtype byref to the callee, since
4678                                                  * that would mean the callee would be able to modify boxed
4679                                                  * primitive types. So we (and MS) make a copy of the boxed
4680                                                  * object, pass that to the callee, and replace the original
4681                                                  * boxed object in the arg array with the copy.
4682                                                  */
4683                                                 MonoObject *orig = mono_array_get (params, MonoObject*, i);
4684                                                 MonoObject *copy = mono_value_box_checked (mono_domain_get (), orig->vtable->klass, mono_object_unbox (orig), &error);
4685                                                 mono_error_raise_exception (&error); /* FIXME don't raise here */
4686                                                 mono_array_setref (params, i, copy);
4687                                         }
4688
4689                                         pa [i] = mono_object_unbox (mono_array_get (params, MonoObject*, i));
4690                                 }
4691                                 break;
4692                         case MONO_TYPE_STRING:
4693                         case MONO_TYPE_OBJECT:
4694                         case MONO_TYPE_CLASS:
4695                         case MONO_TYPE_ARRAY:
4696                         case MONO_TYPE_SZARRAY:
4697                                 if (t->byref)
4698                                         pa [i] = mono_array_addr (params, MonoObject*, i);
4699                                         // FIXME: I need to check this code path
4700                                 else
4701                                         pa [i] = mono_array_get (params, MonoObject*, i);
4702                                 break;
4703                         case MONO_TYPE_GENERICINST:
4704                                 if (t->byref)
4705                                         t = &t->data.generic_class->container_class->this_arg;
4706                                 else
4707                                         t = &t->data.generic_class->container_class->byval_arg;
4708                                 goto again;
4709                         case MONO_TYPE_PTR: {
4710                                 MonoObject *arg;
4711
4712                                 /* The argument should be an IntPtr */
4713                                 arg = mono_array_get (params, MonoObject*, i);
4714                                 if (arg == NULL) {
4715                                         pa [i] = NULL;
4716                                 } else {
4717                                         g_assert (arg->vtable->klass == mono_defaults.int_class);
4718                                         pa [i] = ((MonoIntPtr*)arg)->m_value;
4719                                 }
4720                                 break;
4721                         }
4722                         default:
4723                                 g_error ("type 0x%x not handled in mono_runtime_invoke_array", sig->params [i]->type);
4724                         }
4725                 }
4726         }
4727
4728         if (!strcmp (method->name, ".ctor") && method->klass != mono_defaults.string_class) {
4729                 void *o = obj;
4730
4731                 if (mono_class_is_nullable (method->klass)) {
4732                         /* Need to create a boxed vtype instead */
4733                         g_assert (!obj);
4734
4735                         if (!params)
4736                                 return NULL;
4737                         else {
4738                                 MonoObject *result = mono_value_box_checked (mono_domain_get (), method->klass->cast_class, pa [0], &error);
4739                                 mono_error_raise_exception (&error); /* FIXME don't raise here */
4740                                 return result;
4741                         }
4742                 }
4743
4744                 if (!obj) {
4745                         obj = mono_object_new_checked (mono_domain_get (), method->klass, &error);
4746                         g_assert (obj && mono_error_ok (&error)); /*maybe we should raise a TLE instead?*/ /* FIXME don't swallow error */
4747 #ifndef DISABLE_REMOTING
4748                         if (mono_object_class(obj) == mono_defaults.transparent_proxy_class) {
4749                                 method = mono_marshal_get_remoting_invoke (method->slot == -1 ? method : method->klass->vtable [method->slot]);
4750                         }
4751 #endif
4752                         if (method->klass->valuetype)
4753                                 o = (MonoObject *)mono_object_unbox ((MonoObject *)obj);
4754                         else
4755                                 o = obj;
4756                 } else if (method->klass->valuetype) {
4757                         obj = mono_value_box_checked (mono_domain_get (), method->klass, obj, &error);
4758                         mono_error_raise_exception (&error); /* FIXME don't raise here */
4759                 }
4760
4761                 if (exc) {
4762                         mono_runtime_try_invoke (method, o, pa, exc, &error);
4763                         if (*exc == NULL && !mono_error_ok (&error))
4764                                 *exc = (MonoObject*) mono_error_convert_to_exception (&error);
4765                         else
4766                                 mono_error_cleanup (&error);
4767                 } else {
4768                         mono_runtime_invoke_checked (method, o, pa, &error);
4769                         mono_error_raise_exception (&error); /* FIXME don't raise here */
4770                 }
4771
4772                 return (MonoObject *)obj;
4773         } else {
4774                 if (mono_class_is_nullable (method->klass)) {
4775                         MonoObject *nullable;
4776
4777                         /* Convert the unboxed vtype into a Nullable structure */
4778                         nullable = mono_object_new_checked (mono_domain_get (), method->klass, &error);
4779                         mono_error_raise_exception (&error); /* FIXME don't raise here */
4780
4781                         MonoObject *boxed = mono_value_box_checked (mono_domain_get (), method->klass->cast_class, obj, &error);
4782                         mono_error_raise_exception (&error); /* FIXME don't raise here */
4783                         mono_nullable_init ((guint8 *)mono_object_unbox (nullable), boxed, method->klass);
4784                         obj = mono_object_unbox (nullable);
4785                 }
4786
4787                 /* obj must be already unboxed if needed */
4788                 if (exc) {
4789                         res = mono_runtime_try_invoke (method, obj, pa, exc, &error);
4790                         if (*exc == NULL && !mono_error_ok (&error))
4791                                 *exc = (MonoObject*) mono_error_convert_to_exception (&error);
4792                         else
4793                                 mono_error_cleanup (&error);
4794                 } else {
4795                         res = mono_runtime_invoke_checked (method, obj, pa, &error);
4796                         mono_error_raise_exception (&error); /* FIXME don't raise here */
4797                 }
4798
4799                 if (sig->ret->type == MONO_TYPE_PTR) {
4800                         MonoClass *pointer_class;
4801                         static MonoMethod *box_method;
4802                         void *box_args [2];
4803                         MonoObject *box_exc;
4804
4805                         /*
4806                          * The runtime-invoke wrapper returns a boxed IntPtr, need to
4807                          * convert it to a Pointer object.
4808                          */
4809                         pointer_class = mono_class_get_pointer_class ();
4810                         if (!box_method)
4811                                 box_method = mono_class_get_method_from_name (pointer_class, "Box", -1);
4812
4813                         g_assert (res->vtable->klass == mono_defaults.int_class);
4814                         box_args [0] = ((MonoIntPtr*)res)->m_value;
4815                         box_args [1] = mono_type_get_object_checked (mono_domain_get (), sig->ret, &error);
4816                         mono_error_raise_exception (&error); /* FIXME don't raise here */
4817
4818                         res = mono_runtime_try_invoke (box_method, NULL, box_args, &box_exc, &error);
4819                         g_assert (box_exc == NULL);
4820                         mono_error_assert_ok (&error);
4821                 }
4822
4823                 if (has_byref_nullables) {
4824                         /*
4825                          * The runtime invoke wrapper already converted byref nullables back,
4826                          * and stored them in pa, we just need to copy them back to the
4827                          * managed array.
4828                          */
4829                         for (i = 0; i < mono_array_length (params); i++) {
4830                                 MonoType *t = sig->params [i];
4831
4832                                 if (t->byref && t->type == MONO_TYPE_GENERICINST && mono_class_is_nullable (mono_class_from_mono_type (t)))
4833                                         mono_array_setref (params, i, pa [i]);
4834                         }
4835                 }
4836
4837                 return res;
4838         }
4839 }
4840
4841 /**
4842  * mono_object_new:
4843  * @klass: the class of the object that we want to create
4844  *
4845  * Returns: a newly created object whose definition is
4846  * looked up using @klass.   This will not invoke any constructors,
4847  * so the consumer of this routine has to invoke any constructors on
4848  * its own to initialize the object.
4849  *
4850  * It returns NULL on failure.
4851  */
4852 MonoObject *
4853 mono_object_new (MonoDomain *domain, MonoClass *klass)
4854 {
4855         MONO_REQ_GC_UNSAFE_MODE;
4856
4857         MonoError error;
4858
4859         MonoObject * result = mono_object_new_checked (domain, klass, &error);
4860
4861         mono_error_cleanup (&error);
4862         return result;
4863 }
4864
4865 MonoObject *
4866 ves_icall_object_new (MonoDomain *domain, MonoClass *klass)
4867 {
4868         MONO_REQ_GC_UNSAFE_MODE;
4869
4870         MonoError error;
4871
4872         MonoObject * result = mono_object_new_checked (domain, klass, &error);
4873
4874         mono_error_set_pending_exception (&error);
4875         return result;
4876 }
4877
4878 /**
4879  * mono_object_new_checked:
4880  * @klass: the class of the object that we want to create
4881  * @error: set on error
4882  *
4883  * Returns: a newly created object whose definition is
4884  * looked up using @klass.   This will not invoke any constructors,
4885  * so the consumer of this routine has to invoke any constructors on
4886  * its own to initialize the object.
4887  *
4888  * It returns NULL on failure and sets @error.
4889  */
4890 MonoObject *
4891 mono_object_new_checked (MonoDomain *domain, MonoClass *klass, MonoError *error)
4892 {
4893         MONO_REQ_GC_UNSAFE_MODE;
4894
4895         MonoVTable *vtable;
4896
4897         vtable = mono_class_vtable (domain, klass);
4898         g_assert (vtable); /* FIXME don't swallow the error */
4899
4900         MonoObject *o = mono_object_new_specific_checked (vtable, error);
4901         return o;
4902 }
4903
4904 /**
4905  * mono_object_new_pinned:
4906  *
4907  *   Same as mono_object_new, but the returned object will be pinned.
4908  * For SGEN, these objects will only be freed at appdomain unload.
4909  */
4910 MonoObject *
4911 mono_object_new_pinned (MonoDomain *domain, MonoClass *klass, MonoError *error)
4912 {
4913         MONO_REQ_GC_UNSAFE_MODE;
4914
4915         MonoVTable *vtable;
4916
4917         mono_error_init (error);
4918
4919         vtable = mono_class_vtable (domain, klass);
4920         g_assert (vtable); /* FIXME don't swallow the error */
4921
4922         MonoObject *o = (MonoObject *)mono_gc_alloc_pinned_obj (vtable, mono_class_instance_size (klass));
4923
4924         if (G_UNLIKELY (!o))
4925                 mono_error_set_out_of_memory (error, "Could not allocate %i bytes", mono_class_instance_size (klass));
4926         else if (G_UNLIKELY (vtable->klass->has_finalize))
4927                 mono_object_register_finalizer (o, error);
4928
4929         return o;
4930 }
4931
4932 /**
4933  * mono_object_new_specific:
4934  * @vtable: the vtable of the object that we want to create
4935  *
4936  * Returns: A newly created object with class and domain specified
4937  * by @vtable
4938  */
4939 MonoObject *
4940 mono_object_new_specific (MonoVTable *vtable)
4941 {
4942         MonoError error;
4943         MonoObject *o = mono_object_new_specific_checked (vtable, &error);
4944         mono_error_cleanup (&error);
4945
4946         return o;
4947 }
4948
4949 MonoObject *
4950 mono_object_new_specific_checked (MonoVTable *vtable, MonoError *error)
4951 {
4952         MONO_REQ_GC_UNSAFE_MODE;
4953
4954         MonoObject *o;
4955
4956         mono_error_init (error);
4957
4958         /* check for is_com_object for COM Interop */
4959         if (mono_vtable_is_remote (vtable) || mono_class_is_com_object (vtable->klass))
4960         {
4961                 gpointer pa [1];
4962                 MonoMethod *im = vtable->domain->create_proxy_for_type_method;
4963
4964                 if (im == NULL) {
4965                         MonoClass *klass = mono_class_get_activation_services_class ();
4966
4967                         if (!klass->inited)
4968                                 mono_class_init (klass);
4969
4970                         im = mono_class_get_method_from_name (klass, "CreateProxyForType", 1);
4971                         if (!im) {
4972                                 mono_error_set_not_supported (error, "Linked away.");
4973                                 return NULL;
4974                         }
4975                         vtable->domain->create_proxy_for_type_method = im;
4976                 }
4977
4978                 pa [0] = mono_type_get_object_checked (mono_domain_get (), &vtable->klass->byval_arg, error);
4979                 if (!mono_error_ok (error))
4980                         return NULL;
4981
4982                 o = mono_runtime_invoke_checked (im, NULL, pa, error);
4983                 if (!mono_error_ok (error))
4984                         return NULL;
4985
4986                 if (o != NULL)
4987                         return o;
4988         }
4989
4990         return mono_object_new_alloc_specific_checked (vtable, error);
4991 }
4992
4993 MonoObject *
4994 ves_icall_object_new_specific (MonoVTable *vtable)
4995 {
4996         MonoError error;
4997         MonoObject *o = mono_object_new_specific_checked (vtable, &error);
4998         mono_error_set_pending_exception (&error);
4999
5000         return o;
5001 }
5002
5003 /**
5004  * mono_object_new_alloc_specific:
5005  * @vtable: virtual table for the object.
5006  *
5007  * This function allocates a new `MonoObject` with the type derived
5008  * from the @vtable information.   If the class of this object has a
5009  * finalizer, then the object will be tracked for finalization.
5010  *
5011  * This method might raise an exception on errors.  Use the
5012  * `mono_object_new_fast_checked` method if you want to manually raise
5013  * the exception.
5014  *
5015  * Returns: the allocated object.
5016  */
5017 MonoObject *
5018 mono_object_new_alloc_specific (MonoVTable *vtable)
5019 {
5020         MonoError error;
5021         MonoObject *o = mono_object_new_alloc_specific_checked (vtable, &error);
5022         mono_error_cleanup (&error);
5023
5024         return o;
5025 }
5026
5027 /**
5028  * mono_object_new_alloc_specific_checked:
5029  * @vtable: virtual table for the object.
5030  * @error: holds the error return value.
5031  *
5032  * This function allocates a new `MonoObject` with the type derived
5033  * from the @vtable information. If the class of this object has a
5034  * finalizer, then the object will be tracked for finalization.
5035  *
5036  * If there is not enough memory, the @error parameter will be set
5037  * and will contain a user-visible message with the amount of bytes
5038  * that were requested.
5039  *
5040  * Returns: the allocated object, or NULL if there is not enough memory
5041  *
5042  */
5043 MonoObject *
5044 mono_object_new_alloc_specific_checked (MonoVTable *vtable, MonoError *error)
5045 {
5046         MONO_REQ_GC_UNSAFE_MODE;
5047
5048         MonoObject *o;
5049
5050         mono_error_init (error);
5051
5052         o = (MonoObject *)mono_gc_alloc_obj (vtable, vtable->klass->instance_size);
5053
5054         if (G_UNLIKELY (!o))
5055                 mono_error_set_out_of_memory (error, "Could not allocate %i bytes", vtable->klass->instance_size);
5056         else if (G_UNLIKELY (vtable->klass->has_finalize))
5057                 mono_object_register_finalizer (o, error);
5058
5059         return o;
5060 }
5061
5062 /**
5063  * mono_object_new_fast:
5064  * @vtable: virtual table for the object.
5065  *
5066  * This function allocates a new `MonoObject` with the type derived
5067  * from the @vtable information.   The returned object is not tracked
5068  * for finalization.   If your object implements a finalizer, you should
5069  * use `mono_object_new_alloc_specific` instead.
5070  *
5071  * This method might raise an exception on errors.  Use the
5072  * `mono_object_new_fast_checked` method if you want to manually raise
5073  * the exception.
5074  *
5075  * Returns: the allocated object.
5076  */
5077 MonoObject*
5078 mono_object_new_fast (MonoVTable *vtable)
5079 {
5080         MonoError error;
5081         MonoObject *o = mono_object_new_fast_checked (vtable, &error);
5082         mono_error_cleanup (&error);
5083
5084         return o;
5085 }
5086
5087 /**
5088  * mono_object_new_fast_checked:
5089  * @vtable: virtual table for the object.
5090  * @error: holds the error return value.
5091  *
5092  * This function allocates a new `MonoObject` with the type derived
5093  * from the @vtable information. The returned object is not tracked
5094  * for finalization.   If your object implements a finalizer, you should
5095  * use `mono_object_new_alloc_specific_checked` instead.
5096  *
5097  * If there is not enough memory, the @error parameter will be set
5098  * and will contain a user-visible message with the amount of bytes
5099  * that were requested.
5100  *
5101  * Returns: the allocated object, or NULL if there is not enough memory
5102  *
5103  */
5104 MonoObject*
5105 mono_object_new_fast_checked (MonoVTable *vtable, MonoError *error)
5106 {
5107         MONO_REQ_GC_UNSAFE_MODE;
5108
5109         MonoObject *o;
5110
5111         mono_error_init (error);
5112
5113         o = mono_gc_alloc_obj (vtable, vtable->klass->instance_size);
5114
5115         if (G_UNLIKELY (!o))
5116                 mono_error_set_out_of_memory (error, "Could not allocate %i bytes", vtable->klass->instance_size);
5117
5118         return o;
5119 }
5120
5121 MonoObject *
5122 ves_icall_object_new_fast (MonoVTable *vtable)
5123 {
5124         MonoError error;
5125         MonoObject *o = mono_object_new_fast_checked (vtable, &error);
5126         mono_error_set_pending_exception (&error);
5127
5128         return o;
5129 }
5130
5131 MonoObject*
5132 mono_object_new_mature (MonoVTable *vtable, MonoError *error)
5133 {
5134         MONO_REQ_GC_UNSAFE_MODE;
5135
5136         MonoObject *o;
5137
5138         mono_error_init (error);
5139
5140         o = mono_gc_alloc_mature (vtable, vtable->klass->instance_size);
5141
5142         if (G_UNLIKELY (!o))
5143                 mono_error_set_out_of_memory (error, "Could not allocate %i bytes", vtable->klass->instance_size);
5144         else if (G_UNLIKELY (vtable->klass->has_finalize))
5145                 mono_object_register_finalizer (o, error);
5146
5147         return o;
5148 }
5149
5150 /**
5151  * mono_class_get_allocation_ftn:
5152  * @vtable: vtable
5153  * @for_box: the object will be used for boxing
5154  * @pass_size_in_words:
5155  *
5156  * Return the allocation function appropriate for the given class.
5157  */
5158
5159 void*
5160 mono_class_get_allocation_ftn (MonoVTable *vtable, gboolean for_box, gboolean *pass_size_in_words)
5161 {
5162         MONO_REQ_GC_NEUTRAL_MODE;
5163
5164         *pass_size_in_words = FALSE;
5165
5166         if (mono_class_has_finalizer (vtable->klass) || mono_class_is_marshalbyref (vtable->klass) || (mono_profiler_get_events () & MONO_PROFILE_ALLOCATIONS))
5167                 return ves_icall_object_new_specific;
5168
5169         if (vtable->gc_descr != MONO_GC_DESCRIPTOR_NULL) {
5170
5171                 return ves_icall_object_new_fast;
5172
5173                 /*
5174                  * FIXME: This is actually slower than ves_icall_object_new_fast, because
5175                  * of the overhead of parameter passing.
5176                  */
5177                 /*
5178                 *pass_size_in_words = TRUE;
5179 #ifdef GC_REDIRECT_TO_LOCAL
5180                 return GC_local_gcj_fast_malloc;
5181 #else
5182                 return GC_gcj_fast_malloc;
5183 #endif
5184                 */
5185         }
5186
5187         return ves_icall_object_new_specific;
5188 }
5189
5190 /**
5191  * mono_object_new_from_token:
5192  * @image: Context where the type_token is hosted
5193  * @token: a token of the type that we want to create
5194  *
5195  * Returns: A newly created object whose definition is
5196  * looked up using @token in the @image image
5197  */
5198 MonoObject *
5199 mono_object_new_from_token  (MonoDomain *domain, MonoImage *image, guint32 token)
5200 {
5201         MONO_REQ_GC_UNSAFE_MODE;
5202
5203         MonoError error;
5204         MonoObject *result;
5205         MonoClass *klass;
5206
5207         klass = mono_class_get_checked (image, token, &error);
5208         mono_error_assert_ok (&error);
5209
5210         result = mono_object_new_checked (domain, klass, &error);
5211
5212         mono_error_cleanup (&error);
5213         return result;
5214
5215 }
5216
5217
5218 /**
5219  * mono_object_clone:
5220  * @obj: the object to clone
5221  *
5222  * Returns: A newly created object who is a shallow copy of @obj
5223  */
5224 MonoObject *
5225 mono_object_clone (MonoObject *obj)
5226 {
5227         MonoError error;
5228         MonoObject *o = mono_object_clone_checked (obj, &error);
5229         mono_error_cleanup (&error);
5230
5231         return o;
5232 }
5233
5234 MonoObject *
5235 mono_object_clone_checked (MonoObject *obj, MonoError *error)
5236 {
5237         MONO_REQ_GC_UNSAFE_MODE;
5238
5239         MonoObject *o;
5240         int size;
5241
5242         mono_error_init (error);
5243
5244         size = obj->vtable->klass->instance_size;
5245
5246         if (obj->vtable->klass->rank)
5247                 return (MonoObject*)mono_array_clone_checked ((MonoArray*)obj, error);
5248
5249         o = (MonoObject *)mono_gc_alloc_obj (obj->vtable, size);
5250
5251         if (G_UNLIKELY (!o)) {
5252                 mono_error_set_out_of_memory (error, "Could not allocate %i bytes", size);
5253                 return NULL;
5254         }
5255
5256         /* If the object doesn't contain references this will do a simple memmove. */
5257         mono_gc_wbarrier_object_copy (o, obj);
5258
5259         if (obj->vtable->klass->has_finalize)
5260                 mono_object_register_finalizer (o, error);
5261         return o;
5262 }
5263
5264 /**
5265  * mono_array_full_copy:
5266  * @src: source array to copy
5267  * @dest: destination array
5268  *
5269  * Copies the content of one array to another with exactly the same type and size.
5270  */
5271 void
5272 mono_array_full_copy (MonoArray *src, MonoArray *dest)
5273 {
5274         MONO_REQ_GC_UNSAFE_MODE;
5275
5276         uintptr_t size;
5277         MonoClass *klass = src->obj.vtable->klass;
5278
5279         g_assert (klass == dest->obj.vtable->klass);
5280
5281         size = mono_array_length (src);
5282         g_assert (size == mono_array_length (dest));
5283         size *= mono_array_element_size (klass);
5284 #ifdef HAVE_SGEN_GC
5285         if (klass->element_class->valuetype) {
5286                 if (klass->element_class->has_references)
5287                         mono_value_copy_array (dest, 0, mono_array_addr_with_size_fast (src, 0, 0), mono_array_length (src));
5288                 else
5289                         mono_gc_memmove_atomic (&dest->vector, &src->vector, size);
5290         } else {
5291                 mono_array_memcpy_refs (dest, 0, src, 0, mono_array_length (src));
5292         }
5293 #else
5294         mono_gc_memmove_atomic (&dest->vector, &src->vector, size);
5295 #endif
5296 }
5297
5298 /**
5299  * mono_array_clone_in_domain:
5300  * @domain: the domain in which the array will be cloned into
5301  * @array: the array to clone
5302  * @error: set on error
5303  *
5304  * This routine returns a copy of the array that is hosted on the
5305  * specified MonoDomain.  On failure returns NULL and sets @error.
5306  */
5307 MonoArray*
5308 mono_array_clone_in_domain (MonoDomain *domain, MonoArray *array, MonoError *error)
5309 {
5310         MONO_REQ_GC_UNSAFE_MODE;
5311
5312         MonoArray *o;
5313         uintptr_t size, i;
5314         uintptr_t *sizes;
5315         MonoClass *klass = array->obj.vtable->klass;
5316
5317         mono_error_init (error);
5318
5319         if (array->bounds == NULL) {
5320                 size = mono_array_length (array);
5321                 o = mono_array_new_full_checked (domain, klass, &size, NULL, error);
5322                 return_val_if_nok (error, NULL);
5323
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 (o, 0, mono_array_addr_with_size_fast (array, 0, 0), mono_array_length (array));
5329                         else
5330                                 mono_gc_memmove_atomic (&o->vector, &array->vector, size);
5331                 } else {
5332                         mono_array_memcpy_refs (o, 0, array, 0, mono_array_length (array));
5333                 }
5334 #else
5335                 mono_gc_memmove_atomic (&o->vector, &array->vector, size);
5336 #endif
5337                 return o;
5338         }
5339
5340         sizes = (uintptr_t *)alloca (klass->rank * sizeof(intptr_t) * 2);
5341         size = mono_array_element_size (klass);
5342         for (i = 0; i < klass->rank; ++i) {
5343                 sizes [i] = array->bounds [i].length;
5344                 size *= array->bounds [i].length;
5345                 sizes [i + klass->rank] = array->bounds [i].lower_bound;
5346         }
5347         o = mono_array_new_full_checked (domain, klass, sizes, (intptr_t*)sizes + klass->rank, error);
5348         return_val_if_nok (error, NULL);
5349 #ifdef HAVE_SGEN_GC
5350         if (klass->element_class->valuetype) {
5351                 if (klass->element_class->has_references)
5352                         mono_value_copy_array (o, 0, mono_array_addr_with_size_fast (array, 0, 0), mono_array_length (array));
5353                 else
5354                         mono_gc_memmove_atomic (&o->vector, &array->vector, size);
5355         } else {
5356                 mono_array_memcpy_refs (o, 0, array, 0, mono_array_length (array));
5357         }
5358 #else
5359         mono_gc_memmove_atomic (&o->vector, &array->vector, size);
5360 #endif
5361
5362         return o;
5363 }
5364
5365 /**
5366  * mono_array_clone:
5367  * @array: the array to clone
5368  *
5369  * Returns: A newly created array who is a shallow copy of @array
5370  */
5371 MonoArray*
5372 mono_array_clone (MonoArray *array)
5373 {
5374         MONO_REQ_GC_UNSAFE_MODE;
5375
5376         MonoError error;
5377         MonoArray *result = mono_array_clone_checked (array, &error);
5378         mono_error_cleanup (&error);
5379         return result;
5380 }
5381
5382 /**
5383  * mono_array_clone_checked:
5384  * @array: the array to clone
5385  * @error: set on error
5386  *
5387  * Returns: A newly created array who is a shallow copy of @array.  On
5388  * failure returns NULL and sets @error.
5389  */
5390 MonoArray*
5391 mono_array_clone_checked (MonoArray *array, MonoError *error)
5392 {
5393
5394         MONO_REQ_GC_UNSAFE_MODE;
5395         return mono_array_clone_in_domain (((MonoObject *)array)->vtable->domain, array, error);
5396 }
5397
5398 /* helper macros to check for overflow when calculating the size of arrays */
5399 #ifdef MONO_BIG_ARRAYS
5400 #define MYGUINT64_MAX 0x0000FFFFFFFFFFFFUL
5401 #define MYGUINT_MAX MYGUINT64_MAX
5402 #define CHECK_ADD_OVERFLOW_UN(a,b) \
5403             (G_UNLIKELY ((guint64)(MYGUINT64_MAX) - (guint64)(b) < (guint64)(a)))
5404 #define CHECK_MUL_OVERFLOW_UN(a,b) \
5405             (G_UNLIKELY (((guint64)(a) > 0) && ((guint64)(b) > 0) &&    \
5406                                          ((guint64)(b) > ((MYGUINT64_MAX) / (guint64)(a)))))
5407 #else
5408 #define MYGUINT32_MAX 4294967295U
5409 #define MYGUINT_MAX MYGUINT32_MAX
5410 #define CHECK_ADD_OVERFLOW_UN(a,b) \
5411             (G_UNLIKELY ((guint32)(MYGUINT32_MAX) - (guint32)(b) < (guint32)(a)))
5412 #define CHECK_MUL_OVERFLOW_UN(a,b) \
5413             (G_UNLIKELY (((guint32)(a) > 0) && ((guint32)(b) > 0) &&                    \
5414                                          ((guint32)(b) > ((MYGUINT32_MAX) / (guint32)(a)))))
5415 #endif
5416
5417 gboolean
5418 mono_array_calc_byte_len (MonoClass *klass, uintptr_t len, uintptr_t *res)
5419 {
5420         MONO_REQ_GC_NEUTRAL_MODE;
5421
5422         uintptr_t byte_len;
5423
5424         byte_len = mono_array_element_size (klass);
5425         if (CHECK_MUL_OVERFLOW_UN (byte_len, len))
5426                 return FALSE;
5427         byte_len *= len;
5428         if (CHECK_ADD_OVERFLOW_UN (byte_len, MONO_SIZEOF_MONO_ARRAY))
5429                 return FALSE;
5430         byte_len += MONO_SIZEOF_MONO_ARRAY;
5431
5432         *res = byte_len;
5433
5434         return TRUE;
5435 }
5436
5437 /**
5438  * mono_array_new_full:
5439  * @domain: domain where the object is created
5440  * @array_class: array class
5441  * @lengths: lengths for each dimension in the array
5442  * @lower_bounds: lower bounds for each dimension in the array (may be NULL)
5443  *
5444  * This routine creates a new array objects with the given dimensions,
5445  * lower bounds and type.
5446  */
5447 MonoArray*
5448 mono_array_new_full (MonoDomain *domain, MonoClass *array_class, uintptr_t *lengths, intptr_t *lower_bounds)
5449 {
5450         MonoError error;
5451         MonoArray *array = mono_array_new_full_checked (domain, array_class, lengths, lower_bounds, &error);
5452         mono_error_cleanup (&error);
5453
5454         return array;
5455 }
5456
5457 MonoArray*
5458 mono_array_new_full_checked (MonoDomain *domain, MonoClass *array_class, uintptr_t *lengths, intptr_t *lower_bounds, MonoError *error)
5459 {
5460         MONO_REQ_GC_UNSAFE_MODE;
5461
5462         uintptr_t byte_len = 0, len, bounds_size;
5463         MonoObject *o;
5464         MonoArray *array;
5465         MonoArrayBounds *bounds;
5466         MonoVTable *vtable;
5467         int i;
5468
5469         mono_error_init (error);
5470
5471         if (!array_class->inited)
5472                 mono_class_init (array_class);
5473
5474         len = 1;
5475
5476         /* A single dimensional array with a 0 lower bound is the same as an szarray */
5477         if (array_class->rank == 1 && ((array_class->byval_arg.type == MONO_TYPE_SZARRAY) || (lower_bounds && lower_bounds [0] == 0))) {
5478                 len = lengths [0];
5479                 if (len > MONO_ARRAY_MAX_INDEX) {
5480                         mono_error_set_generic_error (error, "System", "OverflowException", "");
5481                         return NULL;
5482                 }
5483                 bounds_size = 0;
5484         } else {
5485                 bounds_size = sizeof (MonoArrayBounds) * array_class->rank;
5486
5487                 for (i = 0; i < array_class->rank; ++i) {
5488                         if (lengths [i] > MONO_ARRAY_MAX_INDEX) {
5489                                 mono_error_set_generic_error (error, "System", "OverflowException", "");
5490                                 return NULL;
5491                         }
5492                         if (CHECK_MUL_OVERFLOW_UN (len, lengths [i])) {
5493                                 mono_error_set_out_of_memory (error, "Could not allocate %i bytes", MONO_ARRAY_MAX_SIZE);
5494                                 return NULL;
5495                         }
5496                         len *= lengths [i];
5497                 }
5498         }
5499
5500         if (!mono_array_calc_byte_len (array_class, len, &byte_len)) {
5501                 mono_error_set_out_of_memory (error, "Could not allocate %i bytes", MONO_ARRAY_MAX_SIZE);
5502                 return NULL;
5503         }
5504
5505         if (bounds_size) {
5506                 /* align */
5507                 if (CHECK_ADD_OVERFLOW_UN (byte_len, 3)) {
5508                         mono_error_set_out_of_memory (error, "Could not allocate %i bytes", MONO_ARRAY_MAX_SIZE);
5509                         return NULL;
5510                 }
5511                 byte_len = (byte_len + 3) & ~3;
5512                 if (CHECK_ADD_OVERFLOW_UN (byte_len, bounds_size)) {
5513                         mono_error_set_out_of_memory (error, "Could not allocate %i bytes", MONO_ARRAY_MAX_SIZE);
5514                         return NULL;
5515                 }
5516                 byte_len += bounds_size;
5517         }
5518         /*
5519          * Following three lines almost taken from mono_object_new ():
5520          * they need to be kept in sync.
5521          */
5522         vtable = mono_class_vtable_full (domain, array_class, error);
5523         return_val_if_nok (error, NULL);
5524
5525         if (bounds_size)
5526                 o = (MonoObject *)mono_gc_alloc_array (vtable, byte_len, len, bounds_size);
5527         else
5528                 o = (MonoObject *)mono_gc_alloc_vector (vtable, byte_len, len);
5529
5530         if (G_UNLIKELY (!o)) {
5531                 mono_error_set_out_of_memory (error, "Could not allocate %i bytes", byte_len);
5532                 return NULL;
5533         }
5534
5535         array = (MonoArray*)o;
5536
5537         bounds = array->bounds;
5538
5539         if (bounds_size) {
5540                 for (i = 0; i < array_class->rank; ++i) {
5541                         bounds [i].length = lengths [i];
5542                         if (lower_bounds)
5543                                 bounds [i].lower_bound = lower_bounds [i];
5544                 }
5545         }
5546
5547         return array;
5548 }
5549
5550 /**
5551  * mono_array_new:
5552  * @domain: domain where the object is created
5553  * @eclass: element class
5554  * @n: number of array elements
5555  *
5556  * This routine creates a new szarray with @n elements of type @eclass.
5557  */
5558 MonoArray *
5559 mono_array_new (MonoDomain *domain, MonoClass *eclass, uintptr_t n)
5560 {
5561         MONO_REQ_GC_UNSAFE_MODE;
5562
5563         MonoError error;
5564         MonoArray *result = mono_array_new_checked (domain, eclass, n, &error);
5565         mono_error_cleanup (&error);
5566         return result;
5567 }
5568
5569 /**
5570  * mono_array_new_checked:
5571  * @domain: domain where the object is created
5572  * @eclass: element class
5573  * @n: number of array elements
5574  * @error: set on error
5575  *
5576  * This routine creates a new szarray with @n elements of type @eclass.
5577  * On failure returns NULL and sets @error.
5578  */
5579 MonoArray *
5580 mono_array_new_checked (MonoDomain *domain, MonoClass *eclass, uintptr_t n, MonoError *error)
5581 {
5582         MonoClass *ac;
5583
5584         mono_error_init (error);
5585
5586         ac = mono_array_class_get (eclass, 1);
5587         g_assert (ac);
5588
5589         MonoVTable *vtable = mono_class_vtable_full (domain, ac, error);
5590         return_val_if_nok (error, NULL);
5591
5592         return mono_array_new_specific_checked (vtable, n, error);
5593 }
5594
5595 MonoArray*
5596 ves_icall_array_new (MonoDomain *domain, MonoClass *eclass, uintptr_t n)
5597 {
5598         MonoError error;
5599         MonoArray *arr = mono_array_new_checked (domain, eclass, n, &error);
5600         mono_error_set_pending_exception (&error);
5601
5602         return arr;
5603 }
5604
5605 /**
5606  * mono_array_new_specific:
5607  * @vtable: a vtable in the appropriate domain for an initialized class
5608  * @n: number of array elements
5609  *
5610  * This routine is a fast alternative to mono_array_new() for code which
5611  * can be sure about the domain it operates in.
5612  */
5613 MonoArray *
5614 mono_array_new_specific (MonoVTable *vtable, uintptr_t n)
5615 {
5616         MonoError error;
5617         MonoArray *arr = mono_array_new_specific_checked (vtable, n, &error);
5618         mono_error_cleanup (&error);
5619
5620         return arr;
5621 }
5622
5623 MonoArray*
5624 mono_array_new_specific_checked (MonoVTable *vtable, uintptr_t n, MonoError *error)
5625 {
5626         MONO_REQ_GC_UNSAFE_MODE;
5627
5628         MonoObject *o;
5629         uintptr_t byte_len;
5630
5631         mono_error_init (error);
5632
5633         if (G_UNLIKELY (n > MONO_ARRAY_MAX_INDEX)) {
5634                 mono_error_set_generic_error (error, "System", "OverflowException", "");
5635                 return NULL;
5636         }
5637
5638         if (!mono_array_calc_byte_len (vtable->klass, n, &byte_len)) {
5639                 mono_error_set_out_of_memory (error, "Could not allocate %i bytes", MONO_ARRAY_MAX_SIZE);
5640                 return NULL;
5641         }
5642         o = (MonoObject *)mono_gc_alloc_vector (vtable, byte_len, n);
5643
5644         if (G_UNLIKELY (!o)) {
5645                 mono_error_set_out_of_memory (error, "Could not allocate %i bytes", byte_len);
5646                 return NULL;
5647         }
5648
5649         return (MonoArray*)o;
5650 }
5651
5652 MonoArray*
5653 ves_icall_array_new_specific (MonoVTable *vtable, uintptr_t n)
5654 {
5655         MonoError error;
5656         MonoArray *arr = mono_array_new_specific_checked (vtable, n, &error);
5657         mono_error_set_pending_exception (&error);
5658
5659         return arr;
5660 }
5661
5662 /**
5663  * mono_string_new_utf16:
5664  * @text: a pointer to an utf16 string
5665  * @len: the length of the string
5666  *
5667  * Returns: A newly created string object which contains @text.
5668  */
5669 MonoString *
5670 mono_string_new_utf16 (MonoDomain *domain, const guint16 *text, gint32 len)
5671 {
5672         MONO_REQ_GC_UNSAFE_MODE;
5673
5674         MonoError error;
5675         MonoString *res = NULL;
5676         res = mono_string_new_utf16_checked (domain, text, len, &error);
5677         mono_error_cleanup (&error);
5678
5679         return res;
5680 }
5681
5682 /**
5683  * mono_string_new_utf16_checked:
5684  * @text: a pointer to an utf16 string
5685  * @len: the length of the string
5686  * @error: written on error.
5687  *
5688  * Returns: A newly created string object which contains @text.
5689  * On error, returns NULL and sets @error.
5690  */
5691 MonoString *
5692 mono_string_new_utf16_checked (MonoDomain *domain, const guint16 *text, gint32 len, MonoError *error)
5693 {
5694         MONO_REQ_GC_UNSAFE_MODE;
5695
5696         MonoString *s;
5697
5698         mono_error_init (error);
5699
5700         s = mono_string_new_size_checked (domain, len, error);
5701         if (s != NULL)
5702                 memcpy (mono_string_chars (s), text, len * 2);
5703
5704         return s;
5705 }
5706
5707 /**
5708  * mono_string_new_utf32:
5709  * @text: a pointer to an utf32 string
5710  * @len: the length of the string
5711  * @error: set on failure.
5712  *
5713  * Returns: A newly created string object which contains @text. On failure returns NULL and sets @error.
5714  */
5715 static MonoString *
5716 mono_string_new_utf32_checked (MonoDomain *domain, const mono_unichar4 *text, gint32 len, MonoError *error)
5717 {
5718         MONO_REQ_GC_UNSAFE_MODE;
5719
5720         MonoString *s;
5721         mono_unichar2 *utf16_output = NULL;
5722         gint32 utf16_len = 0;
5723         GError *gerror = NULL;
5724         glong items_written;
5725
5726         mono_error_init (error);
5727         utf16_output = g_ucs4_to_utf16 (text, len, NULL, &items_written, &gerror);
5728
5729         if (gerror)
5730                 g_error_free (gerror);
5731
5732         while (utf16_output [utf16_len]) utf16_len++;
5733
5734         s = mono_string_new_size_checked (domain, utf16_len, error);
5735         return_val_if_nok (error, NULL);
5736
5737         memcpy (mono_string_chars (s), utf16_output, utf16_len * 2);
5738
5739         g_free (utf16_output);
5740
5741         return s;
5742 }
5743
5744 /**
5745  * mono_string_new_utf32:
5746  * @text: a pointer to an utf32 string
5747  * @len: the length of the string
5748  *
5749  * Returns: A newly created string object which contains @text.
5750  */
5751 MonoString *
5752 mono_string_new_utf32 (MonoDomain *domain, const mono_unichar4 *text, gint32 len)
5753 {
5754         MonoError error;
5755         MonoString *result = mono_string_new_utf32_checked (domain, text, len, &error);
5756         mono_error_cleanup (&error);
5757         return result;
5758 }
5759
5760 /**
5761  * mono_string_new_size:
5762  * @text: a pointer to an utf16 string
5763  * @len: the length of the string
5764  *
5765  * Returns: A newly created string object of @len
5766  */
5767 MonoString *
5768 mono_string_new_size (MonoDomain *domain, gint32 len)
5769 {
5770         MonoError error;
5771         MonoString *str = mono_string_new_size_checked (domain, len, &error);
5772         mono_error_cleanup (&error);
5773
5774         return str;
5775 }
5776
5777 MonoString *
5778 mono_string_new_size_checked (MonoDomain *domain, gint32 len, MonoError *error)
5779 {
5780         MONO_REQ_GC_UNSAFE_MODE;
5781
5782         MonoString *s;
5783         MonoVTable *vtable;
5784         size_t size;
5785
5786         mono_error_init (error);
5787
5788         /* check for overflow */
5789         if (len < 0 || len > ((SIZE_MAX - G_STRUCT_OFFSET (MonoString, chars) - 8) / 2)) {
5790                 mono_error_set_out_of_memory (error, "Could not allocate %i bytes", -1);
5791                 return NULL;
5792         }
5793
5794         size = (G_STRUCT_OFFSET (MonoString, chars) + (((size_t)len + 1) * 2));
5795         g_assert (size > 0);
5796
5797         vtable = mono_class_vtable (domain, mono_defaults.string_class);
5798         g_assert (vtable);
5799
5800         s = (MonoString *)mono_gc_alloc_string (vtable, size, len);
5801
5802         if (G_UNLIKELY (!s)) {
5803                 mono_error_set_out_of_memory (error, "Could not allocate %i bytes", size);
5804                 return NULL;
5805         }
5806
5807         return s;
5808 }
5809
5810 /**
5811  * mono_string_new_len:
5812  * @text: a pointer to an utf8 string
5813  * @length: number of bytes in @text to consider
5814  *
5815  * Returns: A newly created string object which contains @text.
5816  */
5817 MonoString*
5818 mono_string_new_len (MonoDomain *domain, const char *text, guint length)
5819 {
5820         MONO_REQ_GC_UNSAFE_MODE;
5821
5822         MonoError error;
5823         MonoString *result = mono_string_new_len_checked (domain, text, length, &error);
5824         mono_error_cleanup (&error);
5825         return result;
5826 }
5827
5828 /**
5829  * mono_string_new_len_checked:
5830  * @text: a pointer to an utf8 string
5831  * @length: number of bytes in @text to consider
5832  * @error: set on error
5833  *
5834  * Returns: A newly created string object which contains @text. On
5835  * failure returns NULL and sets @error.
5836  */
5837 MonoString*
5838 mono_string_new_len_checked (MonoDomain *domain, const char *text, guint length, MonoError *error)
5839 {
5840         MONO_REQ_GC_UNSAFE_MODE;
5841
5842         mono_error_init (error);
5843
5844         GError *eg_error = NULL;
5845         MonoString *o = NULL;
5846         guint16 *ut = NULL;
5847         glong items_written;
5848
5849         ut = eg_utf8_to_utf16_with_nuls (text, length, NULL, &items_written, &eg_error);
5850
5851         if (!eg_error)
5852                 o = mono_string_new_utf16_checked (domain, ut, items_written, error);
5853         else
5854                 g_error_free (eg_error);
5855
5856         g_free (ut);
5857
5858         return o;
5859 }
5860
5861 /**
5862  * mono_string_new:
5863  * @text: a pointer to an utf8 string
5864  *
5865  * Returns: A newly created string object which contains @text.
5866  *
5867  * This function asserts if it cannot allocate a new string.
5868  *
5869  * @deprecated Use mono_string_new_checked in new code.
5870  */
5871 MonoString*
5872 mono_string_new (MonoDomain *domain, const char *text)
5873 {
5874         MonoError error;
5875         MonoString *res = NULL;
5876         res = mono_string_new_checked (domain, text, &error);
5877         mono_error_assert_ok (&error);
5878         return res;
5879 }
5880
5881 /**
5882  * mono_string_new_checked:
5883  * @text: a pointer to an utf8 string
5884  * @merror: set on error
5885  *
5886  * Returns: A newly created string object which contains @text.
5887  * On error returns NULL and sets @merror.
5888  */
5889 MonoString*
5890 mono_string_new_checked (MonoDomain *domain, const char *text, MonoError *error)
5891 {
5892         MONO_REQ_GC_UNSAFE_MODE;
5893
5894     GError *eg_error = NULL;
5895     MonoString *o = NULL;
5896     guint16 *ut;
5897     glong items_written;
5898     int l;
5899
5900     mono_error_init (error);
5901
5902     l = strlen (text);
5903
5904     ut = g_utf8_to_utf16 (text, l, NULL, &items_written, &eg_error);
5905
5906     if (!eg_error)
5907             o = mono_string_new_utf16_checked (domain, ut, items_written, error);
5908     else
5909         g_error_free (eg_error);
5910
5911     g_free (ut);
5912
5913 /*FIXME g_utf8_get_char, g_utf8_next_char and g_utf8_validate are not part of eglib.*/
5914 #if 0
5915         gunichar2 *str;
5916         const gchar *end;
5917         int len;
5918         MonoString *o = NULL;
5919
5920         if (!g_utf8_validate (text, -1, &end)) {
5921                 mono_error_set_argument (error, "text", "Not a valid utf8 string");
5922                 goto leave;
5923         }
5924
5925         len = g_utf8_strlen (text, -1);
5926         o = mono_string_new_size_checked (domain, len, error);
5927         if (!o)
5928                 goto leave;
5929         str = mono_string_chars (o);
5930
5931         while (text < end) {
5932                 *str++ = g_utf8_get_char (text);
5933                 text = g_utf8_next_char (text);
5934         }
5935
5936 leave:
5937 #endif
5938         return o;
5939 }
5940
5941 /**
5942  * mono_string_new_wrapper:
5943  * @text: pointer to utf8 characters.
5944  *
5945  * Helper function to create a string object from @text in the current domain.
5946  */
5947 MonoString*
5948 mono_string_new_wrapper (const char *text)
5949 {
5950         MONO_REQ_GC_UNSAFE_MODE;
5951
5952         MonoDomain *domain = mono_domain_get ();
5953
5954         if (text)
5955                 return mono_string_new (domain, text);
5956
5957         return NULL;
5958 }
5959
5960 /**
5961  * mono_value_box:
5962  * @class: the class of the value
5963  * @value: a pointer to the unboxed data
5964  *
5965  * Returns: A newly created object which contains @value.
5966  */
5967 MonoObject *
5968 mono_value_box (MonoDomain *domain, MonoClass *klass, gpointer value)
5969 {
5970         MonoError error;
5971         MonoObject *result = mono_value_box_checked (domain, klass, value, &error);
5972         mono_error_cleanup (&error);
5973         return result;
5974 }
5975
5976 /**
5977  * mono_value_box_checked:
5978  * @domain: the domain of the new object
5979  * @class: the class of the value
5980  * @value: a pointer to the unboxed data
5981  * @error: set on error
5982  *
5983  * Returns: A newly created object which contains @value. On failure
5984  * returns NULL and sets @error.
5985  */
5986 MonoObject *
5987 mono_value_box_checked (MonoDomain *domain, MonoClass *klass, gpointer value, MonoError *error)
5988 {
5989         MONO_REQ_GC_UNSAFE_MODE;
5990         MonoObject *res;
5991         int size;
5992         MonoVTable *vtable;
5993
5994         mono_error_init (error);
5995
5996         g_assert (klass->valuetype);
5997         if (mono_class_is_nullable (klass))
5998                 return mono_nullable_box ((guint8 *)value, klass, error);
5999
6000         vtable = mono_class_vtable (domain, klass);
6001         if (!vtable)
6002                 return NULL;
6003         size = mono_class_instance_size (klass);
6004         res = mono_object_new_alloc_specific_checked (vtable, error);
6005         return_val_if_nok (error, NULL);
6006
6007         size = size - sizeof (MonoObject);
6008
6009 #ifdef HAVE_SGEN_GC
6010         g_assert (size == mono_class_value_size (klass, NULL));
6011         mono_gc_wbarrier_value_copy ((char *)res + sizeof (MonoObject), value, 1, klass);
6012 #else
6013 #if NO_UNALIGNED_ACCESS
6014         mono_gc_memmove_atomic ((char *)res + sizeof (MonoObject), value, size);
6015 #else
6016         switch (size) {
6017         case 1:
6018                 *((guint8 *) res + sizeof (MonoObject)) = *(guint8 *) value;
6019                 break;
6020         case 2:
6021                 *(guint16 *)((guint8 *) res + sizeof (MonoObject)) = *(guint16 *) value;
6022                 break;
6023         case 4:
6024                 *(guint32 *)((guint8 *) res + sizeof (MonoObject)) = *(guint32 *) value;
6025                 break;
6026         case 8:
6027                 *(guint64 *)((guint8 *) res + sizeof (MonoObject)) = *(guint64 *) value;
6028                 break;
6029         default:
6030                 mono_gc_memmove_atomic ((char *)res + sizeof (MonoObject), value, size);
6031         }
6032 #endif
6033 #endif
6034         if (klass->has_finalize) {
6035                 mono_object_register_finalizer (res, error);
6036                 return_val_if_nok (error, NULL);
6037         }
6038         return res;
6039 }
6040
6041 /**
6042  * mono_value_copy:
6043  * @dest: destination pointer
6044  * @src: source pointer
6045  * @klass: a valuetype class
6046  *
6047  * Copy a valuetype from @src to @dest. This function must be used
6048  * when @klass contains references fields.
6049  */
6050 void
6051 mono_value_copy (gpointer dest, gpointer src, MonoClass *klass)
6052 {
6053         MONO_REQ_GC_UNSAFE_MODE;
6054
6055         mono_gc_wbarrier_value_copy (dest, src, 1, klass);
6056 }
6057
6058 /**
6059  * mono_value_copy_array:
6060  * @dest: destination array
6061  * @dest_idx: index in the @dest array
6062  * @src: source pointer
6063  * @count: number of items
6064  *
6065  * Copy @count valuetype items from @src to the array @dest at index @dest_idx.
6066  * This function must be used when @klass contains references fields.
6067  * Overlap is handled.
6068  */
6069 void
6070 mono_value_copy_array (MonoArray *dest, int dest_idx, gpointer src, int count)
6071 {
6072         MONO_REQ_GC_UNSAFE_MODE;
6073
6074         int size = mono_array_element_size (dest->obj.vtable->klass);
6075         char *d = mono_array_addr_with_size_fast (dest, size, dest_idx);
6076         g_assert (size == mono_class_value_size (mono_object_class (dest)->element_class, NULL));
6077         mono_gc_wbarrier_value_copy (d, src, count, mono_object_class (dest)->element_class);
6078 }
6079
6080 /**
6081  * mono_object_get_domain:
6082  * @obj: object to query
6083  *
6084  * Returns: the MonoDomain where the object is hosted
6085  */
6086 MonoDomain*
6087 mono_object_get_domain (MonoObject *obj)
6088 {
6089         MONO_REQ_GC_UNSAFE_MODE;
6090
6091         return mono_object_domain (obj);
6092 }
6093
6094 /**
6095  * mono_object_get_class:
6096  * @obj: object to query
6097  *
6098  * Use this function to obtain the `MonoClass*` for a given `MonoObject`.
6099  *
6100  * Returns: the MonoClass of the object.
6101  */
6102 MonoClass*
6103 mono_object_get_class (MonoObject *obj)
6104 {
6105         MONO_REQ_GC_UNSAFE_MODE;
6106
6107         return mono_object_class (obj);
6108 }
6109 /**
6110  * mono_object_get_size:
6111  * @o: object to query
6112  *
6113  * Returns: the size, in bytes, of @o
6114  */
6115 guint
6116 mono_object_get_size (MonoObject* o)
6117 {
6118         MONO_REQ_GC_UNSAFE_MODE;
6119
6120         MonoClass* klass = mono_object_class (o);
6121         if (klass == mono_defaults.string_class) {
6122                 return sizeof (MonoString) + 2 * mono_string_length ((MonoString*) o) + 2;
6123         } else if (o->vtable->rank) {
6124                 MonoArray *array = (MonoArray*)o;
6125                 size_t size = MONO_SIZEOF_MONO_ARRAY + mono_array_element_size (klass) * mono_array_length (array);
6126                 if (array->bounds) {
6127                         size += 3;
6128                         size &= ~3;
6129                         size += sizeof (MonoArrayBounds) * o->vtable->rank;
6130                 }
6131                 return size;
6132         } else {
6133                 return mono_class_instance_size (klass);
6134         }
6135 }
6136
6137 /**
6138  * mono_object_unbox:
6139  * @obj: object to unbox
6140  *
6141  * Returns: a pointer to the start of the valuetype boxed in this
6142  * object.
6143  *
6144  * This method will assert if the object passed is not a valuetype.
6145  */
6146 gpointer
6147 mono_object_unbox (MonoObject *obj)
6148 {
6149         MONO_REQ_GC_UNSAFE_MODE;
6150
6151         /* add assert for valuetypes? */
6152         g_assert (obj->vtable->klass->valuetype);
6153         return ((char*)obj) + sizeof (MonoObject);
6154 }
6155
6156 /**
6157  * mono_object_isinst:
6158  * @obj: an object
6159  * @klass: a pointer to a class
6160  *
6161  * Returns: @obj if @obj is derived from @klass or NULL otherwise.
6162  */
6163 MonoObject *
6164 mono_object_isinst (MonoObject *obj, MonoClass *klass)
6165 {
6166         MONO_REQ_GC_UNSAFE_MODE;
6167
6168         MonoError error;
6169         MonoObject *result = mono_object_isinst_checked (obj, klass, &error);
6170         mono_error_cleanup (&error);
6171         return result;
6172 }
6173
6174
6175 /**
6176  * mono_object_isinst_checked:
6177  * @obj: an object
6178  * @klass: a pointer to a class
6179  * @error: set on error
6180  *
6181  * Returns: @obj if @obj is derived from @klass or NULL if it isn't.
6182  * On failure returns NULL and sets @error.
6183  */
6184 MonoObject *
6185 mono_object_isinst_checked (MonoObject *obj, MonoClass *klass, MonoError *error)
6186 {
6187         MONO_REQ_GC_UNSAFE_MODE;
6188
6189         mono_error_init (error);
6190
6191         MonoObject *result = NULL;
6192
6193         if (!klass->inited)
6194                 mono_class_init (klass);
6195
6196         if (mono_class_is_marshalbyref (klass) || (klass->flags & TYPE_ATTRIBUTE_INTERFACE)) {
6197                 result = mono_object_isinst_mbyref_checked (obj, klass, error);
6198                 return result;
6199         }
6200
6201         if (!obj)
6202                 return NULL;
6203
6204         return mono_class_is_assignable_from (klass, obj->vtable->klass) ? obj : NULL;
6205 }
6206
6207 MonoObject *
6208 mono_object_isinst_mbyref (MonoObject *obj, MonoClass *klass)
6209 {
6210         MONO_REQ_GC_UNSAFE_MODE;
6211
6212         MonoError error;
6213         MonoObject *result = mono_object_isinst_mbyref_checked (obj, klass, &error);
6214         mono_error_cleanup (&error); /* FIXME better API that doesn't swallow the error */
6215         return result;
6216 }
6217
6218 MonoObject *
6219 mono_object_isinst_mbyref_checked (MonoObject *obj, MonoClass *klass, MonoError *error)
6220 {
6221         MONO_REQ_GC_UNSAFE_MODE;
6222
6223         MonoVTable *vt;
6224
6225         mono_error_init (error);
6226
6227         if (!obj)
6228                 return NULL;
6229
6230         vt = obj->vtable;
6231
6232         if (klass->flags & TYPE_ATTRIBUTE_INTERFACE) {
6233                 if (MONO_VTABLE_IMPLEMENTS_INTERFACE (vt, klass->interface_id)) {
6234                         return obj;
6235                 }
6236
6237                 /*If the above check fails we are in the slow path of possibly raising an exception. So it's ok to it this way.*/
6238                 if (mono_class_has_variant_generic_params (klass) && mono_class_is_assignable_from (klass, obj->vtable->klass))
6239                         return obj;
6240         } else {
6241                 MonoClass *oklass = vt->klass;
6242                 if (mono_class_is_transparent_proxy (oklass))
6243                         oklass = ((MonoTransparentProxy *)obj)->remote_class->proxy_class;
6244
6245                 mono_class_setup_supertypes (klass);
6246                 if ((oklass->idepth >= klass->idepth) && (oklass->supertypes [klass->idepth - 1] == klass))
6247                         return obj;
6248         }
6249 #ifndef DISABLE_REMOTING
6250         if (vt->klass == mono_defaults.transparent_proxy_class && ((MonoTransparentProxy *)obj)->custom_type_info)
6251         {
6252                 MonoDomain *domain = mono_domain_get ();
6253                 MonoObject *res;
6254                 MonoObject *rp = (MonoObject *)((MonoTransparentProxy *)obj)->rp;
6255                 MonoClass *rpklass = mono_defaults.iremotingtypeinfo_class;
6256                 MonoMethod *im = NULL;
6257                 gpointer pa [2];
6258
6259                 im = mono_class_get_method_from_name (rpklass, "CanCastTo", -1);
6260                 if (!im) {
6261                         mono_error_set_not_supported (error, "Linked away.");
6262                         return NULL;
6263                 }
6264                 im = mono_object_get_virtual_method (rp, im);
6265                 g_assert (im);
6266
6267                 pa [0] = mono_type_get_object_checked (domain, &klass->byval_arg, error);
6268                 return_val_if_nok (error, NULL);
6269                 pa [1] = obj;
6270
6271                 res = mono_runtime_invoke_checked (im, rp, pa, error);
6272                 return_val_if_nok (error, NULL);
6273
6274                 if (*(MonoBoolean *) mono_object_unbox(res)) {
6275                         /* Update the vtable of the remote type, so it can safely cast to this new type */
6276                         mono_upgrade_remote_class (domain, obj, klass);
6277                         return obj;
6278                 }
6279         }
6280 #endif /* DISABLE_REMOTING */
6281         return NULL;
6282 }
6283
6284 /**
6285  * mono_object_castclass_mbyref:
6286  * @obj: an object
6287  * @klass: a pointer to a class
6288  *
6289  * Returns: @obj if @obj is derived from @klass, returns NULL otherwise.
6290  */
6291 MonoObject *
6292 mono_object_castclass_mbyref (MonoObject *obj, MonoClass *klass)
6293 {
6294         MONO_REQ_GC_UNSAFE_MODE;
6295         MonoError error;
6296
6297         if (!obj) return NULL;
6298         if (mono_object_isinst_mbyref_checked (obj, klass, &error)) return obj;
6299         mono_error_cleanup (&error);
6300         return NULL;
6301 }
6302
6303 typedef struct {
6304         MonoDomain *orig_domain;
6305         MonoString *ins;
6306         MonoString *res;
6307 } LDStrInfo;
6308
6309 static void
6310 str_lookup (MonoDomain *domain, gpointer user_data)
6311 {
6312         MONO_REQ_GC_UNSAFE_MODE;
6313
6314         LDStrInfo *info = (LDStrInfo *)user_data;
6315         if (info->res || domain == info->orig_domain)
6316                 return;
6317         info->res = (MonoString *)mono_g_hash_table_lookup (domain->ldstr_table, info->ins);
6318 }
6319
6320 static MonoString*
6321 mono_string_get_pinned (MonoString *str, MonoError *error)
6322 {
6323         MONO_REQ_GC_UNSAFE_MODE;
6324
6325         mono_error_init (error);
6326
6327         /* We only need to make a pinned version of a string if this is a moving GC */
6328         if (!mono_gc_is_moving ())
6329                 return str;
6330         int size;
6331         MonoString *news;
6332         size = sizeof (MonoString) + 2 * (mono_string_length (str) + 1);
6333         news = (MonoString *)mono_gc_alloc_pinned_obj (((MonoObject*)str)->vtable, size);
6334         if (news) {
6335                 memcpy (mono_string_chars (news), mono_string_chars (str), mono_string_length (str) * 2);
6336                 news->length = mono_string_length (str);
6337         } else {
6338                 mono_error_set_out_of_memory (error, "Could not allocate %i bytes", size);
6339         }
6340         return news;
6341 }
6342
6343 static MonoString*
6344 mono_string_is_interned_lookup (MonoString *str, int insert, MonoError *error)
6345 {
6346         MONO_REQ_GC_UNSAFE_MODE;
6347
6348         MonoGHashTable *ldstr_table;
6349         MonoString *s, *res;
6350         MonoDomain *domain;
6351
6352         mono_error_init (error);
6353
6354         domain = ((MonoObject *)str)->vtable->domain;
6355         ldstr_table = domain->ldstr_table;
6356         ldstr_lock ();
6357         res = (MonoString *)mono_g_hash_table_lookup (ldstr_table, str);
6358         if (res) {
6359                 ldstr_unlock ();
6360                 return res;
6361         }
6362         if (insert) {
6363                 /* Allocate outside the lock */
6364                 ldstr_unlock ();
6365                 s = mono_string_get_pinned (str, error);
6366                 return_val_if_nok (error, NULL);
6367                 if (s) {
6368                         ldstr_lock ();
6369                         res = (MonoString *)mono_g_hash_table_lookup (ldstr_table, str);
6370                         if (res) {
6371                                 ldstr_unlock ();
6372                                 return res;
6373                         }
6374                         mono_g_hash_table_insert (ldstr_table, s, s);
6375                         ldstr_unlock ();
6376                 }
6377                 return s;
6378         } else {
6379                 LDStrInfo ldstr_info;
6380                 ldstr_info.orig_domain = domain;
6381                 ldstr_info.ins = str;
6382                 ldstr_info.res = NULL;
6383
6384                 mono_domain_foreach (str_lookup, &ldstr_info);
6385                 if (ldstr_info.res) {
6386                         /*
6387                          * the string was already interned in some other domain:
6388                          * intern it in the current one as well.
6389                          */
6390                         mono_g_hash_table_insert (ldstr_table, str, str);
6391                         ldstr_unlock ();
6392                         return str;
6393                 }
6394         }
6395         ldstr_unlock ();
6396         return NULL;
6397 }
6398
6399 /**
6400  * mono_string_is_interned:
6401  * @o: String to probe
6402  *
6403  * Returns whether the string has been interned.
6404  */
6405 MonoString*
6406 mono_string_is_interned (MonoString *o)
6407 {
6408         MonoError error;
6409         MonoString *result = mono_string_is_interned_lookup (o, FALSE, &error);
6410         /* This function does not fail. */
6411         mono_error_assert_ok (&error);
6412         return result;
6413 }
6414
6415 /**
6416  * mono_string_intern:
6417  * @o: String to intern
6418  *
6419  * Interns the string passed.
6420  * Returns: The interned string.
6421  */
6422 MonoString*
6423 mono_string_intern (MonoString *str)
6424 {
6425         MonoError error;
6426         MonoString *result = mono_string_intern_checked (str, &error);
6427         mono_error_assert_ok (&error);
6428         return result;
6429 }
6430
6431 /**
6432  * mono_string_intern_checked:
6433  * @o: String to intern
6434  * @error: set on error.
6435  *
6436  * Interns the string passed.
6437  * Returns: The interned string.  On failure returns NULL and sets @error
6438  */
6439 MonoString*
6440 mono_string_intern_checked (MonoString *str, MonoError *error)
6441 {
6442         MONO_REQ_GC_UNSAFE_MODE;
6443
6444         mono_error_init (error);
6445
6446         return mono_string_is_interned_lookup (str, TRUE, error);
6447 }
6448
6449 /**
6450  * mono_ldstr:
6451  * @domain: the domain where the string will be used.
6452  * @image: a metadata context
6453  * @idx: index into the user string table.
6454  *
6455  * Implementation for the ldstr opcode.
6456  * Returns: a loaded string from the @image/@idx combination.
6457  */
6458 MonoString*
6459 mono_ldstr (MonoDomain *domain, MonoImage *image, guint32 idx)
6460 {
6461         MONO_REQ_GC_UNSAFE_MODE;
6462         MonoError error;
6463
6464         if (image->dynamic) {
6465                 MonoString *str = (MonoString *)mono_lookup_dynamic_token (image, MONO_TOKEN_STRING | idx, NULL, &error);
6466                 mono_error_raise_exception (&error); /* FIXME don't raise here */
6467                 return str;
6468         } else {
6469                 if (!mono_verifier_verify_string_signature (image, idx, NULL))
6470                         return NULL; /*FIXME we should probably be raising an exception here*/
6471                 MonoString *str = mono_ldstr_metadata_sig (domain, mono_metadata_user_string (image, idx), &error);
6472                 mono_error_raise_exception (&error); /* FIXME don't raise here */
6473                 return str;
6474         }
6475 }
6476
6477 /**
6478  * mono_ldstr_metadata_sig
6479  * @domain: the domain for the string
6480  * @sig: the signature of a metadata string
6481  * @error: set on error
6482  *
6483  * Returns: a MonoString for a string stored in the metadata. On
6484  * failure returns NULL and sets @error.
6485  */
6486 static MonoString*
6487 mono_ldstr_metadata_sig (MonoDomain *domain, const char* sig, MonoError *error)
6488 {
6489         MONO_REQ_GC_UNSAFE_MODE;
6490
6491         mono_error_init (error);
6492         const char *str = sig;
6493         MonoString *o, *interned;
6494         size_t len2;
6495
6496         len2 = mono_metadata_decode_blob_size (str, &str);
6497         len2 >>= 1;
6498
6499         o = mono_string_new_utf16_checked (domain, (guint16*)str, len2, error);
6500         return_val_if_nok (error, NULL);
6501 #if G_BYTE_ORDER != G_LITTLE_ENDIAN
6502         {
6503                 int i;
6504                 guint16 *p2 = (guint16*)mono_string_chars (o);
6505                 for (i = 0; i < len2; ++i) {
6506                         *p2 = GUINT16_FROM_LE (*p2);
6507                         ++p2;
6508                 }
6509         }
6510 #endif
6511         ldstr_lock ();
6512         interned = (MonoString *)mono_g_hash_table_lookup (domain->ldstr_table, o);
6513         ldstr_unlock ();
6514         if (interned)
6515                 return interned; /* o will get garbage collected */
6516
6517         o = mono_string_get_pinned (o, error);
6518         if (o) {
6519                 ldstr_lock ();
6520                 interned = (MonoString *)mono_g_hash_table_lookup (domain->ldstr_table, o);
6521                 if (!interned) {
6522                         mono_g_hash_table_insert (domain->ldstr_table, o, o);
6523                         interned = o;
6524                 }
6525                 ldstr_unlock ();
6526         }
6527
6528         return interned;
6529 }
6530
6531 /**
6532  * mono_string_to_utf8:
6533  * @s: a System.String
6534  *
6535  * Returns the UTF8 representation for @s.
6536  * The resulting buffer needs to be freed with mono_free().
6537  *
6538  * @deprecated Use mono_string_to_utf8_checked to avoid having an exception arbritraly raised.
6539  */
6540 char *
6541 mono_string_to_utf8 (MonoString *s)
6542 {
6543         MONO_REQ_GC_UNSAFE_MODE;
6544
6545         MonoError error;
6546         char *result = mono_string_to_utf8_checked (s, &error);
6547
6548         if (!mono_error_ok (&error))
6549                 mono_error_raise_exception (&error);
6550         return result;
6551 }
6552
6553 /**
6554  * mono_string_to_utf8_checked:
6555  * @s: a System.String
6556  * @error: a MonoError.
6557  *
6558  * Converts a MonoString to its UTF8 representation. May fail; check
6559  * @error to determine whether the conversion was successful.
6560  * The resulting buffer should be freed with mono_free().
6561  */
6562 char *
6563 mono_string_to_utf8_checked (MonoString *s, MonoError *error)
6564 {
6565         MONO_REQ_GC_UNSAFE_MODE;
6566
6567         long written = 0;
6568         char *as;
6569         GError *gerror = NULL;
6570
6571         mono_error_init (error);
6572
6573         if (s == NULL)
6574                 return NULL;
6575
6576         if (!s->length)
6577                 return g_strdup ("");
6578
6579         as = g_utf16_to_utf8 (mono_string_chars (s), s->length, NULL, &written, &gerror);
6580         if (gerror) {
6581                 mono_error_set_argument (error, "string", "%s", gerror->message);
6582                 g_error_free (gerror);
6583                 return NULL;
6584         }
6585         /* g_utf16_to_utf8  may not be able to complete the convertion (e.g. NULL values were found, #335488) */
6586         if (s->length > written) {
6587                 /* allocate the total length and copy the part of the string that has been converted */
6588                 char *as2 = (char *)g_malloc0 (s->length);
6589                 memcpy (as2, as, written);
6590                 g_free (as);
6591                 as = as2;
6592         }
6593
6594         return as;
6595 }
6596
6597 /**
6598  * mono_string_to_utf8_ignore:
6599  * @s: a MonoString
6600  *
6601  * Converts a MonoString to its UTF8 representation. Will ignore
6602  * invalid surrogate pairs.
6603  * The resulting buffer should be freed with mono_free().
6604  *
6605  */
6606 char *
6607 mono_string_to_utf8_ignore (MonoString *s)
6608 {
6609         MONO_REQ_GC_UNSAFE_MODE;
6610
6611         long written = 0;
6612         char *as;
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, NULL);
6621
6622         /* g_utf16_to_utf8  may not be able to complete the convertion (e.g. NULL values were found, #335488) */
6623         if (s->length > written) {
6624                 /* allocate the total length and copy the part of the string that has been converted */
6625                 char *as2 = (char *)g_malloc0 (s->length);
6626                 memcpy (as2, as, written);
6627                 g_free (as);
6628                 as = as2;
6629         }
6630
6631         return as;
6632 }
6633
6634 /**
6635  * mono_string_to_utf8_image_ignore:
6636  * @s: a System.String
6637  *
6638  * Same as mono_string_to_utf8_ignore, but allocate the string from the image mempool.
6639  */
6640 char *
6641 mono_string_to_utf8_image_ignore (MonoImage *image, MonoString *s)
6642 {
6643         MONO_REQ_GC_UNSAFE_MODE;
6644
6645         return mono_string_to_utf8_internal (NULL, image, s, TRUE, NULL);
6646 }
6647
6648 /**
6649  * mono_string_to_utf8_mp_ignore:
6650  * @s: a System.String
6651  *
6652  * Same as mono_string_to_utf8_ignore, but allocate the string from a mempool.
6653  */
6654 char *
6655 mono_string_to_utf8_mp_ignore (MonoMemPool *mp, MonoString *s)
6656 {
6657         MONO_REQ_GC_UNSAFE_MODE;
6658
6659         return mono_string_to_utf8_internal (mp, NULL, s, TRUE, NULL);
6660 }
6661
6662
6663 /**
6664  * mono_string_to_utf16:
6665  * @s: a MonoString
6666  *
6667  * Return an null-terminated array of the utf-16 chars
6668  * contained in @s. The result must be freed with g_free().
6669  * This is a temporary helper until our string implementation
6670  * is reworked to always include the null terminating char.
6671  */
6672 mono_unichar2*
6673 mono_string_to_utf16 (MonoString *s)
6674 {
6675         MONO_REQ_GC_UNSAFE_MODE;
6676
6677         char *as;
6678
6679         if (s == NULL)
6680                 return NULL;
6681
6682         as = (char *)g_malloc ((s->length * 2) + 2);
6683         as [(s->length * 2)] = '\0';
6684         as [(s->length * 2) + 1] = '\0';
6685
6686         if (!s->length) {
6687                 return (gunichar2 *)(as);
6688         }
6689
6690         memcpy (as, mono_string_chars(s), s->length * 2);
6691         return (gunichar2 *)(as);
6692 }
6693
6694 /**
6695  * mono_string_to_utf32:
6696  * @s: a MonoString
6697  *
6698  * Return an null-terminated array of the UTF-32 (UCS-4) chars
6699  * contained in @s. The result must be freed with g_free().
6700  */
6701 mono_unichar4*
6702 mono_string_to_utf32 (MonoString *s)
6703 {
6704         MONO_REQ_GC_UNSAFE_MODE;
6705
6706         mono_unichar4 *utf32_output = NULL;
6707         GError *error = NULL;
6708         glong items_written;
6709
6710         if (s == NULL)
6711                 return NULL;
6712
6713         utf32_output = g_utf16_to_ucs4 (s->chars, s->length, NULL, &items_written, &error);
6714
6715         if (error)
6716                 g_error_free (error);
6717
6718         return utf32_output;
6719 }
6720
6721 /**
6722  * mono_string_from_utf16:
6723  * @data: the UTF16 string (LPWSTR) to convert
6724  *
6725  * Converts a NULL terminated UTF16 string (LPWSTR) to a MonoString.
6726  *
6727  * Returns: a MonoString.
6728  */
6729 MonoString *
6730 mono_string_from_utf16 (gunichar2 *data)
6731 {
6732         MONO_REQ_GC_UNSAFE_MODE;
6733
6734         MonoError error;
6735         MonoString *res = NULL;
6736         MonoDomain *domain = mono_domain_get ();
6737         int len = 0;
6738
6739         if (!data)
6740                 return NULL;
6741
6742         while (data [len]) len++;
6743
6744         res = mono_string_new_utf16_checked (domain, data, len, &error);
6745         mono_error_raise_exception (&error); /* FIXME don't raise here */
6746         return res;
6747 }
6748
6749 /**
6750  * mono_string_from_utf32:
6751  * @data: the UTF32 string (LPWSTR) to convert
6752  *
6753  * Converts a UTF32 (UCS-4)to a MonoString.
6754  *
6755  * Returns: a MonoString.
6756  */
6757 MonoString *
6758 mono_string_from_utf32 (mono_unichar4 *data)
6759 {
6760         MONO_REQ_GC_UNSAFE_MODE;
6761
6762         MonoString* result = NULL;
6763         mono_unichar2 *utf16_output = NULL;
6764         GError *error = NULL;
6765         glong items_written;
6766         int len = 0;
6767
6768         if (!data)
6769                 return NULL;
6770
6771         while (data [len]) len++;
6772
6773         utf16_output = g_ucs4_to_utf16 (data, len, NULL, &items_written, &error);
6774
6775         if (error)
6776                 g_error_free (error);
6777
6778         result = mono_string_from_utf16 (utf16_output);
6779         g_free (utf16_output);
6780         return result;
6781 }
6782
6783 static char *
6784 mono_string_to_utf8_internal (MonoMemPool *mp, MonoImage *image, MonoString *s, gboolean ignore_error, MonoError *error)
6785 {
6786         MONO_REQ_GC_UNSAFE_MODE;
6787
6788         char *r;
6789         char *mp_s;
6790         int len;
6791
6792         if (ignore_error) {
6793                 r = mono_string_to_utf8_ignore (s);
6794         } else {
6795                 r = mono_string_to_utf8_checked (s, error);
6796                 if (!mono_error_ok (error))
6797                         return NULL;
6798         }
6799
6800         if (!mp && !image)
6801                 return r;
6802
6803         len = strlen (r) + 1;
6804         if (mp)
6805                 mp_s = (char *)mono_mempool_alloc (mp, len);
6806         else
6807                 mp_s = (char *)mono_image_alloc (image, len);
6808
6809         memcpy (mp_s, r, len);
6810
6811         g_free (r);
6812
6813         return mp_s;
6814 }
6815
6816 /**
6817  * mono_string_to_utf8_image:
6818  * @s: a System.String
6819  *
6820  * Same as mono_string_to_utf8, but allocate the string from the image mempool.
6821  */
6822 char *
6823 mono_string_to_utf8_image (MonoImage *image, MonoString *s, MonoError *error)
6824 {
6825         MONO_REQ_GC_UNSAFE_MODE;
6826
6827         return mono_string_to_utf8_internal (NULL, image, s, FALSE, error);
6828 }
6829
6830 /**
6831  * mono_string_to_utf8_mp:
6832  * @s: a System.String
6833  *
6834  * Same as mono_string_to_utf8, but allocate the string from a mempool.
6835  */
6836 char *
6837 mono_string_to_utf8_mp (MonoMemPool *mp, MonoString *s, MonoError *error)
6838 {
6839         MONO_REQ_GC_UNSAFE_MODE;
6840
6841         return mono_string_to_utf8_internal (mp, NULL, s, FALSE, error);
6842 }
6843
6844
6845 static MonoRuntimeExceptionHandlingCallbacks eh_callbacks;
6846
6847 void
6848 mono_install_eh_callbacks (MonoRuntimeExceptionHandlingCallbacks *cbs)
6849 {
6850         eh_callbacks = *cbs;
6851 }
6852
6853 MonoRuntimeExceptionHandlingCallbacks *
6854 mono_get_eh_callbacks (void)
6855 {
6856         return &eh_callbacks;
6857 }
6858
6859 /**
6860  * mono_raise_exception:
6861  * @ex: exception object
6862  *
6863  * Signal the runtime that the exception @ex has been raised in unmanaged code.
6864  */
6865 void
6866 mono_raise_exception (MonoException *ex)
6867 {
6868         MONO_REQ_GC_UNSAFE_MODE;
6869
6870         /*
6871          * NOTE: Do NOT annotate this function with G_GNUC_NORETURN, since
6872          * that will cause gcc to omit the function epilog, causing problems when
6873          * the JIT tries to walk the stack, since the return address on the stack
6874          * will point into the next function in the executable, not this one.
6875          */
6876         eh_callbacks.mono_raise_exception (ex);
6877 }
6878
6879 void
6880 mono_raise_exception_with_context (MonoException *ex, MonoContext *ctx)
6881 {
6882         MONO_REQ_GC_UNSAFE_MODE;
6883
6884         eh_callbacks.mono_raise_exception_with_ctx (ex, ctx);
6885 }
6886
6887 /**
6888  * mono_wait_handle_new:
6889  * @domain: Domain where the object will be created
6890  * @handle: Handle for the wait handle
6891  * @error: set on error.
6892  *
6893  * Returns: A new MonoWaitHandle created in the given domain for the
6894  * given handle.  On failure returns NULL and sets @rror.
6895  */
6896 MonoWaitHandle *
6897 mono_wait_handle_new (MonoDomain *domain, HANDLE handle, MonoError *error)
6898 {
6899         MONO_REQ_GC_UNSAFE_MODE;
6900
6901         MonoWaitHandle *res;
6902         gpointer params [1];
6903         static MonoMethod *handle_set;
6904
6905         mono_error_init (error);
6906         res = (MonoWaitHandle *)mono_object_new_checked (domain, mono_defaults.manualresetevent_class, error);
6907         return_val_if_nok (error, NULL);
6908
6909         /* Even though this method is virtual, it's safe to invoke directly, since the object type matches.  */
6910         if (!handle_set)
6911                 handle_set = mono_class_get_property_from_name (mono_defaults.manualresetevent_class, "Handle")->set;
6912
6913         params [0] = &handle;
6914
6915         mono_runtime_invoke_checked (handle_set, res, params, error);
6916         return res;
6917 }
6918
6919 HANDLE
6920 mono_wait_handle_get_handle (MonoWaitHandle *handle)
6921 {
6922         MONO_REQ_GC_UNSAFE_MODE;
6923
6924         static MonoClassField *f_safe_handle = NULL;
6925         MonoSafeHandle *sh;
6926
6927         if (!f_safe_handle) {
6928                 f_safe_handle = mono_class_get_field_from_name (mono_defaults.manualresetevent_class, "safeWaitHandle");
6929                 g_assert (f_safe_handle);
6930         }
6931
6932         mono_field_get_value ((MonoObject*)handle, f_safe_handle, &sh);
6933         return sh->handle;
6934 }
6935
6936
6937 static MonoObject*
6938 mono_runtime_capture_context (MonoDomain *domain)
6939 {
6940         MONO_REQ_GC_UNSAFE_MODE;
6941
6942         RuntimeInvokeFunction runtime_invoke;
6943
6944         if (!domain->capture_context_runtime_invoke || !domain->capture_context_method) {
6945                 MonoMethod *method = mono_get_context_capture_method ();
6946                 MonoMethod *wrapper;
6947                 if (!method)
6948                         return NULL;
6949                 wrapper = mono_marshal_get_runtime_invoke (method, FALSE);
6950                 domain->capture_context_runtime_invoke = mono_compile_method (wrapper);
6951                 domain->capture_context_method = mono_compile_method (method);
6952         }
6953
6954         runtime_invoke = (RuntimeInvokeFunction)domain->capture_context_runtime_invoke;
6955
6956         return runtime_invoke (NULL, NULL, NULL, domain->capture_context_method);
6957 }
6958 /**
6959  * mono_async_result_new:
6960  * @domain:domain where the object will be created.
6961  * @handle: wait handle.
6962  * @state: state to pass to AsyncResult
6963  * @data: C closure data.
6964  *
6965  * Creates a new MonoAsyncResult (AsyncResult C# class) in the given domain.
6966  * If the handle is not null, the handle is initialized to a MonOWaitHandle.
6967  *
6968  */
6969 MonoAsyncResult *
6970 mono_async_result_new (MonoDomain *domain, HANDLE handle, MonoObject *state, gpointer data, MonoObject *object_data)
6971 {
6972         MONO_REQ_GC_UNSAFE_MODE;
6973
6974         MonoError error;
6975         MonoAsyncResult *res = (MonoAsyncResult *)mono_object_new_checked (domain, mono_defaults.asyncresult_class, &error);
6976         mono_error_raise_exception (&error); /* FIXME don't raise here */
6977         MonoObject *context = mono_runtime_capture_context (domain);
6978         /* we must capture the execution context from the original thread */
6979         if (context) {
6980                 MONO_OBJECT_SETREF (res, execution_context, context);
6981                 /* note: result may be null if the flow is suppressed */
6982         }
6983
6984         res->data = (void **)data;
6985         MONO_OBJECT_SETREF (res, object_data, object_data);
6986         MONO_OBJECT_SETREF (res, async_state, state);
6987         MonoWaitHandle *wait_handle = mono_wait_handle_new (domain, handle, &error);
6988         mono_error_raise_exception (&error); /* FIXME don't raise here */
6989         if (handle != NULL)
6990                 MONO_OBJECT_SETREF (res, handle, (MonoObject *) wait_handle);
6991
6992         res->sync_completed = FALSE;
6993         res->completed = FALSE;
6994
6995         return res;
6996 }
6997
6998 MonoObject *
6999 ves_icall_System_Runtime_Remoting_Messaging_AsyncResult_Invoke (MonoAsyncResult *ares)
7000 {
7001         MONO_REQ_GC_UNSAFE_MODE;
7002
7003         MonoError error;
7004         MonoAsyncCall *ac;
7005         MonoObject *res;
7006
7007         g_assert (ares);
7008         g_assert (ares->async_delegate);
7009
7010         ac = (MonoAsyncCall*) ares->object_data;
7011         if (!ac) {
7012                 res = mono_runtime_delegate_invoke (ares->async_delegate, (void**) &ares->async_state, NULL);
7013         } else {
7014                 gpointer wait_event = NULL;
7015
7016                 ac->msg->exc = NULL;
7017                 res = mono_message_invoke (ares->async_delegate, ac->msg, &ac->msg->exc, &ac->out_args);
7018                 MONO_OBJECT_SETREF (ac, res, res);
7019
7020                 mono_monitor_enter ((MonoObject*) ares);
7021                 ares->completed = 1;
7022                 if (ares->handle)
7023                         wait_event = mono_wait_handle_get_handle ((MonoWaitHandle*) ares->handle);
7024                 mono_monitor_exit ((MonoObject*) ares);
7025
7026                 if (wait_event != NULL)
7027                         SetEvent (wait_event);
7028
7029                 if (ac->cb_method) {
7030                         mono_runtime_invoke_checked (ac->cb_method, ac->cb_target, (gpointer*) &ares, &error);
7031                         if (mono_error_set_pending_exception (&error))
7032                                 return NULL;
7033                 }
7034         }
7035
7036         return res;
7037 }
7038
7039 void
7040 mono_message_init (MonoDomain *domain,
7041                    MonoMethodMessage *this_obj,
7042                    MonoReflectionMethod *method,
7043                    MonoArray *out_args)
7044 {
7045         MONO_REQ_GC_UNSAFE_MODE;
7046
7047         static MonoClass *object_array_klass;
7048         static MonoClass *byte_array_klass;
7049         static MonoClass *string_array_klass;
7050         MonoError error;
7051         MonoMethodSignature *sig = mono_method_signature (method->method);
7052         MonoString *name;
7053         MonoArray *arr;
7054         int i, j;
7055         char **names;
7056         guint8 arg_type;
7057
7058         if (!object_array_klass) {
7059                 MonoClass *klass;
7060
7061                 klass = mono_array_class_get (mono_defaults.byte_class, 1);
7062                 g_assert (klass);
7063                 byte_array_klass = klass;
7064
7065                 klass = mono_array_class_get (mono_defaults.string_class, 1);
7066                 g_assert (klass);
7067                 string_array_klass = klass;
7068
7069                 klass = mono_array_class_get (mono_defaults.object_class, 1);
7070                 g_assert (klass);
7071
7072                 mono_atomic_store_release (&object_array_klass, klass);
7073         }
7074
7075         MONO_OBJECT_SETREF (this_obj, method, method);
7076
7077         arr = mono_array_new_specific_checked (mono_class_vtable (domain, object_array_klass), sig->param_count, &error);
7078         mono_error_raise_exception (&error); /* FIXME don't raise here */
7079
7080         MONO_OBJECT_SETREF (this_obj, args, arr);
7081
7082         arr = mono_array_new_specific_checked (mono_class_vtable (domain, byte_array_klass), sig->param_count, &error);
7083         mono_error_raise_exception (&error); /* FIXME don't raise here */
7084
7085         MONO_OBJECT_SETREF (this_obj, arg_types, arr);
7086
7087         this_obj->async_result = NULL;
7088         this_obj->call_type = CallType_Sync;
7089
7090         names = g_new (char *, sig->param_count);
7091         mono_method_get_param_names (method->method, (const char **) names);
7092
7093         arr = mono_array_new_specific_checked (mono_class_vtable (domain, string_array_klass), sig->param_count, &error);
7094         mono_error_raise_exception (&error); /* FIXME don't raise here */
7095
7096         MONO_OBJECT_SETREF (this_obj, names, arr);
7097
7098         for (i = 0; i < sig->param_count; i++) {
7099                 name = mono_string_new (domain, names [i]);
7100                 mono_array_setref (this_obj->names, i, name);
7101         }
7102
7103         g_free (names);
7104         for (i = 0, j = 0; i < sig->param_count; i++) {
7105                 if (sig->params [i]->byref) {
7106                         if (out_args) {
7107                                 MonoObject* arg = (MonoObject *)mono_array_get (out_args, gpointer, j);
7108                                 mono_array_setref (this_obj->args, i, arg);
7109                                 j++;
7110                         }
7111                         arg_type = 2;
7112                         if (!(sig->params [i]->attrs & PARAM_ATTRIBUTE_OUT))
7113                                 arg_type |= 1;
7114                 } else {
7115                         arg_type = 1;
7116                         if (sig->params [i]->attrs & PARAM_ATTRIBUTE_OUT)
7117                                 arg_type |= 4;
7118                 }
7119                 mono_array_set (this_obj->arg_types, guint8, i, arg_type);
7120         }
7121 }
7122
7123 #ifndef DISABLE_REMOTING
7124 /**
7125  * mono_remoting_invoke:
7126  * @real_proxy: pointer to a RealProxy object
7127  * @msg: The MonoMethodMessage to execute
7128  * @exc: used to store exceptions
7129  * @out_args: used to store output arguments
7130  *
7131  * This is used to call RealProxy::Invoke(). RealProxy::Invoke() returns an
7132  * IMessage interface and it is not trivial to extract results from there. So
7133  * we call an helper method PrivateInvoke instead of calling
7134  * RealProxy::Invoke() directly.
7135  *
7136  * Returns: the result object.
7137  */
7138 MonoObject *
7139 mono_remoting_invoke (MonoObject *real_proxy, MonoMethodMessage *msg, MonoObject **exc, MonoArray **out_args, MonoError *error)
7140 {
7141         MONO_REQ_GC_UNSAFE_MODE;
7142
7143         MonoObject *o;
7144         MonoMethod *im = real_proxy->vtable->domain->private_invoke_method;
7145         gpointer pa [4];
7146
7147         g_assert (exc);
7148
7149         mono_error_init (error);
7150
7151         /*static MonoObject *(*invoke) (gpointer, gpointer, MonoObject **, MonoArray **) = NULL;*/
7152
7153         if (!im) {
7154                 im = mono_class_get_method_from_name (mono_defaults.real_proxy_class, "PrivateInvoke", 4);
7155                 if (!im) {
7156                         mono_error_set_not_supported (error, "Linked away.");
7157                         return NULL;
7158                 }
7159                 real_proxy->vtable->domain->private_invoke_method = im;
7160         }
7161
7162         pa [0] = real_proxy;
7163         pa [1] = msg;
7164         pa [2] = exc;
7165         pa [3] = out_args;
7166
7167         o = mono_runtime_try_invoke (im, NULL, pa, exc, error);
7168         return_val_if_nok (error, NULL);
7169
7170         return o;
7171 }
7172 #endif
7173
7174 MonoObject *
7175 mono_message_invoke (MonoObject *target, MonoMethodMessage *msg,
7176                      MonoObject **exc, MonoArray **out_args)
7177 {
7178         MONO_REQ_GC_UNSAFE_MODE;
7179
7180         static MonoClass *object_array_klass;
7181         MonoError error;
7182         MonoDomain *domain;
7183         MonoMethod *method;
7184         MonoMethodSignature *sig;
7185         MonoObject *ret;
7186         MonoArray *arr;
7187         int i, j, outarg_count = 0;
7188
7189 #ifndef DISABLE_REMOTING
7190         if (target && mono_object_is_transparent_proxy (target)) {
7191                 MonoTransparentProxy* tp = (MonoTransparentProxy *)target;
7192                 if (mono_class_is_contextbound (tp->remote_class->proxy_class) && tp->rp->context == (MonoObject *) mono_context_get ()) {
7193                         target = tp->rp->unwrapped_server;
7194                 } else {
7195                         ret = mono_remoting_invoke ((MonoObject *)tp->rp, msg, exc, out_args, &error);
7196                         mono_error_raise_exception (&error); /* FIXME don't raise here */
7197
7198                         return ret;
7199                 }
7200         }
7201 #endif
7202
7203         domain = mono_domain_get ();
7204         method = msg->method->method;
7205         sig = mono_method_signature (method);
7206
7207         for (i = 0; i < sig->param_count; i++) {
7208                 if (sig->params [i]->byref)
7209                         outarg_count++;
7210         }
7211
7212         if (!object_array_klass) {
7213                 MonoClass *klass;
7214
7215                 klass = mono_array_class_get (mono_defaults.object_class, 1);
7216                 g_assert (klass);
7217
7218                 mono_memory_barrier ();
7219                 object_array_klass = klass;
7220         }
7221
7222         arr = mono_array_new_specific_checked (mono_class_vtable (domain, object_array_klass), outarg_count, &error);
7223         mono_error_raise_exception (&error); /* FIXME don't raise here */
7224
7225         mono_gc_wbarrier_generic_store (out_args, (MonoObject*) arr);
7226         *exc = NULL;
7227
7228         ret = mono_runtime_invoke_array (method, method->klass->valuetype? mono_object_unbox (target): target, msg->args, exc);
7229
7230         for (i = 0, j = 0; i < sig->param_count; i++) {
7231                 if (sig->params [i]->byref) {
7232                         MonoObject* arg;
7233                         arg = (MonoObject *)mono_array_get (msg->args, gpointer, i);
7234                         mono_array_setref (*out_args, j, arg);
7235                         j++;
7236                 }
7237         }
7238
7239         return ret;
7240 }
7241
7242 /**
7243  * mono_object_to_string:
7244  * @obj: The object
7245  * @exc: Any exception thrown by ToString (). May be NULL.
7246  *
7247  * Returns: the result of calling ToString () on an object.
7248  */
7249 MonoString *
7250 mono_object_to_string (MonoObject *obj, MonoObject **exc)
7251 {
7252         MONO_REQ_GC_UNSAFE_MODE;
7253
7254         static MonoMethod *to_string = NULL;
7255         MonoError error;
7256         MonoMethod *method;
7257         MonoString *s;
7258         void *target = obj;
7259
7260         g_assert (obj);
7261
7262         if (!to_string)
7263                 to_string = mono_class_get_method_from_name_flags (mono_get_object_class (), "ToString", 0, METHOD_ATTRIBUTE_VIRTUAL | METHOD_ATTRIBUTE_PUBLIC);
7264
7265         method = mono_object_get_virtual_method (obj, to_string);
7266
7267         // Unbox value type if needed
7268         if (mono_class_is_valuetype (mono_method_get_class (method))) {
7269                 target = mono_object_unbox (obj);
7270         }
7271
7272         if (exc) {
7273                 s = (MonoString *) mono_runtime_try_invoke (method, target, NULL, exc, &error);
7274                 if (*exc == NULL && !mono_error_ok (&error))
7275                         *exc = (MonoObject*) mono_error_convert_to_exception (&error);
7276                 else
7277                         mono_error_cleanup (&error);
7278         } else {
7279                 s = (MonoString *) mono_runtime_invoke_checked (method, target, NULL, &error);
7280                 mono_error_raise_exception (&error); /* FIXME don't raise here */
7281         }
7282
7283         return s;
7284 }
7285
7286 /**
7287  * mono_print_unhandled_exception:
7288  * @exc: The exception
7289  *
7290  * Prints the unhandled exception.
7291  */
7292 void
7293 mono_print_unhandled_exception (MonoObject *exc)
7294 {
7295         MONO_REQ_GC_UNSAFE_MODE;
7296
7297         MonoString * str;
7298         char *message = (char*)"";
7299         gboolean free_message = FALSE;
7300         MonoError error;
7301
7302         if (exc == (MonoObject*)mono_object_domain (exc)->out_of_memory_ex) {
7303                 message = g_strdup ("OutOfMemoryException");
7304                 free_message = TRUE;
7305         } else if (exc == (MonoObject*)mono_object_domain (exc)->stack_overflow_ex) {
7306                 message = g_strdup ("StackOverflowException"); //if we OVF, we can't expect to have stack space to JIT Exception::ToString.
7307                 free_message = TRUE;
7308         } else {
7309
7310                 if (((MonoException*)exc)->native_trace_ips) {
7311                         message = mono_exception_get_native_backtrace ((MonoException*)exc);
7312                         free_message = TRUE;
7313                 } else {
7314                         MonoObject *other_exc = NULL;
7315                         str = mono_object_to_string (exc, &other_exc);
7316                         if (other_exc) {
7317                                 char *original_backtrace = mono_exception_get_managed_backtrace ((MonoException*)exc);
7318                                 char *nested_backtrace = mono_exception_get_managed_backtrace ((MonoException*)other_exc);
7319
7320                                 message = g_strdup_printf ("Nested exception detected.\nOriginal Exception: %s\nNested exception:%s\n",
7321                                         original_backtrace, nested_backtrace);
7322
7323                                 g_free (original_backtrace);
7324                                 g_free (nested_backtrace);
7325                                 free_message = TRUE;
7326                         } else if (str) {
7327                                 message = mono_string_to_utf8_checked (str, &error);
7328                                 if (!mono_error_ok (&error)) {
7329                                         mono_error_cleanup (&error);
7330                                         message = (char *) "";
7331                                 } else {
7332                                         free_message = TRUE;
7333                                 }
7334                         }
7335                 }
7336         }
7337
7338         /*
7339          * g_printerr ("\nUnhandled Exception: %s.%s: %s\n", exc->vtable->klass->name_space,
7340          *         exc->vtable->klass->name, message);
7341          */
7342         g_printerr ("\nUnhandled Exception:\n%s\n", message);
7343
7344         if (free_message)
7345                 g_free (message);
7346 }
7347
7348 /**
7349  * mono_delegate_ctor:
7350  * @this: pointer to an uninitialized delegate object
7351  * @target: target object
7352  * @addr: pointer to native code
7353  * @method: method
7354  *
7355  * Initialize a delegate and sets a specific method, not the one
7356  * associated with addr.  This is useful when sharing generic code.
7357  * In that case addr will most probably not be associated with the
7358  * correct instantiation of the method.
7359  */
7360 void
7361 mono_delegate_ctor_with_method (MonoObject *this_obj, MonoObject *target, gpointer addr, MonoMethod *method)
7362 {
7363         MONO_REQ_GC_UNSAFE_MODE;
7364
7365         MonoDelegate *delegate = (MonoDelegate *)this_obj;
7366
7367         g_assert (this_obj);
7368         g_assert (addr);
7369
7370         g_assert (mono_class_has_parent (mono_object_class (this_obj), mono_defaults.multicastdelegate_class));
7371
7372         if (method)
7373                 delegate->method = method;
7374
7375         mono_stats.delegate_creations++;
7376
7377 #ifndef DISABLE_REMOTING
7378         if (target && target->vtable->klass == mono_defaults.transparent_proxy_class) {
7379                 g_assert (method);
7380                 method = mono_marshal_get_remoting_invoke (method);
7381                 delegate->method_ptr = mono_compile_method (method);
7382                 MONO_OBJECT_SETREF (delegate, target, target);
7383         } else
7384 #endif
7385         {
7386                 delegate->method_ptr = addr;
7387                 MONO_OBJECT_SETREF (delegate, target, target);
7388         }
7389
7390         delegate->invoke_impl = arch_create_delegate_trampoline (delegate->object.vtable->domain, delegate->object.vtable->klass);
7391         if (callbacks.init_delegate)
7392                 callbacks.init_delegate (delegate);
7393 }
7394
7395 /**
7396  * mono_delegate_ctor:
7397  * @this: pointer to an uninitialized delegate object
7398  * @target: target object
7399  * @addr: pointer to native code
7400  *
7401  * This is used to initialize a delegate.
7402  */
7403 void
7404 mono_delegate_ctor (MonoObject *this_obj, MonoObject *target, gpointer addr)
7405 {
7406         MONO_REQ_GC_UNSAFE_MODE;
7407
7408         MonoDomain *domain = mono_domain_get ();
7409         MonoJitInfo *ji;
7410         MonoMethod *method = NULL;
7411
7412         g_assert (addr);
7413
7414         ji = mono_jit_info_table_find (domain, (char *)mono_get_addr_from_ftnptr (addr));
7415         /* Shared code */
7416         if (!ji && domain != mono_get_root_domain ())
7417                 ji = mono_jit_info_table_find (mono_get_root_domain (), (char *)mono_get_addr_from_ftnptr (addr));
7418         if (ji) {
7419                 method = mono_jit_info_get_method (ji);
7420                 g_assert (!method->klass->generic_container);
7421         }
7422
7423         mono_delegate_ctor_with_method (this_obj, target, addr, method);
7424 }
7425
7426 /**
7427  * mono_method_call_message_new:
7428  * @method: method to encapsulate
7429  * @params: parameters to the method
7430  * @invoke: optional, delegate invoke.
7431  * @cb: async callback delegate.
7432  * @state: state passed to the async callback.
7433  *
7434  * Translates arguments pointers into a MonoMethodMessage.
7435  */
7436 MonoMethodMessage *
7437 mono_method_call_message_new (MonoMethod *method, gpointer *params, MonoMethod *invoke,
7438                               MonoDelegate **cb, MonoObject **state)
7439 {
7440         MONO_REQ_GC_UNSAFE_MODE;
7441
7442         MonoError error;
7443
7444         MonoDomain *domain = mono_domain_get ();
7445         MonoMethodSignature *sig = mono_method_signature (method);
7446         MonoMethodMessage *msg;
7447         int i, count;
7448
7449         msg = (MonoMethodMessage *)mono_object_new_checked (domain, mono_defaults.mono_method_message_class, &error);
7450         mono_error_raise_exception (&error); /* FIXME don't raise here */
7451
7452         if (invoke) {
7453                 MonoReflectionMethod *rm = mono_method_get_object_checked (domain, invoke, NULL, &error);
7454                 mono_error_raise_exception (&error); /* FIXME don't raise here */
7455                 mono_message_init (domain, msg, rm, NULL);
7456                 count =  sig->param_count - 2;
7457         } else {
7458                 MonoReflectionMethod *rm = mono_method_get_object_checked (domain, method, NULL, &error);
7459                 mono_error_raise_exception (&error); /* FIXME don't raise here */
7460                 mono_message_init (domain, msg, rm, NULL);
7461                 count =  sig->param_count;
7462         }
7463
7464         for (i = 0; i < count; i++) {
7465                 gpointer vpos;
7466                 MonoClass *klass;
7467                 MonoObject *arg;
7468
7469                 if (sig->params [i]->byref)
7470                         vpos = *((gpointer *)params [i]);
7471                 else
7472                         vpos = params [i];
7473
7474                 klass = mono_class_from_mono_type (sig->params [i]);
7475
7476                 if (klass->valuetype) {
7477                         arg = mono_value_box_checked (domain, klass, vpos, &error);
7478                         mono_error_raise_exception (&error); /* FIXME don't raise here */
7479                 } else
7480                         arg = *((MonoObject **)vpos);
7481
7482                 mono_array_setref (msg->args, i, arg);
7483         }
7484
7485         if (cb != NULL && state != NULL) {
7486                 *cb = *((MonoDelegate **)params [i]);
7487                 i++;
7488                 *state = *((MonoObject **)params [i]);
7489         }
7490
7491         return msg;
7492 }
7493
7494 /**
7495  * mono_method_return_message_restore:
7496  *
7497  * Restore results from message based processing back to arguments pointers
7498  */
7499 void
7500 mono_method_return_message_restore (MonoMethod *method, gpointer *params, MonoArray *out_args, MonoError *error)
7501 {
7502         MONO_REQ_GC_UNSAFE_MODE;
7503
7504         mono_error_init (error);
7505
7506         MonoMethodSignature *sig = mono_method_signature (method);
7507         int i, j, type, size, out_len;
7508
7509         if (out_args == NULL)
7510                 return;
7511         out_len = mono_array_length (out_args);
7512         if (out_len == 0)
7513                 return;
7514
7515         for (i = 0, j = 0; i < sig->param_count; i++) {
7516                 MonoType *pt = sig->params [i];
7517
7518                 if (pt->byref) {
7519                         char *arg;
7520                         if (j >= out_len) {
7521                                 mono_error_set_execution_engine (error, "The proxy call returned an incorrect number of output arguments");
7522                                 return;
7523                         }
7524
7525                         arg = (char *)mono_array_get (out_args, gpointer, j);
7526                         type = pt->type;
7527
7528                         g_assert (type != MONO_TYPE_VOID);
7529
7530                         if (MONO_TYPE_IS_REFERENCE (pt)) {
7531                                 mono_gc_wbarrier_generic_store (*((MonoObject ***)params [i]), (MonoObject *)arg);
7532                         } else {
7533                                 if (arg) {
7534                                         MonoClass *klass = ((MonoObject*)arg)->vtable->klass;
7535                                         size = mono_class_value_size (klass, NULL);
7536                                         if (klass->has_references)
7537                                                 mono_gc_wbarrier_value_copy (*((gpointer *)params [i]), arg + sizeof (MonoObject), 1, klass);
7538                                         else
7539                                                 mono_gc_memmove_atomic (*((gpointer *)params [i]), arg + sizeof (MonoObject), size);
7540                                 } else {
7541                                         size = mono_class_value_size (mono_class_from_mono_type (pt), NULL);
7542                                         mono_gc_bzero_atomic (*((gpointer *)params [i]), size);
7543                                 }
7544                         }
7545
7546                         j++;
7547                 }
7548         }
7549 }
7550
7551 #ifndef DISABLE_REMOTING
7552
7553 /**
7554  * mono_load_remote_field:
7555  * @this: pointer to an object
7556  * @klass: klass of the object containing @field
7557  * @field: the field to load
7558  * @res: a storage to store the result
7559  *
7560  * This method is called by the runtime on attempts to load fields of
7561  * transparent proxy objects. @this points to such TP, @klass is the class of
7562  * the object containing @field. @res is a storage location which can be
7563  * used to store the result.
7564  *
7565  * Returns: an address pointing to the value of field.
7566  */
7567 gpointer
7568 mono_load_remote_field (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, gpointer *res)
7569 {
7570         MonoError error;
7571         gpointer result = mono_load_remote_field_checked (this_obj, klass, field, res, &error);
7572         mono_error_cleanup (&error);
7573         return result;
7574 }
7575
7576 /**
7577  * mono_load_remote_field_checked:
7578  * @this: pointer to an object
7579  * @klass: klass of the object containing @field
7580  * @field: the field to load
7581  * @res: a storage to store the result
7582  * @error: set on error
7583  *
7584  * This method is called by the runtime on attempts to load fields of
7585  * transparent proxy objects. @this points to such TP, @klass is the class of
7586  * the object containing @field. @res is a storage location which can be
7587  * used to store the result.
7588  *
7589  * Returns: an address pointing to the value of field.  On failure returns NULL and sets @error.
7590  */
7591 gpointer
7592 mono_load_remote_field_checked (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, gpointer *res, MonoError *error)
7593 {
7594         MONO_REQ_GC_UNSAFE_MODE;
7595
7596         static MonoMethod *getter = NULL;
7597
7598         mono_error_init (error);
7599
7600         MonoDomain *domain = mono_domain_get ();
7601         MonoTransparentProxy *tp = (MonoTransparentProxy *) this_obj;
7602         MonoClass *field_class;
7603         MonoMethodMessage *msg;
7604         MonoArray *out_args;
7605         MonoObject *exc;
7606         char* full_name;
7607
7608         g_assert (mono_object_is_transparent_proxy (this_obj));
7609         g_assert (res != NULL);
7610
7611         if (mono_class_is_contextbound (tp->remote_class->proxy_class) && tp->rp->context == (MonoObject *) mono_context_get ()) {
7612                 mono_field_get_value (tp->rp->unwrapped_server, field, res);
7613                 return res;
7614         }
7615
7616         if (!getter) {
7617                 getter = mono_class_get_method_from_name (mono_defaults.object_class, "FieldGetter", -1);
7618                 if (!getter) {
7619                         mono_error_set_not_supported (error, "Linked away.");
7620                         return NULL;
7621                 }
7622         }
7623
7624         field_class = mono_class_from_mono_type (field->type);
7625
7626         msg = (MonoMethodMessage *)mono_object_new_checked (domain, mono_defaults.mono_method_message_class, error);
7627         return_val_if_nok (error, NULL);
7628         out_args = mono_array_new_checked (domain, mono_defaults.object_class, 1, error);
7629         return_val_if_nok (error, NULL);
7630         MonoReflectionMethod *rm = mono_method_get_object_checked (domain, getter, NULL, error);
7631         return_val_if_nok (error, NULL);
7632         mono_message_init (domain, msg, rm, out_args);
7633
7634         full_name = mono_type_get_full_name (klass);
7635         mono_array_setref (msg->args, 0, mono_string_new (domain, full_name));
7636         mono_array_setref (msg->args, 1, mono_string_new (domain, mono_field_get_name (field)));
7637         g_free (full_name);
7638
7639         mono_remoting_invoke ((MonoObject *)(tp->rp), msg, &exc, &out_args, error);
7640         return_val_if_nok (error, NULL);
7641
7642         if (exc) {
7643                 mono_error_set_exception_instance (error, (MonoException *)exc);
7644                 return NULL;
7645         }
7646
7647         if (mono_array_length (out_args) == 0)
7648                 return NULL;
7649
7650         mono_gc_wbarrier_generic_store (res, mono_array_get (out_args, MonoObject *, 0));
7651
7652         if (field_class->valuetype) {
7653                 return ((char *)*res) + sizeof (MonoObject);
7654         } else
7655                 return res;
7656 }
7657
7658 /**
7659  * mono_load_remote_field_new:
7660  * @this:
7661  * @klass:
7662  * @field:
7663  *
7664  * Missing documentation.
7665  */
7666 MonoObject *
7667 mono_load_remote_field_new (MonoObject *this_obj, MonoClass *klass, MonoClassField *field)
7668 {
7669         MonoError error;
7670
7671         MonoObject *result = mono_load_remote_field_new_checked (this_obj, klass, field, &error);
7672         mono_error_cleanup (&error);
7673         return result;
7674 }
7675
7676 /**
7677  * mono_load_remote_field_new_icall:
7678  * @this: pointer to an object
7679  * @klass: klass of the object containing @field
7680  * @field: the field to load
7681  *
7682  * This method is called by the runtime on attempts to load fields of
7683  * transparent proxy objects. @this points to such TP, @klass is the class of
7684  * the object containing @field.
7685  *
7686  * Returns: a freshly allocated object containing the value of the
7687  * field.  On failure returns NULL and throws an exception.
7688  */
7689 MonoObject *
7690 mono_load_remote_field_new_icall (MonoObject *this_obj, MonoClass *klass, MonoClassField *field)
7691 {
7692         MonoError error;
7693         MonoObject *result = mono_load_remote_field_new_checked (this_obj, klass, field, &error);
7694         mono_error_set_pending_exception (&error);
7695         return result;
7696 }
7697
7698 /**
7699  * mono_load_remote_field_new_checked:
7700  * @this: pointer to an object
7701  * @klass: klass of the object containing @field
7702  * @field: the field to load
7703  * @error: set on error.
7704  *
7705  * This method is called by the runtime on attempts to load fields of
7706  * transparent proxy objects. @this points to such TP, @klass is the class of
7707  * the object containing @field.
7708  *
7709  * Returns: a freshly allocated object containing the value of the field.  On failure returns NULL and sets @error.
7710  */
7711 MonoObject *
7712 mono_load_remote_field_new_checked (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, MonoError *error)
7713 {
7714         MONO_REQ_GC_UNSAFE_MODE;
7715
7716         mono_error_init (error);
7717
7718         static MonoMethod *getter = NULL;
7719         MonoDomain *domain = mono_domain_get ();
7720         MonoTransparentProxy *tp = (MonoTransparentProxy *) this_obj;
7721         MonoClass *field_class;
7722         MonoMethodMessage *msg;
7723         MonoArray *out_args;
7724         MonoObject *exc, *res;
7725         char* full_name;
7726
7727         g_assert (mono_object_is_transparent_proxy (this_obj));
7728
7729         field_class = mono_class_from_mono_type (field->type);
7730
7731         if (mono_class_is_contextbound (tp->remote_class->proxy_class) && tp->rp->context == (MonoObject *) mono_context_get ()) {
7732                 gpointer val;
7733                 if (field_class->valuetype) {
7734                         res = mono_object_new_checked (domain, field_class, error);
7735                         return_val_if_nok (error, NULL);
7736                         val = ((gchar *) res) + sizeof (MonoObject);
7737                 } else {
7738                         val = &res;
7739                 }
7740                 mono_field_get_value (tp->rp->unwrapped_server, field, val);
7741                 return res;
7742         }
7743
7744         if (!getter) {
7745                 getter = mono_class_get_method_from_name (mono_defaults.object_class, "FieldGetter", -1);
7746                 if (!getter) {
7747                         mono_error_set_not_supported (error, "Linked away.");
7748                         return NULL;
7749                 }
7750         }
7751
7752         msg = (MonoMethodMessage *)mono_object_new_checked (domain, mono_defaults.mono_method_message_class, error);
7753         return_val_if_nok (error, NULL);
7754         out_args = mono_array_new_checked (domain, mono_defaults.object_class, 1, error);
7755         return_val_if_nok (error, NULL);
7756
7757         MonoReflectionMethod *rm = mono_method_get_object_checked (domain, getter, NULL, error);
7758         return_val_if_nok (error, NULL);
7759         mono_message_init (domain, msg, rm, out_args);
7760
7761         full_name = mono_type_get_full_name (klass);
7762         mono_array_setref (msg->args, 0, mono_string_new (domain, full_name));
7763         mono_array_setref (msg->args, 1, mono_string_new (domain, mono_field_get_name (field)));
7764         g_free (full_name);
7765
7766         mono_remoting_invoke ((MonoObject *)(tp->rp), msg, &exc, &out_args, error);
7767         return_val_if_nok (error, NULL);
7768
7769         if (exc) {
7770                 mono_error_set_exception_instance (error, (MonoException *)exc);
7771                 return NULL;
7772         }
7773
7774         if (mono_array_length (out_args) == 0)
7775                 res = NULL;
7776         else
7777                 res = mono_array_get (out_args, MonoObject *, 0);
7778
7779         return res;
7780 }
7781
7782 /**
7783  * mono_store_remote_field:
7784  * @this_obj: pointer to an object
7785  * @klass: klass of the object containing @field
7786  * @field: the field to load
7787  * @val: the value/object to store
7788  *
7789  * This method is called by the runtime on attempts to store fields of
7790  * transparent proxy objects. @this_obj points to such TP, @klass is the class of
7791  * the object containing @field. @val is the new value to store in @field.
7792  */
7793 void
7794 mono_store_remote_field (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, gpointer val)
7795 {
7796         MonoError error;
7797         (void) mono_store_remote_field_checked (this_obj, klass, field, val, &error);
7798         mono_error_cleanup (&error);
7799 }
7800
7801 /**
7802  * mono_store_remote_field_checked:
7803  * @this_obj: pointer to an object
7804  * @klass: klass of the object containing @field
7805  * @field: the field to load
7806  * @val: the value/object to store
7807  * @error: set on error
7808  *
7809  * This method is called by the runtime on attempts to store fields of
7810  * transparent proxy objects. @this_obj points to such TP, @klass is the class of
7811  * the object containing @field. @val is the new value to store in @field.
7812  *
7813  * Returns: on success returns TRUE, on failure returns FALSE and sets @error.
7814  */
7815 gboolean
7816 mono_store_remote_field_checked (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, gpointer val, MonoError *error)
7817 {
7818
7819         MONO_REQ_GC_UNSAFE_MODE;
7820
7821         static MonoMethod *setter = NULL;
7822
7823         MonoDomain *domain = mono_domain_get ();
7824         MonoTransparentProxy *tp = (MonoTransparentProxy *) this_obj;
7825         MonoClass *field_class;
7826         MonoMethodMessage *msg;
7827         MonoArray *out_args;
7828         MonoObject *exc;
7829         MonoObject *arg;
7830         char* full_name;
7831
7832         mono_error_init (error);
7833
7834         g_assert (mono_object_is_transparent_proxy (this_obj));
7835
7836         field_class = mono_class_from_mono_type (field->type);
7837
7838         if (mono_class_is_contextbound (tp->remote_class->proxy_class) && tp->rp->context == (MonoObject *) mono_context_get ()) {
7839                 if (field_class->valuetype) mono_field_set_value (tp->rp->unwrapped_server, field, val);
7840                 else mono_field_set_value (tp->rp->unwrapped_server, field, *((MonoObject **)val));
7841                 return TRUE;
7842         }
7843
7844         if (!setter) {
7845                 setter = mono_class_get_method_from_name (mono_defaults.object_class, "FieldSetter", -1);
7846                 if (!setter) {
7847                         mono_error_set_not_supported (error, "Linked away.");
7848                         return FALSE;
7849                 }
7850         }
7851
7852         if (field_class->valuetype) {
7853                 arg = mono_value_box_checked (domain, field_class, val, error);
7854                 return_val_if_nok (error, FALSE);
7855         } else
7856                 arg = *((MonoObject **)val);
7857
7858
7859         msg = (MonoMethodMessage *)mono_object_new_checked (domain, mono_defaults.mono_method_message_class, error);
7860         return_val_if_nok (error, FALSE);
7861         MonoReflectionMethod *rm = mono_method_get_object_checked (domain, setter, NULL, error);
7862         return_val_if_nok (error, FALSE);
7863         mono_message_init (domain, msg, rm, NULL);
7864
7865         full_name = mono_type_get_full_name (klass);
7866         mono_array_setref (msg->args, 0, mono_string_new (domain, full_name));
7867         mono_array_setref (msg->args, 1, mono_string_new (domain, mono_field_get_name (field)));
7868         mono_array_setref (msg->args, 2, arg);
7869         g_free (full_name);
7870
7871         mono_remoting_invoke ((MonoObject *)(tp->rp), msg, &exc, &out_args, error);
7872         return_val_if_nok (error, FALSE);
7873
7874         if (exc) {
7875                 mono_error_set_exception_instance (error, (MonoException *)exc);
7876                 return FALSE;
7877         }
7878         return TRUE;
7879 }
7880
7881 /**
7882  * mono_store_remote_field_new:
7883  * @this_obj:
7884  * @klass:
7885  * @field:
7886  * @arg:
7887  *
7888  * Missing documentation
7889  */
7890 void
7891 mono_store_remote_field_new (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, MonoObject *arg)
7892 {
7893         MonoError error;
7894         (void) mono_store_remote_field_new_checked (this_obj, klass, field, arg, &error);
7895         mono_error_cleanup (&error);
7896 }
7897
7898 /**
7899  * mono_store_remote_field_new_icall:
7900  * @this_obj:
7901  * @klass:
7902  * @field:
7903  * @arg:
7904  *
7905  * Missing documentation
7906  */
7907 void
7908 mono_store_remote_field_new_icall (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, MonoObject *arg)
7909 {
7910         MonoError error;
7911         (void) mono_store_remote_field_new_checked (this_obj, klass, field, arg, &error);
7912         mono_error_set_pending_exception (&error);
7913 }
7914
7915 /**
7916  * mono_store_remote_field_new_checked:
7917  * @this_obj:
7918  * @klass:
7919  * @field:
7920  * @arg:
7921  * @error:
7922  *
7923  * Missing documentation
7924  */
7925 gboolean
7926 mono_store_remote_field_new_checked (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, MonoObject *arg, MonoError *error)
7927 {
7928         MONO_REQ_GC_UNSAFE_MODE;
7929
7930         static MonoMethod *setter = NULL;
7931         MonoDomain *domain = mono_domain_get ();
7932         MonoTransparentProxy *tp = (MonoTransparentProxy *) this_obj;
7933         MonoClass *field_class;
7934         MonoMethodMessage *msg;
7935         MonoArray *out_args;
7936         MonoObject *exc;
7937         char* full_name;
7938
7939         mono_error_init (error);
7940
7941         g_assert (mono_object_is_transparent_proxy (this_obj));
7942
7943         field_class = mono_class_from_mono_type (field->type);
7944
7945         if (mono_class_is_contextbound (tp->remote_class->proxy_class) && tp->rp->context == (MonoObject *) mono_context_get ()) {
7946                 if (field_class->valuetype) mono_field_set_value (tp->rp->unwrapped_server, field, ((gchar *) arg) + sizeof (MonoObject));
7947                 else mono_field_set_value (tp->rp->unwrapped_server, field, arg);
7948                 return TRUE;
7949         }
7950
7951         if (!setter) {
7952                 setter = mono_class_get_method_from_name (mono_defaults.object_class, "FieldSetter", -1);
7953                 if (!setter) {
7954                         mono_error_set_not_supported (error, "Linked away.");
7955                         return FALSE;
7956                 }
7957         }
7958
7959         msg = (MonoMethodMessage *)mono_object_new_checked (domain, mono_defaults.mono_method_message_class, error);
7960         return_val_if_nok (error, FALSE);
7961         MonoReflectionMethod *rm = mono_method_get_object_checked (domain, setter, NULL, error);
7962         return_val_if_nok (error, FALSE);
7963         mono_message_init (domain, msg, rm, NULL);
7964
7965         full_name = mono_type_get_full_name (klass);
7966         mono_array_setref (msg->args, 0, mono_string_new (domain, full_name));
7967         mono_array_setref (msg->args, 1, mono_string_new (domain, mono_field_get_name (field)));
7968         mono_array_setref (msg->args, 2, arg);
7969         g_free (full_name);
7970
7971         mono_remoting_invoke ((MonoObject *)(tp->rp), msg, &exc, &out_args, error);
7972         return_val_if_nok (error, FALSE);
7973
7974         if (exc) {
7975                 mono_error_set_exception_instance (error, (MonoException *)exc);
7976                 return FALSE;
7977         }
7978         return TRUE;
7979 }
7980 #endif
7981
7982 /*
7983  * mono_create_ftnptr:
7984  *
7985  *   Given a function address, create a function descriptor for it.
7986  * This is only needed on some platforms.
7987  */
7988 gpointer
7989 mono_create_ftnptr (MonoDomain *domain, gpointer addr)
7990 {
7991         return callbacks.create_ftnptr (domain, addr);
7992 }
7993
7994 /*
7995  * mono_get_addr_from_ftnptr:
7996  *
7997  *   Given a pointer to a function descriptor, return the function address.
7998  * This is only needed on some platforms.
7999  */
8000 gpointer
8001 mono_get_addr_from_ftnptr (gpointer descr)
8002 {
8003         return callbacks.get_addr_from_ftnptr (descr);
8004 }
8005
8006 /**
8007  * mono_string_chars:
8008  * @s: a MonoString
8009  *
8010  * Returns a pointer to the UCS16 characters stored in the MonoString
8011  */
8012 gunichar2 *
8013 mono_string_chars (MonoString *s)
8014 {
8015         // MONO_REQ_GC_UNSAFE_MODE; //FIXME too much trouble for now
8016
8017         return s->chars;
8018 }
8019
8020 /**
8021  * mono_string_length:
8022  * @s: MonoString
8023  *
8024  * Returns the lenght in characters of the string
8025  */
8026 int
8027 mono_string_length (MonoString *s)
8028 {
8029         MONO_REQ_GC_UNSAFE_MODE;
8030
8031         return s->length;
8032 }
8033
8034 /**
8035  * mono_array_length:
8036  * @array: a MonoArray*
8037  *
8038  * Returns the total number of elements in the array. This works for
8039  * both vectors and multidimensional arrays.
8040  */
8041 uintptr_t
8042 mono_array_length (MonoArray *array)
8043 {
8044         MONO_REQ_GC_UNSAFE_MODE;
8045
8046         return array->max_length;
8047 }
8048
8049 /**
8050  * mono_array_addr_with_size:
8051  * @array: a MonoArray*
8052  * @size: size of the array elements
8053  * @idx: index into the array
8054  *
8055  * Use this function to obtain the address for the @idx item on the
8056  * @array containing elements of size @size.
8057  *
8058  * This method performs no bounds checking or type checking.
8059  *
8060  * Returns the address of the @idx element in the array.
8061  */
8062 char*
8063 mono_array_addr_with_size (MonoArray *array, int size, uintptr_t idx)
8064 {
8065         MONO_REQ_GC_UNSAFE_MODE;
8066
8067         return ((char*)(array)->vector) + size * idx;
8068 }
8069
8070
8071 MonoArray *
8072 mono_glist_to_array (GList *list, MonoClass *eclass, MonoError *error)
8073 {
8074         MonoDomain *domain = mono_domain_get ();
8075         MonoArray *res;
8076         int len, i;
8077
8078         mono_error_init (error);
8079         if (!list)
8080                 return NULL;
8081
8082         len = g_list_length (list);
8083         res = mono_array_new_checked (domain, eclass, len, error);
8084         return_val_if_nok (error, NULL);
8085
8086         for (i = 0; list; list = list->next, i++)
8087                 mono_array_set (res, gpointer, i, list->data);
8088
8089         return res;
8090 }
8091
8092 #if NEVER_DEFINED
8093 /*
8094  * The following section is purely to declare prototypes and
8095  * document the API, as these C files are processed by our
8096  * tool
8097  */
8098
8099 /**
8100  * mono_array_set:
8101  * @array: array to alter
8102  * @element_type: A C type name, this macro will use the sizeof(type) to determine the element size
8103  * @index: index into the array
8104  * @value: value to set
8105  *
8106  * Value Type version: This sets the @index's element of the @array
8107  * with elements of size sizeof(type) to the provided @value.
8108  *
8109  * This macro does not attempt to perform type checking or bounds checking.
8110  *
8111  * Use this to set value types in a `MonoArray`.
8112  */
8113 void mono_array_set(MonoArray *array, Type element_type, uintptr_t index, Value value)
8114 {
8115 }
8116
8117 /**
8118  * mono_array_setref:
8119  * @array: array to alter
8120  * @index: index into the array
8121  * @value: value to set
8122  *
8123  * Reference Type version: This sets the @index's element of the
8124  * @array with elements of size sizeof(type) to the provided @value.
8125  *
8126  * This macro does not attempt to perform type checking or bounds checking.
8127  *
8128  * Use this to reference types in a `MonoArray`.
8129  */
8130 void mono_array_setref(MonoArray *array, uintptr_t index, MonoObject *object)
8131 {
8132 }
8133
8134 /**
8135  * mono_array_get:
8136  * @array: array on which to operate on
8137  * @element_type: C element type (example: MonoString *, int, MonoObject *)
8138  * @index: index into the array
8139  *
8140  * Use this macro to retrieve the @index element of an @array and
8141  * extract the value assuming that the elements of the array match
8142  * the provided type value.
8143  *
8144  * This method can be used with both arrays holding value types and
8145  * reference types.   For reference types, the @type parameter should
8146  * be a `MonoObject*` or any subclass of it, like `MonoString*`.
8147  *
8148  * This macro does not attempt to perform type checking or bounds checking.
8149  *
8150  * Returns: The element at the @index position in the @array.
8151  */
8152 Type mono_array_get (MonoArray *array, Type element_type, uintptr_t index)
8153 {
8154 }
8155 #endif
8156