#endif
#include <stdlib.h>
#include <stdio.h>
-#include <signal.h>
#include <string.h>
#include <mono/metadata/mono-endian.h>
#include <mono/metadata/tabledefs.h>
#define mono_type_initialization_unlock() mono_mutex_unlock (&type_initialization_section)
static mono_mutex_t type_initialization_section;
+
+static void
+mono_type_init_lock (TypeInitializationLock *lock)
+{
+ MONO_TRY_BLOCKING
+ mono_mutex_lock (&lock->initialization_section);
+ MONO_FINISH_TRY_BLOCKING
+}
+
+static void
+mono_type_init_unlock (TypeInitializationLock *lock)
+{
+ mono_mutex_unlock (&lock->initialization_section);
+}
+
/* from vtable to lock */
static GHashTable *type_initialization_hash;
MonoClass *klass;
gchar *full_name;
- MONO_ARCH_SAVE_REGS;
-
if (vtable->initialized)
return NULL;
lock->waiting_count = 1;
lock->done = FALSE;
/* grab the vtable lock while this thread still owns type_initialization_section */
- mono_mutex_lock (&lock->initialization_section);
+ mono_type_init_lock (lock);
g_hash_table_insert (type_initialization_hash, vtable, lock);
do_initialization = 1;
} else {
if (last_domain)
mono_domain_set (last_domain, TRUE);
lock->done = TRUE;
- mono_mutex_unlock (&lock->initialization_section);
+ mono_type_init_unlock (lock);
} else {
/* this just blocks until the initializing thread is done */
- mono_mutex_lock (&lock->initialization_section);
- mono_mutex_unlock (&lock->initialization_section);
+ mono_type_init_lock (lock);
+ mono_type_init_unlock (lock);
}
mono_type_initialization_lock ();
* and get_type_init_exception_for_class () needs to be aware of this.
*/
vtable->init_failed = 1;
- mono_mutex_unlock (&lock->initialization_section);
+ mono_type_init_unlock (lock);
--lock->waiting_count;
if (lock->waiting_count == 0) {
mono_mutex_destroy (&lock->initialization_section);
static MonoTrampoline arch_create_jit_trampoline = default_trampoline;
static MonoJumpTrampoline arch_create_jump_trampoline = default_jump_trampoline;
static MonoDelegateTrampoline arch_create_delegate_trampoline = default_delegate_trampoline;
-static MonoImtThunkBuilder imt_thunk_builder = NULL;
-#define ARCH_USE_IMT (imt_thunk_builder != NULL)
+static MonoImtThunkBuilder imt_thunk_builder;
#if (MONO_IMT_SIZE > 32)
#error "MONO_IMT_SIZE cannot be larger than 32"
#endif
class->gc_descr = (gpointer)mono_gc_make_descr_for_string (bitmap, 2);
} else if (class->rank) {
mono_class_compute_gc_descriptor (class->element_class);
- if (!class->element_class->valuetype) {
+ if (MONO_TYPE_IS_REFERENCE (&class->element_class->byval_arg)) {
gsize abm = 1;
class->gc_descr = mono_gc_make_descr_for_array (class->byval_arg.type == MONO_TYPE_SZARRAY, &abm, 1, sizeof (gpointer));
/*printf ("new array descriptor: 0x%x for %s.%s\n", class->gc_descr,
* The IMT thunk might be called with an instance of one of the
* generic virtual methods, so has to fallback to the IMT trampoline.
*/
- imt [i] = initialize_imt_slot (vt, domain, imt_builder [i], callbacks.get_imt_trampoline ? callbacks.get_imt_trampoline (i) : NULL);
+ imt [i] = initialize_imt_slot (vt, domain, imt_builder [i], callbacks.get_imt_trampoline (i));
} else {
imt [i] = initialize_imt_slot (vt, domain, imt_builder [i], NULL);
}
size_t imt_table_bytes;
int gc_bits;
guint32 vtable_size, class_size;
- guint32 cindex;
gpointer iter;
gpointer *interface_offsets;
if (class_size)
vtable_slots++;
- if (ARCH_USE_IMT) {
- if (class->interface_offsets_count) {
- imt_table_bytes = sizeof (gpointer) * (MONO_IMT_SIZE);
- mono_stats.imt_number_of_tables++;
- mono_stats.imt_tables_size += imt_table_bytes;
- } else {
- imt_table_bytes = 0;
- }
+ if (class->interface_offsets_count) {
+ imt_table_bytes = sizeof (gpointer) * (MONO_IMT_SIZE);
+ mono_stats.imt_number_of_tables++;
+ mono_stats.imt_tables_size += imt_table_bytes;
} else {
- imt_table_bytes = sizeof (gpointer) * (class->max_interface_id + 1);
+ imt_table_bytes = 0;
}
vtable_size = imt_table_bytes + MONO_SIZEOF_VTABLE + vtable_slots * sizeof (gpointer);
mono_stats.class_static_data_size += class_size;
}
- cindex = -1;
iter = NULL;
while ((field = mono_class_get_fields (class, &iter))) {
if (!(field->type->attrs & FIELD_ATTRIBUTE_STATIC))
//printf ("Initializing VT for class %s (interface_offsets_count = %d)\n",
// class->name, class->interface_offsets_count);
-
- if (! ARCH_USE_IMT) {
- /* initialize interface offsets */
- for (i = 0; i < class->interface_offsets_count; ++i) {
- int interface_id = class->interfaces_packed [i]->interface_id;
- int slot = class->interface_offsets_packed [i];
- interface_offsets [class->max_interface_id - interface_id] = &(vt->vtable [slot]);
- }
- }
/* Initialize vtable */
if (callbacks.get_vtable_trampoline) {
}
}
- if (ARCH_USE_IMT && imt_table_bytes) {
+ if (imt_table_bytes) {
/* Now that the vtable is full, we can actually fill up the IMT */
- if (callbacks.get_imt_trampoline) {
- /* lazy construction of the IMT entries enabled */
for (i = 0; i < MONO_IMT_SIZE; ++i)
interface_offsets [i] = callbacks.get_imt_trampoline (i);
- } else {
- build_imt (class, vt, domain, interface_offsets, NULL);
- }
}
/*
mono_domain_unlock (domain);
mono_loader_unlock ();
- /* Initialization is now complete, we can throw if the InheritanceDemand aren't satisfied */
- if (mono_security_enabled () && (class->exception_type == MONO_EXCEPTION_SECURITY_INHERITANCEDEMAND) && raise_on_error)
- mono_raise_exception (mono_class_get_exception_for_failure (class));
-
/* make sure the parent is initialized */
/*FIXME shouldn't this fail the current type?*/
if (class->parent)
if (iclass->max_interface_id > max_interface_id) max_interface_id = iclass->max_interface_id;
}
- if (ARCH_USE_IMT) {
- imt_table_bytes = sizeof (gpointer) * MONO_IMT_SIZE;
- mono_stats.imt_number_of_tables++;
- mono_stats.imt_tables_size += imt_table_bytes;
- } else {
- imt_table_bytes = sizeof (gpointer) * (max_interface_id + 1);
- }
+ imt_table_bytes = sizeof (gpointer) * MONO_IMT_SIZE;
+ mono_stats.imt_number_of_tables++;
+ mono_stats.imt_tables_size += imt_table_bytes;
vtsize = imt_table_bytes + MONO_SIZEOF_VTABLE + class->vtable_size * sizeof (gpointer);
bitmap = mono_domain_alloc0 (domain, bsize);
#endif
- if (! ARCH_USE_IMT) {
- /* initialize interface offsets */
- for (i = 0; i < class->interface_offsets_count; ++i) {
- int interface_id = class->interfaces_packed [i]->interface_id;
- int slot = class->interface_offsets_packed [i];
- interface_offsets [class->max_interface_id - interface_id] = &(pvt->vtable [slot]);
- }
- }
for (i = 0; i < class->interface_offsets_count; ++i) {
int interface_id = class->interfaces_packed [i]->interface_id;
bitmap [interface_id >> 3] |= (1 << (interface_id & 7));
for (list_item = extra_interfaces; list_item != NULL; list_item=list_item->next) {
interf = list_item->data;
- if (! ARCH_USE_IMT) {
- interface_offsets [max_interface_id - interf->interface_id] = &pvt->vtable [slot];
- }
bitmap [interf->interface_id >> 3] |= (1 << (interf->interface_id & 7));
iter = NULL;
slot += mono_class_num_methods (interf);
}
- if (! ARCH_USE_IMT) {
- g_slist_free (extra_interfaces);
- }
}
- if (ARCH_USE_IMT) {
- /* Now that the vtable is full, we can actually fill up the IMT */
- build_imt (class, pvt, domain, interface_offsets, extra_interfaces);
- if (extra_interfaces) {
- g_slist_free (extra_interfaces);
- }
+ /* Now that the vtable is full, we can actually fill up the IMT */
+ build_imt (class, pvt, domain, interface_offsets, extra_interfaces);
+ if (extra_interfaces) {
+ g_slist_free (extra_interfaces);
}
#ifdef COMPRESSED_INTERFACE_BITMAP
#endif
{
if (method->is_inflated) {
+ MonoError error;
/* Have to inflate the result */
- res = mono_class_inflate_generic_method (res, &((MonoMethodInflated*)method)->context);
+ res = mono_class_inflate_generic_method_checked (res, &((MonoMethodInflated*)method)->context, &error);
+ g_assert (mono_error_ok (&error)); /* FIXME don't swallow the error */
}
}
return mono_compile_method (method);
}
-static void
-set_value (MonoType *type, void *dest, void *value, int deref_pointer)
+void
+mono_copy_value (MonoType *type, void *dest, void *value, int deref_pointer)
{
int t;
if (type->byref) {
g_return_if_fail (!(field->type->attrs & FIELD_ATTRIBUTE_STATIC));
dest = (char*)obj + field->offset;
- set_value (field->type, dest, value, FALSE);
+ mono_copy_value (field->type, dest, value, FALSE);
}
/**
} else {
dest = (char*)mono_vtable_get_static_field_data (vt) + field->offset;
}
- set_value (field->type, dest, value, FALSE);
+ mono_copy_value (field->type, dest, value, FALSE);
}
/**
g_return_if_fail (!(field->type->attrs & FIELD_ATTRIBUTE_STATIC));
src = (char*)obj + field->offset;
- set_value (field->type, value, src, TRUE);
+ mono_copy_value (field->type, value, src, TRUE);
}
/**
}
/* MONO_TYPE_PTR is passed by value to runtime_invoke () */
- args [0] = *ptr;
+ args [0] = ptr ? *ptr : NULL;
args [1] = mono_type_get_object (mono_domain_get (), type);
return mono_runtime_invoke (m, NULL, args, NULL);
} else {
src = (char*)mono_vtable_get_static_field_data (vt) + field->offset;
}
- set_value (field->type, value, src, TRUE);
+ mono_copy_value (field->type, value, src, TRUE);
}
/**
return o;
}
+#ifndef HAVE_SGEN_GC
/**
* mono_object_allocate_ptrfree:
* @size: number of bytes to allocate
ALLOC_PTRFREE (o, vtable, size);
return o;
}
+#endif
static inline void *
mono_object_allocate_spec (size_t size, MonoVTable *vtable)
{
MonoVTable *vtable;
- MONO_ARCH_SAVE_REGS;
vtable = mono_class_vtable (domain, klass);
if (!vtable)
return NULL;
{
MonoVTable *vtable;
- MONO_ARCH_SAVE_REGS;
vtable = mono_class_vtable (domain, klass);
if (!vtable)
return NULL;
{
MonoObject *o;
- MONO_ARCH_SAVE_REGS;
-
/* check for is_com_object for COM Interop */
if (mono_vtable_is_remote (vtable) || mono_class_is_com_object (vtable->klass))
{
o = mono_object_allocate (size, obj->vtable);
- if (obj->vtable->klass->has_references) {
- mono_gc_wbarrier_object_copy (o, obj);
- } else {
- int size = obj->vtable->klass->instance_size;
- /* do not copy the sync state */
- mono_gc_memmove_atomic ((char*)o + sizeof (MonoObject), (char*)obj + sizeof (MonoObject), size - sizeof (MonoObject));
- }
+ /* If the object doesn't contain references this will do a simple memmove. */
+ mono_gc_wbarrier_object_copy (o, obj);
+
if (G_UNLIKELY (profile_allocs))
mono_profiler_allocation (o, obj->vtable->klass);
uintptr_t size;
MonoClass *klass = src->obj.vtable->klass;
- MONO_ARCH_SAVE_REGS;
-
g_assert (klass == dest->obj.vtable->klass);
size = mono_array_length (src);
uintptr_t *sizes;
MonoClass *klass = array->obj.vtable->klass;
- MONO_ARCH_SAVE_REGS;
-
if (array->bounds == NULL) {
size = mono_array_length (array);
o = mono_array_new_full (domain, klass, &size, NULL);
{
MonoClass *ac;
- MONO_ARCH_SAVE_REGS;
-
ac = mono_array_class_get (eclass, 1);
g_assert (ac);
MonoArray *ao;
uintptr_t byte_len;
- MONO_ARCH_SAVE_REGS;
-
if (G_UNLIKELY (n > MONO_ARRAY_MAX_INDEX)) {
arith_overflow ();
return NULL;
size_t size;
/* check for overflow */
- if (len < 0 || len > ((SIZE_MAX - G_STRUCT_OFFSET (MonoString, chars) - 2) / 2))
+ if (len < 0 || len > ((SIZE_MAX - G_STRUCT_OFFSET (MonoString, chars) - 8) / 2))
mono_gc_out_of_memory (-1);
- size = (G_STRUCT_OFFSET (MonoString, chars) + ((len + 1) * 2));
+ size = (G_STRUCT_OFFSET (MonoString, chars) + (((size_t)len + 1) * 2));
g_assert (size > 0);
vtable = mono_class_vtable (domain, mono_defaults.string_class);
{
MonoDomain *domain = mono_domain_get ();
- MONO_ARCH_SAVE_REGS;
-
if (text)
return mono_string_new (domain, text);
mono_string_is_interned_lookup (MonoString *str, int insert)
{
MonoGHashTable *ldstr_table;
- MonoString *res;
+ MonoString *s, *res;
MonoDomain *domain;
domain = ((MonoObject *)str)->vtable->domain;
ldstr_table = domain->ldstr_table;
ldstr_lock ();
- if ((res = mono_g_hash_table_lookup (ldstr_table, str))) {
+ res = mono_g_hash_table_lookup (ldstr_table, str);
+ if (res) {
ldstr_unlock ();
return res;
}
if (insert) {
- str = mono_string_get_pinned (str);
- if (str)
- mono_g_hash_table_insert (ldstr_table, str, str);
+ /* Allocate outside the lock */
ldstr_unlock ();
- return str;
+ s = mono_string_get_pinned (str);
+ if (s) {
+ ldstr_lock ();
+ res = mono_g_hash_table_lookup (ldstr_table, str);
+ if (res) {
+ ldstr_unlock ();
+ return res;
+ }
+ mono_g_hash_table_insert (ldstr_table, s, s);
+ ldstr_unlock ();
+ }
+ return s;
} else {
LDStrInfo ldstr_info;
ldstr_info.orig_domain = domain;
MonoString*
mono_ldstr (MonoDomain *domain, MonoImage *image, guint32 idx)
{
- MONO_ARCH_SAVE_REGS;
-
if (image->dynamic) {
MonoString *str = mono_lookup_dynamic_token (image, MONO_TOKEN_STRING | idx, NULL);
return str;
}
#endif
ldstr_lock ();
- if ((interned = mono_g_hash_table_lookup (domain->ldstr_table, o))) {
- ldstr_unlock ();
- /* o will get garbage collected */
- return interned;
- }
+ interned = mono_g_hash_table_lookup (domain->ldstr_table, o);
+ ldstr_unlock ();
+ if (interned)
+ return interned; /* o will get garbage collected */
o = mono_string_get_pinned (o);
- if (o)
- mono_g_hash_table_insert (domain->ldstr_table, o, o);
- ldstr_unlock ();
+ if (o) {
+ ldstr_lock ();
+ interned = mono_g_hash_table_lookup (domain->ldstr_table, o);
+ if (!interned) {
+ mono_g_hash_table_insert (domain->ldstr_table, o, o);
+ interned = o;
+ }
+ ldstr_unlock ();
+ }
- return o;
+ return interned;
}
/**
return res;
}
+MonoObject *
+mono_async_result_invoke (MonoAsyncResult *ares, MonoObject **exc)
+{
+ MonoAsyncCall *ac;
+ MonoObject *res;
+ MonoInternalThread *thread;
+
+ g_assert (ares);
+ g_assert (ares->async_delegate);
+
+ thread = mono_thread_internal_current ();
+
+ if (!ares->execution_context) {
+ ares->original_context = NULL;
+ } else {
+ /* use captured ExecutionContext (if available) */
+ MONO_OBJECT_SETREF (ares, original_context, mono_thread_get_execution_context ());
+ mono_thread_set_execution_context (ares->execution_context);
+ }
+
+ ac = (MonoAsyncCall*) ares->object_data;
+ if (!ac) {
+ thread->async_invoke_method = ((MonoDelegate*) ares->async_delegate)->method;
+ res = mono_runtime_delegate_invoke (ares->async_delegate, (void**) &ares->async_state, exc);
+ thread->async_invoke_method = NULL;
+ } else {
+ MonoArray *out_args = NULL;
+ gpointer wait_event = NULL;
+
+ ac->msg->exc = NULL;
+ res = mono_message_invoke (ares->async_delegate, ac->msg, exc, &out_args);
+ MONO_OBJECT_SETREF (ac->msg, exc, *exc);
+ MONO_OBJECT_SETREF (ac, res, res);
+ MONO_OBJECT_SETREF (ac, out_args, out_args);
+
+ mono_monitor_enter ((MonoObject*) ares);
+ ares->completed = 1;
+ if (ares->handle)
+ wait_event = mono_wait_handle_get_handle ((MonoWaitHandle*) ares->handle);
+ mono_monitor_exit ((MonoObject*) ares);
+
+ if (wait_event != NULL)
+ SetEvent (wait_event);
+
+ if (!ac->cb_method) {
+ *exc = NULL;
+ } else {
+ thread->async_invoke_method = ac->cb_method;
+ mono_runtime_invoke (ac->cb_method, ac->cb_target, (gpointer*) &ares, exc);
+ thread->async_invoke_method = NULL;
+ }
+ }
+
+ /* restore original thread execution context if flow isn't suppressed, i.e. non null */
+ if (ares->original_context) {
+ mono_thread_set_execution_context (ares->original_context);
+ ares->original_context = NULL;
+ }
+
+ return res;
+}
+
+MonoObject *
+ves_icall_System_Runtime_Remoting_Messaging_AsyncResult_Invoke (MonoAsyncResult *this)
+{
+ MonoObject *exc = NULL;
+ MonoObject *res = mono_async_result_invoke (this, &exc);
+ if (exc)
+ mono_raise_exception ((MonoException*) exc);
+ return res;
+}
+
void
mono_message_init (MonoDomain *domain,
MonoMethodMessage *this,
if (exc == (MonoObject*)mono_object_domain (exc)->out_of_memory_ex) {
message = g_strdup ("OutOfMemoryException");
free_message = TRUE;
+ } else if (exc == (MonoObject*)mono_object_domain (exc)->stack_overflow_ex) {
+ message = g_strdup ("StackOverflowException"); //if we OVF, we can't expect to have stack space to JIT Exception::ToString.
+ free_message = TRUE;
} else {
if (((MonoException*)exc)->native_trace_ips) {
mono_delegate_ctor_with_method (MonoObject *this, MonoObject *target, gpointer addr, MonoMethod *method)
{
MonoDelegate *delegate = (MonoDelegate *)this;
- MonoClass *class;
g_assert (this);
g_assert (addr);
+ g_assert (mono_class_has_parent (mono_object_class (this), mono_defaults.multicastdelegate_class));
+
if (method)
delegate->method = method;
- class = this->vtable->klass;
mono_stats.delegate_creations++;
#ifndef DISABLE_REMOTING
MonoDomain *domain = mono_domain_get ();
MonoMethodSignature *sig = mono_method_signature (method);
MonoMethodMessage *msg;
- int i, count, type;
+ int i, count;
msg = (MonoMethodMessage *)mono_object_new (domain, mono_defaults.mono_method_message_class);
else
vpos = params [i];
- type = sig->params [i]->type;
class = mono_class_from_mono_type (sig->params [i]);
if (class->valuetype)