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