static MonoString*
mono_ldstr_metadata_sig (MonoDomain *domain, const char* sig);
+static void
+free_main_args (void);
+
#define ldstr_lock() EnterCriticalSection (&ldstr_section)
#define ldstr_unlock() LeaveCriticalSection (&ldstr_section)
static CRITICAL_SECTION ldstr_section;
* mono_release_type_locks
*/
DeleteCriticalSection (&type_initialization_section);
+ g_hash_table_destroy (type_initialization_hash);
+ type_initialization_hash = NULL;
#endif
DeleteCriticalSection (&ldstr_section);
+ g_hash_table_destroy (blocked_thread_hash);
+ blocked_thread_hash = NULL;
+
+ free_main_args ();
}
/**
MonoVTable *module_vtable = mono_class_vtable_full (vtable->domain, module_klass, raise_exception);
if (!module_vtable)
return NULL;
- mono_runtime_class_init (module_vtable);
+ exc = mono_runtime_class_init_full (module_vtable, raise_exception);
+ if (exc)
+ return exc;
}
}
method = mono_class_get_cctor (klass);
size = max_size;
}
+#ifdef HAVE_SGEN_GC
+ /*An Ephemeron cannot be marked by sgen*/
+ if (!static_fields && class->image == mono_defaults.corlib && !strcmp ("Ephemeron", class->name)) {
+ *max_set = 0;
+ memset (bitmap, 0, size / 8);
+ return bitmap;
+ }
+#endif
+
for (p = class; p != NULL; p = p->parent) {
gpointer iter = NULL;
while ((field = mono_class_get_fields (p, &iter))) {
return SPECIAL_STATIC_NONE;
}
-static gpointer imt_trampoline = NULL;
-
-void
-mono_install_imt_trampoline (gpointer tramp_code)
-{
- imt_trampoline = tramp_code;
-}
-
#define rot(x,k) (((x)<<(k)) | ((x)>>(32-(k))))
#define mix(a,b,c) { \
a -= c; a ^= rot(c, 4); c += b; \
* 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], imt_trampoline);
+ imt [i] = initialize_imt_slot (vt, domain, imt_builder [i], callbacks.get_imt_trampoline ? callbacks.get_imt_trampoline (i) : NULL);
} else {
imt [i] = initialize_imt_slot (vt, domain, imt_builder [i], NULL);
}
mono_loader_lock (); /*FIXME build_imt_slots requires the loader lock.*/
mono_domain_lock (vtable->domain);
/* we change the slot only if it wasn't changed from the generic imt trampoline already */
- if (imt [imt_slot] == imt_trampoline)
+ if (imt [imt_slot] == callbacks.get_imt_trampoline (imt_slot))
build_imt_slots (vtable->klass, vtable, vtable->domain, imt, NULL, imt_slot);
mono_domain_unlock (vtable->domain);
mono_loader_unlock ();
if (++gvc->count == THUNK_THRESHOLD) {
gpointer *old_thunk = *vtable_slot;
- gpointer vtable_trampoline = callbacks.get_vtable_trampoline ? callbacks.get_vtable_trampoline ((gpointer*)vtable_slot - (gpointer*)vtable) : NULL;
+ gpointer vtable_trampoline = NULL;
+ gpointer imt_trampoline = NULL;
+
+ if ((gpointer)vtable_slot < (gpointer)vtable) {
+ int displacement = (gpointer*)vtable_slot - (gpointer*)vtable;
+ int imt_slot = MONO_IMT_SIZE + displacement;
- if ((gpointer)vtable_slot < (gpointer)vtable)
/* Force the rebuild of the thunk at the next call */
+ imt_trampoline = callbacks.get_imt_trampoline (imt_slot);
*vtable_slot = imt_trampoline;
- else {
+ } else {
+ vtable_trampoline = callbacks.get_vtable_trampoline ? callbacks.get_vtable_trampoline ((gpointer*)vtable_slot - (gpointer*)vtable->vtable) : NULL;
+
entries = get_generic_virtual_entries (domain, vtable_slot);
sorted = imt_sort_slot_entries (entries);
g_ptr_array_free (sorted, TRUE);
}
+#ifndef __native_client__
+ /* We don't re-use any thunks as there is a lot of overhead */
+ /* to deleting and re-using code in Native Client. */
if (old_thunk != vtable_trampoline && old_thunk != imt_trampoline)
invalidate_generic_virtual_thunk (domain, old_thunk);
+#endif
}
mono_domain_unlock (domain);
if (!class->vtable_size)
mono_class_setup_vtable (class);
+ if (class->generic_class && !class->vtable)
+ mono_class_check_vtable_constraints (class, NULL);
+
if (class->exception_type) {
mono_domain_unlock (domain);
mono_loader_unlock ();
if (special_static != SPECIAL_STATIC_NONE) {
guint32 size, offset;
gint32 align;
+ gsize default_bitmap [4] = {0};
+ gsize *bitmap;
+ int max_set = 0;
+ MonoClass *fclass;
+ if (mono_type_is_reference (field->type)) {
+ default_bitmap [0] = 1;
+ max_set = 1;
+ bitmap = default_bitmap;
+ } else if (mono_type_is_struct (field->type)) {
+ fclass = mono_class_from_mono_type (field->type);
+ bitmap = compute_class_bitmap (fclass, default_bitmap, sizeof (default_bitmap) * 8, 0, &max_set, FALSE);
+ } else {
+ default_bitmap [0] = 0;
+ max_set = 0;
+ bitmap = default_bitmap;
+ }
size = mono_type_size (field->type, &align);
- offset = mono_alloc_special_static_data (special_static, size, align);
+ offset = mono_alloc_special_static_data (special_static, size, align, bitmap, max_set);
if (!domain->special_static_fields)
domain->special_static_fields = g_hash_table_new (NULL, NULL);
g_hash_table_insert (domain->special_static_fields, field, GUINT_TO_POINTER (offset));
+ if (bitmap != default_bitmap)
+ g_free (bitmap);
/*
* This marks the field as special static to speed up the
* checks in mono_field_static_get/set_value ().
if (ARCH_USE_IMT && imt_table_bytes) {
/* Now that the vtable is full, we can actually fill up the IMT */
- if (imt_trampoline) {
+ if (callbacks.get_imt_trampoline) {
/* lazy construction of the IMT entries enabled */
for (i = 0; i < MONO_IMT_SIZE; ++i)
- interface_offsets [i] = imt_trampoline;
+ interface_offsets [i] = callbacks.get_imt_trampoline (i);
} else {
build_imt (class, vt, domain, interface_offsets, NULL);
}
/*FIXME check for OOM*/
vt->type = mono_type_get_object (domain, &class->byval_arg);
-#if HAVE_SGEN_GC
- if (mono_object_get_class (vt->type) != mono_defaults.monotype_class) {
- static void *type_desc = NULL;
-
- if (!type_desc) {
- gsize bmap = 1;
- type_desc = mono_gc_make_descr_from_bitmap (&bmap, 1);
- }
-
+ if (mono_object_get_class (vt->type) != mono_defaults.monotype_class)
/* This is unregistered in
unregister_vtable_reflection_type() in
domain.c. */
- mono_gc_register_root ((char*)&vt->type, sizeof (gpointer), type_desc);
- }
-#endif
+ MONO_GC_REGISTER_ROOT_IF_MOVING(vt->type);
if (class->contextbound)
vt->remote = 1;
else
MonoClass *class = remote_class->proxy_class;
gpointer *interface_offsets;
uint8_t *bitmap;
- int bsize, bcsize;
+ int bsize;
+
+#ifdef COMPRESSED_INTERFACE_BITMAP
+ int bcsize;
+#endif
vt = mono_class_vtable (domain, class);
g_assert (vt); /*FIXME property handle failure*/
return FALSE;
}
+/**
+ * mono_class_field_get_special_static_type:
+ * @field: The MonoClassField describing the field.
+ *
+ * Returns: SPECIAL_STATIC_THREAD if the field is thread static, SPECIAL_STATIC_CONTEXT if it is context static,
+ * SPECIAL_STATIC_NONE otherwise.
+ */
+guint32
+mono_class_field_get_special_static_type (MonoClassField *field)
+{
+ if (!(field->type->attrs & FIELD_ATTRIBUTE_STATIC))
+ return SPECIAL_STATIC_NONE;
+ if (mono_field_is_deleted (field))
+ return SPECIAL_STATIC_NONE;
+ if (!(field->type->attrs & FIELD_ATTRIBUTE_LITERAL))
+ return field_is_special_static (field->parent, field);
+ return SPECIAL_STATIC_NONE;
+}
+
/**
* mono_class_has_special_static_fields:
*
if (field->offset == -1) {
/* Special static */
- gpointer addr = g_hash_table_lookup (vt->domain->special_static_fields, field);
+ gpointer addr;
+
+ mono_domain_lock (vt->domain);
+ addr = g_hash_table_lookup (vt->domain->special_static_fields, field);
+ mono_domain_unlock (vt->domain);
dest = mono_get_special_static_data (GPOINTER_TO_UINT (addr));
} else {
dest = (char*)vt->data + field->offset;
if (field->type->attrs & FIELD_ATTRIBUTE_STATIC) {
if (field->offset == -1) {
/* Special static */
- gpointer addr = g_hash_table_lookup (vt->domain->special_static_fields, field);
+ gpointer addr;
+
+ mono_domain_lock (vt->domain);
+ addr = g_hash_table_lookup (vt->domain->special_static_fields, field);
+ mono_domain_unlock (vt->domain);
src = mono_get_special_static_data (GPOINTER_TO_UINT (addr));
} else {
src = (guint8*)vt->data + field->offset;
{
void *src;
+ g_assert (obj);
+
g_return_if_fail (!(field->type->attrs & FIELD_ATTRIBUTE_STATIC));
src = (char*)obj + field->offset;
gchar *v;
gboolean is_static = FALSE;
gboolean is_ref = FALSE;
+ gboolean is_literal = FALSE;
+ gboolean is_ptr = FALSE;
+ MonoError error;
+ MonoType *type = mono_field_get_type_checked (field, &error);
+
+ if (!mono_error_ok (&error))
+ mono_error_raise_exception (&error);
- switch (field->type->type) {
+ switch (type->type) {
case MONO_TYPE_STRING:
case MONO_TYPE_OBJECT:
case MONO_TYPE_CLASS:
case MONO_TYPE_I8:
case MONO_TYPE_R8:
case MONO_TYPE_VALUETYPE:
- is_ref = field->type->byref;
+ is_ref = type->byref;
break;
case MONO_TYPE_GENERICINST:
- is_ref = !field->type->data.generic_class->container_class->valuetype;
+ is_ref = !mono_type_generic_inst_is_valuetype (type);
+ break;
+ case MONO_TYPE_PTR:
+ is_ptr = TRUE;
break;
default:
g_error ("type 0x%x not handled in "
- "mono_field_get_value_object", field->type->type);
+ "mono_field_get_value_object", type->type);
return NULL;
}
- if (field->type->attrs & FIELD_ATTRIBUTE_STATIC) {
+ if (type->attrs & FIELD_ATTRIBUTE_LITERAL)
+ is_literal = TRUE;
+
+ if (type->attrs & FIELD_ATTRIBUTE_STATIC) {
is_static = TRUE;
- vtable = mono_class_vtable (domain, field->parent);
- if (!vtable) {
- char *name = mono_type_get_full_name (field->parent);
- g_warning ("Could not retrieve the vtable for type %s in mono_field_get_value_object", name);
- g_free (name);
- return NULL;
+
+ if (!is_literal) {
+ vtable = mono_class_vtable (domain, field->parent);
+ if (!vtable) {
+ char *name = mono_type_get_full_name (field->parent);
+ /*FIXME extend this to use the MonoError api*/
+ g_warning ("Could not retrieve the vtable for type %s in mono_field_get_value_object", name);
+ g_free (name);
+ return NULL;
+ }
+ if (!vtable->initialized)
+ mono_runtime_class_init (vtable);
}
- if (!vtable->initialized)
- mono_runtime_class_init (vtable);
+ } else {
+ g_assert (obj);
}
if (is_ref) {
- if (is_static) {
+ if (is_literal) {
+ get_default_field_value (domain, field, &o);
+ } else if (is_static) {
mono_field_static_get_value (vtable, field, &o);
} else {
mono_field_get_value (obj, field, &o);
return o;
}
+ if (is_ptr) {
+ static MonoMethod *m;
+ gpointer args [2];
+ gpointer *ptr;
+ gpointer v;
+
+ if (!m) {
+ MonoClass *ptr_klass = mono_class_from_name_cached (mono_defaults.corlib, "System.Reflection", "Pointer");
+ m = mono_class_get_method_from_name_flags (ptr_klass, "Box", 2, METHOD_ATTRIBUTE_STATIC);
+ g_assert (m);
+ }
+
+ v = &ptr;
+ if (is_literal) {
+ get_default_field_value (domain, field, v);
+ } else if (is_static) {
+ mono_field_static_get_value (vtable, field, v);
+ } else {
+ mono_field_get_value (obj, field, v);
+ }
+
+ /* MONO_TYPE_PTR is passed by value to runtime_invoke () */
+ args [0] = *ptr;
+ args [1] = mono_type_get_object (mono_domain_get (), type);
+
+ return mono_runtime_invoke (m, NULL, args, NULL);
+ }
+
/* boxed value type */
- klass = mono_class_from_mono_type (field->type);
+ klass = mono_class_from_mono_type (type);
if (mono_class_is_nullable (klass))
return mono_nullable_box (mono_field_get_addr (obj, vtable, field), klass);
o = mono_object_new (domain, klass);
v = ((gchar *) o) + sizeof (MonoObject);
- if (is_static) {
+
+ if (is_literal) {
+ get_default_field_value (domain, field, v);
+ } else if (is_static) {
mono_field_static_get_value (vtable, field, v);
} else {
mono_field_get_value (obj, field, v);
mono_get_constant_value_from_blob (domain, def_type, data, value);
}
+void
+mono_field_static_get_value_for_thread (MonoInternalThread *thread, MonoVTable *vt, MonoClassField *field, void *value)
+{
+ void *src;
+
+ g_return_if_fail (field->type->attrs & FIELD_ATTRIBUTE_STATIC);
+
+ if (field->type->attrs & FIELD_ATTRIBUTE_LITERAL) {
+ get_default_field_value (vt->domain, field, value);
+ return;
+ }
+
+ if (field->offset == -1) {
+ /* Special static */
+ gpointer addr = g_hash_table_lookup (vt->domain->special_static_fields, field);
+ src = mono_get_special_static_data_for_thread (thread, GPOINTER_TO_UINT (addr));
+ } else {
+ src = (char*)vt->data + field->offset;
+ }
+ set_value (field->type, value, src, TRUE);
+}
+
/**
* mono_field_static_get_value:
* @vt: vtable to the object
void
mono_field_static_get_value (MonoVTable *vt, MonoClassField *field, void *value)
{
- void *src;
-
- g_return_if_fail (field->type->attrs & FIELD_ATTRIBUTE_STATIC);
-
- if (field->type->attrs & FIELD_ATTRIBUTE_LITERAL) {
- get_default_field_value (vt->domain, field, value);
- return;
- }
-
- if (field->offset == -1) {
- /* Special static */
- gpointer addr = g_hash_table_lookup (vt->domain->special_static_fields, field);
- src = mono_get_special_static_data (GPOINTER_TO_UINT (addr));
- } else {
- src = (char*)vt->data + field->offset;
- }
- set_value (field->type, value, src, TRUE);
+ return mono_field_static_get_value_for_thread (mono_thread_internal_current (), vt, field, value);
}
/**
* mono_get_delegate_invoke:
* @klass: The delegate class
*
- * Returns: the MonoMethod for the "Invoke" method in the delegate klass
+ * Returns: the MonoMethod for the "Invoke" method in the delegate klass or NULL if @klass is a broken delegate type
*/
MonoMethod *
mono_get_delegate_invoke (MonoClass *klass)
if (klass->exception_type)
return NULL;
im = mono_class_get_method_from_name (klass, "Invoke", -1);
- g_assert (im);
-
return im;
}
}
static void
-fire_process_exit_event (void)
+free_main_args (void)
{
- MonoClassField *field;
- MonoDomain *domain = mono_domain_get ();
- gpointer pa [2];
- MonoObject *delegate, *exc;
-
- field = mono_class_get_field_from_name (mono_defaults.appdomain_class, "ProcessExit");
- g_assert (field);
-
- if (domain != mono_get_root_domain ())
- return;
-
- delegate = *(MonoObject **)(((char *)domain->domain) + field->offset);
- if (delegate == NULL)
- return;
+ int i;
- pa [0] = domain;
- pa [1] = NULL;
- mono_runtime_delegate_invoke (delegate, pa, &exc);
+ for (i = 0; i < num_main_args; ++i)
+ g_free (main_args [i]);
+ g_free (main_args);
}
/**
MonoArray *args = NULL;
MonoDomain *domain = mono_domain_get ();
gchar *utf8_fullpath;
- int result;
+ MonoMethodSignature *sig;
g_assert (method != NULL);
}
argc--;
argv++;
- if (mono_method_signature (method)->param_count) {
+
+ sig = mono_method_signature (method);
+ if (!sig) {
+ g_print ("Unable to load Main method.\n");
+ exit (-1);
+ }
+
+ if (sig->param_count) {
args = (MonoArray*)mono_array_new (domain, mono_defaults.string_class, argc);
for (i = 0; i < argc; ++i) {
/* The encodings should all work, given that
mono_assembly_set_main (method->klass->image->assembly);
- result = mono_runtime_exec_main (method, args, exc);
- fire_process_exit_event ();
- return result;
+ return mono_runtime_exec_main (method, args, exc);
}
static MonoObject*
}
}
-/*
+/**
+ * mono_runtime_exec_managed_code:
+ * @domain: Application domain
+ * @main_func: function to invoke from the execution thread
+ * @main_args: parameter to the main_func
+ *
* Launch a new thread to execute a function
*
* main_func is called back from the thread with main_args as the
if (!obj) {
obj = mono_object_new (mono_domain_get (), method->klass);
+ g_assert (obj); /*maybe we should raise a TLE instead?*/
if (mono_object_class(obj) == mono_defaults.transparent_proxy_class) {
method = mono_marshal_get_remoting_invoke (method->slot == -1 ? method : method->klass->vtable [method->slot]);
}
return mono_object_new_specific (vtable);
}
+/**
+ * mono_object_new_pinned:
+ *
+ * Same as mono_object_new, but the returned object will be pinned.
+ * For SGEN, these objects will only be freed at appdomain unload.
+ */
+MonoObject *
+mono_object_new_pinned (MonoDomain *domain, MonoClass *klass)
+{
+ MonoVTable *vtable;
+
+ MONO_ARCH_SAVE_REGS;
+ vtable = mono_class_vtable (domain, klass);
+ if (!vtable)
+ return NULL;
+
+#ifdef HAVE_SGEN_GC
+ return mono_gc_alloc_pinned_obj (vtable, mono_class_instance_size (klass));
+#else
+ return mono_object_new_specific (vtable);
+#endif
+}
+
/**
* mono_object_new_specific:
* @vtable: the vtable of the object that we want to create
MonoString *news;
size = sizeof (MonoString) + 2 * (mono_string_length (str) + 1);
news = mono_gc_alloc_pinned_obj (((MonoObject*)str)->vtable, size);
- memcpy (mono_string_chars (news), mono_string_chars (str), mono_string_length (str) * 2);
- news->length = mono_string_length (str);
+ if (news) {
+ memcpy (mono_string_chars (news), mono_string_chars (str), mono_string_length (str) * 2);
+ news->length = mono_string_length (str);
+ }
return news;
}
}
if (insert) {
str = mono_string_get_pinned (str);
- mono_g_hash_table_insert (ldstr_table, str, str);
+ if (str)
+ mono_g_hash_table_insert (ldstr_table, str, str);
ldstr_unlock ();
return str;
} else {
}
o = mono_string_get_pinned (o);
- mono_g_hash_table_insert (domain->ldstr_table, o, o);
+ if (o)
+ mono_g_hash_table_insert (domain->ldstr_table, o, o);
ldstr_unlock ();
return o;
* mono_string_to_utf8:
* @s: a System.String
*
- * Return the UTF8 representation for @s.
- * the resulting buffer nedds to be freed with g_free().
+ * Returns the UTF8 representation for @s.
+ * The resulting buffer needs to be freed with mono_free().
*
* @deprecated Use mono_string_to_utf8_checked to avoid having an exception arbritraly raised.
*/
return result;
}
+/**
+ * mono_string_to_utf8_checked:
+ * @s: a System.String
+ * @error: a MonoError.
+ *
+ * Converts a MonoString to its UTF8 representation. May fail; check
+ * @error to determine whether the conversion was successful.
+ * The resulting buffer should be freed with mono_free().
+ */
char *
mono_string_to_utf8_checked (MonoString *s, MonoError *error)
{
return ret;
}
+/**
+ * mono_object_to_string:
+ * @obj: The object
+ * @exc: Any exception thrown by ToString (). May be NULL.
+ *
+ * Returns: the result of calling ToString () on an object.
+ */
+MonoString *
+mono_object_to_string (MonoObject *obj, MonoObject **exc)
+{
+ static MonoMethod *to_string = NULL;
+ MonoMethod *method;
+
+ g_assert (obj);
+
+ if (!to_string)
+ to_string = mono_class_get_method_from_name_flags (mono_get_object_class (), "ToString", 0, METHOD_ATTRIBUTE_VIRTUAL | METHOD_ATTRIBUTE_PUBLIC);
+
+ method = mono_object_get_virtual_method (obj, to_string);
+
+ return (MonoString *) mono_runtime_invoke (method, obj, NULL, exc);
+}
+
/**
* mono_print_unhandled_exception:
* @exc: The exception
void
mono_print_unhandled_exception (MonoObject *exc)
{
- MonoError error;
- char *message = (char *) "";
- MonoString *str;
- MonoMethod *method;
- MonoClass *klass;
+ MonoString * str;
+ char *message = (char*)"";
gboolean free_message = FALSE;
+ MonoError error;
- if (mono_object_isinst (exc, mono_defaults.exception_class)) {
- klass = exc->vtable->klass;
- method = NULL;
- while (klass && method == NULL) {
- method = mono_class_get_method_from_name_flags (klass, "ToString", 0, METHOD_ATTRIBUTE_VIRTUAL | METHOD_ATTRIBUTE_PUBLIC);
- if (method == NULL)
- klass = klass->parent;
- }
-
- g_assert (method);
-
- str = (MonoString *) mono_runtime_invoke (method, exc, NULL, NULL);
+ if (exc == (MonoObject*)mono_object_domain (exc)->out_of_memory_ex) {
+ message = g_strdup ("OutOfMemoryException");
+ } else {
+ str = mono_object_to_string (exc, NULL);
if (str) {
message = mono_string_to_utf8_checked (str, &error);
if (!mono_error_ok (&error)) {
mono_error_cleanup (&error);
- message = (char *)"";
+ message = (char *) "";
} else {
free_message = TRUE;
}
}
- }
+ }
/*
* g_printerr ("\nUnhandled Exception: %s.%s: %s\n", exc->vtable->klass->name_space,