From 335952335d783b31fc13b86d9a80ef24ea598662 Mon Sep 17 00:00:00 2001 From: Mark Probst Date: Mon, 11 May 2015 09:32:18 -0700 Subject: [PATCH] [sgen] `GCObject*` instead of `char*` where appropriate. --- mono/metadata/sgen-client-mono.h | 137 +++++++-------- mono/metadata/sgen-mono.c | 111 ++++++------ mono/metadata/sgen-new-bridge.c | 6 +- mono/metadata/sgen-old-bridge.c | 8 +- mono/metadata/sgen-tarjan-bridge.c | 8 +- mono/metadata/sgen-toggleref.c | 12 +- mono/sgen/sgen-cardtable.c | 6 +- mono/sgen/sgen-cardtable.h | 2 +- mono/sgen/sgen-client.h | 4 +- mono/sgen/sgen-copy-object.h | 2 +- mono/sgen/sgen-debug.c | 161 +++++++++--------- mono/sgen/sgen-descriptor.h | 20 +-- mono/sgen/sgen-fin-weak-hash.c | 24 +-- mono/sgen/sgen-gc.c | 28 +-- mono/sgen/sgen-gc.h | 91 +++++----- mono/sgen/sgen-gray.c | 2 +- mono/sgen/sgen-gray.h | 10 +- mono/sgen/sgen-los.c | 42 ++--- mono/sgen/sgen-marksweep-drain-gray-stack.h | 18 +- .../sgen-marksweep-scan-object-concurrent.h | 16 +- mono/sgen/sgen-marksweep.c | 60 +++---- mono/sgen/sgen-minor-copy-object.h | 24 +-- mono/sgen/sgen-minor-scan-object.h | 6 +- mono/sgen/sgen-nursery-allocator.c | 2 +- mono/sgen/sgen-pinning-stats.c | 15 +- mono/sgen/sgen-pinning.c | 8 +- mono/sgen/sgen-pinning.h | 4 +- mono/sgen/sgen-scan-object.h | 12 +- mono/sgen/sgen-simple-nursery.c | 2 +- mono/sgen/sgen-split-nursery.c | 8 +- mono/sgen/sgen-workers.c | 2 +- 31 files changed, 434 insertions(+), 417 deletions(-) diff --git a/mono/metadata/sgen-client-mono.h b/mono/metadata/sgen-client-mono.h index 6a8b0745b49..05645383d42 100644 --- a/mono/metadata/sgen-client-mono.h +++ b/mono/metadata/sgen-client-mono.h @@ -27,8 +27,11 @@ typedef MonoObject GCObject; typedef MonoVTable* GCVTable; -/* FIXME: This should return a GCVTable and be a function. */ -#define SGEN_LOAD_VTABLE_UNCHECKED(obj) ((void*)(((GCObject*)(obj))->vtable)) +static inline GCVTable +SGEN_LOAD_VTABLE_UNCHECKED (GCObject *obj) +{ + return obj->vtable; +} static inline mword sgen_vtable_get_descriptor (GCVTable vtable) @@ -36,69 +39,6 @@ sgen_vtable_get_descriptor (GCVTable vtable) return (mword)vtable->gc_descr; } -static mword /*__attribute__((noinline)) not sure if this hint is a good idea*/ -sgen_client_slow_object_get_size (GCVTable vtable, GCObject* o) -{ - MonoClass *klass = ((MonoVTable*)vtable)->klass; - - /* - * We depend on mono_string_length_fast and - * mono_array_length_fast not using the object's vtable. - */ - if (klass == mono_defaults.string_class) { - return G_STRUCT_OFFSET (MonoString, chars) + 2 * mono_string_length_fast ((MonoString*) o) + 2; - } else if (klass->rank) { - MonoArray *array = (MonoArray*)o; - size_t size = sizeof (MonoArray) + klass->sizes.element_size * mono_array_length_fast (array); - if (G_UNLIKELY (array->bounds)) { - size += sizeof (mono_array_size_t) - 1; - size &= ~(sizeof (mono_array_size_t) - 1); - size += sizeof (MonoArrayBounds) * klass->rank; - } - return size; - } else { - /* from a created object: the class must be inited already */ - return klass->instance_size; - } -} - -/* - * This function can be called on an object whose first word, the - * vtable field, is not intact. This is necessary for the parallel - * collector. - */ -static MONO_NEVER_INLINE mword -sgen_client_par_object_get_size (GCVTable vtable, GCObject* o) -{ - mword descr = sgen_vtable_get_descriptor (vtable); - mword type = descr & DESC_TYPE_MASK; - - if (type == DESC_TYPE_RUN_LENGTH || type == DESC_TYPE_SMALL_PTRFREE) { - mword size = descr & 0xfff8; - SGEN_ASSERT (9, size >= sizeof (MonoObject), "Run length object size to small"); - return size; - } else if (descr == SGEN_DESC_STRING) { - return G_STRUCT_OFFSET (MonoString, chars) + 2 * mono_string_length_fast ((MonoString*) o) + 2; - } else if (type == DESC_TYPE_VECTOR) { - int element_size = ((descr) >> VECTOR_ELSIZE_SHIFT) & MAX_ELEMENT_SIZE; - MonoArray *array = (MonoArray*)o; - size_t size = sizeof (MonoArray) + element_size * mono_array_length_fast (array); - - /* - * Non-vector arrays with a single dimension whose lower bound is zero are - * allocated without bounds. - */ - if ((descr & VECTOR_KIND_ARRAY) && array->bounds) { - size += sizeof (mono_array_size_t) - 1; - size &= ~(sizeof (mono_array_size_t) - 1); - size += sizeof (MonoArrayBounds) * ((MonoVTable*)vtable)->klass->rank; - } - return size; - } - - return sgen_client_slow_object_get_size (vtable, o); -} - typedef struct _SgenClientThreadInfo SgenClientThreadInfo; struct _SgenClientThreadInfo { MonoThreadInfo info; @@ -166,6 +106,69 @@ enum { #define SGEN_CLIENT_OBJECT_HEADER_SIZE (sizeof (GCObject)) #define SGEN_CLIENT_MINIMUM_OBJECT_SIZE SGEN_CLIENT_OBJECT_HEADER_SIZE +static mword /*__attribute__((noinline)) not sure if this hint is a good idea*/ +sgen_client_slow_object_get_size (GCVTable vtable, GCObject* o) +{ + MonoClass *klass = ((MonoVTable*)vtable)->klass; + + /* + * We depend on mono_string_length_fast and + * mono_array_length_fast not using the object's vtable. + */ + if (klass == mono_defaults.string_class) { + return G_STRUCT_OFFSET (MonoString, chars) + 2 * mono_string_length_fast ((MonoString*) o) + 2; + } else if (klass->rank) { + MonoArray *array = (MonoArray*)o; + size_t size = sizeof (MonoArray) + klass->sizes.element_size * mono_array_length_fast (array); + if (G_UNLIKELY (array->bounds)) { + size += sizeof (mono_array_size_t) - 1; + size &= ~(sizeof (mono_array_size_t) - 1); + size += sizeof (MonoArrayBounds) * klass->rank; + } + return size; + } else { + /* from a created object: the class must be inited already */ + return klass->instance_size; + } +} + +/* + * This function can be called on an object whose first word, the + * vtable field, is not intact. This is necessary for the parallel + * collector. + */ +static MONO_NEVER_INLINE mword +sgen_client_par_object_get_size (GCVTable vtable, GCObject* o) +{ + mword descr = sgen_vtable_get_descriptor (vtable); + mword type = descr & DESC_TYPE_MASK; + + if (type == DESC_TYPE_RUN_LENGTH || type == DESC_TYPE_SMALL_PTRFREE) { + mword size = descr & 0xfff8; + SGEN_ASSERT (9, size >= sizeof (MonoObject), "Run length object size to small"); + return size; + } else if (descr == SGEN_DESC_STRING) { + return G_STRUCT_OFFSET (MonoString, chars) + 2 * mono_string_length_fast ((MonoString*) o) + 2; + } else if (type == DESC_TYPE_VECTOR) { + int element_size = ((descr) >> VECTOR_ELSIZE_SHIFT) & MAX_ELEMENT_SIZE; + MonoArray *array = (MonoArray*)o; + size_t size = sizeof (MonoArray) + element_size * mono_array_length_fast (array); + + /* + * Non-vector arrays with a single dimension whose lower bound is zero are + * allocated without bounds. + */ + if ((descr & VECTOR_KIND_ARRAY) && array->bounds) { + size += sizeof (mono_array_size_t) - 1; + size &= ~(sizeof (mono_array_size_t) - 1); + size += sizeof (MonoArrayBounds) * ((MonoVTable*)vtable)->klass->rank; + } + return size; + } + + return sgen_client_slow_object_get_size (vtable, o); +} + static MONO_ALWAYS_INLINE size_t G_GNUC_UNUSED sgen_client_array_element_size (GCVTable gc_vtable) { @@ -242,7 +245,7 @@ sgen_client_object_has_critical_finalizer (GCObject *obj) if (!mono_defaults.critical_finalizer_object) return FALSE; - class = ((MonoVTable*)SGEN_LOAD_VTABLE (obj))->klass; + class = SGEN_LOAD_VTABLE (obj)->klass; return mono_class_has_parent_fast (class, mono_defaults.critical_finalizer_object); } @@ -568,7 +571,7 @@ sgen_client_binary_protocol_dislink_update (gpointer link, gpointer obj, gboolea { #ifdef ENABLE_DTRACE if (MONO_GC_WEAK_UPDATE_ENABLED ()) { - GCVTable vt = obj ? (GCVTable)SGEN_LOAD_VTABLE (obj) : NULL; + GCVTable vt = obj ? SGEN_LOAD_VTABLE (obj) : NULL; MONO_GC_WEAK_UPDATE ((mword)link, (mword)obj, obj ? (mword)sgen_safe_object_get_size (obj) : (mword)0, diff --git a/mono/metadata/sgen-mono.c b/mono/metadata/sgen-mono.c index cae0c9235de..05133715550 100644 --- a/mono/metadata/sgen-mono.c +++ b/mono/metadata/sgen-mono.c @@ -450,7 +450,7 @@ mono_gc_get_vtable_bits (MonoClass *class) static gboolean is_finalization_aware (MonoObject *obj) { - MonoVTable *vt = ((MonoVTable*)SGEN_LOAD_VTABLE (obj)); + MonoVTable *vt = SGEN_LOAD_VTABLE (obj); return (vt->gc_bits & SGEN_GC_BIT_FINALIZER_AWARE) == SGEN_GC_BIT_FINALIZER_AWARE; } @@ -463,7 +463,7 @@ sgen_client_object_queued_for_finalization (GCObject *obj) #ifdef ENABLE_DTRACE if (G_UNLIKELY (MONO_GC_FINALIZE_ENQUEUE_ENABLED ())) { int gen = sgen_ptr_in_nursery (obj) ? GENERATION_NURSERY : GENERATION_OLD; - GCVTable vt = (GCVTable)SGEN_LOAD_VTABLE (obj); + GCVTable vt = SGEN_LOAD_VTABLE (obj); MONO_GC_FINALIZE_ENQUEUE ((mword)obj, sgen_safe_object_get_size (obj), sgen_client_vtable_get_namespace (vt), sgen_client_vtable_get_name (vt), gen, sgen_client_object_has_critical_finalizer (obj)); @@ -548,12 +548,12 @@ typedef struct _EphemeronLinkNode EphemeronLinkNode; struct _EphemeronLinkNode { EphemeronLinkNode *next; - char *array; + MonoArray *array; }; typedef struct { - void *key; - void *value; + GCObject *key; + GCObject *value; } Ephemeron; static EphemeronLinkNode *ephemeron_list; @@ -594,17 +594,16 @@ sgen_client_clear_unreachable_ephemerons (ScanCopyContext ctx) CopyOrMarkObjectFunc copy_func = ctx.ops->copy_or_mark_object; SgenGrayQueue *queue = ctx.queue; EphemeronLinkNode *current = ephemeron_list, *prev = NULL; - MonoArray *array; Ephemeron *cur, *array_end; - char *tombstone; + GCObject *tombstone; while (current) { - char *object = current->array; + MonoArray *array = current->array; - if (!sgen_is_object_alive_for_current_gen (object)) { + if (!sgen_is_object_alive_for_current_gen ((GCObject*)array)) { EphemeronLinkNode *tmp = current; - SGEN_LOG (5, "Dead Ephemeron array at %p", object); + SGEN_LOG (5, "Dead Ephemeron array at %p", array); if (prev) prev->next = current->next; @@ -617,18 +616,17 @@ sgen_client_clear_unreachable_ephemerons (ScanCopyContext ctx) continue; } - copy_func ((void**)&object, queue); - current->array = object; + copy_func ((GCObject**)&array, queue); + current->array = array; - SGEN_LOG (5, "Clearing unreachable entries for ephemeron array at %p", object); + SGEN_LOG (5, "Clearing unreachable entries for ephemeron array at %p", array); - array = (MonoArray*)object; cur = mono_array_addr (array, Ephemeron, 0); array_end = cur + mono_array_length_fast (array); - tombstone = (char*)((MonoVTable*)SGEN_LOAD_VTABLE (object))->domain->ephemeron_tombstone; + tombstone = SGEN_LOAD_VTABLE ((GCObject*)array)->domain->ephemeron_tombstone; for (; cur < array_end; ++cur) { - char *key = (char*)cur->key; + GCObject *key = cur->key; if (!key || key == tombstone) continue; @@ -660,29 +658,27 @@ sgen_client_mark_ephemerons (ScanCopyContext ctx) SgenGrayQueue *queue = ctx.queue; gboolean nothing_marked = TRUE; EphemeronLinkNode *current = ephemeron_list; - MonoArray *array; Ephemeron *cur, *array_end; - char *tombstone; + GCObject *tombstone; for (current = ephemeron_list; current; current = current->next) { - char *object = current->array; - SGEN_LOG (5, "Ephemeron array at %p", object); + MonoArray *array = current->array; + SGEN_LOG (5, "Ephemeron array at %p", array); /*It has to be alive*/ - if (!sgen_is_object_alive_for_current_gen (object)) { + if (!sgen_is_object_alive_for_current_gen ((GCObject*)array)) { SGEN_LOG (5, "\tnot reachable"); continue; } - copy_func ((void**)&object, queue); + copy_func ((GCObject**)&array, queue); - array = (MonoArray*)object; cur = mono_array_addr (array, Ephemeron, 0); array_end = cur + mono_array_length_fast (array); - tombstone = (char*)((MonoVTable*)SGEN_LOAD_VTABLE (object))->domain->ephemeron_tombstone; + tombstone = SGEN_LOAD_VTABLE ((GCObject*)array)->domain->ephemeron_tombstone; for (; cur < array_end; ++cur) { - char *key = cur->key; + GCObject *key = cur->key; if (!key || key == tombstone) continue; @@ -692,13 +688,13 @@ sgen_client_mark_ephemerons (ScanCopyContext ctx) cur->value, cur->value && sgen_is_object_alive_for_current_gen (cur->value) ? "reachable" : "unreachable"); if (sgen_is_object_alive_for_current_gen (key)) { - char *value = cur->value; + GCObject *value = cur->value; - copy_func ((void**)&cur->key, queue); + copy_func (&cur->key, queue); if (value) { if (!sgen_is_object_alive_for_current_gen (value)) nothing_marked = FALSE; - copy_func ((void**)&cur->value, queue); + copy_func (&cur->value, queue); } } } @@ -720,7 +716,7 @@ mono_gc_ephemeron_array_add (MonoObject *obj) UNLOCK_GC; return FALSE; } - node->array = (char*)obj; + node->array = (MonoArray*)obj; node->next = ephemeron_list; ephemeron_list = node; @@ -747,7 +743,7 @@ mono_gc_set_current_thread_appdomain (MonoDomain *domain) } static gboolean -need_remove_object_for_domain (char *start, MonoDomain *domain) +need_remove_object_for_domain (GCObject *start, MonoDomain *domain) { if (mono_object_domain (start) == domain) { SGEN_LOG (4, "Need to cleanup object %p", start); @@ -758,9 +754,9 @@ need_remove_object_for_domain (char *start, MonoDomain *domain) } static void -process_object_for_domain_clearing (char *start, MonoDomain *domain) +process_object_for_domain_clearing (GCObject *start, MonoDomain *domain) { - MonoVTable *vt = (MonoVTable*)SGEN_LOAD_VTABLE (start); + MonoVTable *vt = SGEN_LOAD_VTABLE (start); if (vt->klass == mono_defaults.internal_thread_class) g_assert (mono_object_domain (start) == mono_get_root_domain ()); /* The object could be a proxy for an object in the domain @@ -780,15 +776,15 @@ process_object_for_domain_clearing (char *start, MonoDomain *domain) } static gboolean -clear_domain_process_object (char *obj, MonoDomain *domain) +clear_domain_process_object (GCObject *obj, MonoDomain *domain) { gboolean remove; process_object_for_domain_clearing (obj, domain); remove = need_remove_object_for_domain (obj, domain); - if (remove && ((MonoObject*)obj)->synchronisation) { - void **dislink = mono_monitor_get_object_monitor_weak_link ((MonoObject*)obj); + if (remove && obj->synchronisation) { + void **dislink = mono_monitor_get_object_monitor_weak_link (obj); if (dislink) sgen_register_disappearing_link (NULL, dislink, FALSE, TRUE); } @@ -797,7 +793,7 @@ clear_domain_process_object (char *obj, MonoDomain *domain) } static void -clear_domain_process_minor_object_callback (char *obj, size_t size, MonoDomain *domain) +clear_domain_process_minor_object_callback (GCObject *obj, size_t size, MonoDomain *domain) { if (clear_domain_process_object (obj, domain)) { CANARIFY_SIZE (size); @@ -806,20 +802,20 @@ clear_domain_process_minor_object_callback (char *obj, size_t size, MonoDomain * } static void -clear_domain_process_major_object_callback (char *obj, size_t size, MonoDomain *domain) +clear_domain_process_major_object_callback (GCObject *obj, size_t size, MonoDomain *domain) { clear_domain_process_object (obj, domain); } static void -clear_domain_free_major_non_pinned_object_callback (char *obj, size_t size, MonoDomain *domain) +clear_domain_free_major_non_pinned_object_callback (GCObject *obj, size_t size, MonoDomain *domain) { if (need_remove_object_for_domain (obj, domain)) major_collector.free_non_pinned_object (obj, size); } static void -clear_domain_free_major_pinned_object_callback (char *obj, size_t size, MonoDomain *domain) +clear_domain_free_major_pinned_object_callback (GCObject *obj, size_t size, MonoDomain *domain) { if (need_remove_object_for_domain (obj, domain)) major_collector.free_pinned_object (obj, size); @@ -885,11 +881,11 @@ mono_gc_clear_domain (MonoDomain * domain) the first object is a proxy. */ major_collector.iterate_objects (ITERATE_OBJECTS_SWEEP_ALL, (IterateObjectCallbackFunc)clear_domain_process_major_object_callback, domain); for (bigobj = los_object_list; bigobj; bigobj = bigobj->next) - clear_domain_process_object (bigobj->data, domain); + clear_domain_process_object ((GCObject*)bigobj->data, domain); prev = NULL; for (bigobj = los_object_list; bigobj;) { - if (need_remove_object_for_domain (bigobj->data, domain)) { + if (need_remove_object_for_domain ((GCObject*)bigobj->data, domain)) { LOSObject *to_free = bigobj; if (prev) prev->next = bigobj->next; @@ -1590,9 +1586,9 @@ find_next_card (guint8 *card_data, guint8 *end) #define ARRAY_OBJ_INDEX(ptr,array,elem_size) (((char*)(ptr) - ((char*)(array) + G_STRUCT_OFFSET (MonoArray, vector))) / (elem_size)) gboolean -sgen_client_cardtable_scan_object (char *obj, mword block_obj_size, guint8 *cards, gboolean mod_union, ScanCopyContext ctx) +sgen_client_cardtable_scan_object (GCObject *obj, mword block_obj_size, guint8 *cards, gboolean mod_union, ScanCopyContext ctx) { - MonoVTable *vt = (MonoVTable*)SGEN_LOAD_VTABLE (obj); + MonoVTable *vt = SGEN_LOAD_VTABLE (obj); MonoClass *klass = vt->klass; SGEN_ASSERT (0, SGEN_VTABLE_HAS_REFERENCES (vt), "Why would we ever call this on reference-free objects?"); @@ -1601,8 +1597,8 @@ sgen_client_cardtable_scan_object (char *obj, mword block_obj_size, guint8 *card guint8 *card_data, *card_base; guint8 *card_data_end; char *obj_start = sgen_card_table_align_pointer (obj); - mword obj_size = sgen_client_par_object_get_size (vt, (GCObject*)obj); - char *obj_end = obj + obj_size; + mword obj_size = sgen_client_par_object_get_size (vt, obj); + char *obj_end = (char*)obj + obj_size; size_t card_count; size_t extra_idx = 0; @@ -1675,7 +1671,7 @@ LOOP_HEAD: gpointer new, old = *(gpointer*)elem; if ((mod_union && old) || G_UNLIKELY (sgen_ptr_in_nursery (old))) { HEAVY_STAT (++los_array_remsets); - copy_func ((void**)elem, ctx.queue); + copy_func ((GCObject**)elem, ctx.queue); new = *(gpointer*)elem; if (G_UNLIKELY (sgen_ptr_in_nursery (new))) sgen_add_to_global_remset (elem, new); @@ -1847,7 +1843,7 @@ mono_gc_set_string_length (MonoString *str, gint32 new_length) * the space to be reclaimed by SGen. */ if (nursery_canaries_enabled () && sgen_ptr_in_nursery (str)) { - CHECK_CANARY_FOR_OBJECT (str); + CHECK_CANARY_FOR_OBJECT ((GCObject*)str); memset (new_end, 0, (str->length - new_length + 1) * sizeof (mono_unichar2) + CANARY_SIZE); memcpy (new_end + 1 , CANARY_STRING, CANARY_SIZE); } else { @@ -1885,7 +1881,7 @@ add_profile_gc_root (GCRootReport *report, void *object, int rtype, uintptr_t ex notify_gc_roots (report); report->objects [report->count] = object; report->root_types [report->count] = rtype; - report->extra_info [report->count++] = (uintptr_t)((MonoVTable*)SGEN_LOAD_VTABLE (object))->klass; + report->extra_info [report->count++] = (uintptr_t)SGEN_LOAD_VTABLE (object)->klass; } void @@ -1967,7 +1963,7 @@ precisely_report_roots_from (GCRootReport *report, void** start_root, void** end break; } case ROOT_DESC_USER: { - MonoGCRootMarkFunc marker = sgen_get_user_descriptor_func (desc); + MonoGCRootMarkFunc marker = (MonoGCRootMarkFunc)sgen_get_user_descriptor_func (desc); root_report = report; marker (start_root, single_arg_report_root, NULL); break; @@ -2020,10 +2016,10 @@ sgen_client_collecting_major_1 (void) } void -sgen_client_pinned_los_object (char *obj) +sgen_client_pinned_los_object (GCObject *obj) { if (profile_roots) - add_profile_gc_root (&major_root_report, obj, MONO_PROFILE_GC_ROOT_PINNING | MONO_PROFILE_GC_ROOT_MISC, 0); + add_profile_gc_root (&major_root_report, (char*)obj, MONO_PROFILE_GC_ROOT_PINNING | MONO_PROFILE_GC_ROOT_MISC, 0); } void @@ -2098,22 +2094,23 @@ typedef struct { } while (0) static void -collect_references (HeapWalkInfo *hwi, char *start, size_t size) +collect_references (HeapWalkInfo *hwi, GCObject *obj, size_t size) { - mword desc = sgen_obj_get_descriptor (start); + char *start = (char*)obj; + mword desc = sgen_obj_get_descriptor (obj); #include "sgen/sgen-scan-object.h" } static void -walk_references (char *start, size_t size, void *data) +walk_references (GCObject *start, size_t size, void *data) { HeapWalkInfo *hwi = data; hwi->called = 0; hwi->count = 0; collect_references (hwi, start, size); if (hwi->count || !hwi->called) - hwi->callback ((MonoObject*)start, mono_object_class (start), hwi->called? 0: size, hwi->count, hwi->refs, hwi->offsets, hwi->data); + hwi->callback (start, mono_object_class (start), hwi->called? 0: size, hwi->count, hwi->refs, hwi->offsets, hwi->data); } /** @@ -2323,7 +2320,7 @@ void* mono_gc_scan_object (void *obj, void *gc_data) { ScanCopyContext *ctx = gc_data; - ctx->ops->copy_or_mark_object (&obj, ctx->queue); + ctx->ops->copy_or_mark_object ((GCObject**)&obj, ctx->queue); return obj; } @@ -2544,7 +2541,7 @@ mono_gc_get_heap_size (void) void* mono_gc_make_root_descr_user (MonoGCRootMarkFunc marker) { - return sgen_make_user_root_descriptor (marker); + return sgen_make_user_root_descriptor ((SgenUserRootMarkFunc)marker); } void* diff --git a/mono/metadata/sgen-new-bridge.c b/mono/metadata/sgen-new-bridge.c index 86c0faa37cd..c894b065bed 100644 --- a/mono/metadata/sgen-new-bridge.c +++ b/mono/metadata/sgen-new-bridge.c @@ -664,7 +664,7 @@ dfs1 (HashEntry *obj_entry) if (!obj_entry->v.dfs1.is_visited) { int num_links = 0; - mword desc = sgen_obj_get_descriptor_safe (start); + mword desc = sgen_obj_get_descriptor_safe (obj); obj_entry->v.dfs1.is_visited = 1; @@ -932,7 +932,7 @@ dump_graph (void) fprintf (file, "\n"); SGEN_HASH_TABLE_FOREACH (&hash_table, obj, entry) { - MonoVTable *vt = (MonoVTable*) SGEN_LOAD_VTABLE (obj); + MonoVTable *vt = SGEN_LOAD_VTABLE (obj); fprintf (file, "\n", obj, vt->klass->name_space, vt->klass->name, entry->is_bridge ? "true" : "false"); } SGEN_HASH_TABLE_FOREACH_END; @@ -1201,7 +1201,7 @@ processing_build_callback_data (int generation) HashEntryWithAccounting *entry = (HashEntryWithAccounting*)all_entries [i]; if (entry->entry.is_bridge) { MonoObject *obj = sgen_hash_table_key_for_value_pointer (entry); - MonoClass *klass = ((MonoVTable*)SGEN_LOAD_VTABLE (obj))->klass; + MonoClass *klass = SGEN_LOAD_VTABLE (obj)->klass; mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_GC, "OBJECT %s::%s (%p) weight %f", klass->name_space, klass->name, obj, entry->weight); } } diff --git a/mono/metadata/sgen-old-bridge.c b/mono/metadata/sgen-old-bridge.c index 084c017b4ce..581bb67d3a2 100644 --- a/mono/metadata/sgen-old-bridge.c +++ b/mono/metadata/sgen-old-bridge.c @@ -514,17 +514,16 @@ dfs1 (HashEntry *obj_entry) do { GCObject *obj; - char *start; ++dfs1_passes; obj_entry = dyn_array_ptr_pop (&dfs_stack); if (obj_entry) { + char *start; mword desc; src = dyn_array_ptr_pop (&dfs_stack); obj = obj_entry->obj; - start = (char*)obj; - desc = sgen_obj_get_descriptor_safe (start); + desc = sgen_obj_get_descriptor_safe (obj); if (src) { //g_print ("link %s -> %s\n", sgen_safe_name (src->obj), sgen_safe_name (obj)); @@ -542,6 +541,7 @@ dfs1 (HashEntry *obj_entry) /* NULL marks that the next entry is to be finished */ dyn_array_ptr_push (&dfs_stack, NULL); + start = (char*)obj; #include "sgen/sgen-scan-object.h" } else { obj_entry = dyn_array_ptr_pop (&dfs_stack); @@ -765,7 +765,7 @@ processing_build_callback_data (int generation) for (i = 0; i < hash_table.num_entries; ++i) { HashEntryWithAccounting *entry = (HashEntryWithAccounting*)all_entries [i]; if (entry->entry.is_bridge) { - MonoClass *klass = ((MonoVTable*)SGEN_LOAD_VTABLE (entry->entry.obj))->klass; + MonoClass *klass = SGEN_LOAD_VTABLE (entry->entry.obj)->klass; mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_GC, "OBJECT %s::%s (%p) weight %f", klass->name_space, klass->name, entry->entry.obj, entry->weight); } } diff --git a/mono/metadata/sgen-tarjan-bridge.c b/mono/metadata/sgen-tarjan-bridge.c index 54e3f01200a..9537c0710be 100644 --- a/mono/metadata/sgen-tarjan-bridge.c +++ b/mono/metadata/sgen-tarjan-bridge.c @@ -448,7 +448,7 @@ bridge_object_forward (GCObject *obj) static const char* safe_name_bridge (GCObject *obj) { - GCVTable vt = (GCVTable)SGEN_LOAD_VTABLE (obj); + GCVTable vt = SGEN_LOAD_VTABLE (obj); return vt->klass->name; } @@ -591,7 +591,7 @@ register_bridge_object (GCObject *obj) static gboolean is_opaque_object (GCObject *obj) { - MonoVTable *vt = (MonoVTable*)SGEN_LOAD_VTABLE (obj); + MonoVTable *vt = SGEN_LOAD_VTABLE (obj); if ((vt->gc_bits & SGEN_GC_BIT_BRIDGE_OPAQUE_OBJECT) == SGEN_GC_BIT_BRIDGE_OPAQUE_OBJECT) { SGEN_LOG (6, "ignoring %s\n", vt->klass->name); ++ignored_objects; @@ -658,7 +658,7 @@ push_all (ScanData *data) { GCObject *obj = data->obj; char *start = (char*)obj; - mword desc = sgen_obj_get_descriptor_safe (start); + mword desc = sgen_obj_get_descriptor_safe (obj); #if DUMP_GRAPH printf ("**scanning %p %s\n", obj, safe_name_bridge (obj)); @@ -710,7 +710,7 @@ compute_low (ScanData *data) { GCObject *obj = data->obj; char *start = (char*)obj; - mword desc = sgen_obj_get_descriptor_safe (start); + mword desc = sgen_obj_get_descriptor_safe (obj); #include "sgen/sgen-scan-object.h" } diff --git a/mono/metadata/sgen-toggleref.c b/mono/metadata/sgen-toggleref.c index 94c11ddc0b6..66c746b0da3 100644 --- a/mono/metadata/sgen-toggleref.c +++ b/mono/metadata/sgen-toggleref.c @@ -32,8 +32,8 @@ /*only one of the two can be non null at a given time*/ typedef struct { - void *strong_ref; - void *weak_ref; + GCObject *strong_ref; + GCObject *weak_ref; } MonoGCToggleRef; static MonoToggleRefStatus (*toggleref_callback) (MonoObject *obj); @@ -101,8 +101,8 @@ void sgen_client_mark_togglerefs (char *start, char *end, ScanCopyContext ctx) for (i = 0; i < toggleref_array_size; ++i) { if (toggleref_array [i].strong_ref) { - char *object = toggleref_array [i].strong_ref; - if (object >= start && object < end) { + GCObject *object = toggleref_array [i].strong_ref; + if ((char*)object >= start && (char*)object < end) { SGEN_LOG (6, "\tcopying strong slot %d", i); copy_func (&toggleref_array [i].strong_ref, queue); } @@ -121,9 +121,9 @@ void sgen_client_clear_togglerefs (char *start, char *end, ScanCopyContext ctx) for (i = 0; i < toggleref_array_size; ++i) { if (toggleref_array [i].weak_ref) { - char *object = toggleref_array [i].weak_ref; + GCObject *object = toggleref_array [i].weak_ref; - if (object >= start && object < end) { + if ((char*)object >= start && (char*)object < end) { if (sgen_gc_is_object_ready_for_finalization (object)) { SGEN_LOG (6, "\tcleaning weak slot %d", i); toggleref_array [i].weak_ref = NULL; /* We defer compaction to only happen on the callback step. */ diff --git a/mono/sgen/sgen-cardtable.c b/mono/sgen/sgen-cardtable.c index 6343de1be07..fb18def266d 100644 --- a/mono/sgen/sgen-cardtable.c +++ b/mono/sgen/sgen-cardtable.c @@ -467,7 +467,7 @@ sgen_get_card_table_configuration (int *shift_bits, gpointer *mask) #if 0 void -sgen_card_table_dump_obj_card (char *object, size_t size, void *dummy) +sgen_card_table_dump_obj_card (GCObject *object, size_t size, void *dummy) { guint8 *start = sgen_card_table_get_card_scan_address (object); guint8 *end = start + sgen_card_table_number_of_cards_in_range (object, size); @@ -486,7 +486,7 @@ sgen_card_table_dump_obj_card (char *object, size_t size, void *dummy) #endif void -sgen_cardtable_scan_object (char *obj, mword block_obj_size, guint8 *cards, gboolean mod_union, ScanCopyContext ctx) +sgen_cardtable_scan_object (GCObject *obj, mword block_obj_size, guint8 *cards, gboolean mod_union, ScanCopyContext ctx) { HEAVY_STAT (++large_objects); @@ -501,7 +501,7 @@ sgen_cardtable_scan_object (char *obj, mword block_obj_size, guint8 *cards, gboo ctx.ops->scan_object (obj, sgen_obj_get_descriptor (obj), ctx.queue); } - binary_protocol_card_scan (obj, sgen_safe_object_get_size ((GCObject*)obj)); + binary_protocol_card_scan (obj, sgen_safe_object_get_size (obj)); } #ifdef CARDTABLE_STATS diff --git a/mono/sgen/sgen-cardtable.h b/mono/sgen/sgen-cardtable.h index 85a6924650f..bda77e4e925 100644 --- a/mono/sgen/sgen-cardtable.h +++ b/mono/sgen/sgen-cardtable.h @@ -30,7 +30,7 @@ mword sgen_card_table_number_of_cards_in_range (mword address, mword size); void sgen_card_table_reset_region (mword start, mword end); void* sgen_card_table_align_pointer (void *ptr); void sgen_card_table_mark_range (mword address, mword size); -void sgen_cardtable_scan_object (char *obj, mword obj_size, guint8 *cards, +void sgen_cardtable_scan_object (GCObject *obj, mword obj_size, guint8 *cards, gboolean mod_union, ScanCopyContext ctx); gboolean sgen_card_table_get_card_data (guint8 *dest, mword address, mword cards); diff --git a/mono/sgen/sgen-client.h b/mono/sgen/sgen-client.h index 87ec6906026..cb332823789 100644 --- a/mono/sgen/sgen-client.h +++ b/mono/sgen/sgen-client.h @@ -92,7 +92,7 @@ void sgen_client_clear_unreachable_ephemerons (ScanCopyContext ctx); * parts of the object based on which cards are marked, do so and return TRUE. Otherwise, * return FALSE. */ -gboolean sgen_client_cardtable_scan_object (char *obj, mword block_obj_size, guint8 *cards, gboolean mod_union, ScanCopyContext ctx); +gboolean sgen_client_cardtable_scan_object (GCObject *obj, mword block_obj_size, guint8 *cards, gboolean mod_union, ScanCopyContext ctx); /* * Called after nursery objects have been pinned. No action is necessary. @@ -114,7 +114,7 @@ void sgen_client_collecting_major_3 (SgenPointerQueue *fin_ready_queue, SgenPoin /* * Called after a LOS object has been pinned. No action is necessary. */ -void sgen_client_pinned_los_object (char *obj); +void sgen_client_pinned_los_object (GCObject *obj); /* * Called for every degraded allocation. No action is necessary. diff --git a/mono/sgen/sgen-copy-object.h b/mono/sgen/sgen-copy-object.h index dd6c002a2a1..8484e8fdeea 100644 --- a/mono/sgen/sgen-copy-object.h +++ b/mono/sgen/sgen-copy-object.h @@ -41,7 +41,7 @@ par_copy_object_no_checks (char *destination, GCVTable vt, void *obj, mword objs binary_protocol_copy (obj, destination, vt, objsize); /* FIXME: assumes object layout */ - memcpy (destination + sizeof (mword), (char*)obj + sizeof (mword), objsize - sizeof (mword)); + memcpy ((char*)destination + sizeof (mword), (char*)obj + sizeof (mword), objsize - sizeof (mword)); /* adjust array->bounds */ SGEN_ASSERT (9, sgen_vtable_get_descriptor (vt), "vtable %p has no gc descriptor", vt); diff --git a/mono/sgen/sgen-debug.c b/mono/sgen/sgen-debug.c index 6011bcc35a7..07d423012f2 100644 --- a/mono/sgen/sgen-debug.c +++ b/mono/sgen/sgen-debug.c @@ -43,7 +43,7 @@ #define safe_object_get_size sgen_safe_object_get_size void describe_ptr (char *ptr); -void check_object (char *start); +void check_object (GCObject *obj); /* * ###################################################################### @@ -80,7 +80,7 @@ describe_pointer (char *ptr, gboolean need_setup) if (!start) return; ptr = start; - vtable = (GCVTable)LOAD_VTABLE (ptr); + vtable = LOAD_VTABLE ((GCObject*)ptr); } else { if (sgen_ptr_is_in_los (ptr, &start)) { if (ptr == start) @@ -89,7 +89,7 @@ describe_pointer (char *ptr, gboolean need_setup) printf ("Pointer is at offset 0x%x of object %p in LOS space.\n", (int)(ptr - start), start); ptr = start; mono_sgen_los_describe_pointer (ptr); - vtable = (GCVTable)LOAD_VTABLE (ptr); + vtable = LOAD_VTABLE ((GCObject*)ptr); } else if (major_collector.ptr_is_in_non_pinned_space (ptr, &start)) { if (ptr == start) printf ("Pointer is the start of object %p in oldspace.\n", start); @@ -100,10 +100,10 @@ describe_pointer (char *ptr, gboolean need_setup) if (start) ptr = start; vtable = (GCVTable)major_collector.describe_pointer (ptr); - } else if (major_collector.obj_is_from_pinned_alloc (ptr)) { + } else if (major_collector.ptr_is_from_pinned_alloc (ptr)) { // FIXME: Handle pointers to the inside of objects printf ("Pointer is inside a pinned chunk.\n"); - vtable = (GCVTable)LOAD_VTABLE (ptr); + vtable = LOAD_VTABLE ((GCObject*)ptr); } else { printf ("Pointer unknown.\n"); return; @@ -162,7 +162,7 @@ static gboolean missing_remsets; #define HANDLE_PTR(ptr,obj) do { \ if (*(ptr) && sgen_ptr_in_nursery ((char*)*(ptr))) { \ if (!sgen_get_remset ()->find_address ((char*)(ptr)) && !sgen_cement_lookup (*(ptr))) { \ - GCVTable __vt = SGEN_LOAD_VTABLE ((obj)); \ + GCVTable __vt = SGEN_LOAD_VTABLE (obj); \ SGEN_LOG (0, "Oldspace->newspace reference %p at offset %zd in object %p (%s.%s) not found in remsets.", *(ptr), (char*)(ptr) - (char*)(obj), (obj), sgen_client_vtable_get_namespace (__vt), sgen_client_vtable_get_name (__vt)); \ binary_protocol_missing_remset ((obj), __vt, (int) ((char*)(ptr) - (char*)(obj)), *(ptr), (gpointer)LOAD_VTABLE(*(ptr)), object_is_pinned (*(ptr))); \ if (!object_is_pinned (*(ptr))) \ @@ -176,9 +176,10 @@ static gboolean missing_remsets; * be found in the remembered sets. */ static void -check_consistency_callback (char *start, size_t size, void *dummy) +check_consistency_callback (GCObject *obj, size_t size, void *dummy) { - GCVTable vt = (GCVTable)LOAD_VTABLE (start); + char *start = (char*)obj; + GCVTable vt = LOAD_VTABLE (obj); mword desc = sgen_vtable_get_descriptor (vt); SGEN_LOG (8, "Scanning object %p, vtable: %p (%s)", start, vt, sgen_client_vtable_get_name (vt)); @@ -211,7 +212,7 @@ sgen_check_consistency (void) } static gboolean -is_major_or_los_object_marked (char *obj) +is_major_or_los_object_marked (GCObject *obj) { if (sgen_safe_object_get_size ((GCObject*)obj) > SGEN_MAX_SMALL_OBJ_SIZE) { return sgen_los_object_is_pinned (obj); @@ -222,9 +223,9 @@ is_major_or_los_object_marked (char *obj) #undef HANDLE_PTR #define HANDLE_PTR(ptr,obj) do { \ - if (*(ptr) && !sgen_ptr_in_nursery ((char*)*(ptr)) && !is_major_or_los_object_marked ((char*)*(ptr))) { \ + if (*(ptr) && !sgen_ptr_in_nursery ((char*)*(ptr)) && !is_major_or_los_object_marked ((GCObject*)*(ptr))) { \ if (!sgen_get_remset ()->find_address_with_cards (start, cards, (char*)(ptr))) { \ - GCVTable __vt = SGEN_LOAD_VTABLE ((obj)); \ + GCVTable __vt = SGEN_LOAD_VTABLE (obj); \ SGEN_LOG (0, "major->major reference %p at offset %zd in object %p (%s.%s) not found in remsets.", *(ptr), (char*)(ptr) - (char*)(obj), (obj), sgen_client_vtable_get_namespace (__vt), sgen_client_vtable_get_name (__vt)); \ binary_protocol_missing_remset ((obj), __vt, (int) ((char*)(ptr) - (char*)(obj)), *(ptr), (gpointer)LOAD_VTABLE(*(ptr)), object_is_pinned (*(ptr))); \ missing_remsets = TRUE; \ @@ -233,21 +234,22 @@ is_major_or_los_object_marked (char *obj) } while (0) static void -check_mod_union_callback (char *start, size_t size, void *dummy) +check_mod_union_callback (GCObject *obj, size_t size, void *dummy) { + char *start = (char*)obj; gboolean in_los = (gboolean) (size_t) dummy; - GCVTable vt = (GCVTable)LOAD_VTABLE (start); + GCVTable vt = LOAD_VTABLE (obj); mword desc = sgen_vtable_get_descriptor (vt); guint8 *cards; - SGEN_LOG (8, "Scanning object %p, vtable: %p (%s)", start, vt, sgen_client_vtable_get_name (vt)); + SGEN_LOG (8, "Scanning object %p, vtable: %p (%s)", obj, vt, sgen_client_vtable_get_name (vt)); - if (!is_major_or_los_object_marked (start)) + if (!is_major_or_los_object_marked (obj)) return; if (in_los) - cards = sgen_los_header_for_object (start)->cardtable_mod_union; + cards = sgen_los_header_for_object (obj)->cardtable_mod_union; else - cards = sgen_get_major_collector ()->get_cardtable_mod_union_for_object (start); + cards = sgen_get_major_collector ()->get_cardtable_mod_union_for_reference (start); SGEN_ASSERT (0, cards, "we must have mod union for marked major objects"); @@ -274,9 +276,10 @@ sgen_check_mod_union_consistency (void) } while (0) static void -check_major_refs_callback (char *start, size_t size, void *dummy) +check_major_refs_callback (GCObject *obj, size_t size, void *dummy) { - mword desc = sgen_obj_get_descriptor (start); + char *start = (char*)obj; + mword desc = sgen_obj_get_descriptor (obj); #include "sgen-scan-object.h" } @@ -303,25 +306,26 @@ sgen_check_major_refs (void) * reference fields are valid. */ void -check_object (char *start) +check_object (GCObject *obj) { + char *start = (char*)obj; mword desc; if (!start) return; - desc = sgen_obj_get_descriptor (start); + desc = sgen_obj_get_descriptor (obj); #include "sgen-scan-object.h" } -static char **valid_nursery_objects; +static GCObject **valid_nursery_objects; static int valid_nursery_object_count; static gboolean broken_heap; static void -setup_mono_sgen_scan_area_with_callback (char *object, size_t size, void *data) +setup_mono_sgen_scan_area_with_callback (GCObject *object, size_t size, void *data) { valid_nursery_objects [valid_nursery_object_count++] = object; } @@ -341,10 +345,10 @@ find_object_in_nursery_dump (char *object) int first = 0, last = valid_nursery_object_count; while (first < last) { int middle = first + ((last - first) >> 1); - if (object == valid_nursery_objects [middle]) + if (object == (char*)valid_nursery_objects [middle]) return TRUE; - if (object < valid_nursery_objects [middle]) + if (object < (char*)valid_nursery_objects [middle]) last = middle; else first = middle + 1; @@ -358,8 +362,8 @@ iterate_valid_nursery_objects (IterateObjectCallbackFunc callback, void *data) { int i; for (i = 0; i < valid_nursery_object_count; ++i) { - char *obj = valid_nursery_objects [i]; - callback (obj, safe_object_get_size ((GCObject*)obj), data); + GCObject *obj = valid_nursery_objects [i]; + callback (obj, safe_object_get_size (obj), data); } } @@ -372,20 +376,20 @@ describe_nursery_ptr (char *ptr, gboolean need_setup) setup_valid_nursery_objects (); for (i = 0; i < valid_nursery_object_count - 1; ++i) { - if (valid_nursery_objects [i + 1] > ptr) + if ((char*)valid_nursery_objects [i + 1] > ptr) break; } - if (i >= valid_nursery_object_count || valid_nursery_objects [i] + safe_object_get_size ((GCObject *)valid_nursery_objects [i]) < ptr) { + if (i >= valid_nursery_object_count || (char*)valid_nursery_objects [i] + safe_object_get_size (valid_nursery_objects [i]) < ptr) { SGEN_LOG (0, "nursery-ptr (unalloc'd-memory)"); return NULL; } else { - char *obj = valid_nursery_objects [i]; - if (obj == ptr) + GCObject *obj = valid_nursery_objects [i]; + if ((char*)obj == ptr) SGEN_LOG (0, "nursery-ptr %p", obj); else - SGEN_LOG (0, "nursery-ptr %p (interior-ptr offset %zd)", obj, ptr - obj); - return obj; + SGEN_LOG (0, "nursery-ptr %p (interior-ptr offset %zd)", obj, ptr - (char*)obj); + return (char*)obj; } } @@ -407,7 +411,7 @@ static void bad_pointer_spew (char *obj, char **slot) { char *ptr = *slot; - GCVTable vtable = (GCVTable)LOAD_VTABLE (obj); + GCVTable vtable = LOAD_VTABLE ((GCObject*)obj); SGEN_LOG (0, "Invalid object pointer %p at offset %zd in object %p (%s.%s):", ptr, (char*)slot - obj, @@ -420,7 +424,7 @@ static void missing_remset_spew (char *obj, char **slot) { char *ptr = *slot; - GCVTable vtable = (GCVTable)LOAD_VTABLE (obj); + GCVTable vtable = LOAD_VTABLE ((GCObject*)obj); SGEN_LOG (0, "Oldspace->newspace reference %p at offset %zd in object %p (%s.%s) not found in remsets.", ptr, (char*)slot - obj, obj, @@ -438,17 +442,18 @@ FIXME Flag missing remsets due to pinning as non fatal if (!is_valid_object_pointer (*(char**)ptr)) { \ bad_pointer_spew ((char*)obj, (char**)ptr); \ } else if (!sgen_ptr_in_nursery (obj) && sgen_ptr_in_nursery ((char*)*ptr)) { \ - if (!sgen_get_remset ()->find_address ((char*)(ptr)) && !sgen_cement_lookup ((char*)*(ptr)) && (!allow_missing_pinned || !SGEN_OBJECT_IS_PINNED ((char*)*(ptr)))) \ + if (!sgen_get_remset ()->find_address ((char*)(ptr)) && !sgen_cement_lookup (*(ptr)) && (!allow_missing_pinned || !SGEN_OBJECT_IS_PINNED (*(ptr)))) \ missing_remset_spew ((char*)obj, (char**)ptr); \ } \ } \ } while (0) static void -verify_object_pointers_callback (char *start, size_t size, void *data) +verify_object_pointers_callback (GCObject *obj, size_t size, void *data) { + char *start = (char*)obj; gboolean allow_missing_pinned = (gboolean) (size_t) data; - mword desc = sgen_obj_get_descriptor (start); + mword desc = sgen_obj_get_descriptor (obj); #include "sgen-scan-object.h" } @@ -561,31 +566,32 @@ find_pinning_reference (char *obj, size_t size) } else { \ mword __size = sgen_safe_object_get_size ((GCObject*)__target); \ if (__size <= SGEN_MAX_SMALL_OBJ_SIZE) \ - g_assert (major_collector.is_object_live (__target)); \ + g_assert (major_collector.is_object_live ((GCObject*)__target)); \ else \ - g_assert (sgen_los_object_is_pinned (__target)); \ + g_assert (sgen_los_object_is_pinned ((GCObject*)__target)); \ } \ } \ } while (0) static void -check_marked_callback (char *start, size_t size, void *dummy) +check_marked_callback (GCObject *obj, size_t size, void *dummy) { + char *start = (char*)obj; gboolean flag = (gboolean) (size_t) dummy; mword desc; if (sgen_ptr_in_nursery (start)) { if (flag) - SGEN_ASSERT (0, SGEN_OBJECT_IS_PINNED (start), "All objects remaining in the nursery must be pinned"); + SGEN_ASSERT (0, SGEN_OBJECT_IS_PINNED (obj), "All objects remaining in the nursery must be pinned"); } else if (flag) { - if (!sgen_los_object_is_pinned (start)) + if (!sgen_los_object_is_pinned (obj)) return; } else { - if (!major_collector.is_object_live (start)) + if (!major_collector.is_object_live (obj)) return; } - desc = sgen_obj_get_descriptor_safe (start); + desc = sgen_obj_get_descriptor_safe (obj); #include "sgen-scan-object.h" } @@ -665,7 +671,7 @@ sgen_debug_verify_nursery (gboolean do_dump_nursery_content) verify_scan_starts (cur, cur + size); is_array_fill = sgen_client_object_is_array_fill ((GCObject*)cur); if (do_dump_nursery_content) { - GCVTable vtable = SGEN_LOAD_VTABLE (cur); + GCVTable vtable = SGEN_LOAD_VTABLE ((GCObject*)cur); if (cur > hole_start) SGEN_LOG (0, "HOLE [%p %p %d]", hole_start, cur, (int)(cur - hole_start)); SGEN_LOG (0, "OBJ [%p %p %d %d %s.%s %d]", cur, cur + size, (int)size, (int)ss, @@ -673,7 +679,7 @@ sgen_debug_verify_nursery (gboolean do_dump_nursery_content) is_array_fill); } if (nursery_canaries_enabled () && !is_array_fill) { - CHECK_CANARY_FOR_OBJECT (cur); + CHECK_CANARY_FOR_OBJECT ((GCObject*)cur); CANARIFY_SIZE (size); } cur += size; @@ -725,32 +731,33 @@ static gboolean scan_object_for_specific_ref_precise = TRUE; } while (0) static void -scan_object_for_specific_ref (char *start, GCObject *key) +scan_object_for_specific_ref (GCObject *obj, GCObject *key) { - char *forwarded; + GCObject *forwarded; - if ((forwarded = SGEN_OBJECT_IS_FORWARDED (start))) - start = forwarded; + if ((forwarded = SGEN_OBJECT_IS_FORWARDED (obj))) + obj = forwarded; if (scan_object_for_specific_ref_precise) { - mword desc = sgen_obj_get_descriptor_safe (start); + char *start = (char*)obj; + mword desc = sgen_obj_get_descriptor_safe (obj); #include "sgen-scan-object.h" } else { - mword *words = (mword*)start; - size_t size = safe_object_get_size ((GCObject*)start); + mword *words = (mword*)obj; + size_t size = safe_object_get_size (obj); int i; for (i = 0; i < size / sizeof (mword); ++i) { if (words [i] == (mword)key) { - GCVTable vtable = SGEN_LOAD_VTABLE (start); + GCVTable vtable = SGEN_LOAD_VTABLE (obj); g_print ("found possible ref to %p in object %p (%s.%s) at offset %zd\n", - key, start, sgen_client_vtable_get_namespace (vtable), sgen_client_vtable_get_name (vtable), i * sizeof (mword)); + key, obj, sgen_client_vtable_get_namespace (vtable), sgen_client_vtable_get_name (vtable), i * sizeof (mword)); } } } } static void -scan_object_for_specific_ref_callback (char *obj, size_t size, GCObject *key) +scan_object_for_specific_ref_callback (GCObject *obj, size_t size, GCObject *key) { scan_object_for_specific_ref (obj, key); } @@ -767,7 +774,7 @@ static GCObject *check_key = NULL; static RootRecord *check_root = NULL; static void -check_root_obj_specific_ref_from_marker (void **obj, void *gc_data) +check_root_obj_specific_ref_from_marker (GCObject **obj, void *gc_data) { check_root_obj_specific_ref (check_root, check_key, *obj); } @@ -869,9 +876,9 @@ check_obj_not_in_domain (MonoObject **o) static void -check_obj_not_in_domain_callback (void **o, void *gc_data) +check_obj_not_in_domain_callback (GCObject **o, void *gc_data) { - g_assert (((MonoObject*)(*o))->vtable->domain != check_domain); + g_assert ((*o)->vtable->domain != check_domain); } void @@ -932,10 +939,10 @@ sgen_scan_for_registered_roots_in_domain (MonoDomain *domain, int root_type) } static gboolean -is_xdomain_ref_allowed (gpointer *ptr, char *obj, MonoDomain *domain) +is_xdomain_ref_allowed (GCObject **ptr, GCObject *obj, MonoDomain *domain) { MonoObject *o = (MonoObject*)(obj); - MonoObject *ref = (MonoObject*)*(ptr); + MonoObject *ref = *ptr; size_t offset = (char*)(ptr) - (char*)o; if (o->vtable->klass == mono_defaults.thread_class && offset == G_STRUCT_OFFSET (MonoThread, internal_thread)) @@ -974,11 +981,10 @@ is_xdomain_ref_allowed (gpointer *ptr, char *obj, MonoDomain *domain) } static void -check_reference_for_xdomain (gpointer *ptr, char *obj, MonoDomain *domain) +check_reference_for_xdomain (GCObject **ptr, GCObject *obj, MonoDomain *domain) { - MonoObject *o = (MonoObject*)(obj); - MonoObject *ref = (MonoObject*)*(ptr); - size_t offset = (char*)(ptr) - (char*)o; + MonoObject *ref = *ptr; + size_t offset = (char*)(ptr) - (char*)obj; MonoClass *class; MonoClassField *field; char *str; @@ -989,7 +995,7 @@ check_reference_for_xdomain (gpointer *ptr, char *obj, MonoDomain *domain) return; field = NULL; - for (class = o->vtable->klass; class; class = class->parent) { + for (class = obj->vtable->klass; class; class = class->parent) { int i; for (i = 0; i < class->field.count; ++i) { @@ -1007,10 +1013,10 @@ check_reference_for_xdomain (gpointer *ptr, char *obj, MonoDomain *domain) else str = NULL; g_print ("xdomain reference in %p (%s.%s) at offset %d (%s) to %p (%s.%s) (%s) - pointed to by:\n", - o, o->vtable->klass->name_space, o->vtable->klass->name, + obj, obj->vtable->klass->name_space, obj->vtable->klass->name, offset, field ? field->name : "", ref, ref->vtable->klass->name_space, ref->vtable->klass->name, str ? str : ""); - mono_gc_scan_for_specific_ref (o, TRUE); + mono_gc_scan_for_specific_ref (obj, TRUE); if (str) g_free (str); } @@ -1019,9 +1025,10 @@ check_reference_for_xdomain (gpointer *ptr, char *obj, MonoDomain *domain) #define HANDLE_PTR(ptr,obj) check_reference_for_xdomain ((ptr), (obj), domain) static void -scan_object_for_xdomain_refs (char *start, mword size, void *data) +scan_object_for_xdomain_refs (GCObject *obj, mword size, void *data) { - MonoVTable *vt = (MonoVTable*)SGEN_LOAD_VTABLE (start); + char *start = (char*)obj; + MonoVTable *vt = SGEN_LOAD_VTABLE (obj); MonoDomain *domain = vt->domain; mword desc = sgen_vtable_get_descriptor (vt); @@ -1039,7 +1046,7 @@ sgen_check_for_xdomain_refs (void) major_collector.iterate_objects (ITERATE_OBJECTS_SWEEP_ALL, (IterateObjectCallbackFunc)scan_object_for_xdomain_refs, NULL); for (bigobj = los_object_list; bigobj; bigobj = bigobj->next) - scan_object_for_xdomain_refs (bigobj->data, sgen_los_object_size (bigobj), NULL); + scan_object_for_xdomain_refs ((GCObject*)bigobj->data, sgen_los_object_size (bigobj), NULL); } #endif @@ -1080,7 +1087,7 @@ sgen_dump_section (GCMemSection *section, const char *type) if (!occ_start) occ_start = start; - //vt = (GCVTable)SGEN_LOAD_VTABLE (start); + //vt = SGEN_LOAD_VTABLE (start); //class = vt->klass; size = SGEN_ALIGN_UP (safe_object_get_size ((GCObject*) start)); @@ -1189,21 +1196,21 @@ sgen_debug_dump_heap (const char *type, int num, const char *reason) fprintf (heap_dump_file, "\n"); } -static char *found_obj; +static GCObject *found_obj; static void -find_object_for_ptr_callback (char *obj, size_t size, void *user_data) +find_object_for_ptr_callback (GCObject *obj, size_t size, void *user_data) { char *ptr = user_data; - if (ptr >= obj && ptr < obj + size) { + if (ptr >= (char*)obj && ptr < (char*)obj + size) { g_assert (!found_obj); found_obj = obj; } } /* for use in the debugger */ -char* +GCObject* sgen_find_object_for_ptr (char *ptr) { if (ptr >= nursery_section->data && ptr < nursery_section->end_data) { diff --git a/mono/sgen/sgen-descriptor.h b/mono/sgen/sgen-descriptor.h index 335ba1a8054..e5958181513 100644 --- a/mono/sgen/sgen-descriptor.h +++ b/mono/sgen/sgen-descriptor.h @@ -131,7 +131,7 @@ enum { ROOT_DESC_TYPE_SHIFT = 3, }; -typedef void (*SgenUserMarkFunc) (void **addr, void *gc_data); +typedef void (*SgenUserMarkFunc) (GCObject **addr, void *gc_data); typedef void (*SgenUserRootMarkFunc) (void *addr, SgenUserMarkFunc mark_func, void *gc_data); void* sgen_make_user_root_descriptor (SgenUserRootMarkFunc marker); @@ -188,7 +188,7 @@ sgen_gc_descr_has_references (mword desc) _objptr += ((desc) >> 16) & 0xff; \ _objptr_end = _objptr + (((desc) >> 24) & 0xff); \ while (_objptr < _objptr_end) { \ - HANDLE_PTR (_objptr, (obj)); \ + HANDLE_PTR ((GCObject**)_objptr, (obj)); \ _objptr++; \ }; \ } \ @@ -207,7 +207,7 @@ sgen_gc_descr_has_references (mword desc) int _index = GNUC_BUILTIN_CTZ (_bmap); \ _objptr += _index; \ _bmap >>= (_index + 1); \ - HANDLE_PTR (_objptr, (obj)); \ + HANDLE_PTR ((GCObject**)_objptr, (obj)); \ ++_objptr; \ } while (_bmap); \ } while (0) @@ -219,7 +219,7 @@ sgen_gc_descr_has_references (mword desc) _objptr += OBJECT_HEADER_WORDS; \ do { \ if ((_bmap & 1)) { \ - HANDLE_PTR (_objptr, (obj)); \ + HANDLE_PTR ((GCObject**)_objptr, (obj)); \ } \ _bmap >>= 1; \ ++_objptr; \ @@ -240,7 +240,7 @@ sgen_gc_descr_has_references (mword desc) /*g_print ("bitmap: 0x%x/%d at %p\n", _bmap, bwords, _objptr);*/ \ while (_bmap) { \ if ((_bmap & 1)) { \ - HANDLE_PTR (_objptr, (obj)); \ + HANDLE_PTR ((GCObject**)_objptr, (obj)); \ } \ _bmap >>= 1; \ ++_objptr; \ @@ -252,7 +252,7 @@ sgen_gc_descr_has_references (mword desc) /* this one is untested */ #define OBJ_COMPLEX_ARR_FOREACH_PTR(desc,obj) do { \ /* there are pointers */ \ - GCVTable vt = (GCVTable)SGEN_LOAD_VTABLE (obj); \ + GCVTable vt = SGEN_LOAD_VTABLE (obj); \ gsize *mbitmap_data = sgen_get_complex_descriptor ((desc)); \ gsize mbwords = (*mbitmap_data++) - 1; \ gsize el_size = sgen_client_array_element_size (vt); \ @@ -268,7 +268,7 @@ sgen_gc_descr_has_references (mword desc) /*g_print ("bitmap: 0x%x\n", _bmap);*/ \ while (_bmap) { \ if ((_bmap & 1)) { \ - HANDLE_PTR (_objptr, (obj)); \ + HANDLE_PTR ((GCObject**)_objptr, (obj)); \ } \ _bmap >>= 1; \ ++_objptr; \ @@ -290,7 +290,7 @@ sgen_gc_descr_has_references (mword desc) void **end_refs = (void**)((char*)p + el_size * sgen_client_array_length ((GCObject*)(obj))); \ /* Note: this code can handle also arrays of struct with only references in them */ \ while (p < end_refs) { \ - HANDLE_PTR (p, (obj)); \ + HANDLE_PTR ((GCObject**)p, (obj)); \ ++p; \ } \ } else if (etype == DESC_TYPE_V_RUN_LEN << 14) { \ @@ -303,7 +303,7 @@ sgen_gc_descr_has_references (mword desc) int i; \ p += offset; \ for (i = 0; i < num_refs; ++i) { \ - HANDLE_PTR (p + i, (obj)); \ + HANDLE_PTR ((GCObject**)p + i, (obj)); \ } \ e_start += el_size; \ } \ @@ -316,7 +316,7 @@ sgen_gc_descr_has_references (mword desc) /* Note: there is no object header here to skip */ \ while (_bmap) { \ if ((_bmap & 1)) { \ - HANDLE_PTR (p, (obj)); \ + HANDLE_PTR ((GCObject**)p, (obj)); \ } \ _bmap >>= 1; \ ++p; \ diff --git a/mono/sgen/sgen-fin-weak-hash.c b/mono/sgen/sgen-fin-weak-hash.c index 84e3a20e624..a0994b9a1be 100644 --- a/mono/sgen/sgen-fin-weak-hash.c +++ b/mono/sgen/sgen-fin-weak-hash.c @@ -115,7 +115,7 @@ sgen_collect_bridge_objects (int generation, ScanCopyContext ctx) SgenHashTable *hash_table = get_finalize_entry_hash_table (generation); GCObject *object; gpointer dummy G_GNUC_UNUSED; - char *copy; + GCObject *copy; SgenPointerQueue moved_fin_objects; sgen_pointer_queue_init (&moved_fin_objects, INTERNAL_MEM_TEMPORARY); @@ -132,7 +132,7 @@ sgen_collect_bridge_objects (int generation, ScanCopyContext ctx) continue; /* Object is a bridge object and major heap says it's dead */ - if (major_collector.is_object_live ((char*)object)) + if (major_collector.is_object_live (object)) continue; /* Nursery says the object is dead. */ @@ -142,10 +142,10 @@ sgen_collect_bridge_objects (int generation, ScanCopyContext ctx) if (!sgen_client_bridge_is_bridge_object (object)) continue; - copy = (char*)object; - copy_func ((void**)©, queue); + copy = object; + copy_func (©, queue); - sgen_client_bridge_register_finalized_object ((GCObject*)copy); + sgen_client_bridge_register_finalized_object (copy); if (hash_table == &minor_finalizable_hash && !ptr_in_nursery (copy)) { /* remove from the list */ @@ -157,7 +157,7 @@ sgen_collect_bridge_objects (int generation, ScanCopyContext ctx) SGEN_LOG (5, "Promoting finalization of object %p (%s) (was at %p) to major table", copy, sgen_client_vtable_get_name (SGEN_LOAD_VTABLE (copy)), object); continue; - } else if (copy != (char*)object) { + } else if (copy != object) { /* update pointer */ SGEN_HASH_TABLE_FOREACH_REMOVE (TRUE); @@ -196,10 +196,10 @@ sgen_finalize_in_range (int generation, ScanCopyContext ctx) SGEN_HASH_TABLE_FOREACH (hash_table, object, dummy) { int tag = tagged_object_get_tag (object); object = tagged_object_get_object (object); - if (!major_collector.is_object_live ((char*)object)) { + if (!major_collector.is_object_live (object)) { gboolean is_fin_ready = sgen_gc_is_object_ready_for_finalization (object); GCObject *copy = object; - copy_func ((void**)©, queue); + copy_func (©, queue); if (is_fin_ready) { /* remove and put in fin_ready_list */ SGEN_HASH_TABLE_FOREACH_REMOVE (TRUE); @@ -672,7 +672,7 @@ sgen_null_link_in_range (int generation, gboolean before_finalization, ScanCopyC SgenHashTable *hash = get_dislink_hash_table (generation); SGEN_HASH_TABLE_FOREACH (hash, link, dummy) { - char *object; + GCObject *object; gboolean track; /* @@ -716,8 +716,8 @@ sgen_null_link_in_range (int generation, gboolean before_finalization, ScanCopyC SGEN_HASH_TABLE_FOREACH_REMOVE (TRUE); continue; } else { - char *copy = object; - copy_func ((void**)©, queue); + GCObject *copy = object; + copy_func (©, queue); /* Update pointer if it's moved. If the object * has been moved out of the nursery, we need to @@ -732,7 +732,7 @@ sgen_null_link_in_range (int generation, gboolean before_finalization, ScanCopyC g_assert (copy); *link = HIDE_POINTER (copy, track); - add_or_remove_disappearing_link ((GCObject*)copy, link, GENERATION_OLD); + add_or_remove_disappearing_link (copy, link, GENERATION_OLD); binary_protocol_dislink_update (link, copy, track, 0); SGEN_LOG (5, "Upgraded dislink at %p to major because object %p moved to %p", link, object, copy); diff --git a/mono/sgen/sgen-gc.c b/mono/sgen/sgen-gc.c index 5d8cb5db3fe..666d0ef8722 100644 --- a/mono/sgen/sgen-gc.c +++ b/mono/sgen/sgen-gc.c @@ -484,9 +484,9 @@ sgen_scan_area_with_callback (char *start, char *end, IterateObjectCallbackFunc } if (!sgen_client_object_is_array_fill ((GCObject*)obj)) { - CHECK_CANARY_FOR_OBJECT (obj); + CHECK_CANARY_FOR_OBJECT ((GCObject*)obj); size = ALIGN_UP (safe_object_get_size ((GCObject*)obj)); - callback (obj, size, data); + callback ((GCObject*)obj, size, data); CANARIFY_SIZE (size); } else { size = ALIGN_UP (safe_object_get_size ((GCObject*)obj)); @@ -554,7 +554,7 @@ sgen_drain_gray_stack (int max_objs, ScanCopyContext ctx) do { int i; for (i = 0; i != max_objs; ++i) { - char *obj; + GCObject *obj; mword desc; GRAY_OBJECT_DEQUEUE (queue, &obj, &desc); if (!obj) @@ -889,7 +889,7 @@ static void unpin_objects_from_queue (SgenGrayQueue *queue) { for (;;) { - char *addr; + GCObject *addr; mword desc; GRAY_OBJECT_DEQUEUE (queue, &addr, &desc); if (!addr) @@ -900,7 +900,7 @@ unpin_objects_from_queue (SgenGrayQueue *queue) } static void -single_arg_user_copy_or_mark (void **obj, void *gc_data) +single_arg_user_copy_or_mark (GCObject **obj, void *gc_data) { ScanCopyContext *ctx = gc_data; ctx->ops->copy_or_mark_object (obj, ctx->queue); @@ -925,7 +925,7 @@ precisely_scan_objects_from (void** start_root, void** end_root, char* n_start, desc >>= ROOT_DESC_TYPE_SHIFT; while (desc) { if ((desc & 1) && *start_root) { - copy_func (start_root, queue); + copy_func ((GCObject**)start_root, queue); SGEN_LOG (9, "Overwrote root at %p with %p", start_root, *start_root); } desc >>= 1; @@ -942,7 +942,7 @@ precisely_scan_objects_from (void** start_root, void** end_root, char* n_start, void **objptr = start_run; while (bmap) { if ((bmap & 1) && *objptr) { - copy_func (objptr, queue); + copy_func ((GCObject**)objptr, queue); SGEN_LOG (9, "Overwrote root at %p with %p", objptr, *objptr); } bmap >>= 1; @@ -1049,7 +1049,7 @@ scan_finalizer_entries (SgenPointerQueue *fin_queue, ScanCopyContext ctx) if (!obj) continue; SGEN_LOG (5, "Scan of fin ready object: %p (%s)\n", obj, sgen_client_vtable_get_name (SGEN_LOAD_VTABLE (obj))); - copy_func (&fin_queue->data [i], queue); + copy_func ((GCObject**)&fin_queue->data [i], queue); } } @@ -1672,7 +1672,7 @@ collect_nursery (SgenGrayQueue *unpin_queue, gboolean finish_up_concurrent_mark) } static void -scan_nursery_objects_callback (char *obj, size_t size, ScanCopyContext *ctx) +scan_nursery_objects_callback (GCObject *obj, size_t size, ScanCopyContext *ctx) { /* * This is called on all objects in the nursery, including pinned ones, so we need @@ -1796,8 +1796,8 @@ major_copy_or_mark_from_roots (size_t *old_next_pin_slot, CopyOrMarkFromRootsMod SGEN_LOG (6, "Pinning from large objects"); for (bigobj = los_object_list; bigobj; bigobj = bigobj->next) { size_t dummy; - if (sgen_find_optimized_pin_queue_area (bigobj->data, (char*)bigobj->data + sgen_los_object_size (bigobj), &dummy, &dummy)) { - binary_protocol_pin (bigobj->data, (gpointer)LOAD_VTABLE (bigobj->data), safe_object_get_size (((GCObject*)(bigobj->data)))); + if (sgen_find_optimized_pin_queue_area ((char*)bigobj->data, (char*)bigobj->data + sgen_los_object_size (bigobj), &dummy, &dummy)) { + binary_protocol_pin (bigobj->data, (gpointer)LOAD_VTABLE (bigobj->data), safe_object_get_size (bigobj->data)); if (sgen_los_object_is_pinned (bigobj->data)) { SGEN_ASSERT (0, mode == COPY_OR_MARK_FROM_ROOTS_FINISH_CONCURRENT, "LOS objects can only be pinned here after concurrent marking."); @@ -1805,8 +1805,8 @@ major_copy_or_mark_from_roots (size_t *old_next_pin_slot, CopyOrMarkFromRootsMod } sgen_los_pin_object (bigobj->data); if (SGEN_OBJECT_HAS_REFERENCES (bigobj->data)) - GRAY_OBJECT_ENQUEUE (WORKERS_DISTRIBUTE_GRAY_QUEUE, bigobj->data, sgen_obj_get_descriptor (bigobj->data)); - sgen_pin_stats_register_object ((char*) bigobj->data, safe_object_get_size ((GCObject*) bigobj->data)); + GRAY_OBJECT_ENQUEUE (WORKERS_DISTRIBUTE_GRAY_QUEUE, bigobj->data, sgen_obj_get_descriptor ((GCObject*)bigobj->data)); + sgen_pin_stats_register_object (bigobj->data, safe_object_get_size (bigobj->data)); SGEN_LOG (6, "Marked large object %p (%s) size: %lu from roots", bigobj->data, sgen_client_vtable_get_name (SGEN_LOAD_VTABLE (bigobj->data)), (unsigned long)sgen_los_object_size (bigobj)); @@ -2482,7 +2482,7 @@ sgen_is_object_alive (void *object) * are never alive during a minor collection. */ static inline int -sgen_is_object_alive_and_on_current_collection (char *object) +sgen_is_object_alive_and_on_current_collection (GCObject *object) { if (ptr_in_nursery (object)) return sgen_nursery_is_object_alive (object); diff --git a/mono/sgen/sgen-gc.h b/mono/sgen/sgen-gc.h index eba51c1da9c..44cc7d42629 100644 --- a/mono/sgen/sgen-gc.h +++ b/mono/sgen/sgen-gc.h @@ -41,8 +41,6 @@ typedef struct _SgenThreadInfo SgenThreadInfo; #include "mono/utils/atomic.h" #include "mono/utils/mono-mutex.h" #include "mono/sgen/sgen-conf.h" -#include "mono/sgen/sgen-descriptor.h" -#include "mono/sgen/sgen-gray.h" #include "mono/sgen/sgen-hash-table.h" #include "mono/sgen/sgen-protocol.h" @@ -276,7 +274,7 @@ sgen_get_nursery_end (void) * Since we set bits in the vtable, use the macro to load it from the pointer to * an object that is potentially pinned. */ -#define SGEN_LOAD_VTABLE(obj) SGEN_POINTER_UNTAG_ALL (SGEN_LOAD_VTABLE_UNCHECKED ((obj))) +#define SGEN_LOAD_VTABLE(obj) ((GCVTable)(SGEN_POINTER_UNTAG_ALL (SGEN_LOAD_VTABLE_UNCHECKED ((obj))))) /* List of what each bit on of the vtable gc bits means. @@ -309,15 +307,12 @@ extern SgenHashTable roots_hash [ROOT_TYPE_NUM]; int sgen_register_root (char *start, size_t size, void *descr, int root_type); void sgen_deregister_root (char* addr); -typedef void (*IterateObjectCallbackFunc) (char*, size_t, void*); - void sgen_gc_init (void); void sgen_os_init (void); void sgen_update_heap_boundaries (mword low, mword high); -void sgen_scan_area_with_callback (char *start, char *end, IterateObjectCallbackFunc callback, void *data, gboolean allow_flags); void sgen_check_section_scan_starts (GCMemSection *section); void sgen_conservatively_pin_objects_from (void **start, void **end, void *start_nursery, void *end_nursery, int pin_type); @@ -384,6 +379,13 @@ void sgen_init_internal_allocator (void); #endif #undef SGEN_DEFINE_OBJECT_VTABLE +#include "mono/sgen/sgen-descriptor.h" +#include "mono/sgen/sgen-gray.h" + +typedef void (*IterateObjectCallbackFunc) (GCObject*, size_t, void*); + +void sgen_scan_area_with_callback (char *start, char *end, IterateObjectCallbackFunc callback, void *data, gboolean allow_flags); + /* eventually share with MonoThread? */ /* * This structure extends the MonoThreadInfo structure. @@ -406,9 +408,9 @@ struct _SgenThreadInfo { gboolean sgen_is_worker_thread (MonoNativeThreadId thread); -typedef void (*CopyOrMarkObjectFunc) (void**, SgenGrayQueue*); -typedef void (*ScanObjectFunc) (char *obj, mword desc, SgenGrayQueue*); -typedef void (*ScanVTypeFunc) (char *full_object, char *start, mword desc, SgenGrayQueue* BINARY_PROTOCOL_ARG (size_t size)); +typedef void (*CopyOrMarkObjectFunc) (GCObject**, SgenGrayQueue*); +typedef void (*ScanObjectFunc) (GCObject *obj, mword desc, SgenGrayQueue*); +typedef void (*ScanVTypeFunc) (GCObject *full_object, char *start, mword desc, SgenGrayQueue* BINARY_PROTOCOL_ARG (size_t size)); typedef struct { CopyOrMarkObjectFunc copy_or_mark_object; @@ -439,8 +441,8 @@ void* sgen_alloc_internal_dynamic (size_t size, int type, gboolean assert_on_fai void sgen_free_internal_dynamic (void *addr, size_t size, int type); void sgen_pin_stats_enable (void); -void sgen_pin_stats_register_object (char *obj, size_t size); -void sgen_pin_stats_register_global_remset (char *obj); +void sgen_pin_stats_register_object (GCObject *obj, size_t size); +void sgen_pin_stats_register_global_remset (GCObject *obj); void sgen_pin_stats_print_class_stats (void); void sgen_sort_addresses (void **array, size_t size); @@ -497,9 +499,9 @@ extern char *sgen_space_bitmap; extern size_t sgen_space_bitmap_size; static inline gboolean -sgen_nursery_is_to_space (char *object) +sgen_nursery_is_to_space (void *object) { - size_t idx = (object - sgen_nursery_start) >> SGEN_TO_SPACE_GRANULE_BITS; + size_t idx = ((char*)object - sgen_nursery_start) >> SGEN_TO_SPACE_GRANULE_BITS; size_t byte = idx >> 3; size_t bit = idx & 0x7; @@ -510,13 +512,13 @@ sgen_nursery_is_to_space (char *object) } static inline gboolean -sgen_nursery_is_from_space (char *object) +sgen_nursery_is_from_space (void *object) { return !sgen_nursery_is_to_space (object); } static inline gboolean -sgen_nursery_is_object_alive (char *obj) +sgen_nursery_is_object_alive (GCObject *obj) { /* FIXME put this asserts under a non default level */ g_assert (sgen_ptr_in_nursery (obj)); @@ -533,7 +535,7 @@ sgen_nursery_is_object_alive (char *obj) typedef struct { gboolean is_split; - char* (*alloc_for_promotion) (GCVTable vtable, char *obj, size_t objsize, gboolean has_references); + char* (*alloc_for_promotion) (GCVTable vtable, GCObject *obj, size_t objsize, gboolean has_references); SgenObjectOperations serial_ops; @@ -610,7 +612,7 @@ struct _SgenMajorCollector { gboolean *want_synchronous_collection; void* (*alloc_heap) (mword nursery_size, mword nursery_align, int nursery_bits); - gboolean (*is_object_live) (char *obj); + gboolean (*is_object_live) (GCObject *obj); void* (*alloc_small_pinned_obj) (GCVTable vtable, size_t size, gboolean has_references); void* (*alloc_degraded) (GCVTable vtable, size_t size); @@ -620,7 +622,7 @@ struct _SgenMajorCollector { SgenObjectOperations major_ops_concurrent_finish; void* (*alloc_object) (GCVTable vtable, size_t size, gboolean has_references); - void (*free_pinned_object) (char *obj, size_t size); + void (*free_pinned_object) (GCObject *obj, size_t size); /* * This is used for domain unloading, heap walking from the logging profiler, and @@ -628,9 +630,9 @@ struct _SgenMajorCollector { */ void (*iterate_objects) (IterateObjectsFlags flags, IterateObjectCallbackFunc callback, void *data); - void (*free_non_pinned_object) (char *obj, size_t size); + void (*free_non_pinned_object) (GCObject *obj, size_t size); void (*pin_objects) (SgenGrayQueue *queue); - void (*pin_major_object) (char *obj, SgenGrayQueue *queue); + void (*pin_major_object) (GCObject *obj, SgenGrayQueue *queue); void (*scan_card_table) (gboolean mod_union, ScanCopyContext ctx); void (*iterate_live_block_ranges) (sgen_cardtable_block_callback callback); void (*update_cardtable_mod_union) (void); @@ -648,16 +650,16 @@ struct _SgenMajorCollector { void (*finish_major_collection) (ScannedObjectCounts *counts); gboolean (*drain_gray_stack) (ScanCopyContext ctx); gboolean (*ptr_is_in_non_pinned_space) (char *ptr, char **start); - gboolean (*obj_is_from_pinned_alloc) (char *obj); + gboolean (*ptr_is_from_pinned_alloc) (char *ptr); void (*report_pinned_memory_usage) (void); size_t (*get_num_major_sections) (void); size_t (*get_bytes_survived_last_sweep) (void); gboolean (*handle_gc_param) (const char *opt); void (*print_gc_param_usage) (void); void (*post_param_init) (SgenMajorCollector *collector); - gboolean (*is_valid_object) (char *object); + gboolean (*is_valid_object) (char *ptr); GCVTable (*describe_pointer) (char *pointer); - guint8* (*get_cardtable_mod_union_for_object) (char *object); + guint8* (*get_cardtable_mod_union_for_reference) (char *object); long long (*get_and_reset_num_major_objects_marked) (void); void (*count_cards) (long long *num_total_cards, long long *num_marked_cards); }; @@ -703,7 +705,7 @@ void mono_gc_wbarrier_generic_store_atomic (gpointer ptr, GCObject *value); void sgen_wbarrier_value_copy_bitmap (gpointer _dest, gpointer _src, int size, unsigned bitmap); static inline mword -sgen_obj_get_descriptor (char *obj) +sgen_obj_get_descriptor (GCObject *obj) { GCVTable vtable = SGEN_LOAD_VTABLE_UNCHECKED (obj); SGEN_ASSERT (9, !SGEN_POINTER_IS_TAGGED_ANY (vtable), "Object can't be tagged"); @@ -711,21 +713,24 @@ sgen_obj_get_descriptor (char *obj) } static inline mword -sgen_obj_get_descriptor_safe (char *obj) +sgen_obj_get_descriptor_safe (GCObject *obj) { - GCVTable vtable = (GCVTable)SGEN_LOAD_VTABLE (obj); + GCVTable vtable = SGEN_LOAD_VTABLE (obj); return sgen_vtable_get_descriptor (vtable); } +static mword sgen_client_par_object_get_size (GCVTable vtable, GCObject* o); +static mword sgen_client_slow_object_get_size (GCVTable vtable, GCObject* o); + static inline mword sgen_safe_object_get_size (GCObject *obj) { - char *forwarded; + GCObject *forwarded; if ((forwarded = SGEN_OBJECT_IS_FORWARDED (obj))) - obj = (GCObject*)forwarded; + obj = forwarded; - return sgen_client_par_object_get_size ((GCVTable)SGEN_LOAD_VTABLE (obj), obj); + return sgen_client_par_object_get_size (SGEN_LOAD_VTABLE (obj), obj); } static inline gboolean @@ -743,13 +748,13 @@ sgen_safe_object_is_small (GCObject *obj, int type) static inline guint sgen_safe_object_get_size_unaligned (GCObject *obj) { - char *forwarded; + GCObject *forwarded; - if ((forwarded = SGEN_OBJECT_IS_FORWARDED (obj))) { - obj = (GCObject*)forwarded; - } + if ((forwarded = SGEN_OBJECT_IS_FORWARDED (obj))) { + obj = (GCObject*)forwarded; + } - return sgen_client_slow_object_get_size ((GCVTable)SGEN_LOAD_VTABLE (obj), obj); + return sgen_client_slow_object_get_size (SGEN_LOAD_VTABLE (obj), obj); } #ifdef SGEN_CLIENT_HEADER @@ -844,7 +849,7 @@ struct _LOSObject { #if SIZEOF_VOID_P < 8 mword dummy; /* to align object to sizeof (double) */ #endif - char data [MONO_ZERO_LEN_ARRAY]; + GCObject data [MONO_ZERO_LEN_ARRAY]; }; extern LOSObject *los_object_list; @@ -861,10 +866,10 @@ void sgen_los_update_cardtable_mod_union (void); void sgen_los_count_cards (long long *num_total_cards, long long *num_marked_cards); gboolean sgen_los_is_valid_object (char *object); gboolean mono_sgen_los_describe_pointer (char *ptr); -LOSObject* sgen_los_header_for_object (char *data); +LOSObject* sgen_los_header_for_object (GCObject *data); mword sgen_los_object_size (LOSObject *obj); -void sgen_los_pin_object (char *obj); -gboolean sgen_los_object_is_pinned (char *obj); +void sgen_los_pin_object (GCObject *obj); +gboolean sgen_los_object_is_pinned (GCObject *obj); void sgen_los_mark_mod_union_card (GCObject *mono_obj, void **ptr); @@ -886,7 +891,7 @@ void sgen_nursery_retire_region (void *address, ptrdiff_t size); void sgen_nursery_alloc_prepare_for_minor (void); void sgen_nursery_alloc_prepare_for_major (void); -char* sgen_alloc_for_promotion (char *obj, size_t objsize, gboolean has_references); +char* sgen_alloc_for_promotion (GCObject *obj, size_t objsize, gboolean has_references); void* sgen_alloc_obj_nolock (GCVTable vtable, size_t size); void* sgen_try_alloc_obj_nolock (GCVTable vtable, size_t size); @@ -899,7 +904,7 @@ void sgen_thread_unregister (SgenThreadInfo *p); /* Finalization/ephemeron support */ static inline gboolean -sgen_major_is_object_alive (void *object) +sgen_major_is_object_alive (GCObject *object) { mword objsize; @@ -911,7 +916,7 @@ sgen_major_is_object_alive (void *object) * FIXME: major_collector.is_object_live() also calculates the * size. Avoid the double calculation. */ - objsize = SGEN_ALIGN_UP (sgen_safe_object_get_size ((GCObject*)object)); + objsize = SGEN_ALIGN_UP (sgen_safe_object_get_size (object)); if (objsize > SGEN_MAX_SMALL_OBJ_SIZE) return sgen_los_object_is_pinned (object); @@ -923,7 +928,7 @@ sgen_major_is_object_alive (void *object) * and we're currently doing a minor collection. */ static inline int -sgen_is_object_alive_for_current_gen (char *object) +sgen_is_object_alive_for_current_gen (GCObject *object) { if (sgen_ptr_in_nursery (object)) return sgen_nursery_is_object_alive (object); @@ -990,7 +995,7 @@ void sgen_check_objref (char *obj); void sgen_check_heap_marked (gboolean nursery_must_be_pinned); void sgen_check_nursery_objects_pinned (gboolean pinned); void sgen_check_for_xdomain_refs (void); -char* sgen_find_object_for_ptr (char *ptr); +GCObject* sgen_find_object_for_ptr (char *ptr); void mono_gc_scan_for_specific_ref (GCObject *key, gboolean precise); diff --git a/mono/sgen/sgen-gray.c b/mono/sgen/sgen-gray.c index 331484adf31..5b6040eabd8 100644 --- a/mono/sgen/sgen-gray.c +++ b/mono/sgen/sgen-gray.c @@ -96,7 +96,7 @@ sgen_gray_object_free_queue_section (GrayQueueSection *section) */ void -sgen_gray_object_enqueue (SgenGrayQueue *queue, char *obj, mword desc) +sgen_gray_object_enqueue (SgenGrayQueue *queue, GCObject *obj, mword desc) { GrayQueueEntry entry = SGEN_GRAY_QUEUE_ENTRY (obj, desc); diff --git a/mono/sgen/sgen-gray.h b/mono/sgen/sgen-gray.h index 966a3773623..101454f932e 100644 --- a/mono/sgen/sgen-gray.h +++ b/mono/sgen/sgen-gray.h @@ -70,7 +70,7 @@ typedef enum { typedef struct _GrayQueueEntry GrayQueueEntry; struct _GrayQueueEntry { - char *obj; + GCObject *obj; mword desc; }; @@ -98,7 +98,7 @@ struct _GrayQueueSection { typedef struct _SgenGrayQueue SgenGrayQueue; typedef void (*GrayQueueAllocPrepareFunc) (SgenGrayQueue*); -typedef void (*GrayQueueEnqueueCheckFunc) (char*); +typedef void (*GrayQueueEnqueueCheckFunc) (GCObject*); struct _SgenGrayQueue { GrayQueueEntry *cursor; @@ -136,7 +136,7 @@ extern guint64 stat_gray_queue_dequeue_slow_path; void sgen_init_gray_queues (void); -void sgen_gray_object_enqueue (SgenGrayQueue *queue, char *obj, mword desc); +void sgen_gray_object_enqueue (SgenGrayQueue *queue, GCObject *obj, mword desc); GrayQueueEntry sgen_gray_object_dequeue (SgenGrayQueue *queue); GrayQueueSection* sgen_gray_object_dequeue_section (SgenGrayQueue *queue); void sgen_gray_object_enqueue_section (SgenGrayQueue *queue, GrayQueueSection *section); @@ -166,7 +166,7 @@ sgen_gray_object_queue_is_empty (SgenGrayQueue *queue) } static inline MONO_ALWAYS_INLINE void -GRAY_OBJECT_ENQUEUE (SgenGrayQueue *queue, char* obj, mword desc) +GRAY_OBJECT_ENQUEUE (SgenGrayQueue *queue, GCObject *obj, mword desc) { #if SGEN_MAX_DEBUG_LEVEL >= 9 sgen_gray_object_enqueue (queue, obj, desc); @@ -187,7 +187,7 @@ GRAY_OBJECT_ENQUEUE (SgenGrayQueue *queue, char* obj, mword desc) } static inline MONO_ALWAYS_INLINE void -GRAY_OBJECT_DEQUEUE (SgenGrayQueue *queue, char** obj, mword *desc) +GRAY_OBJECT_DEQUEUE (SgenGrayQueue *queue, GCObject** obj, mword *desc) { GrayQueueEntry entry; #if SGEN_MAX_DEBUG_LEVEL >= 9 diff --git a/mono/sgen/sgen-los.c b/mono/sgen/sgen-los.c index b2dacab99aa..70cf34fb8a9 100644 --- a/mono/sgen/sgen-los.c +++ b/mono/sgen/sgen-los.c @@ -402,7 +402,7 @@ sgen_los_alloc_large_inner (GCVTable vtable, size_t size) return obj->data; } -static void sgen_los_unpin_object (char *data); +static void sgen_los_unpin_object (GCObject *data); void sgen_los_sweep (void) @@ -418,7 +418,7 @@ sgen_los_sweep (void) SGEN_ASSERT (0, !SGEN_OBJECT_IS_PINNED (bigobj->data), "Who pinned a LOS object?"); if (bigobj->cardtable_mod_union) { - sgen_card_table_free_mod_union (bigobj->cardtable_mod_union, bigobj->data, bigobj->size); + sgen_card_table_free_mod_union (bigobj->cardtable_mod_union, (char*)bigobj->data, bigobj->size); bigobj->cardtable_mod_union = NULL; } @@ -502,10 +502,10 @@ sgen_ptr_is_in_los (char *ptr, char **start) *start = NULL; for (obj = los_object_list; obj; obj = obj->next) { - char *end = obj->data + obj->size; + char *end = (char*)obj->data + obj->size; - if (ptr >= obj->data && ptr < end) { - *start = obj->data; + if (ptr >= (char*)obj->data && ptr < end) { + *start = (char*)obj->data; return TRUE; } } @@ -527,7 +527,7 @@ sgen_los_is_valid_object (char *object) LOSObject *obj; for (obj = los_object_list; obj; obj = obj->next) { - if (obj->data == object) + if ((char*)obj->data == object) return TRUE; } return FALSE; @@ -543,7 +543,7 @@ mono_sgen_los_describe_pointer (char *ptr) mword size; gboolean pinned; - if (obj->data > ptr || obj->data + obj->size <= ptr) + if ((char*)obj->data > ptr || (char*)obj->data + obj->size <= ptr) continue; size = sgen_los_object_size (obj); @@ -554,11 +554,11 @@ mono_sgen_los_describe_pointer (char *ptr) else los_kind = "los-ptr"; - if (obj->data == ptr) { + if ((char*)obj->data == ptr) { SGEN_LOG (0, "%s (size %d pin %d)\n", los_kind, (int)size, pinned ? 1 : 0); } else { SGEN_LOG (0, "%s (interior-ptr offset %zd size %d pin %d)", - los_kind, ptr - obj->data, (int)size, pinned ? 1 : 0); + los_kind, ptr - (char*)obj->data, (int)size, pinned ? 1 : 0); } return TRUE; @@ -571,7 +571,7 @@ sgen_los_iterate_live_block_ranges (sgen_cardtable_block_callback callback) { LOSObject *obj; for (obj = los_object_list; obj; obj = obj->next) { - GCVTable vt = (GCVTable)SGEN_LOAD_VTABLE (obj->data); + GCVTable vt = SGEN_LOAD_VTABLE (obj->data); if (SGEN_VTABLE_HAS_REFERENCES (vt)) callback ((mword)obj->data, (mword)obj->size); } @@ -584,13 +584,13 @@ get_cardtable_mod_union_for_object (LOSObject *obj) guint8 *other; if (mod_union) return mod_union; - mod_union = sgen_card_table_alloc_mod_union (obj->data, obj->size); + mod_union = sgen_card_table_alloc_mod_union ((char*)obj->data, obj->size); other = SGEN_CAS_PTR ((gpointer*)&obj->cardtable_mod_union, mod_union, NULL); if (!other) { SGEN_ASSERT (0, obj->cardtable_mod_union == mod_union, "Why did CAS not replace?"); return mod_union; } - sgen_card_table_free_mod_union (mod_union, obj->data, obj->size); + sgen_card_table_free_mod_union (mod_union, (char*)obj->data, obj->size); return other; } @@ -655,7 +655,7 @@ sgen_los_update_cardtable_mod_union (void) if (!SGEN_OBJECT_HAS_REFERENCES (obj->data)) continue; sgen_card_table_update_mod_union (get_cardtable_mod_union_for_object (obj), - obj->data, obj->size, NULL); + (char*)obj->data, obj->size, NULL); } } @@ -666,32 +666,32 @@ sgen_los_object_size (LOSObject *obj) } LOSObject* -sgen_los_header_for_object (char *data) +sgen_los_header_for_object (GCObject *data) { #if _MSC_VER - return (LOSObject*)(data - (int)(&(((LOSObject*)0)->data))); + return (LOSObject*)((char*)data - (int)(&(((LOSObject*)0)->data))); #else - return (LOSObject*)(data - sizeof (LOSObject)); + return (LOSObject*)((char*)data - sizeof (LOSObject)); #endif } void -sgen_los_pin_object (char *data) +sgen_los_pin_object (GCObject *data) { LOSObject *obj = sgen_los_header_for_object (data); obj->size = obj->size | 1; - binary_protocol_pin (data, (gpointer)SGEN_LOAD_VTABLE (data), sgen_safe_object_get_size ((GCObject*)data)); + binary_protocol_pin (data, (gpointer)SGEN_LOAD_VTABLE (data), sgen_safe_object_get_size (data)); } static void -sgen_los_unpin_object (char *data) +sgen_los_unpin_object (GCObject *data) { LOSObject *obj = sgen_los_header_for_object (data); obj->size = sgen_los_object_size (obj); } gboolean -sgen_los_object_is_pinned (char *data) +sgen_los_object_is_pinned (GCObject *data) { LOSObject *obj = sgen_los_header_for_object (data); return obj->size & 1; @@ -700,7 +700,7 @@ sgen_los_object_is_pinned (char *data) void sgen_los_mark_mod_union_card (GCObject *mono_obj, void **ptr) { - LOSObject *obj = sgen_los_header_for_object ((char*)mono_obj); + LOSObject *obj = sgen_los_header_for_object (mono_obj); guint8 *mod_union = get_cardtable_mod_union_for_object (obj); size_t offset = sgen_card_table_get_card_offset ((char*)ptr, (char*)sgen_card_table_align_pointer ((char*)obj)); SGEN_ASSERT (0, mod_union, "FIXME: optionally allocate the mod union if it's not here and CAS it in."); diff --git a/mono/sgen/sgen-marksweep-drain-gray-stack.h b/mono/sgen/sgen-marksweep-drain-gray-stack.h index 01398a05918..47a40c3c11f 100644 --- a/mono/sgen/sgen-marksweep-drain-gray-stack.h +++ b/mono/sgen/sgen-marksweep-drain-gray-stack.h @@ -33,7 +33,7 @@ /* Returns whether the object is still in the nursery. */ static inline MONO_ALWAYS_INLINE gboolean -COPY_OR_MARK_FUNCTION_NAME (void **ptr, void *obj, SgenGrayQueue *queue) +COPY_OR_MARK_FUNCTION_NAME (GCObject **ptr, GCObject *obj, SgenGrayQueue *queue) { MSBlockInfo *block; @@ -56,7 +56,7 @@ COPY_OR_MARK_FUNCTION_NAME (void **ptr, void *obj, SgenGrayQueue *queue) if (sgen_ptr_in_nursery (obj)) { int word, bit; - char *forwarded, *old_obj; + GCObject *forwarded, *old_obj; mword vtable_word = *(mword*)obj; HEAVY_STAT (++stat_optimized_copy_nursery); @@ -125,7 +125,7 @@ COPY_OR_MARK_FUNCTION_NAME (void **ptr, void *obj, SgenGrayQueue *queue) MS_CALC_MARK_BIT (word, bit, obj); SGEN_ASSERT (9, !MS_MARK_BIT (block, word, bit), "object %p already marked", obj); MS_SET_MARK_BIT (block, word, bit); - binary_protocol_mark (obj, (gpointer)LOAD_VTABLE (obj), sgen_safe_object_get_size ((GCObject*)obj)); + binary_protocol_mark (obj, (gpointer)LOAD_VTABLE (obj), sgen_safe_object_get_size (obj)); return FALSE; } else { @@ -137,7 +137,7 @@ COPY_OR_MARK_FUNCTION_NAME (void **ptr, void *obj, SgenGrayQueue *queue) #ifdef COPY_OR_MARK_WITH_EVACUATION { - char *forwarded; + GCObject *forwarded; if ((forwarded = SGEN_VTABLE_IS_FORWARDED (vtable_word))) { HEAVY_STAT (++stat_optimized_copy_major_forwarded); SGEN_UPDATE_REFERENCE (ptr, forwarded); @@ -152,7 +152,7 @@ COPY_OR_MARK_FUNCTION_NAME (void **ptr, void *obj, SgenGrayQueue *queue) desc = sgen_vtable_get_descriptor ((GCVTable)vtable_word); type = desc & DESC_TYPE_MASK; - if (sgen_safe_object_is_small ((GCObject*)obj, type)) { + if (sgen_safe_object_is_small (obj, type)) { #ifdef HEAVY_STATISTICS if (type <= DESC_TYPE_MAX_SMALL_OBJ) ++stat_optimized_copy_major_small_fast; @@ -181,7 +181,7 @@ COPY_OR_MARK_FUNCTION_NAME (void **ptr, void *obj, SgenGrayQueue *queue) if (sgen_los_object_is_pinned (obj)) return FALSE; - binary_protocol_pin (obj, (gpointer)SGEN_LOAD_VTABLE (obj), sgen_safe_object_get_size ((GCObject*)obj)); + binary_protocol_pin (obj, (gpointer)SGEN_LOAD_VTABLE (obj), sgen_safe_object_get_size (obj)); sgen_los_pin_object (obj); if (SGEN_OBJECT_HAS_REFERENCES (obj)) @@ -194,9 +194,9 @@ COPY_OR_MARK_FUNCTION_NAME (void **ptr, void *obj, SgenGrayQueue *queue) } static void -SCAN_OBJECT_FUNCTION_NAME (char *obj, mword desc, SgenGrayQueue *queue) +SCAN_OBJECT_FUNCTION_NAME (GCObject *obj, mword desc, SgenGrayQueue *queue) { - char *start = obj; + char *start = (char*)obj; #ifdef HEAVY_STATISTICS ++stat_optimized_major_scan; @@ -235,7 +235,7 @@ DRAIN_GRAY_STACK_FUNCTION_NAME (ScanCopyContext ctx) SGEN_ASSERT (0, ctx.ops->scan_object == major_scan_object_with_evacuation, "Wrong scan function"); for (;;) { - char *obj; + GCObject *obj; mword desc; HEAVY_STAT (++stat_drain_loops); diff --git a/mono/sgen/sgen-marksweep-scan-object-concurrent.h b/mono/sgen/sgen-marksweep-scan-object-concurrent.h index bdad9737591..855f9247248 100644 --- a/mono/sgen/sgen-marksweep-scan-object-concurrent.h +++ b/mono/sgen/sgen-marksweep-scan-object-concurrent.h @@ -34,7 +34,7 @@ extern guint64 stat_scan_object_called_major; #undef HANDLE_PTR #define HANDLE_PTR(ptr,obj) do { \ - void *__old = *(ptr); \ + GCObject *__old = *(ptr); \ SGEN_OBJECT_LAYOUT_STATISTICS_MARK_BITMAP ((obj), (ptr)); \ binary_protocol_scan_process_reference ((obj), (ptr), __old); \ if (__old && !sgen_ptr_in_nursery (__old)) { \ @@ -42,19 +42,19 @@ extern guint64 stat_scan_object_called_major; major_copy_or_mark_object_concurrent ((ptr), __old, queue); \ } else { \ if (G_UNLIKELY (sgen_ptr_in_nursery (__old) && !sgen_ptr_in_nursery ((ptr)))) \ - ADD_TO_GLOBAL_REMSET ((GCObject*)(full_object), (ptr), __old); \ + ADD_TO_GLOBAL_REMSET ((full_object), (ptr), __old); \ } \ } while (0) /* FIXME: Unify this with optimized code in sgen-marksweep.c. */ #undef ADD_TO_GLOBAL_REMSET -#define ADD_TO_GLOBAL_REMSET(object,ptr,target) mark_mod_union_card ((object), (ptr)) +#define ADD_TO_GLOBAL_REMSET(object,ptr,target) mark_mod_union_card ((object), (void**)(ptr)) static void -major_scan_object_no_mark_concurrent_anywhere (char *full_object, mword desc, SgenGrayQueue *queue) +major_scan_object_no_mark_concurrent_anywhere (GCObject *full_object, mword desc, SgenGrayQueue *queue) { - char *start = full_object; + char *start = (char*)full_object; SGEN_OBJECT_LAYOUT_STATISTICS_DECLARE_BITMAP; @@ -73,13 +73,13 @@ major_scan_object_no_mark_concurrent_anywhere (char *full_object, mword desc, Sg } static void -major_scan_object_no_mark_concurrent_start (char *start, mword desc, SgenGrayQueue *queue) +major_scan_object_no_mark_concurrent_start (GCObject *start, mword desc, SgenGrayQueue *queue) { major_scan_object_no_mark_concurrent_anywhere (start, desc, queue); } static void -major_scan_object_no_mark_concurrent (char *start, mword desc, SgenGrayQueue *queue) +major_scan_object_no_mark_concurrent (GCObject *start, mword desc, SgenGrayQueue *queue) { SGEN_ASSERT (0, !sgen_ptr_in_nursery (start), "Why are we scanning nursery objects in the concurrent collector?"); major_scan_object_no_mark_concurrent_anywhere (start, desc, queue); @@ -89,7 +89,7 @@ major_scan_object_no_mark_concurrent (char *start, mword desc, SgenGrayQueue *qu #define ADD_TO_GLOBAL_REMSET(object,ptr,target) sgen_add_to_global_remset ((ptr), (target)) static void -major_scan_vtype_concurrent_finish (char *full_object, char *start, mword desc, SgenGrayQueue *queue BINARY_PROTOCOL_ARG (size_t size)) +major_scan_vtype_concurrent_finish (GCObject *full_object, char *start, mword desc, SgenGrayQueue *queue BINARY_PROTOCOL_ARG (size_t size)) { SGEN_OBJECT_LAYOUT_STATISTICS_DECLARE_BITMAP; diff --git a/mono/sgen/sgen-marksweep.c b/mono/sgen/sgen-marksweep.c index 369a6d41784..7aafced9d8e 100644 --- a/mono/sgen/sgen-marksweep.c +++ b/mono/sgen/sgen-marksweep.c @@ -121,7 +121,7 @@ struct _MSBlockInfo { #define MS_BLOCK_FOR_BLOCK_INFO(b) ((char*)(b)) -#define MS_BLOCK_OBJ(b,i) (MS_BLOCK_FOR_BLOCK_INFO(b) + MS_BLOCK_SKIP + (b)->obj_size * (i)) +#define MS_BLOCK_OBJ(b,i) ((void*)(MS_BLOCK_FOR_BLOCK_INFO(b) + MS_BLOCK_SKIP + (b)->obj_size * (i))) #define MS_BLOCK_OBJ_FOR_SIZE(b,i,obj_size) (MS_BLOCK_FOR_BLOCK_INFO(b) + MS_BLOCK_SKIP + (obj_size) * (i)) #define MS_BLOCK_DATA_FOR_OBJ(o) ((char*)((mword)(o) & ~(mword)(MS_BLOCK_SIZE - 1))) @@ -573,7 +573,7 @@ ms_alloc_block (int size_index, gboolean pinned, gboolean has_references) } static gboolean -obj_is_from_pinned_alloc (char *ptr) +ptr_is_from_pinned_alloc (char *ptr) { MSBlockInfo *block; @@ -676,7 +676,7 @@ major_alloc_object (GCVTable vtable, size_t size, gboolean has_references) * single thread and has the GC lock, so we don't need an extra lock. */ static void -free_object (char *obj, size_t size, gboolean pinned) +free_object (GCObject *obj, size_t size, gboolean pinned) { MSBlockInfo *block = MS_BLOCK_FOR_OBJ (obj); int word, bit; @@ -705,7 +705,7 @@ free_object (char *obj, size_t size, gboolean pinned) } static void -major_free_non_pinned_object (char *obj, size_t size) +major_free_non_pinned_object (GCObject *obj, size_t size) { free_object (obj, size, FALSE); } @@ -728,7 +728,7 @@ major_alloc_small_pinned_obj (GCVTable vtable, size_t size, gboolean has_referen } static void -free_pinned_object (char *obj, size_t size) +free_pinned_object (GCObject *obj, size_t size) { free_object (obj, size, TRUE); } @@ -753,7 +753,7 @@ major_alloc_degraded (GCVTable vtable, size_t size) * been marked or copied. */ static gboolean -major_is_object_live (char *obj) +major_is_object_live (GCObject *obj) { MSBlockInfo *block; int word, bit; @@ -762,7 +762,7 @@ major_is_object_live (char *obj) if (sgen_ptr_in_nursery (obj)) return FALSE; - objsize = SGEN_ALIGN_UP (sgen_safe_object_get_size ((GCObject*)obj)); + objsize = SGEN_ALIGN_UP (sgen_safe_object_get_size (obj)); /* LOS */ if (objsize > SGEN_MAX_SMALL_OBJ_SIZE) @@ -787,7 +787,7 @@ major_ptr_is_in_non_pinned_space (char *ptr, char **start) *start = NULL; for (i = 0; i <= count; ++i) { - if (ptr >= MS_BLOCK_OBJ (block, i) && ptr < MS_BLOCK_OBJ (block, i + 1)) { + if (ptr >= (char*)MS_BLOCK_OBJ (block, i) && ptr < (char*)MS_BLOCK_OBJ (block, i + 1)) { *start = MS_BLOCK_OBJ (block, i); break; } @@ -897,7 +897,7 @@ major_iterate_objects (IterateObjectsFlags flags, IterateObjectCallbackFunc call continue; } if (MS_OBJ_ALLOCED (obj, block)) - callback ((char*)obj, block->obj_size, data); + callback ((GCObject*)obj, block->obj_size, data); } } END_FOREACH_BLOCK_NO_LOCK; } @@ -947,7 +947,7 @@ major_describe_pointer (char *ptr) idx = MS_BLOCK_OBJ_INDEX (ptr, block); obj = (char*)MS_BLOCK_OBJ (block, idx); live = MS_OBJ_ALLOCED (obj, block); - vtable = live ? (GCVTable)SGEN_LOAD_VTABLE (obj) : NULL; + vtable = live ? SGEN_LOAD_VTABLE ((GCObject*)obj) : NULL; MS_CALC_MARK_BIT (w, b, obj); marked = MS_MARK_BIT (block, w, b); @@ -1065,7 +1065,7 @@ major_get_cardtable_mod_union_for_reference (char *ptr) static void mark_mod_union_card (GCObject *obj, void **ptr) { - int type = sgen_obj_get_descriptor ((char*)obj) & DESC_TYPE_MASK; + int type = sgen_obj_get_descriptor (obj) & DESC_TYPE_MASK; if (sgen_safe_object_is_small (obj, type)) { guint8 *card_byte = major_get_cardtable_mod_union_for_reference ((char*)ptr); SGEN_ASSERT (0, MS_BLOCK_FOR_OBJ (obj) == MS_BLOCK_FOR_OBJ (ptr), "How can an object and a reference inside it not be in the same block?"); @@ -1084,7 +1084,7 @@ mark_mod_union_card (GCObject *obj, void **ptr) MS_SET_MARK_BIT ((block), __word, __bit); \ if (sgen_gc_descr_has_references (desc)) \ GRAY_OBJECT_ENQUEUE ((queue), (obj), (desc)); \ - binary_protocol_mark ((obj), (gpointer)LOAD_VTABLE ((obj)), sgen_safe_object_get_size ((GCObject*)(obj))); \ + binary_protocol_mark ((obj), (gpointer)LOAD_VTABLE ((obj)), sgen_safe_object_get_size ((obj))); \ INC_NUM_MAJOR_OBJECTS_MARKED (); \ } \ } while (0) @@ -1096,13 +1096,13 @@ mark_mod_union_card (GCObject *obj, void **ptr) MS_SET_MARK_BIT ((block), __word, __bit); \ if (sgen_gc_descr_has_references (desc)) \ GRAY_OBJECT_ENQUEUE ((queue), (obj), (desc)); \ - binary_protocol_mark ((obj), (gpointer)LOAD_VTABLE ((obj)), sgen_safe_object_get_size ((GCObject*)(obj))); \ + binary_protocol_mark ((obj), (gpointer)LOAD_VTABLE ((obj)), sgen_safe_object_get_size ((obj))); \ INC_NUM_MAJOR_OBJECTS_MARKED (); \ } \ } while (0) static void -pin_major_object (char *obj, SgenGrayQueue *queue) +pin_major_object (GCObject *obj, SgenGrayQueue *queue) { MSBlockInfo *block; @@ -1117,7 +1117,7 @@ pin_major_object (char *obj, SgenGrayQueue *queue) #include "sgen-major-copy-object.h" static void -major_copy_or_mark_object_concurrent (void **ptr, void *obj, SgenGrayQueue *queue) +major_copy_or_mark_object_concurrent (GCObject **ptr, GCObject *obj, SgenGrayQueue *queue) { SGEN_ASSERT (9, sgen_concurrent_collection_in_progress (), "Why are we scanning concurrently when there's no concurrent collection on?"); SGEN_ASSERT (9, !sgen_workers_are_working () || sgen_thread_pool_is_thread_pool_thread (mono_native_thread_id_get ()), "We must not scan from two threads at the same time!"); @@ -1127,7 +1127,7 @@ major_copy_or_mark_object_concurrent (void **ptr, void *obj, SgenGrayQueue *queu if (!sgen_ptr_in_nursery (obj)) { mword objsize; - objsize = SGEN_ALIGN_UP (sgen_safe_object_get_size ((GCObject*)obj)); + objsize = SGEN_ALIGN_UP (sgen_safe_object_get_size (obj)); if (objsize <= SGEN_MAX_SMALL_OBJ_SIZE) { MSBlockInfo *block = MS_BLOCK_FOR_OBJ (obj); @@ -1192,7 +1192,7 @@ static guint64 stat_drain_prefetch_fill_failures; static guint64 stat_drain_loops; #endif -static void major_scan_object_with_evacuation (char *start, mword desc, SgenGrayQueue *queue); +static void major_scan_object_with_evacuation (GCObject *start, mword desc, SgenGrayQueue *queue); #define COPY_OR_MARK_FUNCTION_NAME major_copy_or_mark_object_no_evacuation #define SCAN_OBJECT_FUNCTION_NAME major_scan_object_no_evacuation @@ -1226,19 +1226,19 @@ drain_gray_stack (ScanCopyContext ctx) #include "sgen-marksweep-scan-object-concurrent.h" static void -major_copy_or_mark_object_canonical (void **ptr, SgenGrayQueue *queue) +major_copy_or_mark_object_canonical (GCObject **ptr, SgenGrayQueue *queue) { major_copy_or_mark_object_with_evacuation (ptr, *ptr, queue); } static void -major_copy_or_mark_object_concurrent_canonical (void **ptr, SgenGrayQueue *queue) +major_copy_or_mark_object_concurrent_canonical (GCObject **ptr, SgenGrayQueue *queue) { major_copy_or_mark_object_concurrent (ptr, *ptr, queue); } static void -major_copy_or_mark_object_concurrent_finish_canonical (void **ptr, SgenGrayQueue *queue) +major_copy_or_mark_object_concurrent_finish_canonical (GCObject **ptr, SgenGrayQueue *queue) { major_copy_or_mark_object_no_evacuation (ptr, *ptr, queue); } @@ -1259,7 +1259,7 @@ mark_pinned_objects_in_block (MSBlockInfo *block, size_t first_entry, size_t las for (; entry < end; ++entry) { int index = MS_BLOCK_OBJ_INDEX (*entry, block); - char *obj; + GCObject *obj; SGEN_ASSERT (9, index >= 0 && index < MS_BLOCK_FREE / block->obj_size, "invalid object %p index %d max-index %d", *entry, index, (int)(MS_BLOCK_FREE / block->obj_size)); if (index == last_index) continue; @@ -1689,9 +1689,9 @@ static int count_nonpinned_ref; static int count_nonpinned_nonref; static void -count_nonpinned_callback (char *obj, size_t size, void *data) +count_nonpinned_callback (GCObject *obj, size_t size, void *data) { - GCVTable vtable = (GCVTable)LOAD_VTABLE (obj); + GCVTable vtable = LOAD_VTABLE (obj); if (SGEN_VTABLE_HAS_REFERENCES (vtable)) ++count_nonpinned_ref; @@ -1700,9 +1700,9 @@ count_nonpinned_callback (char *obj, size_t size, void *data) } static void -count_pinned_callback (char *obj, size_t size, void *data) +count_pinned_callback (GCObject *obj, size_t size, void *data) { - GCVTable vtable = (GCVTable)LOAD_VTABLE (obj); + GCVTable vtable = LOAD_VTABLE (obj); if (SGEN_VTABLE_HAS_REFERENCES (vtable)) ++count_pinned_ref; @@ -2283,12 +2283,14 @@ scan_card_table_for_block (MSBlockInfo *block, gboolean mod_union, ScanCopyConte goto next_object; } + GCObject *object = (GCObject*)obj; + if (small_objects) { HEAVY_STAT (++scanned_objects); - scan_func (obj, sgen_obj_get_descriptor (obj), queue); + scan_func (object, sgen_obj_get_descriptor (object), queue); } else { size_t offset = sgen_card_table_get_card_offset (obj, block_start); - sgen_cardtable_scan_object (obj, block_obj_size, card_base + offset, mod_union, ctx); + sgen_cardtable_scan_object (object, block_obj_size, card_base + offset, mod_union, ctx); } next_object: obj += block_obj_size; @@ -2462,7 +2464,7 @@ sgen_marksweep_init_internal (SgenMajorCollector *collector, gboolean is_concurr collector->iterate_live_block_ranges = (void*)(void*) major_iterate_live_block_ranges; if (is_concurrent) { collector->update_cardtable_mod_union = update_cardtable_mod_union; - collector->get_cardtable_mod_union_for_object = major_get_cardtable_mod_union_for_reference; + collector->get_cardtable_mod_union_for_reference = major_get_cardtable_mod_union_for_reference; } collector->init_to_space = major_init_to_space; collector->sweep = major_sweep; @@ -2477,7 +2479,7 @@ sgen_marksweep_init_internal (SgenMajorCollector *collector, gboolean is_concurr collector->start_major_collection = major_start_major_collection; collector->finish_major_collection = major_finish_major_collection; collector->ptr_is_in_non_pinned_space = major_ptr_is_in_non_pinned_space; - collector->obj_is_from_pinned_alloc = obj_is_from_pinned_alloc; + collector->ptr_is_from_pinned_alloc = ptr_is_from_pinned_alloc; collector->report_pinned_memory_usage = major_report_pinned_memory_usage; collector->get_num_major_sections = get_num_major_sections; collector->get_bytes_survived_last_sweep = get_bytes_survived_last_sweep; diff --git a/mono/sgen/sgen-minor-copy-object.h b/mono/sgen/sgen-minor-copy-object.h index 28c7629448a..49b42265c7a 100644 --- a/mono/sgen/sgen-minor-copy-object.h +++ b/mono/sgen/sgen-minor-copy-object.h @@ -47,11 +47,11 @@ extern guint64 stat_nursery_copy_object_failed_to_space; /* from sgen-gc.c */ */ static MONO_ALWAYS_INLINE void -SERIAL_COPY_OBJECT (void **obj_slot, SgenGrayQueue *queue) +SERIAL_COPY_OBJECT (GCObject **obj_slot, SgenGrayQueue *queue) { - char *forwarded; - char *copy; - char *obj = *obj_slot; + GCObject *forwarded; + GCObject *copy; + GCObject *obj = *obj_slot; SGEN_ASSERT (9, current_collection_generation == GENERATION_NURSERY, "calling minor-serial-copy from a %d generation collection", current_collection_generation); @@ -78,7 +78,7 @@ SERIAL_COPY_OBJECT (void **obj_slot, SgenGrayQueue *queue) return; } if (G_UNLIKELY (SGEN_OBJECT_IS_PINNED (obj))) { - SGEN_ASSERT (9, sgen_vtable_get_descriptor ((GCVTable)SGEN_LOAD_VTABLE(obj)), "pinned object %p has no gc descriptor", obj); + SGEN_ASSERT (9, sgen_vtable_get_descriptor (SGEN_LOAD_VTABLE(obj)), "pinned object %p has no gc descriptor", obj); SGEN_LOG (9, " (pinned, no change)"); HEAVY_STAT (++stat_nursery_copy_object_failed_pinned); return; @@ -86,7 +86,7 @@ SERIAL_COPY_OBJECT (void **obj_slot, SgenGrayQueue *queue) #ifndef SGEN_SIMPLE_NURSERY if (sgen_nursery_is_to_space (obj)) { - SGEN_ASSERT (9, sgen_vtable_get_descriptor ((GCVTable)SGEN_LOAD_VTABLE(obj)), "to space object %p has no gc descriptor", obj); + SGEN_ASSERT (9, sgen_vtable_get_descriptor (SGEN_LOAD_VTABLE(obj)), "to space object %p has no gc descriptor", obj); SGEN_LOG (9, " (tospace, no change)"); HEAVY_STAT (++stat_nursery_copy_object_failed_to_space); return; @@ -105,11 +105,11 @@ SERIAL_COPY_OBJECT (void **obj_slot, SgenGrayQueue *queue) * Similar to SERIAL_COPY_OBJECT, but assumes that OBJ_SLOT is part of an object, so it handles global remsets as well. */ static MONO_ALWAYS_INLINE void -SERIAL_COPY_OBJECT_FROM_OBJ (void **obj_slot, SgenGrayQueue *queue) +SERIAL_COPY_OBJECT_FROM_OBJ (GCObject **obj_slot, SgenGrayQueue *queue) { - char *forwarded; - char *obj = *obj_slot; - void *copy; + GCObject *forwarded; + GCObject *obj = *obj_slot; + GCObject *copy; SGEN_ASSERT (9, current_collection_generation == GENERATION_NURSERY, "calling minor-serial-copy-from-obj from a %d generation collection", current_collection_generation); @@ -140,7 +140,7 @@ SERIAL_COPY_OBJECT_FROM_OBJ (void **obj_slot, SgenGrayQueue *queue) return; } if (G_UNLIKELY (SGEN_OBJECT_IS_PINNED (obj))) { - SGEN_ASSERT (9, sgen_vtable_get_descriptor ((GCVTable)SGEN_LOAD_VTABLE(obj)), "pinned object %p has no gc descriptor", obj); + SGEN_ASSERT (9, sgen_vtable_get_descriptor (SGEN_LOAD_VTABLE(obj)), "pinned object %p has no gc descriptor", obj); SGEN_LOG (9, " (pinned, no change)"); HEAVY_STAT (++stat_nursery_copy_object_failed_pinned); if (!sgen_ptr_in_nursery (obj_slot) && !SGEN_OBJECT_IS_CEMENTED (obj)) @@ -151,7 +151,7 @@ SERIAL_COPY_OBJECT_FROM_OBJ (void **obj_slot, SgenGrayQueue *queue) #ifndef SGEN_SIMPLE_NURSERY if (sgen_nursery_is_to_space (obj)) { /* FIXME: all of these could just use `sgen_obj_get_descriptor_safe()` */ - SGEN_ASSERT (9, sgen_vtable_get_descriptor ((GCVTable)SGEN_LOAD_VTABLE(obj)), "to space object %p has no gc descriptor", obj); + SGEN_ASSERT (9, sgen_vtable_get_descriptor (SGEN_LOAD_VTABLE(obj)), "to space object %p has no gc descriptor", obj); SGEN_LOG (9, " (tospace, no change)"); HEAVY_STAT (++stat_nursery_copy_object_failed_to_space); diff --git a/mono/sgen/sgen-minor-scan-object.h b/mono/sgen/sgen-minor-scan-object.h index efe782f058a..5bd452578d9 100644 --- a/mono/sgen/sgen-minor-scan-object.h +++ b/mono/sgen/sgen-minor-scan-object.h @@ -46,8 +46,10 @@ extern guint64 stat_scan_object_called_nursery; } while (0) static void -SERIAL_SCAN_OBJECT (char *start, mword desc, SgenGrayQueue *queue) +SERIAL_SCAN_OBJECT (GCObject *object, mword desc, SgenGrayQueue *queue) { + char *start = (char*)object; + SGEN_OBJECT_LAYOUT_STATISTICS_DECLARE_BITMAP; #ifdef HEAVY_STATISTICS @@ -64,7 +66,7 @@ SERIAL_SCAN_OBJECT (char *start, mword desc, SgenGrayQueue *queue) } static void -SERIAL_SCAN_VTYPE (char *full_object, char *start, mword desc, SgenGrayQueue *queue BINARY_PROTOCOL_ARG (size_t size)) +SERIAL_SCAN_VTYPE (GCObject *full_object, char *start, mword desc, SgenGrayQueue *queue BINARY_PROTOCOL_ARG (size_t size)) { SGEN_OBJECT_LAYOUT_STATISTICS_DECLARE_BITMAP; diff --git a/mono/sgen/sgen-nursery-allocator.c b/mono/sgen/sgen-nursery-allocator.c index e680cefa5a1..dc6152c77e7 100644 --- a/mono/sgen/sgen-nursery-allocator.c +++ b/mono/sgen/sgen-nursery-allocator.c @@ -753,7 +753,7 @@ sgen_build_nursery_fragments (GCMemSection *nursery_section, SgenGrayQueue *unpi if (addr0 < addr1) { if (unpin_queue) - GRAY_OBJECT_ENQUEUE (unpin_queue, addr0, sgen_obj_get_descriptor_safe (addr0)); + GRAY_OBJECT_ENQUEUE (unpin_queue, (GCObject*)addr0, sgen_obj_get_descriptor_safe ((GCObject*)addr0)); else SGEN_UNPIN_OBJECT (addr0); size = SGEN_ALIGN_UP (sgen_safe_object_get_size ((GCObject*)addr0)); diff --git a/mono/sgen/sgen-pinning-stats.c b/mono/sgen/sgen-pinning-stats.c index f245c5fb2c4..546f895583c 100644 --- a/mono/sgen/sgen-pinning-stats.c +++ b/mono/sgen/sgen-pinning-stats.c @@ -116,8 +116,9 @@ sgen_pin_stats_register_address (char *addr, int pin_type) } static void -pin_stats_count_object_from_tree (char *obj, size_t size, PinStatAddress *node, int *pin_types) +pin_stats_count_object_from_tree (GCObject *object, size_t size, PinStatAddress *node, int *pin_types) { + char *obj = (char*)object; if (!node) return; if (node->addr >= obj && node->addr < obj + size) { @@ -131,9 +132,9 @@ pin_stats_count_object_from_tree (char *obj, size_t size, PinStatAddress *node, } } if (obj < node->addr) - pin_stats_count_object_from_tree (obj, size, node->left, pin_types); + pin_stats_count_object_from_tree (object, size, node->left, pin_types); if (obj + size - 1 > node->addr) - pin_stats_count_object_from_tree (obj, size, node->right, pin_types); + pin_stats_count_object_from_tree (object, size, node->right, pin_types); } static gpointer @@ -169,7 +170,7 @@ register_vtable (GCVTable vtable, int pin_types) } void -sgen_pin_stats_register_object (char *obj, size_t size) +sgen_pin_stats_register_object (GCObject *obj, size_t size) { int pin_types = 0; @@ -180,11 +181,11 @@ sgen_pin_stats_register_object (char *obj, size_t size) sgen_pointer_queue_add (&pinned_objects, obj); if (pin_types) - register_vtable ((GCVTable)SGEN_LOAD_VTABLE (obj), pin_types); + register_vtable (SGEN_LOAD_VTABLE (obj), pin_types); } void -sgen_pin_stats_register_global_remset (char *obj) +sgen_pin_stats_register_global_remset (GCObject *obj) { GlobalRemsetClassEntry empty_entry; GlobalRemsetClassEntry *entry; @@ -193,7 +194,7 @@ sgen_pin_stats_register_global_remset (char *obj) return; memset (&empty_entry, 0, sizeof (GlobalRemsetClassEntry)); - entry = lookup_vtable_entry (&global_remset_class_hash_table, (GCVTable)SGEN_LOAD_VTABLE (obj), &empty_entry); + entry = lookup_vtable_entry (&global_remset_class_hash_table, SGEN_LOAD_VTABLE (obj), &empty_entry); ++entry->num_remsets; } diff --git a/mono/sgen/sgen-pinning.c b/mono/sgen/sgen-pinning.c index 6d122f8ab39..fc0ba0bbdf6 100644 --- a/mono/sgen/sgen-pinning.c +++ b/mono/sgen/sgen-pinning.c @@ -180,7 +180,7 @@ sgen_dump_pin_queue (void) typedef struct _CementHashEntry CementHashEntry; struct _CementHashEntry { - char *obj; + GCObject *obj; unsigned int count; }; @@ -202,7 +202,7 @@ sgen_cement_reset (void) } gboolean -sgen_cement_lookup (char *obj) +sgen_cement_lookup (GCObject *obj) { guint hv = sgen_aligned_addr_hash (obj); int i = SGEN_CEMENT_HASH (hv); @@ -221,7 +221,7 @@ sgen_cement_lookup (char *obj) } gboolean -sgen_cement_lookup_or_register (char *obj) +sgen_cement_lookup_or_register (GCObject *obj) { guint hv; int i; @@ -252,7 +252,7 @@ sgen_cement_lookup_or_register (char *obj) SGEN_CEMENT_OBJECT (obj); binary_protocol_cement (obj, (gpointer)SGEN_LOAD_VTABLE (obj), - (int)sgen_safe_object_get_size ((GCObject*)obj)); + (int)sgen_safe_object_get_size (obj)); } return FALSE; diff --git a/mono/sgen/sgen-pinning.h b/mono/sgen/sgen-pinning.h index dd8051fbdef..e7f1e288f81 100644 --- a/mono/sgen/sgen-pinning.h +++ b/mono/sgen/sgen-pinning.h @@ -56,8 +56,8 @@ void sgen_pin_stats_reset (void); void sgen_cement_init (gboolean enabled); void sgen_cement_reset (void); -gboolean sgen_cement_lookup (char *obj); -gboolean sgen_cement_lookup_or_register (char *obj); +gboolean sgen_cement_lookup (GCObject *obj); +gboolean sgen_cement_lookup_or_register (GCObject *obj); void sgen_pin_cemented_objects (void); void sgen_cement_clear_below_threshold (void); diff --git a/mono/sgen/sgen-scan-object.h b/mono/sgen/sgen-scan-object.h index 9d1611c22c3..b7f97364631 100644 --- a/mono/sgen/sgen-scan-object.h +++ b/mono/sgen/sgen-scan-object.h @@ -46,7 +46,7 @@ { #ifndef SCAN_OBJECT_NOVTABLE #if defined(SGEN_HEAVY_BINARY_PROTOCOL) && defined(SCAN_OBJECT_PROTOCOL) - binary_protocol_scan_begin (start, SGEN_LOAD_VTABLE (start), sgen_safe_object_get_size ((GCObject*)start)); + binary_protocol_scan_begin ((GCObject*)start, SGEN_LOAD_VTABLE ((GCObject*)start), sgen_safe_object_get_size ((GCObject*)start)); #endif #else #if defined(SGEN_HEAVY_BINARY_PROTOCOL) && defined(SCAN_OBJECT_PROTOCOL) @@ -55,21 +55,21 @@ #endif switch (desc & DESC_TYPE_MASK) { case DESC_TYPE_RUN_LENGTH: -#define SCAN OBJ_RUN_LEN_FOREACH_PTR (desc, start) +#define SCAN OBJ_RUN_LEN_FOREACH_PTR (desc, ((GCObject*)start)) #ifndef SCAN_OBJECT_NOSCAN SCAN; #endif #undef SCAN break; case DESC_TYPE_VECTOR: -#define SCAN OBJ_VECTOR_FOREACH_PTR (desc, start) +#define SCAN OBJ_VECTOR_FOREACH_PTR (desc, ((GCObject*)start)) #ifndef SCAN_OBJECT_NOSCAN SCAN; #endif #undef SCAN break; case DESC_TYPE_BITMAP: -#define SCAN OBJ_BITMAP_FOREACH_PTR (desc, start) +#define SCAN OBJ_BITMAP_FOREACH_PTR (desc, ((GCObject*)start)) #ifndef SCAN_OBJECT_NOSCAN SCAN; #endif @@ -77,7 +77,7 @@ break; case DESC_TYPE_COMPLEX: /* this is a complex object */ -#define SCAN OBJ_COMPLEX_FOREACH_PTR (desc, start) +#define SCAN OBJ_COMPLEX_FOREACH_PTR (desc, ((GCObject*)start)) #ifndef SCAN_OBJECT_NOSCAN SCAN; #endif @@ -86,7 +86,7 @@ #ifndef SCAN_OBJECT_NOVTABLE case DESC_TYPE_COMPLEX_ARR: /* this is an array of complex structs */ -#define SCAN OBJ_COMPLEX_ARR_FOREACH_PTR (desc, start) +#define SCAN OBJ_COMPLEX_ARR_FOREACH_PTR (desc, ((GCObject*)start)) #ifndef SCAN_OBJECT_NOSCAN SCAN; #endif diff --git a/mono/sgen/sgen-simple-nursery.c b/mono/sgen/sgen-simple-nursery.c index f0827a95069..d1497f6e18a 100644 --- a/mono/sgen/sgen-simple-nursery.c +++ b/mono/sgen/sgen-simple-nursery.c @@ -31,7 +31,7 @@ #include "mono/sgen/sgen-client.h" static inline char* -alloc_for_promotion (GCVTable vtable, char *obj, size_t objsize, gboolean has_references) +alloc_for_promotion (GCVTable vtable, GCObject *obj, size_t objsize, gboolean has_references) { return major_collector.alloc_object (vtable, objsize, has_references); } diff --git a/mono/sgen/sgen-split-nursery.c b/mono/sgen/sgen-split-nursery.c index 7ef988e368f..d323acaa872 100644 --- a/mono/sgen/sgen-split-nursery.c +++ b/mono/sgen/sgen-split-nursery.c @@ -148,9 +148,9 @@ static AgeAllocationBuffer age_alloc_buffers [MAX_AGE]; static SgenFragmentAllocator collector_allocator; static inline int -get_object_age (char *object) +get_object_age (GCObject *object) { - size_t idx = (object - sgen_nursery_start) >> SGEN_TO_SPACE_GRANULE_BITS; + size_t idx = ((char*)object - sgen_nursery_start) >> SGEN_TO_SPACE_GRANULE_BITS; return region_age [idx]; } @@ -259,7 +259,7 @@ alloc_for_promotion_slow_path (int age, size_t objsize) } static inline char* -alloc_for_promotion (GCVTable vtable, char *obj, size_t objsize, gboolean has_references) +alloc_for_promotion (GCVTable vtable, GCObject *obj, size_t objsize, gboolean has_references) { char *p = NULL; int age; @@ -287,7 +287,7 @@ alloc_for_promotion (GCVTable vtable, char *obj, size_t objsize, gboolean has_re } static char* -minor_alloc_for_promotion (GCVTable vtable, char *obj, size_t objsize, gboolean has_references) +minor_alloc_for_promotion (GCVTable vtable, GCObject *obj, size_t objsize, gboolean has_references) { /* We only need to check for a non-nursery object if we're doing a major collection. diff --git a/mono/sgen/sgen-workers.c b/mono/sgen/sgen-workers.c index 613f332cca4..b2623429847 100644 --- a/mono/sgen/sgen-workers.c +++ b/mono/sgen/sgen-workers.c @@ -227,7 +227,7 @@ workers_get_work (WorkerData *data) } static void -concurrent_enqueue_check (char *obj) +concurrent_enqueue_check (GCObject *obj) { g_assert (sgen_concurrent_collection_in_progress ()); g_assert (!sgen_ptr_in_nursery (obj)); -- 2.25.1