#include "mono/metadata/metadata-internals.h"
#include "mono/metadata/class-internals.h"
#include <mono/metadata/assembly.h>
-#include <mono/metadata/threadpool.h>
#include <mono/metadata/marshal.h>
#include "mono/metadata/debug-helpers.h"
#include "mono/metadata/marshal.h"
#include <mono/utils/mono-memory-model.h>
#include "cominterop.h"
-#if defined(HAVE_BOEHM_GC)
-#define NEED_TO_ZERO_PTRFREE 1
-#define GC_NO_DESCRIPTOR ((gpointer)(0 | GC_DS_LENGTH))
-#define ALLOC_PTRFREE(obj,vt,size) do { (obj) = GC_MALLOC_ATOMIC ((size)); (obj)->vtable = (vt); (obj)->synchronisation = NULL;} while (0)
-#define ALLOC_OBJECT(obj,vt,size) do { (obj) = GC_MALLOC ((size)); (obj)->vtable = (vt);} while (0)
-#define ALLOC_TYPED(dest,size,type) do { (dest) = GC_GCJ_MALLOC ((size),(type)); } while (0)
-#elif defined(HAVE_SGEN_GC)
-#define GC_NO_DESCRIPTOR (NULL)
-#define ALLOC_PTRFREE(obj,vt,size) do { (obj) = mono_gc_alloc_obj (vt, size);} while (0)
-#define ALLOC_OBJECT(obj,vt,size) do { (obj) = mono_gc_alloc_obj (vt, size);} while (0)
-#define ALLOC_TYPED(dest,size,type) do { (dest) = mono_gc_alloc_obj (type, size);} while (0)
-#else
-#define NEED_TO_ZERO_PTRFREE 1
-#define GC_NO_DESCRIPTOR (NULL)
-#define ALLOC_PTRFREE(obj,vt,size) do { (obj) = malloc ((size)); (obj)->vtable = (vt); (obj)->synchronisation = NULL;} while (0)
-#define ALLOC_OBJECT(obj,vt,size) do { (obj) = calloc (1, (size)); (obj)->vtable = (vt);} while (0)
-#define ALLOC_TYPED(dest,size,type) do { (dest) = calloc (1, (size)); *(gpointer*)dest = (type);} while (0)
-#endif
-
-static MonoObject* mono_object_new_ptrfree (MonoVTable *vtable);
-static MonoObject* mono_object_new_ptrfree_box (MonoVTable *vtable);
-
static void
get_default_field_value (MonoDomain* domain, MonoClassField *field, void *value);
#define ldstr_unlock() mono_mutex_unlock (&ldstr_section)
static mono_mutex_t ldstr_section;
-static gboolean profile_allocs = TRUE;
-
void
mono_runtime_object_init (MonoObject *this)
{
static void
mono_type_init_lock (TypeInitializationLock *lock)
{
- MONO_TRY_BLOCKING
+ MONO_TRY_BLOCKING;
mono_mutex_lock (&lock->initialization_section);
- MONO_FINISH_TRY_BLOCKING
+ MONO_FINISH_TRY_BLOCKING;
}
static void
if (!gcj_inited) {
mono_loader_lock ();
- mono_register_jit_icall (mono_object_new_ptrfree, "mono_object_new_ptrfree", mono_create_icall_signature ("object ptr"), FALSE);
- mono_register_jit_icall (mono_object_new_ptrfree_box, "mono_object_new_ptrfree_box", mono_create_icall_signature ("object ptr"), FALSE);
mono_register_jit_icall (mono_object_new_fast, "mono_object_new_fast", mono_create_icall_signature ("object ptr"), FALSE);
mono_register_jit_icall (mono_string_alloc, "mono_string_alloc", mono_create_icall_signature ("object int"), FALSE);
return;
class->gc_descr_inited = TRUE;
- class->gc_descr = GC_NO_DESCRIPTOR;
+ class->gc_descr = MONO_GC_DESCRIPTOR_NULL;
bitmap = default_bitmap;
if (class == mono_defaults.string_class) {
- class->gc_descr = (gpointer)mono_gc_make_descr_for_string (bitmap, 2);
+ class->gc_descr = mono_gc_make_descr_for_string (bitmap, 2);
} else if (class->rank) {
mono_class_compute_gc_descriptor (class->element_class);
if (MONO_TYPE_IS_REFERENCE (&class->element_class->byval_arg)) {
if (count++ > 58)
return;*/
bitmap = compute_class_bitmap (class, default_bitmap, sizeof (default_bitmap) * 8, 0, &max_set, FALSE);
- class->gc_descr = (gpointer)mono_gc_make_descr_for_object (bitmap, max_set + 1, class->instance_size);
+ class->gc_descr = mono_gc_make_descr_for_object (bitmap, max_set + 1, class->instance_size);
/*
- if (class->gc_descr == GC_NO_DESCRIPTOR)
+ if (class->gc_descr == MONO_GC_DESCRIPTOR_NULL)
g_print ("disabling typed alloc (%d) for %s.%s\n", max_set, class->name_space, class->name);
*/
/*printf ("new descriptor: %p 0x%x for %s.%s\n", class->gc_descr, bitmap [0], class->name_space, class->name);*/
*/
#ifdef HAVE_BOEHM_GC
if (domain != mono_get_root_domain () && !mono_dont_free_domains)
- vt->gc_descr = GC_NO_DESCRIPTOR;
+ vt->gc_descr = MONO_GC_DESCRIPTOR_NULL;
else
#endif
vt->gc_descr = class->gc_descr;
if (class_size) {
/* we store the static field pointer at the end of the vtable: vt->vtable [class->vtable_size] */
if (class->has_static_refs) {
- gpointer statics_gc_descr;
+ MonoGCDescriptor statics_gc_descr;
int max_set = 0;
gsize default_bitmap [4] = {0};
gsize *bitmap;
mono_raise_exception (mono_get_exception_overflow ());
}
-/**
- * mono_object_allocate:
- * @size: number of bytes to allocate
- *
- * This is a very simplistic routine until we have our GC-aware
- * memory allocator.
- *
- * Returns: an allocated object of size @size, or NULL on failure.
- */
-static inline void *
-mono_object_allocate (size_t size, MonoVTable *vtable)
-{
- MonoObject *o;
- ALLOC_OBJECT (o, vtable, size);
-
- return o;
-}
-
-#ifndef HAVE_SGEN_GC
-/**
- * mono_object_allocate_ptrfree:
- * @size: number of bytes to allocate
- *
- * Note that the memory allocated is not zeroed.
- * Returns: an allocated object of size @size, or NULL on failure.
- */
-static inline void *
-mono_object_allocate_ptrfree (size_t size, MonoVTable *vtable)
-{
- MonoObject *o;
- ALLOC_PTRFREE (o, vtable, size);
- return o;
-}
-#endif
-
-static inline void *
-mono_object_allocate_spec (size_t size, MonoVTable *vtable)
-{
- void *o;
- ALLOC_TYPED (o, size, vtable);
-
- return o;
-}
-
/**
* mono_object_new:
* @klass: the class of the object that we want to create
MonoObject *
mono_object_new_alloc_specific (MonoVTable *vtable)
{
- MonoObject *o;
+ MonoObject *o = mono_gc_alloc_obj (vtable, vtable->klass->instance_size);
- if (!vtable->klass->has_references) {
- o = mono_object_new_ptrfree (vtable);
- } else if (vtable->gc_descr != GC_NO_DESCRIPTOR) {
- o = mono_object_allocate_spec (vtable->klass->instance_size, vtable);
- } else {
-/* printf("OBJECT: %s.%s.\n", vtable->klass->name_space, vtable->klass->name); */
- o = mono_object_allocate (vtable->klass->instance_size, vtable);
- }
if (G_UNLIKELY (vtable->klass->has_finalize))
mono_object_register_finalizer (o);
-
- if (G_UNLIKELY (profile_allocs))
- mono_profiler_allocation (o, vtable->klass);
+
return o;
}
MonoObject*
mono_object_new_fast (MonoVTable *vtable)
{
- MonoObject *o;
- ALLOC_TYPED (o, vtable->klass->instance_size, vtable);
- return o;
-}
-
-static MonoObject*
-mono_object_new_ptrfree (MonoVTable *vtable)
-{
- MonoObject *obj;
- ALLOC_PTRFREE (obj, vtable, vtable->klass->instance_size);
-#if NEED_TO_ZERO_PTRFREE
- /* an inline memset is much faster for the common vcase of small objects
- * note we assume the allocated size is a multiple of sizeof (void*).
- */
- if (vtable->klass->instance_size < 128) {
- gpointer *p, *end;
- end = (gpointer*)((char*)obj + vtable->klass->instance_size);
- p = (gpointer*)((char*)obj + sizeof (MonoObject));
- while (p < end) {
- *p = NULL;
- ++p;
- }
- } else {
- memset ((char*)obj + sizeof (MonoObject), 0, vtable->klass->instance_size - sizeof (MonoObject));
- }
-#endif
- return obj;
-}
-
-static MonoObject*
-mono_object_new_ptrfree_box (MonoVTable *vtable)
-{
- MonoObject *obj;
- ALLOC_PTRFREE (obj, vtable, vtable->klass->instance_size);
- /* the object will be boxed right away, no need to memzero it */
- return obj;
+ return mono_gc_alloc_obj (vtable, vtable->klass->instance_size);
}
/**
{
*pass_size_in_words = FALSE;
- if (!(mono_profiler_get_events () & MONO_PROFILE_ALLOCATIONS))
- profile_allocs = FALSE;
-
if (mono_class_has_finalizer (vtable->klass) || mono_class_is_marshalbyref (vtable->klass) || (mono_profiler_get_events () & MONO_PROFILE_ALLOCATIONS))
return mono_object_new_specific;
- if (!vtable->klass->has_references) {
- //g_print ("ptrfree for %s.%s\n", vtable->klass->name_space, vtable->klass->name);
- if (for_box)
- return mono_object_new_ptrfree_box;
- return mono_object_new_ptrfree;
- }
-
- if (vtable->gc_descr != GC_NO_DESCRIPTOR) {
+ if (vtable->gc_descr != MONO_GC_DESCRIPTOR_NULL) {
return mono_object_new_fast;
if (obj->vtable->klass->rank)
return (MonoObject*)mono_array_clone ((MonoArray*)obj);
- o = mono_object_allocate (size, obj->vtable);
+ o = mono_gc_alloc_obj (obj->vtable, size);
/* 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);
-
if (obj->vtable->klass->has_finalize)
mono_object_register_finalizer (o);
return o;
* they need to be kept in sync.
*/
vtable = mono_class_vtable_full (domain, array_class, TRUE);
-#ifndef HAVE_SGEN_GC
- if (!array_class->has_references) {
- o = mono_object_allocate_ptrfree (byte_len, vtable);
-#if NEED_TO_ZERO_PTRFREE
- memset ((char*)o + sizeof (MonoObject), 0, byte_len - sizeof (MonoObject));
-#endif
- } else if (vtable->gc_descr != GC_NO_DESCRIPTOR) {
- o = mono_object_allocate_spec (byte_len, vtable);
- }else {
- o = mono_object_allocate (byte_len, vtable);
- }
-
- array = (MonoArray*)o;
- array->max_length = len;
-
- if (bounds_size) {
- bounds = (MonoArrayBounds*)((char*)array + byte_len - bounds_size);
- array->bounds = bounds;
- }
-#else
if (bounds_size)
o = mono_gc_alloc_array (vtable, byte_len, len, bounds_size);
else
array = (MonoArray*)o;
bounds = array->bounds;
-#endif
if (bounds_size) {
for (i = 0; i < array_class->rank; ++i) {
}
}
- if (G_UNLIKELY (profile_allocs))
- mono_profiler_allocation (o, array_class);
-
return array;
}
mono_gc_out_of_memory (MONO_ARRAY_MAX_SIZE);
return NULL;
}
-#ifndef HAVE_SGEN_GC
- if (!vtable->klass->has_references) {
- o = mono_object_allocate_ptrfree (byte_len, vtable);
-#if NEED_TO_ZERO_PTRFREE
- ((MonoArray*)o)->bounds = NULL;
- memset ((char*)o + sizeof (MonoObject), 0, byte_len - sizeof (MonoObject));
-#endif
- } else if (vtable->gc_descr != GC_NO_DESCRIPTOR) {
- o = mono_object_allocate_spec (byte_len, vtable);
- } else {
-/* printf("ARRAY: %s.%s.\n", vtable->klass->name_space, vtable->klass->name); */
- o = mono_object_allocate (byte_len, vtable);
- }
-
- ao = (MonoArray *)o;
- ao->max_length = n;
-#else
o = mono_gc_alloc_vector (vtable, byte_len, n);
ao = (MonoArray*)o;
-#endif
-
- if (G_UNLIKELY (profile_allocs))
- mono_profiler_allocation (o, vtable->klass);
return ao;
}
vtable = mono_class_vtable (domain, mono_defaults.string_class);
g_assert (vtable);
-#ifndef HAVE_SGEN_GC
- s = mono_object_allocate_ptrfree (size, vtable);
-
- s->length = len;
-#else
s = mono_gc_alloc_string (vtable, size, len);
-#endif
-#if NEED_TO_ZERO_PTRFREE
- s->chars [len] = 0;
-#endif
- if (G_UNLIKELY (profile_allocs))
- mono_profiler_allocation ((MonoObject*)s, mono_defaults.string_class);
return s;
}
return NULL;
size = mono_class_instance_size (class);
res = mono_object_new_alloc_specific (vtable);
- if (G_UNLIKELY (profile_allocs))
- mono_profiler_allocation (res, class);
size = size - sizeof (MonoObject);
}
MonoObject *
-mono_async_result_invoke (MonoAsyncResult *ares, MonoObject **exc)
+ves_icall_System_Runtime_Remoting_Messaging_AsyncResult_Invoke (MonoAsyncResult *ares)
{
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;
+ res = mono_runtime_delegate_invoke (ares->async_delegate, (void**) &ares->async_state, 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);
+ res = mono_message_invoke (ares->async_delegate, ac->msg, &ac->msg->exc, &ac->out_args);
MONO_OBJECT_SETREF (ac, res, res);
- MONO_OBJECT_SETREF (ac, out_args, out_args);
mono_monitor_enter ((MonoObject*) ares);
ares->completed = 1;
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;
+ if (ac->cb_method) {
+ /* we swallow the excepton as it is the behavior on .NET */
+ MonoObject *exc = NULL;
+ mono_runtime_invoke (ac->cb_method, ac->cb_target, (gpointer*) &ares, &exc);
+ if (exc)
+ mono_unhandled_exception (exc);
}
}
- /* 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,
+ MonoMethodMessage *this_obj,
MonoReflectionMethod *method,
MonoArray *out_args)
{
mono_atomic_store_release (&object_array_klass, klass);
}
- MONO_OBJECT_SETREF (this, method, method);
+ MONO_OBJECT_SETREF (this_obj, method, method);
- MONO_OBJECT_SETREF (this, args, mono_array_new_specific (mono_class_vtable (domain, object_array_klass), sig->param_count));
- MONO_OBJECT_SETREF (this, arg_types, mono_array_new_specific (mono_class_vtable (domain, byte_array_klass), sig->param_count));
- this->async_result = NULL;
- this->call_type = CallType_Sync;
+ MONO_OBJECT_SETREF (this_obj, args, mono_array_new_specific (mono_class_vtable (domain, object_array_klass), sig->param_count));
+ MONO_OBJECT_SETREF (this_obj, arg_types, mono_array_new_specific (mono_class_vtable (domain, byte_array_klass), sig->param_count));
+ this_obj->async_result = NULL;
+ this_obj->call_type = CallType_Sync;
names = g_new (char *, sig->param_count);
mono_method_get_param_names (method->method, (const char **) names);
- MONO_OBJECT_SETREF (this, names, mono_array_new_specific (mono_class_vtable (domain, string_array_klass), sig->param_count));
+ MONO_OBJECT_SETREF (this_obj, names, mono_array_new_specific (mono_class_vtable (domain, string_array_klass), sig->param_count));
for (i = 0; i < sig->param_count; i++) {
name = mono_string_new (domain, names [i]);
- mono_array_setref (this->names, i, name);
+ mono_array_setref (this_obj->names, i, name);
}
g_free (names);
if (sig->params [i]->byref) {
if (out_args) {
MonoObject* arg = mono_array_get (out_args, gpointer, j);
- mono_array_setref (this->args, i, arg);
+ mono_array_setref (this_obj->args, i, arg);
j++;
}
arg_type = 2;
if (sig->params [i]->attrs & PARAM_ATTRIBUTE_OUT)
arg_type |= 4;
}
- mono_array_set (this->arg_types, guint8, i, arg_type);
+ mono_array_set (this_obj->arg_types, guint8, i, arg_type);
}
}
object_array_klass = klass;
}
- /* FIXME: GC ensure we insert a write barrier for out_args, maybe in the caller? */
- *out_args = mono_array_new_specific (mono_class_vtable (domain, object_array_klass), outarg_count);
+ mono_gc_wbarrier_generic_store (out_args, (MonoObject*) mono_array_new_specific (mono_class_vtable (domain, object_array_klass), outarg_count));
*exc = NULL;
ret = mono_runtime_invoke_array (method, method->klass->valuetype? mono_object_unbox (target): target, msg->args, exc);
* correct instantiation of the method.
*/
void
-mono_delegate_ctor_with_method (MonoObject *this, MonoObject *target, gpointer addr, MonoMethod *method)
+mono_delegate_ctor_with_method (MonoObject *this_obj, MonoObject *target, gpointer addr, MonoMethod *method)
{
- MonoDelegate *delegate = (MonoDelegate *)this;
+ MonoDelegate *delegate = (MonoDelegate *)this_obj;
- g_assert (this);
+ g_assert (this_obj);
g_assert (addr);
- g_assert (mono_class_has_parent (mono_object_class (this), mono_defaults.multicastdelegate_class));
+ g_assert (mono_class_has_parent (mono_object_class (this_obj), mono_defaults.multicastdelegate_class));
if (method)
delegate->method = method;
* This is used to initialize a delegate.
*/
void
-mono_delegate_ctor (MonoObject *this, MonoObject *target, gpointer addr)
+mono_delegate_ctor (MonoObject *this_obj, MonoObject *target, gpointer addr)
{
MonoDomain *domain = mono_domain_get ();
MonoJitInfo *ji;
g_assert (!method->klass->generic_container);
}
- mono_delegate_ctor_with_method (this, target, addr, method);
+ mono_delegate_ctor_with_method (this_obj, target, addr, method);
}
/**
* Returns: an address pointing to the value of field.
*/
gpointer
-mono_load_remote_field (MonoObject *this, MonoClass *klass, MonoClassField *field, gpointer *res)
+mono_load_remote_field (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, gpointer *res)
{
static MonoMethod *getter = NULL;
MonoDomain *domain = mono_domain_get ();
- MonoTransparentProxy *tp = (MonoTransparentProxy *) this;
+ MonoTransparentProxy *tp = (MonoTransparentProxy *) this_obj;
MonoClass *field_class;
MonoMethodMessage *msg;
MonoArray *out_args;
MonoObject *exc;
char* full_name;
- g_assert (mono_object_is_transparent_proxy (this));
+ g_assert (mono_object_is_transparent_proxy (this_obj));
g_assert (res != NULL);
if (mono_class_is_contextbound (tp->remote_class->proxy_class) && tp->rp->context == (MonoObject *) mono_context_get ()) {
* Missing documentation.
*/
MonoObject *
-mono_load_remote_field_new (MonoObject *this, MonoClass *klass, MonoClassField *field)
+mono_load_remote_field_new (MonoObject *this_obj, MonoClass *klass, MonoClassField *field)
{
static MonoMethod *getter = NULL;
MonoDomain *domain = mono_domain_get ();
- MonoTransparentProxy *tp = (MonoTransparentProxy *) this;
+ MonoTransparentProxy *tp = (MonoTransparentProxy *) this_obj;
MonoClass *field_class;
MonoMethodMessage *msg;
MonoArray *out_args;
MonoObject *exc, *res;
char* full_name;
- g_assert (mono_object_is_transparent_proxy (this));
+ g_assert (mono_object_is_transparent_proxy (this_obj));
field_class = mono_class_from_mono_type (field->type);
/**
* mono_store_remote_field:
- * @this: pointer to an object
+ * @this_obj: pointer to an object
* @klass: klass of the object containing @field
* @field: the field to load
* @val: the value/object to store
*
* This method is called by the runtime on attempts to store fields of
- * transparent proxy objects. @this points to such TP, @klass is the class of
+ * transparent proxy objects. @this_obj points to such TP, @klass is the class of
* the object containing @field. @val is the new value to store in @field.
*/
void
-mono_store_remote_field (MonoObject *this, MonoClass *klass, MonoClassField *field, gpointer val)
+mono_store_remote_field (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, gpointer val)
{
static MonoMethod *setter = NULL;
MonoDomain *domain = mono_domain_get ();
- MonoTransparentProxy *tp = (MonoTransparentProxy *) this;
+ MonoTransparentProxy *tp = (MonoTransparentProxy *) this_obj;
MonoClass *field_class;
MonoMethodMessage *msg;
MonoArray *out_args;
MonoObject *arg;
char* full_name;
- g_assert (mono_object_is_transparent_proxy (this));
+ g_assert (mono_object_is_transparent_proxy (this_obj));
field_class = mono_class_from_mono_type (field->type);
/**
* mono_store_remote_field_new:
- * @this:
+ * @this_obj:
* @klass:
* @field:
* @arg:
* Missing documentation
*/
void
-mono_store_remote_field_new (MonoObject *this, MonoClass *klass, MonoClassField *field, MonoObject *arg)
+mono_store_remote_field_new (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, MonoObject *arg)
{
static MonoMethod *setter = NULL;
MonoDomain *domain = mono_domain_get ();
- MonoTransparentProxy *tp = (MonoTransparentProxy *) this;
+ MonoTransparentProxy *tp = (MonoTransparentProxy *) this_obj;
MonoClass *field_class;
MonoMethodMessage *msg;
MonoArray *out_args;
MonoObject *exc;
char* full_name;
- g_assert (mono_object_is_transparent_proxy (this));
+ g_assert (mono_object_is_transparent_proxy (this_obj));
field_class = mono_class_from_mono_type (field->type);
projects / mono.git / blobdiff