2 * domain.c: MonoDomain functions
5 * Dietmar Maurer (dietmar@ximian.com)
8 * (C) 2001 Ximian, Inc.
16 #include <mono/os/gc_wrapper.h>
18 #include <mono/utils/mono-compiler.h>
19 #include <mono/utils/mono-logger.h>
20 #include <mono/metadata/object.h>
21 #include <mono/metadata/object-internals.h>
22 #include <mono/metadata/domain-internals.h>
23 #include <mono/metadata/class-internals.h>
24 #include <mono/metadata/assembly.h>
25 #include <mono/metadata/exception.h>
26 #include <mono/metadata/cil-coff.h>
27 #include <mono/metadata/rawbuffer.h>
28 #include <mono/metadata/metadata-internals.h>
29 #include <mono/metadata/gc-internal.h>
30 #include <mono/metadata/appdomain.h>
31 #include <mono/metadata/mono-debug-debugger.h>
32 #include <metadata/threads.h>
34 /* #define DEBUG_DOMAIN_UNLOAD */
36 /* we need to use both the Tls* functions and __thread because
37 * some archs may generate faster jit code with one meachanism
38 * or the other (we used to do it because tls slots were GC-tracked,
39 * but we can't depend on this).
41 static guint32 appdomain_thread_id
= -1;
44 static __thread MonoDomain
* tls_appdomain MONO_TLS_FAST
;
45 #define GET_APPDOMAIN() tls_appdomain
46 #define SET_APPDOMAIN(x) do { \
48 TlsSetValue (appdomain_thread_id, x); \
53 #define GET_APPDOMAIN() ((MonoDomain *)TlsGetValue (appdomain_thread_id))
54 #define SET_APPDOMAIN(x) TlsSetValue (appdomain_thread_id, x);
58 #define GET_APPCONTEXT() (mono_thread_current ()->current_appcontext)
59 #define SET_APPCONTEXT(x) MONO_OBJECT_SETREF (mono_thread_current (), current_appcontext, (x))
61 static guint16 appdomain_list_size
= 0;
62 static guint16 appdomain_next
= 0;
63 static MonoDomain
**appdomains_list
= NULL
;
65 #define mono_appdomains_lock() EnterCriticalSection (&appdomains_mutex)
66 #define mono_appdomains_unlock() LeaveCriticalSection (&appdomains_mutex)
67 static CRITICAL_SECTION appdomains_mutex
;
69 static MonoDomain
*mono_root_domain
= NULL
;
71 /* AppConfigInfo: Information about runtime versions supported by an
75 GSList
*supported_runtimes
;
76 char *required_runtime
;
77 int configuration_count
;
82 * AotModuleInfo: Contains information about AOT modules.
89 static const MonoRuntimeInfo
*current_runtime
= NULL
;
91 static MonoJitInfoFindInAot jit_info_find_in_aot_func
= NULL
;
94 * Contains information about AOT loaded code.
96 static MonoJitInfoTable
*aot_modules
= NULL
;
98 /* This is the list of runtime versions supported by this JIT.
100 static const MonoRuntimeInfo supported_runtimes
[] = {
101 {"v1.0.3705", "1.0", { {1,0,5000,0}, {7,0,5000,0} } },
102 {"v1.1.4322", "1.0", { {1,0,5000,0}, {7,0,5000,0} } },
103 {"v2.0.50215","2.0", { {2,0,0,0}, {8,0,0,0} } },
104 {"v2.0.50727","2.0", { {2,0,0,0}, {8,0,0,0} } }
108 /* The stable runtime version */
109 #define DEFAULT_RUNTIME_VERSION "v1.1.4322"
112 get_runtimes_from_exe (const char *exe_file
, const MonoRuntimeInfo
** runtimes
);
114 static const MonoRuntimeInfo
*
115 get_runtime_by_version (const char *version
);
118 mono_jit_info_find_aot_module (guint8
* addr
);
121 mono_domain_get_tls_key (void)
123 return appdomain_thread_id
;
127 mono_domain_get_tls_offset (void)
130 MONO_THREAD_VAR_OFFSET (tls_appdomain
, offset
);
131 /* __asm ("jmp 1f; .section writetext, \"awx\"; 1: movl $tls_appdomain@ntpoff, %0; jmp 2f; .previous; 2:"
136 static MonoJitInfoTable
*
137 mono_jit_info_table_new (void)
139 return g_array_new (FALSE
, FALSE
, sizeof (gpointer
));
143 mono_jit_info_table_free (MonoJitInfoTable
*table
)
145 g_array_free (table
, TRUE
);
149 mono_jit_info_table_index (MonoJitInfoTable
*table
, char *addr
)
151 int left
= 0, right
= table
->len
;
153 while (left
< right
) {
154 int pos
= (left
+ right
) / 2;
155 MonoJitInfo
*ji
= g_array_index (table
, gpointer
, pos
);
156 char *start
= ji
->code_start
;
157 char *end
= start
+ ji
->code_size
;
161 else if (addr
>= end
)
171 mono_jit_info_table_find (MonoDomain
*domain
, char *addr
)
173 MonoJitInfoTable
*table
= domain
->jit_info_table
;
175 guint left
= 0, right
;
177 mono_domain_lock (domain
);
180 while (left
< right
) {
181 guint pos
= (left
+ right
) / 2;
182 ji
= g_array_index (table
, gpointer
, pos
);
184 if (addr
< (char*)ji
->code_start
)
186 else if (addr
>= (char*)ji
->code_start
+ ji
->code_size
)
189 mono_domain_unlock (domain
);
193 mono_domain_unlock (domain
);
195 /* maybe it is shared code, so we also search in the root domain */
197 if (domain
!= mono_root_domain
)
198 ji
= mono_jit_info_table_find (mono_root_domain
, addr
);
201 /* Maybe its an AOT module */
202 MonoImage
*image
= mono_jit_info_find_aot_module ((guint8
*)addr
);
204 ji
= jit_info_find_in_aot_func (domain
, image
, addr
);
211 mono_jit_info_table_add (MonoDomain
*domain
, MonoJitInfo
*ji
)
213 MonoJitInfoTable
*table
= domain
->jit_info_table
;
214 gpointer start
= ji
->code_start
;
217 mono_domain_lock (domain
);
218 pos
= mono_jit_info_table_index (table
, start
);
220 g_array_insert_val (table
, pos
, ji
);
221 mono_domain_unlock (domain
);
225 mono_jit_info_table_remove (MonoDomain
*domain
, MonoJitInfo
*ji
)
227 MonoJitInfoTable
*table
= domain
->jit_info_table
;
228 gpointer start
= ji
->code_start
;
231 mono_domain_lock (domain
);
232 pos
= mono_jit_info_table_index (table
, start
);
233 if (g_array_index (table
, gpointer
, pos
) != ji
) {
234 MonoJitInfo
*ji2
= g_array_index (table
, gpointer
, pos
);
235 g_assert (ji
== ji2
);
237 g_assert (g_array_index (table
, gpointer
, pos
) == ji
);
239 g_array_remove_index (table
, pos
);
240 mono_domain_unlock (domain
);
244 aot_info_table_index (MonoJitInfoTable
*table
, char *addr
)
246 int left
= 0, right
= table
->len
;
248 while (left
< right
) {
249 int pos
= (left
+ right
) / 2;
250 AotModuleInfo
*ainfo
= g_array_index (table
, gpointer
, pos
);
251 char *start
= ainfo
->start
;
252 char *end
= ainfo
->end
;
256 else if (addr
>= end
)
266 mono_jit_info_add_aot_module (MonoImage
*image
, gpointer start
, gpointer end
)
268 AotModuleInfo
*ainfo
= g_new0 (AotModuleInfo
, 1);
271 ainfo
->image
= image
;
272 ainfo
->start
= start
;
275 mono_appdomains_lock ();
278 aot_modules
= mono_jit_info_table_new ();
280 pos
= aot_info_table_index (aot_modules
, start
);
282 g_array_insert_val (aot_modules
, pos
, ainfo
);
284 mono_appdomains_unlock ();
288 mono_jit_info_find_aot_module (guint8
* addr
)
290 guint left
= 0, right
;
295 mono_appdomains_lock ();
297 right
= aot_modules
->len
;
298 while (left
< right
) {
299 guint pos
= (left
+ right
) / 2;
300 AotModuleInfo
*ai
= g_array_index (aot_modules
, gpointer
, pos
);
302 if (addr
< (guint8
*)ai
->start
)
304 else if (addr
>= (guint8
*)ai
->end
)
307 mono_appdomains_unlock ();
312 mono_appdomains_unlock ();
318 mono_install_jit_info_find_in_aot (MonoJitInfoFindInAot func
)
320 jit_info_find_in_aot_func
= func
;
324 mono_jit_info_get_code_start (MonoJitInfo
* ji
)
326 return ji
->code_start
;
330 mono_jit_info_get_code_size (MonoJitInfo
* ji
)
332 return ji
->code_size
;
336 mono_jit_info_get_method (MonoJitInfo
* ji
)
343 * @s1: First string to compare
344 * @s2: Second string to compare
346 * Returns FALSE if the strings differ.
349 mono_string_equal (MonoString
*s1
, MonoString
*s2
)
351 int l1
= mono_string_length (s1
);
352 int l2
= mono_string_length (s2
);
359 return memcmp (mono_string_chars (s1
), mono_string_chars (s2
), l1
* 2) == 0;
364 * @s: the string to hash
366 * Returns the hash for the string.
369 mono_string_hash (MonoString
*s
)
371 const guint16
*p
= mono_string_chars (s
);
372 int i
, len
= mono_string_length (s
);
375 for (i
= 0; i
< len
; i
++) {
376 h
= (h
<< 5) - h
+ *p
;
384 mono_ptrarray_equal (gpointer
*s1
, gpointer
*s2
)
386 int len
= GPOINTER_TO_INT (s1
[0]);
387 if (len
!= GPOINTER_TO_INT (s2
[0]))
390 return memcmp (s1
+ 1, s2
+ 1, len
* sizeof(gpointer
)) == 0;
394 mono_ptrarray_hash (gpointer
*s
)
397 int len
= GPOINTER_TO_INT (s
[0]);
400 for (i
= 1; i
< len
; i
++)
401 hash
+= GPOINTER_TO_UINT (s
[i
]);
407 * Allocate an id for domain and set domain->domain_id.
408 * LOCKING: must be called while holding appdomains_mutex.
409 * We try to assign low numbers to the domain, so it can be used
410 * as an index in data tables to lookup domain-specific info
411 * with minimal memory overhead. We also try not to reuse the
412 * same id too quickly (to help debugging).
415 domain_id_alloc (MonoDomain
*domain
)
418 if (!appdomains_list
) {
419 appdomain_list_size
= 2;
420 appdomains_list
= mono_gc_alloc_fixed (appdomain_list_size
* sizeof (void*), NULL
);
422 for (i
= appdomain_next
; i
< appdomain_list_size
; ++i
) {
423 if (!appdomains_list
[i
]) {
429 for (i
= 0; i
< appdomain_next
; ++i
) {
430 if (!appdomains_list
[i
]) {
437 MonoDomain
**new_list
;
438 int new_size
= appdomain_list_size
* 2;
439 if (new_size
>= (1 << 16))
440 g_assert_not_reached ();
441 id
= appdomain_list_size
;
442 new_list
= mono_gc_alloc_fixed (new_size
* sizeof (void*), NULL
);
443 memcpy (new_list
, appdomains_list
, appdomain_list_size
* sizeof (void*));
444 mono_gc_free_fixed (appdomains_list
);
445 appdomains_list
= new_list
;
446 appdomain_list_size
= new_size
;
448 domain
->domain_id
= id
;
449 appdomains_list
[id
] = domain
;
451 if (appdomain_next
> appdomain_list_size
)
456 static guint32 domain_gc_bitmap
[sizeof(MonoDomain
)/4/32 + 1];
457 static gpointer domain_gc_desc
= NULL
;
460 mono_domain_create (void)
464 mono_appdomains_lock ();
465 if (!domain_gc_desc
) {
466 unsigned int i
, bit
= 0;
467 for (i
= G_STRUCT_OFFSET (MonoDomain
, MONO_DOMAIN_FIRST_OBJECT
); i
< G_STRUCT_OFFSET (MonoDomain
, MONO_DOMAIN_FIRST_GC_TRACKED
); i
+= sizeof (gpointer
)) {
468 bit
= i
/ sizeof (gpointer
);
469 domain_gc_bitmap
[bit
/ 32] |= 1 << (bit
% 32);
471 domain_gc_desc
= mono_gc_make_descr_from_bitmap (domain_gc_bitmap
, bit
+ 1);
473 mono_appdomains_unlock ();
475 domain
= mono_gc_alloc_fixed (sizeof (MonoDomain
), domain_gc_desc
);
476 domain
->domain
= NULL
;
477 domain
->setup
= NULL
;
478 domain
->friendly_name
= NULL
;
479 domain
->search_path
= NULL
;
481 domain
->mp
= mono_mempool_new ();
482 domain
->code_mp
= mono_code_manager_new ();
483 domain
->env
= mono_g_hash_table_new_type ((GHashFunc
)mono_string_hash
, (GCompareFunc
)mono_string_equal
, MONO_HASH_KEY_VALUE_GC
);
484 domain
->domain_assemblies
= NULL
;
485 domain
->class_vtable_hash
= g_hash_table_new (mono_aligned_addr_hash
, NULL
);
486 domain
->proxy_vtable_hash
= g_hash_table_new ((GHashFunc
)mono_ptrarray_hash
, (GCompareFunc
)mono_ptrarray_equal
);
487 domain
->static_data_array
= NULL
;
488 domain
->jit_code_hash
= g_hash_table_new (mono_aligned_addr_hash
, NULL
);
489 domain
->ldstr_table
= mono_g_hash_table_new ((GHashFunc
)mono_string_hash
, (GCompareFunc
)mono_string_equal
);
490 domain
->jit_info_table
= mono_jit_info_table_new ();
491 domain
->class_init_trampoline_hash
= g_hash_table_new (mono_aligned_addr_hash
, NULL
);
492 domain
->jump_trampoline_hash
= g_hash_table_new (mono_aligned_addr_hash
, NULL
);
493 domain
->finalizable_objects_hash
= g_hash_table_new (mono_aligned_addr_hash
, NULL
);
494 domain
->jit_trampoline_hash
= g_hash_table_new (mono_aligned_addr_hash
, NULL
);
495 domain
->delegate_trampoline_hash
= g_hash_table_new (mono_aligned_addr_hash
, NULL
);
497 InitializeCriticalSection (&domain
->lock
);
498 InitializeCriticalSection (&domain
->assemblies_lock
);
500 mono_appdomains_lock ();
501 domain_id_alloc (domain
);
502 mono_appdomains_unlock ();
508 * mono_init_internal:
510 * Creates the initial application domain and initializes the mono_defaults
512 * This function is guaranteed to not run any IL code.
513 * If exe_filename is not NULL, the method will determine the required runtime
514 * from the exe configuration file or the version PE field.
515 * If runtime_version is not NULL, that runtime version will be used.
516 * Either exe_filename or runtime_version must be provided.
518 * Returns: the initial domain.
521 mono_init_internal (const char *filename
, const char *exe_filename
, const char *runtime_version
)
523 static MonoDomain
*domain
= NULL
;
524 MonoAssembly
*ass
= NULL
;
525 MonoImageOpenStatus status
= MONO_IMAGE_OK
;
526 const MonoRuntimeInfo
* runtimes
[G_N_ELEMENTS (supported_runtimes
) + 1];
530 g_assert_not_reached ();
534 appdomain_thread_id
= TlsAlloc ();
536 InitializeCriticalSection (&appdomains_mutex
);
538 mono_metadata_init ();
539 mono_raw_buffer_init ();
541 mono_assemblies_init ();
542 mono_classes_init ();
545 /* FIXME: When should we release this memory? */
546 MONO_GC_REGISTER_ROOT (appdomains_list
);
548 domain
= mono_domain_create ();
549 mono_root_domain
= domain
;
551 SET_APPDOMAIN (domain
);
553 /* Get a list of runtimes supported by the exe */
554 if (exe_filename
!= NULL
) {
555 get_runtimes_from_exe (exe_filename
, runtimes
);
556 } else if (runtime_version
!= NULL
) {
557 runtimes
[0] = get_runtime_by_version (runtime_version
);
561 if (runtimes
[0] == NULL
) {
562 const MonoRuntimeInfo
*default_runtime
= get_runtime_by_version (DEFAULT_RUNTIME_VERSION
);
563 runtimes
[0] = default_runtime
;
565 g_print ("WARNING: The runtime version supported by this application is unavailable.\n");
566 g_print ("Using default runtime: %s\n", default_runtime
->runtime_version
);
569 /* The selected runtime will be the first one for which there is a mscrolib.dll */
570 for (n
= 0; runtimes
[n
] != NULL
&& ass
== NULL
; n
++) {
571 current_runtime
= runtimes
[n
];
572 ass
= mono_assembly_load_corlib (current_runtime
, &status
);
573 if (status
!= MONO_IMAGE_OK
&& status
!= MONO_IMAGE_ERROR_ERRNO
)
577 if ((status
!= MONO_IMAGE_OK
) || (ass
== NULL
)) {
579 case MONO_IMAGE_ERROR_ERRNO
: {
580 char *corlib_file
= g_build_filename (mono_assembly_getrootdir (), "mono", current_runtime
->framework_version
, "mscorlib.dll", NULL
);
581 g_print ("The assembly mscorlib.dll was not found or could not be loaded.\n");
582 g_print ("It should have been installed in the `%s' directory.\n", corlib_file
);
583 g_free (corlib_file
);
586 case MONO_IMAGE_IMAGE_INVALID
:
587 g_print ("The file %s/mscorlib.dll is an invalid CIL image\n",
588 mono_assembly_getrootdir ());
590 case MONO_IMAGE_MISSING_ASSEMBLYREF
:
591 g_print ("Missing assembly reference in %s/mscorlib.dll\n",
592 mono_assembly_getrootdir ());
595 /* to suppress compiler warning */
601 mono_defaults
.corlib
= mono_assembly_get_image (ass
);
603 mono_defaults
.object_class
= mono_class_from_name (
604 mono_defaults
.corlib
, "System", "Object");
605 g_assert (mono_defaults
.object_class
!= 0);
607 mono_defaults
.void_class
= mono_class_from_name (
608 mono_defaults
.corlib
, "System", "Void");
609 g_assert (mono_defaults
.void_class
!= 0);
611 mono_defaults
.boolean_class
= mono_class_from_name (
612 mono_defaults
.corlib
, "System", "Boolean");
613 g_assert (mono_defaults
.boolean_class
!= 0);
615 mono_defaults
.byte_class
= mono_class_from_name (
616 mono_defaults
.corlib
, "System", "Byte");
617 g_assert (mono_defaults
.byte_class
!= 0);
619 mono_defaults
.sbyte_class
= mono_class_from_name (
620 mono_defaults
.corlib
, "System", "SByte");
621 g_assert (mono_defaults
.sbyte_class
!= 0);
623 mono_defaults
.int16_class
= mono_class_from_name (
624 mono_defaults
.corlib
, "System", "Int16");
625 g_assert (mono_defaults
.int16_class
!= 0);
627 mono_defaults
.uint16_class
= mono_class_from_name (
628 mono_defaults
.corlib
, "System", "UInt16");
629 g_assert (mono_defaults
.uint16_class
!= 0);
631 mono_defaults
.int32_class
= mono_class_from_name (
632 mono_defaults
.corlib
, "System", "Int32");
633 g_assert (mono_defaults
.int32_class
!= 0);
635 mono_defaults
.uint32_class
= mono_class_from_name (
636 mono_defaults
.corlib
, "System", "UInt32");
637 g_assert (mono_defaults
.uint32_class
!= 0);
639 mono_defaults
.uint_class
= mono_class_from_name (
640 mono_defaults
.corlib
, "System", "UIntPtr");
641 g_assert (mono_defaults
.uint_class
!= 0);
643 mono_defaults
.int_class
= mono_class_from_name (
644 mono_defaults
.corlib
, "System", "IntPtr");
645 g_assert (mono_defaults
.int_class
!= 0);
647 mono_defaults
.int64_class
= mono_class_from_name (
648 mono_defaults
.corlib
, "System", "Int64");
649 g_assert (mono_defaults
.int64_class
!= 0);
651 mono_defaults
.uint64_class
= mono_class_from_name (
652 mono_defaults
.corlib
, "System", "UInt64");
653 g_assert (mono_defaults
.uint64_class
!= 0);
655 mono_defaults
.single_class
= mono_class_from_name (
656 mono_defaults
.corlib
, "System", "Single");
657 g_assert (mono_defaults
.single_class
!= 0);
659 mono_defaults
.double_class
= mono_class_from_name (
660 mono_defaults
.corlib
, "System", "Double");
661 g_assert (mono_defaults
.double_class
!= 0);
663 mono_defaults
.char_class
= mono_class_from_name (
664 mono_defaults
.corlib
, "System", "Char");
665 g_assert (mono_defaults
.char_class
!= 0);
667 mono_defaults
.string_class
= mono_class_from_name (
668 mono_defaults
.corlib
, "System", "String");
669 g_assert (mono_defaults
.string_class
!= 0);
671 mono_defaults
.enum_class
= mono_class_from_name (
672 mono_defaults
.corlib
, "System", "Enum");
673 g_assert (mono_defaults
.enum_class
!= 0);
675 mono_defaults
.array_class
= mono_class_from_name (
676 mono_defaults
.corlib
, "System", "Array");
677 g_assert (mono_defaults
.array_class
!= 0);
679 mono_defaults
.delegate_class
= mono_class_from_name (
680 mono_defaults
.corlib
, "System", "Delegate");
681 g_assert (mono_defaults
.delegate_class
!= 0 );
683 mono_defaults
.multicastdelegate_class
= mono_class_from_name (
684 mono_defaults
.corlib
, "System", "MulticastDelegate");
685 g_assert (mono_defaults
.multicastdelegate_class
!= 0 );
687 mono_defaults
.asyncresult_class
= mono_class_from_name (
688 mono_defaults
.corlib
, "System.Runtime.Remoting.Messaging",
690 g_assert (mono_defaults
.asyncresult_class
!= 0 );
692 mono_defaults
.waithandle_class
= mono_class_from_name (
693 mono_defaults
.corlib
, "System.Threading", "WaitHandle");
694 g_assert (mono_defaults
.waithandle_class
!= 0 );
696 mono_defaults
.typehandle_class
= mono_class_from_name (
697 mono_defaults
.corlib
, "System", "RuntimeTypeHandle");
698 g_assert (mono_defaults
.typehandle_class
!= 0);
700 mono_defaults
.methodhandle_class
= mono_class_from_name (
701 mono_defaults
.corlib
, "System", "RuntimeMethodHandle");
702 g_assert (mono_defaults
.methodhandle_class
!= 0);
704 mono_defaults
.fieldhandle_class
= mono_class_from_name (
705 mono_defaults
.corlib
, "System", "RuntimeFieldHandle");
706 g_assert (mono_defaults
.fieldhandle_class
!= 0);
708 mono_defaults
.systemtype_class
= mono_class_from_name (
709 mono_defaults
.corlib
, "System", "Type");
710 g_assert (mono_defaults
.systemtype_class
!= 0);
712 mono_defaults
.monotype_class
= mono_class_from_name (
713 mono_defaults
.corlib
, "System", "MonoType");
714 g_assert (mono_defaults
.monotype_class
!= 0);
716 mono_defaults
.exception_class
= mono_class_from_name (
717 mono_defaults
.corlib
, "System", "Exception");
718 g_assert (mono_defaults
.exception_class
!= 0);
720 mono_defaults
.threadabortexception_class
= mono_class_from_name (
721 mono_defaults
.corlib
, "System.Threading", "ThreadAbortException");
722 g_assert (mono_defaults
.threadabortexception_class
!= 0);
724 mono_defaults
.thread_class
= mono_class_from_name (
725 mono_defaults
.corlib
, "System.Threading", "Thread");
726 g_assert (mono_defaults
.thread_class
!= 0);
728 mono_defaults
.appdomain_class
= mono_class_from_name (
729 mono_defaults
.corlib
, "System", "AppDomain");
730 g_assert (mono_defaults
.appdomain_class
!= 0);
732 mono_defaults
.transparent_proxy_class
= mono_class_from_name (
733 mono_defaults
.corlib
, "System.Runtime.Remoting.Proxies", "TransparentProxy");
734 g_assert (mono_defaults
.transparent_proxy_class
!= 0);
736 mono_defaults
.real_proxy_class
= mono_class_from_name (
737 mono_defaults
.corlib
, "System.Runtime.Remoting.Proxies", "RealProxy");
738 g_assert (mono_defaults
.real_proxy_class
!= 0);
740 mono_defaults
.mono_method_message_class
= mono_class_from_name (
741 mono_defaults
.corlib
, "System.Runtime.Remoting.Messaging", "MonoMethodMessage");
742 g_assert (mono_defaults
.mono_method_message_class
!= 0);
744 mono_defaults
.field_info_class
= mono_class_from_name (
745 mono_defaults
.corlib
, "System.Reflection", "FieldInfo");
746 g_assert (mono_defaults
.field_info_class
!= 0);
748 mono_defaults
.method_info_class
= mono_class_from_name (
749 mono_defaults
.corlib
, "System.Reflection", "MethodInfo");
750 g_assert (mono_defaults
.method_info_class
!= 0);
752 mono_defaults
.stringbuilder_class
= mono_class_from_name (
753 mono_defaults
.corlib
, "System.Text", "StringBuilder");
754 g_assert (mono_defaults
.stringbuilder_class
!= 0);
756 mono_defaults
.math_class
= mono_class_from_name (
757 mono_defaults
.corlib
, "System", "Math");
758 g_assert (mono_defaults
.math_class
!= 0);
760 mono_defaults
.stack_frame_class
= mono_class_from_name (
761 mono_defaults
.corlib
, "System.Diagnostics", "StackFrame");
762 g_assert (mono_defaults
.stack_frame_class
!= 0);
764 mono_defaults
.stack_trace_class
= mono_class_from_name (
765 mono_defaults
.corlib
, "System.Diagnostics", "StackTrace");
766 g_assert (mono_defaults
.stack_trace_class
!= 0);
768 mono_defaults
.marshal_class
= mono_class_from_name (
769 mono_defaults
.corlib
, "System.Runtime.InteropServices", "Marshal");
770 g_assert (mono_defaults
.marshal_class
!= 0);
772 mono_defaults
.iserializeable_class
= mono_class_from_name (
773 mono_defaults
.corlib
, "System.Runtime.Serialization", "ISerializable");
774 g_assert (mono_defaults
.iserializeable_class
!= 0);
776 mono_defaults
.serializationinfo_class
= mono_class_from_name (
777 mono_defaults
.corlib
, "System.Runtime.Serialization", "SerializationInfo");
778 g_assert (mono_defaults
.serializationinfo_class
!= 0);
780 mono_defaults
.streamingcontext_class
= mono_class_from_name (
781 mono_defaults
.corlib
, "System.Runtime.Serialization", "StreamingContext");
782 g_assert (mono_defaults
.streamingcontext_class
!= 0);
784 mono_defaults
.typed_reference_class
= mono_class_from_name (
785 mono_defaults
.corlib
, "System", "TypedReference");
786 g_assert (mono_defaults
.typed_reference_class
!= 0);
788 mono_defaults
.argumenthandle_class
= mono_class_from_name (
789 mono_defaults
.corlib
, "System", "RuntimeArgumentHandle");
790 g_assert (mono_defaults
.argumenthandle_class
!= 0);
792 mono_defaults
.marshalbyrefobject_class
= mono_class_from_name (
793 mono_defaults
.corlib
, "System", "MarshalByRefObject");
794 g_assert (mono_defaults
.marshalbyrefobject_class
!= 0);
796 mono_defaults
.monitor_class
= mono_class_from_name (
797 mono_defaults
.corlib
, "System.Threading", "Monitor");
798 g_assert (mono_defaults
.monitor_class
!= 0);
800 mono_defaults
.iremotingtypeinfo_class
= mono_class_from_name (
801 mono_defaults
.corlib
, "System.Runtime.Remoting", "IRemotingTypeInfo");
802 g_assert (mono_defaults
.iremotingtypeinfo_class
!= 0);
804 mono_defaults
.runtimesecurityframe_class
= mono_class_from_name (
805 mono_defaults
.corlib
, "System.Security", "RuntimeSecurityFrame");
807 mono_defaults
.executioncontext_class
= mono_class_from_name (
808 mono_defaults
.corlib
, "System.Threading", "ExecutionContext");
810 mono_defaults
.internals_visible_class
= mono_class_from_name (
811 mono_defaults
.corlib
, "System.Runtime.CompilerServices", "InternalsVisibleToAttribute");
813 mono_defaults
.variant_class
= mono_class_from_name (
814 mono_defaults
.corlib
, "System", "Variant");
816 mono_defaults
.com_object_class
= mono_class_from_name (
817 mono_defaults
.corlib
, "System", "__ComObject");
819 mono_defaults
.com_interop_proxy_class
= mono_class_from_name (
820 mono_defaults
.corlib
, "Mono.Interop", "ComInteropProxy");
822 mono_defaults
.safehandle_class
= mono_class_from_name (
823 mono_defaults
.corlib
, "System.Runtime.InteropServices", "SafeHandle");
826 * Note that mono_defaults.generic_*_class is only non-NULL if we're
827 * using the 2.0 corlib.
829 mono_class_init (mono_defaults
.array_class
);
830 mono_defaults
.generic_nullable_class
= mono_class_from_name (
831 mono_defaults
.corlib
, "System", "Nullable`1");
832 mono_defaults
.generic_ilist_class
= mono_class_from_name (
833 mono_defaults
.corlib
, "System.Collections.Generic", "IList`1");
835 domain
->friendly_name
= g_path_get_basename (filename
);
843 * Creates the initial application domain and initializes the mono_defaults
845 * This function is guaranteed to not run any IL code.
846 * The runtime is initialized using the default runtime version.
848 * Returns: the initial domain.
851 mono_init (const char *domain_name
)
853 return mono_init_internal (domain_name
, NULL
, DEFAULT_RUNTIME_VERSION
);
857 * mono_init_from_assembly:
859 * Creates the initial application domain and initializes the mono_defaults
861 * This function is guaranteed to not run any IL code.
862 * The runtime is initialized using the runtime version required by the
863 * provided executable. The version is determined by looking at the exe
864 * configuration file and the version PE field)
866 * Returns: the initial domain.
869 mono_init_from_assembly (const char *domain_name
, const char *filename
)
871 return mono_init_internal (domain_name
, filename
, NULL
);
877 * Creates the initial application domain and initializes the mono_defaults
879 * This function is guaranteed to not run any IL code.
880 * The runtime is initialized using the provided rutime version.
882 * Returns: the initial domain.
885 mono_init_version (const char *domain_name
, const char *version
)
887 return mono_init_internal (domain_name
, NULL
, version
);
893 * Cleans up all metadata modules.
898 mono_loader_cleanup ();
899 mono_classes_cleanup ();
900 mono_assemblies_cleanup ();
901 mono_images_cleanup ();
902 mono_raw_buffer_cleanup ();
903 mono_metadata_cleanup ();
905 TlsFree (appdomain_thread_id
);
906 DeleteCriticalSection (&appdomains_mutex
);
910 * mono_get_root_domain:
912 * The root AppDomain is the initial domain created by the runtime when it is
913 * initialized. Programs execute on this AppDomain, but can create new ones
914 * later. Currently there is no unmanaged API to create new AppDomains, this
915 * must be done from managed code.
917 * Returns: the root appdomain, to obtain the current domain, use mono_domain_get ()
920 mono_get_root_domain (void)
922 return mono_root_domain
;
928 * Returns: the current domain, to obtain the root domain use
929 * mono_get_root_domain().
934 return GET_APPDOMAIN ();
938 * mono_domain_set_internal:
939 * @domain: the new domain
941 * Sets the current domain to @domain.
944 mono_domain_set_internal (MonoDomain
*domain
)
946 SET_APPDOMAIN (domain
);
947 SET_APPCONTEXT (domain
->default_context
);
951 mono_domain_foreach (MonoDomainFunc func
, gpointer user_data
)
957 * Create a copy of the data to avoid calling the user callback
958 * inside the lock because that could lead to deadlocks.
959 * We can do this because this function is not perf. critical.
961 mono_appdomains_lock ();
962 size
= appdomain_list_size
;
963 copy
= mono_gc_alloc_fixed (appdomain_list_size
* sizeof (void*), NULL
);
964 memcpy (copy
, appdomains_list
, appdomain_list_size
* sizeof (void*));
965 mono_appdomains_unlock ();
967 for (i
= 0; i
< size
; ++i
) {
969 func (copy
[i
], user_data
);
972 mono_gc_free_fixed (copy
);
976 * mono_domain_assembly_open:
977 * @domain: the application domain
978 * @name: file name of the assembly
980 * fixme: maybe we should integrate this with mono_assembly_open ??
983 mono_domain_assembly_open (MonoDomain
*domain
, const char *name
)
988 mono_domain_assemblies_lock (domain
);
989 for (tmp
= domain
->domain_assemblies
; tmp
; tmp
= tmp
->next
) {
991 if (strcmp (name
, ass
->aname
.name
) == 0) {
992 mono_domain_assemblies_unlock (domain
);
996 mono_domain_assemblies_unlock (domain
);
998 if (!(ass
= mono_assembly_open (name
, NULL
)))
1005 dynamic_method_info_free (gpointer key
, gpointer value
, gpointer user_data
)
1007 MonoJitDynamicMethodInfo
*di
= value
;
1008 mono_code_manager_destroy (di
->code_mp
);
1013 delete_jump_list (gpointer key
, gpointer value
, gpointer user_data
)
1015 g_slist_free (value
);
1019 mono_domain_free (MonoDomain
*domain
, gboolean force
)
1022 if ((domain
== mono_root_domain
) && !force
) {
1023 g_warning ("cant unload root domain");
1027 mono_appdomains_lock ();
1028 appdomains_list
[domain
->domain_id
] = NULL
;
1029 mono_appdomains_unlock ();
1031 /* FIXME: free delegate_hash_table when it's used */
1032 if (domain
->search_path
) {
1033 g_strfreev (domain
->search_path
);
1034 domain
->search_path
= NULL
;
1036 domain
->create_proxy_for_type_method
= NULL
;
1037 domain
->private_invoke_method
= NULL
;
1038 domain
->default_context
= NULL
;
1039 domain
->out_of_memory_ex
= NULL
;
1040 domain
->null_reference_ex
= NULL
;
1041 domain
->stack_overflow_ex
= NULL
;
1042 domain
->entry_assembly
= NULL
;
1043 for (tmp
= domain
->domain_assemblies
; tmp
; tmp
= tmp
->next
) {
1044 MonoAssembly
*ass
= tmp
->data
;
1045 mono_trace (G_LOG_LEVEL_INFO
, MONO_TRACE_ASSEMBLY
, "Unloading domain %s %p, assembly %s %p, refcount=%d\n", domain
->friendly_name
, domain
, ass
->aname
.name
, ass
, ass
->ref_count
);
1046 mono_assembly_close (ass
);
1048 g_slist_free (domain
->domain_assemblies
);
1049 domain
->domain_assemblies
= NULL
;
1051 g_free (domain
->friendly_name
);
1052 domain
->friendly_name
= NULL
;
1053 mono_g_hash_table_destroy (domain
->env
);
1055 g_hash_table_destroy (domain
->class_vtable_hash
);
1056 domain
->class_vtable_hash
= NULL
;
1057 g_hash_table_destroy (domain
->proxy_vtable_hash
);
1058 domain
->proxy_vtable_hash
= NULL
;
1059 if (domain
->static_data_array
) {
1060 mono_gc_free_fixed (domain
->static_data_array
);
1061 domain
->static_data_array
= NULL
;
1063 g_hash_table_destroy (domain
->jit_code_hash
);
1064 domain
->jit_code_hash
= NULL
;
1065 if (domain
->dynamic_code_hash
) {
1066 g_hash_table_foreach (domain
->dynamic_code_hash
, dynamic_method_info_free
, NULL
);
1067 g_hash_table_destroy (domain
->dynamic_code_hash
);
1068 domain
->dynamic_code_hash
= NULL
;
1070 mono_g_hash_table_destroy (domain
->ldstr_table
);
1071 domain
->ldstr_table
= NULL
;
1072 mono_jit_info_table_free (domain
->jit_info_table
);
1073 domain
->jit_info_table
= NULL
;
1074 #ifdef DEBUG_DOMAIN_UNLOAD
1075 mono_mempool_invalidate (domain
->mp
);
1076 mono_code_manager_invalidate (domain
->code_mp
);
1078 mono_mempool_destroy (domain
->mp
);
1080 mono_code_manager_destroy (domain
->code_mp
);
1081 domain
->code_mp
= NULL
;
1083 if (domain
->jump_target_hash
) {
1084 g_hash_table_foreach (domain
->jump_target_hash
, delete_jump_list
, NULL
);
1085 g_hash_table_destroy (domain
->jump_target_hash
);
1086 domain
->jump_target_hash
= NULL
;
1088 if (domain
->type_hash
) {
1089 mono_g_hash_table_destroy (domain
->type_hash
);
1090 domain
->type_hash
= NULL
;
1092 if (domain
->refobject_hash
) {
1093 mono_g_hash_table_destroy (domain
->refobject_hash
);
1094 domain
->refobject_hash
= NULL
;
1096 if (domain
->type_init_exception_hash
) {
1097 mono_g_hash_table_destroy (domain
->type_init_exception_hash
);
1098 domain
->type_init_exception_hash
= NULL
;
1100 g_hash_table_destroy (domain
->class_init_trampoline_hash
);
1101 domain
->class_init_trampoline_hash
= NULL
;
1102 g_hash_table_destroy (domain
->jump_trampoline_hash
);
1103 domain
->jump_trampoline_hash
= NULL
;
1104 g_hash_table_destroy (domain
->finalizable_objects_hash
);
1105 domain
->finalizable_objects_hash
= NULL
;
1106 g_hash_table_destroy (domain
->jit_trampoline_hash
);
1107 domain
->jit_trampoline_hash
= NULL
;
1108 g_hash_table_destroy (domain
->delegate_trampoline_hash
);
1109 domain
->delegate_trampoline_hash
= NULL
;
1110 if (domain
->special_static_fields
) {
1111 g_hash_table_destroy (domain
->special_static_fields
);
1112 domain
->special_static_fields
= NULL
;
1114 DeleteCriticalSection (&domain
->assemblies_lock
);
1115 DeleteCriticalSection (&domain
->lock
);
1116 domain
->setup
= NULL
;
1118 /* FIXME: anything else required ? */
1120 mono_gc_free_fixed (domain
);
1122 if ((domain
== mono_root_domain
))
1123 mono_root_domain
= NULL
;
1127 * mono_domain_get_id:
1130 * Returns: the a domain for a specific domain id.
1133 mono_domain_get_by_id (gint32 domainid
)
1135 MonoDomain
* domain
;
1137 mono_appdomains_lock ();
1138 if (domainid
< appdomain_list_size
)
1139 domain
= appdomains_list
[domainid
];
1142 mono_appdomains_unlock ();
1148 mono_domain_get_id (MonoDomain
*domain
)
1150 return domain
->domain_id
;
1154 mono_context_set (MonoAppContext
* new_context
)
1156 SET_APPCONTEXT (new_context
);
1160 mono_context_get (void)
1162 return GET_APPCONTEXT ();
1165 /* LOCKING: the caller holds the lock for this domain */
1167 mono_domain_add_class_static_data (MonoDomain
*domain
, MonoClass
*klass
, gpointer data
, guint32
*bitmap
)
1169 /* The first entry in the array is the index of the next free slot
1170 * and the total size of the array
1173 if (domain
->static_data_array
) {
1174 int size
= GPOINTER_TO_INT (domain
->static_data_array
[1]);
1175 next
= GPOINTER_TO_INT (domain
->static_data_array
[0]);
1177 gpointer
*new_array
= mono_gc_alloc_fixed (sizeof (gpointer
) * (size
* 2), NULL
);
1178 memcpy (new_array
, domain
->static_data_array
, sizeof (gpointer
) * size
);
1180 new_array
[1] = GINT_TO_POINTER (size
);
1181 mono_gc_free_fixed (domain
->static_data_array
);
1182 domain
->static_data_array
= new_array
;
1186 gpointer
*new_array
= mono_gc_alloc_fixed (sizeof (gpointer
) * size
, NULL
);
1188 new_array
[0] = GINT_TO_POINTER (next
);
1189 new_array
[1] = GINT_TO_POINTER (size
);
1190 domain
->static_data_array
= new_array
;
1192 domain
->static_data_array
[next
++] = data
;
1193 domain
->static_data_array
[0] = GINT_TO_POINTER (next
);
1197 mono_get_corlib (void)
1199 return mono_defaults
.corlib
;
1203 mono_get_object_class (void)
1205 return mono_defaults
.object_class
;
1209 mono_get_byte_class (void)
1211 return mono_defaults
.byte_class
;
1215 mono_get_void_class (void)
1217 return mono_defaults
.void_class
;
1221 mono_get_boolean_class (void)
1223 return mono_defaults
.boolean_class
;
1227 mono_get_sbyte_class (void)
1229 return mono_defaults
.sbyte_class
;
1233 mono_get_int16_class (void)
1235 return mono_defaults
.int16_class
;
1239 mono_get_uint16_class (void)
1241 return mono_defaults
.uint16_class
;
1245 mono_get_int32_class (void)
1247 return mono_defaults
.int32_class
;
1251 mono_get_uint32_class (void)
1253 return mono_defaults
.uint32_class
;
1257 mono_get_intptr_class (void)
1259 return mono_defaults
.int_class
;
1263 mono_get_uintptr_class (void)
1265 return mono_defaults
.uint_class
;
1269 mono_get_int64_class (void)
1271 return mono_defaults
.int64_class
;
1275 mono_get_uint64_class (void)
1277 return mono_defaults
.uint64_class
;
1281 mono_get_single_class (void)
1283 return mono_defaults
.single_class
;
1287 mono_get_double_class (void)
1289 return mono_defaults
.double_class
;
1293 mono_get_char_class (void)
1295 return mono_defaults
.char_class
;
1299 mono_get_string_class (void)
1301 return mono_defaults
.string_class
;
1305 mono_get_enum_class (void)
1307 return mono_defaults
.enum_class
;
1311 mono_get_array_class (void)
1313 return mono_defaults
.array_class
;
1317 mono_get_thread_class (void)
1319 return mono_defaults
.thread_class
;
1323 mono_get_exception_class (void)
1325 return mono_defaults
.exception_class
;
1329 static char* get_attribute_value (const gchar
**attribute_names
,
1330 const gchar
**attribute_values
,
1331 const char *att_name
)
1334 for (n
=0; attribute_names
[n
] != NULL
; n
++) {
1335 if (strcmp (attribute_names
[n
], att_name
) == 0)
1336 return g_strdup (attribute_values
[n
]);
1341 static void start_element (GMarkupParseContext
*context
,
1342 const gchar
*element_name
,
1343 const gchar
**attribute_names
,
1344 const gchar
**attribute_values
,
1348 AppConfigInfo
* app_config
= (AppConfigInfo
*) user_data
;
1350 if (strcmp (element_name
, "configuration") == 0) {
1351 app_config
->configuration_count
++;
1354 if (strcmp (element_name
, "startup") == 0) {
1355 app_config
->startup_count
++;
1359 if (app_config
->configuration_count
!= 1 || app_config
->startup_count
!= 1)
1362 if (strcmp (element_name
, "requiredRuntime") == 0) {
1363 app_config
->required_runtime
= get_attribute_value (attribute_names
, attribute_values
, "version");
1364 } else if (strcmp (element_name
, "supportedRuntime") == 0) {
1365 char *version
= get_attribute_value (attribute_names
, attribute_values
, "version");
1366 app_config
->supported_runtimes
= g_slist_append (app_config
->supported_runtimes
, version
);
1370 static void end_element (GMarkupParseContext
*context
,
1371 const gchar
*element_name
,
1375 AppConfigInfo
* app_config
= (AppConfigInfo
*) user_data
;
1377 if (strcmp (element_name
, "configuration") == 0) {
1378 app_config
->configuration_count
--;
1379 } else if (strcmp (element_name
, "startup") == 0) {
1380 app_config
->startup_count
--;
1384 static const GMarkupParser
1393 static AppConfigInfo
*
1394 app_config_parse (const char *filename
)
1396 AppConfigInfo
*app_config
;
1397 GMarkupParseContext
*context
;
1402 if (stat (filename
, &buf
) != 0)
1405 app_config
= g_new0 (AppConfigInfo
, 1);
1407 if (!g_file_get_contents (filename
, &text
, &len
, NULL
))
1410 context
= g_markup_parse_context_new (&mono_parser
, 0, app_config
, NULL
);
1411 if (g_markup_parse_context_parse (context
, text
, len
, NULL
)) {
1412 g_markup_parse_context_end_parse (context
, NULL
);
1414 g_markup_parse_context_free (context
);
1420 app_config_free (AppConfigInfo
* app_config
)
1423 GSList
*list
= app_config
->supported_runtimes
;
1424 while (list
!= NULL
) {
1425 rt
= (char*)list
->data
;
1427 list
= g_slist_next (list
);
1429 g_slist_free (app_config
->supported_runtimes
);
1430 g_free (app_config
->required_runtime
);
1431 g_free (app_config
);
1435 static const MonoRuntimeInfo
*
1436 get_runtime_by_version (const char *version
)
1439 int max
= G_N_ELEMENTS (supported_runtimes
);
1441 for (n
=0; n
<max
; n
++) {
1442 if (strcmp (version
, supported_runtimes
[n
].runtime_version
) == 0)
1443 return &supported_runtimes
[n
];
1449 get_runtimes_from_exe (const char *exe_file
, const MonoRuntimeInfo
** runtimes
)
1451 AppConfigInfo
* app_config
;
1454 const MonoRuntimeInfo
* runtime
= NULL
;
1455 MonoImage
*image
= NULL
;
1457 config_name
= g_strconcat (exe_file
, ".config", NULL
);
1458 app_config
= app_config_parse (config_name
);
1459 g_free (config_name
);
1461 if (app_config
!= NULL
) {
1462 /* Check supportedRuntime elements, if none is supported, fail.
1463 * If there are no such elements, look for a requiredRuntime element.
1465 if (app_config
->supported_runtimes
!= NULL
) {
1467 GSList
*list
= app_config
->supported_runtimes
;
1468 while (list
!= NULL
) {
1469 version
= (char*) list
->data
;
1470 runtime
= get_runtime_by_version (version
);
1471 if (runtime
!= NULL
)
1472 runtimes
[n
++] = runtime
;
1473 list
= g_slist_next (list
);
1475 runtimes
[n
] = NULL
;
1476 app_config_free (app_config
);
1480 /* Check the requiredRuntime element. This is for 1.0 apps only. */
1481 if (app_config
->required_runtime
!= NULL
) {
1482 runtimes
[0] = get_runtime_by_version (app_config
->required_runtime
);
1483 runtimes
[1] = NULL
;
1484 app_config_free (app_config
);
1487 app_config_free (app_config
);
1490 /* Look for a runtime with the exact version */
1491 image
= mono_image_open (exe_file
, NULL
);
1492 if (image
== NULL
) {
1493 /* The image is wrong or the file was not found. In this case return
1494 * a default runtime and leave to the initialization method the work of
1495 * reporting the error.
1497 runtimes
[0] = get_runtime_by_version (DEFAULT_RUNTIME_VERSION
);
1498 runtimes
[1] = NULL
;
1503 * FIXME: This would cause us to unload the image, and it will be loaded again later.
1504 * Disabling it will mean the initial exe will not be unloaded on shutdown.
1506 //mono_image_close (image);
1508 runtimes
[0] = get_runtime_by_version (image
->version
);
1509 runtimes
[1] = NULL
;
1514 * mono_get_runtime_info:
1516 * Returns: the version of the current runtime instance.
1518 const MonoRuntimeInfo
*
1519 mono_get_runtime_info (void)
1521 return current_runtime
;
1525 mono_debugger_check_runtime_version (const char *filename
)
1527 const MonoRuntimeInfo
* runtimes
[G_N_ELEMENTS (supported_runtimes
) + 1];
1528 const MonoRuntimeInfo
*rinfo
;
1530 get_runtimes_from_exe (filename
, runtimes
);
1531 rinfo
= runtimes
[0];
1534 return g_strdup_printf ("Cannot get runtime version from assembly `%s'", filename
);
1536 if (rinfo
!= current_runtime
)
1537 return g_strdup_printf ("The Mono Debugger is currently using the `%s' runtime, but "
1538 "the assembly `%s' requires version `%s'", current_runtime
->runtime_version
,
1539 filename
, rinfo
->runtime_version
);