o = (MonoArray*)start;
o->obj.vtable = (MonoVTable*)get_array_fill_vtable ();
/* Mark this as not a real object */
- o->obj.synchronisation = GINT_TO_POINTER (-1);
+ o->obj.synchronisation = (MonoThreadsSync *)GINT_TO_POINTER (-1);
o->bounds = NULL;
o->max_length = (mono_array_size_t)(size - MONO_SIZEOF_MONO_ARRAY);
static gboolean
object_in_domain_predicate (MonoObject *obj, void *user_data)
{
- MonoDomain *domain = user_data;
+ MonoDomain *domain = (MonoDomain *)user_data;
if (mono_object_domain (obj) == domain) {
SGEN_LOG (5, "Unregistering finalizer for object: %p (%s)", obj, sgen_client_vtable_get_name (SGEN_LOAD_VTABLE (obj)));
return TRUE;
LOCK_GC;
- node = sgen_alloc_internal (INTERNAL_MEM_EPHEMERON_LINK);
+ node = (EphemeronLinkNode *)sgen_alloc_internal (INTERNAL_MEM_EPHEMERON_LINK);
if (!node) {
UNLOCK_GC;
return FALSE;
void *res = calloc (1, size);
if (!res)
return NULL;
- if (!mono_gc_register_root (res, size, descr, source, msg)) {
+ if (!mono_gc_register_root ((char *)res, size, descr, source, msg)) {
free (res);
res = NULL;
}
void
mono_gc_free_fixed (void* addr)
{
- mono_gc_deregister_root (addr);
+ mono_gc_deregister_root ((char *)addr);
free (addr);
}
mono_mb_patch_short_branch (mb, pos);
- clause = mono_image_alloc0 (mono_defaults.corlib, sizeof (MonoExceptionClause));
+ clause = (MonoExceptionClause *)mono_image_alloc0 (mono_defaults.corlib, sizeof (MonoExceptionClause));
clause->try_offset = mono_mb_get_label (mb);
/* vtable->klass->sizes.element_size */
MonoArray *arr = (MonoArray*)obj;
guint8 *card_data, *card_base;
guint8 *card_data_end;
- char *obj_start = sgen_card_table_align_pointer (obj);
+ char *obj_start = (char *)sgen_card_table_align_pointer (obj);
mword bounds_size;
mword obj_size = sgen_mono_array_size (vt, arr, &bounds_size, sgen_vtable_get_descriptor (vt));
/* We don't want to scan the bounds entries at the end of multidimensional arrays */
HEAVY_STAT (++los_array_cards);
for (; elem < card_end; elem += SIZEOF_VOID_P) {
- gpointer new, old = *(gpointer*)elem;
+ GCObject *new_;
+ gpointer old = *(gpointer*)elem;
if ((mod_union && old) || G_UNLIKELY (sgen_ptr_in_nursery (old))) {
HEAVY_STAT (++los_array_remsets);
copy_func ((GCObject**)elem, ctx.queue);
- new = *(gpointer*)elem;
- if (G_UNLIKELY (sgen_ptr_in_nursery (new)))
- sgen_add_to_global_remset (elem, new);
+ new_ = *(GCObject **)elem;
+ if (G_UNLIKELY (sgen_ptr_in_nursery (new_)))
+ sgen_add_to_global_remset (elem, new_);
}
}
}
}
return;
case ROOT_DESC_COMPLEX: {
- gsize *bitmap_data = sgen_get_complex_descriptor_bitmap (desc);
+ gsize *bitmap_data = (gsize *)sgen_get_complex_descriptor_bitmap (desc);
gsize bwords = (*bitmap_data) - 1;
void **start_run = start_root;
bitmap_data++;
void **start_root;
RootRecord *root;
report.count = 0;
- SGEN_HASH_TABLE_FOREACH (&roots_hash [root_type], start_root, root) {
+ SGEN_HASH_TABLE_FOREACH (&roots_hash [root_type], void **, start_root, RootRecord *, root) {
SGEN_LOG (6, "Precise root scan %p-%p (desc: %p)", start_root, root->end_root, (void*)root->root_desc);
precisely_report_roots_from (&report, start_root, (void**)root->end_root, root->root_desc);
} SGEN_HASH_TABLE_FOREACH_END;
static void
walk_references (GCObject *start, size_t size, void *data)
{
- HeapWalkInfo *hwi = data;
+ HeapWalkInfo *hwi = (HeapWalkInfo *)data;
hwi->called = 0;
hwi->count = 0;
collect_references (hwi, start, size);
void
mono_gc_conservatively_scan_area (void *start, void *end)
{
- sgen_conservatively_pin_objects_from (start, end, scan_area_arg_start, scan_area_arg_end, PIN_TYPE_STACK);
+ sgen_conservatively_pin_objects_from ((void **)start, (void **)end, scan_area_arg_start, scan_area_arg_end, PIN_TYPE_STACK);
}
void*
mono_gc_scan_object (void *obj, void *gc_data)
{
- ScanCopyContext *ctx = gc_data;
+ ScanCopyContext *ctx = (ScanCopyContext *)gc_data;
ctx->ops->copy_or_mark_object ((GCObject**)&obj, ctx->queue);
return obj;
}
g_assert (info->client_info.suspend_done);
SGEN_LOG (3, "Scanning thread %p, range: %p-%p, size: %zd, pinned=%zd", info, info->client_info.stack_start, info->client_info.stack_end, (char*)info->client_info.stack_end - (char*)info->client_info.stack_start, sgen_get_pinned_count ());
if (mono_gc_get_gc_callbacks ()->thread_mark_func && !conservative_stack_mark) {
- mono_gc_get_gc_callbacks ()->thread_mark_func (info->client_info.runtime_data, aligned_stack_start, info->client_info.stack_end, precise, &ctx);
+ mono_gc_get_gc_callbacks ()->thread_mark_func (info->client_info.runtime_data, (guint8 *)aligned_stack_start, (guint8 *)info->client_info.stack_end, precise, &ctx);
} else if (!precise) {
if (!conservative_stack_mark) {
fprintf (stderr, "Precise stack mark not supported - disabling.\n");
conservative_stack_mark = TRUE;
}
- sgen_conservatively_pin_objects_from (aligned_stack_start, info->client_info.stack_end, start_nursery, end_nursery, PIN_TYPE_STACK);
+ sgen_conservatively_pin_objects_from ((void **)aligned_stack_start, (void **)info->client_info.stack_end, start_nursery, end_nursery, PIN_TYPE_STACK);
}
if (!precise) {
// We force a spill of all registers into the stack and pass a chunk of data into sgen.
MonoThreadUnwindState *state = &info->client_info.info.thread_saved_state [SELF_SUSPEND_STATE_INDEX];
if (state && state->gc_stackdata) {
- sgen_conservatively_pin_objects_from (state->gc_stackdata, (void**)((char*)state->gc_stackdata + state->gc_stackdata_size),
+ sgen_conservatively_pin_objects_from ((void **)state->gc_stackdata, (void**)((char*)state->gc_stackdata + state->gc_stackdata_size),
start_nursery, end_nursery, PIN_TYPE_STACK);
}
}
gboolean
mono_gchandle_is_in_domain (guint32 gchandle, MonoDomain *domain)
{
- MonoDomain *gchandle_domain = sgen_gchandle_get_metadata (gchandle);
+ MonoDomain *gchandle_domain = (MonoDomain *)sgen_gchandle_get_metadata (gchandle);
return domain->domain_id == gchandle_domain->domain_id;
}
static gpointer
null_link_if_in_domain (gpointer hidden, GCHandleType handle_type, int max_generation, gpointer user)
{
- MonoDomain *unloading_domain = user;
+ MonoDomain *unloading_domain = (MonoDomain *)user;
MonoDomain *obj_domain;
gboolean is_weak = MONO_GC_HANDLE_TYPE_IS_WEAK (handle_type);
if (MONO_GC_HANDLE_IS_OBJECT_POINTER (hidden)) {
- MonoObject *obj = MONO_GC_REVEAL_POINTER (hidden, is_weak);
+ MonoObject *obj = (MonoObject *)MONO_GC_REVEAL_POINTER (hidden, is_weak);
obj_domain = mono_object_domain (obj);
} else {
- obj_domain = MONO_GC_REVEAL_POINTER (hidden, is_weak);
+ obj_domain = (MonoDomain *)MONO_GC_REVEAL_POINTER (hidden, is_weak);
}
if (unloading_domain->domain_id == obj_domain->domain_id)
return NULL;
{
guint type;
for (type = HANDLE_TYPE_MIN; type < HANDLE_TYPE_MAX; ++type)
- sgen_gchandle_iterate (type, GENERATION_OLD, null_link_if_in_domain, domain);
+ sgen_gchandle_iterate ((GCHandleType)type, GENERATION_OLD, null_link_if_in_domain, domain);
}
void
mono_gc_wait_for_bridge_processing ();
}
-gboolean
-mono_gc_set_allow_synchronous_major (gboolean flag)
-{
- return sgen_set_allow_synchronous_major (flag);
-}
-
void*
mono_gc_invoke_with_gc_lock (MonoGCLockedCallbackFunc func, void *data)
{
cb.thread_detach = sgen_thread_detach;
cb.thread_unregister = sgen_thread_unregister;
cb.thread_attach = sgen_thread_attach;
- cb.mono_method_is_critical = (gpointer)is_critical_method;
+ cb.mono_method_is_critical = (gboolean (*)(void *))is_critical_method;
cb.mono_thread_in_critical_region = thread_in_critical_region;
mono_threads_init (&cb, sizeof (SgenThreadInfo));
if (nursery_canaries_enabled ())
sgen_set_use_managed_allocator (FALSE);
+
+#if defined(HAVE_KW_THREAD)
+ /* This can happen with using libmonosgen.so */
+ if (mono_tls_key_get_offset (TLS_KEY_SGEN_TLAB_NEXT_ADDR) == -1)
+ sgen_set_use_managed_allocator (FALSE);
+#endif
}
void