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