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