if (mono_class_has_variant_generic_params (iface))
has_variant_iface = TRUE;
+ mono_class_setup_methods (iface);
vt_slot = interface_offset;
for (method_slot_in_interface = 0; method_slot_in_interface < iface->method.count; method_slot_in_interface++) {
MonoMethod *method;
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);
+ bitmap = compute_class_bitmap (fclass, default_bitmap, sizeof (default_bitmap) * 8, - (int)(sizeof (MonoObject) / sizeof (gpointer)), &max_set, FALSE);
numbits = max_set + 1;
} else {
default_bitmap [0] = 0;
MonoClass *class = mono_class_from_mono_type (type);
int size = mono_class_value_size (class, NULL);
if (value == NULL)
- mono_gc_bzero (dest, size);
+ mono_gc_bzero_atomic (dest, size);
else
mono_gc_wbarrier_value_copy (dest, value, 1, class);
}
void
mono_field_static_get_value (MonoVTable *vt, MonoClassField *field, void *value)
{
- return mono_field_static_get_value_for_thread (mono_thread_internal_current (), vt, field, value);
+ mono_field_static_get_value_for_thread (mono_thread_internal_current (), vt, field, value);
}
/**
if (param_class->has_references)
mono_gc_wbarrier_value_copy (buf + klass->fields [0].offset - sizeof (MonoObject), mono_object_unbox (value), 1, param_class);
else
- mono_gc_memmove (buf + klass->fields [0].offset - sizeof (MonoObject), mono_object_unbox (value), mono_class_value_size (param_class, NULL));
+ mono_gc_memmove_atomic (buf + klass->fields [0].offset - sizeof (MonoObject), mono_object_unbox (value), mono_class_value_size (param_class, NULL));
} else {
- mono_gc_bzero (buf + klass->fields [0].offset - sizeof (MonoObject), mono_class_value_size (param_class, NULL));
+ mono_gc_bzero_atomic (buf + klass->fields [0].offset - sizeof (MonoObject), mono_class_value_size (param_class, NULL));
}
}
if (param_class->has_references)
mono_gc_wbarrier_value_copy (mono_object_unbox (o), buf + klass->fields [0].offset - sizeof (MonoObject), 1, param_class);
else
- mono_gc_memmove (mono_object_unbox (o), buf + klass->fields [0].offset - sizeof (MonoObject), mono_class_value_size (param_class, NULL));
+ mono_gc_memmove_atomic (mono_object_unbox (o), buf + klass->fields [0].offset - sizeof (MonoObject), mono_class_value_size (param_class, NULL));
return o;
}
else
}
static char **main_args = NULL;
-static int num_main_args;
+static int num_main_args = 0;
/**
* mono_runtime_get_main_args:
int i;
MonoDomain *domain = mono_domain_get ();
- if (!main_args)
- return NULL;
-
res = (MonoArray*)mono_array_new (domain, mono_defaults.string_class, num_main_args);
for (i = 0; i < num_main_args; ++i)
for (i = 0; i < num_main_args; ++i)
g_free (main_args [i]);
g_free (main_args);
+ num_main_args = 0;
+ main_args = NULL;
+}
+
+/**
+ * mono_runtime_set_main_args:
+ * @argc: number of arguments from the command line
+ * @argv: array of strings from the command line
+ *
+ * Set the command line arguments from an embedding application that doesn't otherwise call
+ * mono_runtime_run_main ().
+ */
+int
+mono_runtime_set_main_args (int argc, char* argv[])
+{
+ int i;
+
+ free_main_args ();
+ main_args = g_new0 (char*, argc);
+ num_main_args = argc;
+
+ for (i = 0; i < argc; ++i) {
+ gchar *utf8_arg;
+
+ utf8_arg = mono_utf8_from_external (argv[i]);
+ if (utf8_arg == NULL) {
+ g_print ("\nCannot determine the text encoding for argument %d (%s).\n", i, argv [i]);
+ g_print ("Please add the correct encoding to MONO_EXTERNAL_ENCODINGS and try again.\n");
+ exit (-1);
+ }
+
+ main_args [i] = utf8_arg;
+ }
+
+ return 0;
}
/**
}
mono_thread_init_apartment_state ();
- mono_debugger_event (MONO_DEBUGGER_EVENT_REACHED_MAIN, 0, 0);
-
/* FIXME: check signature of method */
if (mono_method_signature (method)->ret->type == MONO_TYPE_I4) {
MonoObject *res;
}
}
- mono_debugger_event (MONO_DEBUGGER_EVENT_MAIN_EXITED, (guint64) (gsize) rval, 0);
-
return rval;
}
} else {
int size = obj->vtable->klass->instance_size;
/* do not copy the sync state */
- mono_gc_memmove ((char*)o + sizeof (MonoObject), (char*)obj + sizeof (MonoObject), size - sizeof (MonoObject));
+ mono_gc_memmove_atomic ((char*)o + sizeof (MonoObject), (char*)obj + sizeof (MonoObject), size - sizeof (MonoObject));
}
if (G_UNLIKELY (profile_allocs))
mono_profiler_allocation (o, obj->vtable->klass);
#ifdef HAVE_SGEN_GC
if (klass->element_class->valuetype) {
if (klass->element_class->has_references)
- mono_value_copy_array (dest, 0, mono_array_addr_with_size (src, 0, 0), mono_array_length (src));
+ mono_value_copy_array (dest, 0, mono_array_addr_with_size_fast (src, 0, 0), mono_array_length (src));
else
- mono_gc_memmove (&dest->vector, &src->vector, size);
+ mono_gc_memmove_atomic (&dest->vector, &src->vector, size);
} else {
mono_array_memcpy_refs (dest, 0, src, 0, mono_array_length (src));
}
#else
- mono_gc_memmove (&dest->vector, &src->vector, size);
+ mono_gc_memmove_atomic (&dest->vector, &src->vector, size);
#endif
}
#ifdef HAVE_SGEN_GC
if (klass->element_class->valuetype) {
if (klass->element_class->has_references)
- mono_value_copy_array (o, 0, mono_array_addr_with_size (array, 0, 0), mono_array_length (array));
+ mono_value_copy_array (o, 0, mono_array_addr_with_size_fast (array, 0, 0), mono_array_length (array));
else
- mono_gc_memmove (&o->vector, &array->vector, size);
+ mono_gc_memmove_atomic (&o->vector, &array->vector, size);
} else {
mono_array_memcpy_refs (o, 0, array, 0, mono_array_length (array));
}
#else
- mono_gc_memmove (&o->vector, &array->vector, size);
+ mono_gc_memmove_atomic (&o->vector, &array->vector, size);
#endif
return o;
}
#ifdef HAVE_SGEN_GC
if (klass->element_class->valuetype) {
if (klass->element_class->has_references)
- mono_value_copy_array (o, 0, mono_array_addr_with_size (array, 0, 0), mono_array_length (array));
+ mono_value_copy_array (o, 0, mono_array_addr_with_size_fast (array, 0, 0), mono_array_length (array));
else
- mono_gc_memmove (&o->vector, &array->vector, size);
+ mono_gc_memmove_atomic (&o->vector, &array->vector, size);
} else {
mono_array_memcpy_refs (o, 0, array, 0, mono_array_length (array));
}
#else
- mono_gc_memmove (&o->vector, &array->vector, size);
+ mono_gc_memmove_atomic (&o->vector, &array->vector, size);
#endif
return o;
MonoArray*
mono_array_new_full (MonoDomain *domain, MonoClass *array_class, uintptr_t *lengths, intptr_t *lower_bounds)
{
- uintptr_t byte_len, len, bounds_size;
+ uintptr_t byte_len = 0, len, bounds_size;
MonoObject *o;
MonoArray *array;
MonoArrayBounds *bounds;
{
MonoString *s;
MonoVTable *vtable;
- size_t size = (sizeof (MonoString) + ((len + 1) * 2));
+ size_t size;
- /* overflow ? can't fit it, can't allocate it! */
- if (len > size)
+ /* check for overflow */
+ if (len < 0 || len > ((SIZE_MAX - sizeof (MonoString) - 2) / 2))
mono_gc_out_of_memory (-1);
+ size = (sizeof (MonoString) + ((len + 1) * 2));
+ g_assert (size > 0);
+
vtable = mono_class_vtable (domain, mono_defaults.string_class);
g_assert (vtable);
mono_gc_wbarrier_value_copy ((char *)res + sizeof (MonoObject), value, 1, class);
#else
#if NO_UNALIGNED_ACCESS
- mono_gc_memmove ((char *)res + sizeof (MonoObject), value, size);
+ mono_gc_memmove_atomic ((char *)res + sizeof (MonoObject), value, size);
#else
switch (size) {
case 1:
*(guint64 *)((guint8 *) res + sizeof (MonoObject)) = *(guint64 *) value;
break;
default:
- mono_gc_memmove ((char *)res + sizeof (MonoObject), value, size);
+ mono_gc_memmove_atomic ((char *)res + sizeof (MonoObject), value, size);
}
#endif
#endif
mono_value_copy_array (MonoArray *dest, int dest_idx, gpointer src, int count)
{
int size = mono_array_element_size (dest->obj.vtable->klass);
- char *d = mono_array_addr_with_size (dest, size, dest_idx);
+ char *d = mono_array_addr_with_size_fast (dest, size, dest_idx);
g_assert (size == mono_class_value_size (mono_object_class (dest)->element_class, NULL));
mono_gc_wbarrier_value_copy (d, src, count, mono_object_class (dest)->element_class);
}
if (!ji && domain != mono_get_root_domain ())
ji = mono_jit_info_table_find (mono_get_root_domain (), mono_get_addr_from_ftnptr (addr));
if (ji) {
- method = ji->method;
+ method = mono_jit_info_get_method (ji);
g_assert (!method->klass->generic_container);
}
if (class->has_references)
mono_gc_wbarrier_value_copy (*((gpointer *)params [i]), arg + sizeof (MonoObject), 1, class);
else
- mono_gc_memmove (*((gpointer *)params [i]), arg + sizeof (MonoObject), size);
+ mono_gc_memmove_atomic (*((gpointer *)params [i]), arg + sizeof (MonoObject), size);
} else {
size = mono_class_value_size (mono_class_from_mono_type (pt), NULL);
- mono_gc_bzero (*((gpointer *)params [i]), size);
+ mono_gc_bzero_atomic (*((gpointer *)params [i]), size);
}
}