[sgen] Make GCVTable type opaque, not a pointer.

diff --git a/mono/metadata/sgen-client-mono.h b/mono/metadata/sgen-client-mono.h
index eb52ac990f34625a2e2b49552776b62c65363de9..6a8b0745b495bfcace9dbc1384bcee1accdd63ad 100644 (file)
--- a/mono/metadata/sgen-client-mono.h
+++ b/mono/metadata/sgen-client-mono.h
@@ -25,19 +25,19 @@
 #include "metadata/object-internals.h"
 
 typedef MonoObject GCObject;
-typedef MonoVTable GCVTable;
+typedef MonoVTable* GCVTable;
 
-/* FIXME: This should return a GCVTable* and be a function. */
+/* FIXME: This should return a GCVTable and be a function. */
 #define SGEN_LOAD_VTABLE_UNCHECKED(obj)        ((void*)(((GCObject*)(obj))->vtable))
 
 static inline mword
-sgen_vtable_get_descriptor (GCVTable *vtable)
+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)
+sgen_client_slow_object_get_size (GCVTable vtable, GCObject* o)
 {
        MonoClass *klass = ((MonoVTable*)vtable)->klass;
 
@@ -68,7 +68,7 @@ sgen_client_slow_object_get_size (GCVTable *vtable, GCObject* o)
  * collector.
  */
 static MONO_NEVER_INLINE mword
-sgen_client_par_object_get_size (GCVTable *vtable, GCObject* o)
+sgen_client_par_object_get_size (GCVTable vtable, GCObject* o)
 {
        mword descr = sgen_vtable_get_descriptor (vtable);
        mword type = descr & DESC_TYPE_MASK;
@@ -167,7 +167,7 @@ enum {
 #define SGEN_CLIENT_MINIMUM_OBJECT_SIZE                SGEN_CLIENT_OBJECT_HEADER_SIZE
 
 static MONO_ALWAYS_INLINE size_t G_GNUC_UNUSED
-sgen_client_array_element_size (GCVTable *gc_vtable)
+sgen_client_array_element_size (GCVTable gc_vtable)
 {
        MonoVTable *vt = (MonoVTable*)gc_vtable;
        return mono_array_element_size (vt->klass);
@@ -192,14 +192,14 @@ sgen_client_object_is_array_fill (GCObject *o)
 }
 
 static MONO_ALWAYS_INLINE void G_GNUC_UNUSED
-sgen_client_pre_copy_checks (char *destination, GCVTable *gc_vtable, void *obj, mword objsize)
+sgen_client_pre_copy_checks (char *destination, GCVTable gc_vtable, void *obj, mword objsize)
 {
        MonoVTable *vt = (MonoVTable*)gc_vtable;
        SGEN_ASSERT (9, vt->klass->inited, "vtable %p for class %s:%s was not initialized", vt, vt->klass->name_space, vt->klass->name);
 }
 
 static MONO_ALWAYS_INLINE void G_GNUC_UNUSED
-sgen_client_update_copied_object (char *destination, GCVTable *gc_vtable, void *obj, mword objsize)
+sgen_client_update_copied_object (char *destination, GCVTable gc_vtable, void *obj, mword objsize)
 {
        MonoVTable *vt = (MonoVTable*)gc_vtable;
        if (G_UNLIKELY (vt->rank && ((MonoArray*)obj)->bounds)) {
@@ -247,8 +247,8 @@ sgen_client_object_has_critical_finalizer (GCObject *obj)
        return mono_class_has_parent_fast (class, mono_defaults.critical_finalizer_object);
 }
 
-const char* sgen_client_vtable_get_namespace (GCVTable *vtable);
-const char* sgen_client_vtable_get_name (GCVTable *vtable);
+const char* sgen_client_vtable_get_namespace (GCVTable vtable);
+const char* sgen_client_vtable_get_name (GCVTable vtable);
 
 static gboolean G_GNUC_UNUSED
 sgen_client_bridge_need_processing (void)
@@ -568,7 +568,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 ? (GCVTable)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 9050c3b1d2f9d45bfaa907bc35d4c83330e5dc5d..cae0c9235def7273b55adf7ceeaa6bb48dd8f756 100644 (file)
--- a/mono/metadata/sgen-mono.c
+++ b/mono/metadata/sgen-mono.c
@@ -354,9 +354,9 @@ mono_gc_get_write_barrier (void)
  */
 
 /* Vtable of the objects used to fill out nursery fragments before a collection */
-static GCVTable *array_fill_vtable;
+static GCVTable array_fill_vtable;
 
-static GCVTable*
+static GCVTable
 get_array_fill_vtable (void)
 {
        if (!array_fill_vtable) {
@@ -379,7 +379,7 @@ get_array_fill_vtable (void)
                vtable->gc_descr = mono_gc_make_descr_for_array (TRUE, &bmap, 0, 1);
                vtable->rank = 1;
 
-               array_fill_vtable = (GCVTable*)vtable;
+               array_fill_vtable = vtable;
        }
        return array_fill_vtable;
 }
@@ -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 = (GCVTable)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));
@@ -1595,7 +1595,7 @@ sgen_client_cardtable_scan_object (char *obj, mword block_obj_size, guint8 *card
        MonoVTable *vt = (MonoVTable*)SGEN_LOAD_VTABLE (obj);
        MonoClass *klass = vt->klass;
 
-       SGEN_ASSERT (0, SGEN_VTABLE_HAS_REFERENCES ((GCVTable*)vt), "Why would we ever call this on reference-free objects?");
+       SGEN_ASSERT (0, SGEN_VTABLE_HAS_REFERENCES (vt), "Why would we ever call this on reference-free objects?");
 
        if (vt->rank) {
                guint8 *card_data, *card_base;
@@ -1716,7 +1716,7 @@ mono_gc_alloc_vector (MonoVTable *vtable, size_t size, uintptr_t max_length)
 
 #ifndef DISABLE_CRITICAL_REGION
        ENTER_CRITICAL_REGION;
-       arr = sgen_try_alloc_obj_nolock ((GCVTable*)vtable, size);
+       arr = sgen_try_alloc_obj_nolock (vtable, size);
        if (arr) {
                /*This doesn't require fencing since EXIT_CRITICAL_REGION already does it for us*/
                arr->max_length = (mono_array_size_t)max_length;
@@ -1728,7 +1728,7 @@ mono_gc_alloc_vector (MonoVTable *vtable, size_t size, uintptr_t max_length)
 
        LOCK_GC;
 
-       arr = sgen_alloc_obj_nolock ((GCVTable*)vtable, size);
+       arr = sgen_alloc_obj_nolock (vtable, size);
        if (G_UNLIKELY (!arr)) {
                UNLOCK_GC;
                return mono_gc_out_of_memory (size);
@@ -1742,7 +1742,7 @@ mono_gc_alloc_vector (MonoVTable *vtable, size_t size, uintptr_t max_length)
        if (G_UNLIKELY (alloc_events))
                mono_profiler_allocation (&arr->obj);
 
-       SGEN_ASSERT (6, SGEN_ALIGN_UP (size) == SGEN_ALIGN_UP (sgen_client_par_object_get_size ((GCVTable*)vtable, (GCObject*)arr)), "Vector has incorrect size.");
+       SGEN_ASSERT (6, SGEN_ALIGN_UP (size) == SGEN_ALIGN_UP (sgen_client_par_object_get_size (vtable, (GCObject*)arr)), "Vector has incorrect size.");
        return arr;
 }
 
@@ -1758,7 +1758,7 @@ mono_gc_alloc_array (MonoVTable *vtable, size_t size, uintptr_t max_length, uint
 
 #ifndef DISABLE_CRITICAL_REGION
        ENTER_CRITICAL_REGION;
-       arr = sgen_try_alloc_obj_nolock ((GCVTable*)vtable, size);
+       arr = sgen_try_alloc_obj_nolock (vtable, size);
        if (arr) {
                /*This doesn't require fencing since EXIT_CRITICAL_REGION already does it for us*/
                arr->max_length = (mono_array_size_t)max_length;
@@ -1773,7 +1773,7 @@ mono_gc_alloc_array (MonoVTable *vtable, size_t size, uintptr_t max_length, uint
 
        LOCK_GC;
 
-       arr = sgen_alloc_obj_nolock ((GCVTable*)vtable, size);
+       arr = sgen_alloc_obj_nolock (vtable, size);
        if (G_UNLIKELY (!arr)) {
                UNLOCK_GC;
                return mono_gc_out_of_memory (size);
@@ -1790,7 +1790,7 @@ mono_gc_alloc_array (MonoVTable *vtable, size_t size, uintptr_t max_length, uint
        if (G_UNLIKELY (alloc_events))
                mono_profiler_allocation (&arr->obj);
 
-       SGEN_ASSERT (6, SGEN_ALIGN_UP (size) == SGEN_ALIGN_UP (sgen_client_par_object_get_size ((GCVTable*)vtable, (GCObject*)arr)), "Array has incorrect size.");
+       SGEN_ASSERT (6, SGEN_ALIGN_UP (size) == SGEN_ALIGN_UP (sgen_client_par_object_get_size (vtable, (GCObject*)arr)), "Array has incorrect size.");
        return arr;
 }
 
@@ -1805,7 +1805,7 @@ mono_gc_alloc_string (MonoVTable *vtable, size_t size, gint32 len)
 
 #ifndef DISABLE_CRITICAL_REGION
        ENTER_CRITICAL_REGION;
-       str = sgen_try_alloc_obj_nolock ((GCVTable*)vtable, size);
+       str = sgen_try_alloc_obj_nolock (vtable, size);
        if (str) {
                /*This doesn't require fencing since EXIT_CRITICAL_REGION already does it for us*/
                str->length = len;
@@ -1817,7 +1817,7 @@ mono_gc_alloc_string (MonoVTable *vtable, size_t size, gint32 len)
 
        LOCK_GC;
 
-       str = sgen_alloc_obj_nolock ((GCVTable*)vtable, size);
+       str = sgen_alloc_obj_nolock (vtable, size);
        if (G_UNLIKELY (!str)) {
                UNLOCK_GC;
                return mono_gc_out_of_memory (size);
@@ -2707,23 +2707,20 @@ sgen_client_pre_collection_checks (void)
 }
 
 gboolean
-sgen_client_vtable_is_inited (GCVTable *gc_vtable)
+sgen_client_vtable_is_inited (MonoVTable *vt)
 {
-       MonoVTable *vt = (MonoVTable*)gc_vtable;
        return vt->klass->inited;
 }
 
 const char*
-sgen_client_vtable_get_namespace (GCVTable *gc_vtable)
+sgen_client_vtable_get_namespace (MonoVTable *vt)
 {
-       MonoVTable *vt = (MonoVTable*)gc_vtable;
        return vt->klass->name_space;
 }
 
 const char*
-sgen_client_vtable_get_name (GCVTable *gc_vtable)
+sgen_client_vtable_get_name (MonoVTable *vt)
 {
-       MonoVTable *vt = (MonoVTable*)gc_vtable;
        return vt->klass->name;
 }
 

diff --git a/mono/metadata/sgen-new-bridge.c b/mono/metadata/sgen-new-bridge.c
index 38997535e5e8190619825563aded2e78580cceda..86c0faa37cd4ae3848ed150486cc1832dac021ef 100644 (file)
--- a/mono/metadata/sgen-new-bridge.c
+++ b/mono/metadata/sgen-new-bridge.c
@@ -1325,7 +1325,7 @@ processing_after_callback (int generation)
        if (bridge_accounting_enabled) {
                for (i = 0; i < num_sccs; ++i) {
                        for (j = 0; j < api_sccs [i]->num_objs; ++j) {
-                               GCVTable *vtable = SGEN_LOAD_VTABLE (api_sccs [i]->objs [j]);
+                               GCVTable vtable = SGEN_LOAD_VTABLE (api_sccs [i]->objs [j]);
                                mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_GC,
                                        "OBJECT %s (%p) SCC [%d] %s",
                                                sgen_client_vtable_get_namespace (vtable), sgen_client_vtable_get_name (vtable), api_sccs [i]->objs [j],

diff --git a/mono/metadata/sgen-old-bridge.c b/mono/metadata/sgen-old-bridge.c
index 2cef968485d4b0c88cc3488fab635ff2c9b73e57..084c017b4cecdca4305413c0fa84efaddc7855bc 100644 (file)
--- a/mono/metadata/sgen-old-bridge.c
+++ b/mono/metadata/sgen-old-bridge.c
@@ -884,7 +884,7 @@ processing_after_callback (int generation)
        if (bridge_accounting_enabled) {
                for (i = 0; i < num_sccs; ++i) {
                        for (j = 0; j < api_sccs [i]->num_objs; ++j) {
-                               GCVTable *vtable = SGEN_LOAD_VTABLE (api_sccs [i]->objs [j]);
+                               GCVTable vtable = SGEN_LOAD_VTABLE (api_sccs [i]->objs [j]);
                                mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_GC,
                                        "OBJECT %s.%s (%p) SCC [%d] %s",
                                                sgen_client_vtable_get_namespace (vtable), sgen_client_vtable_get_name (vtable), api_sccs [i]->objs [j],

diff --git a/mono/metadata/sgen-tarjan-bridge.c b/mono/metadata/sgen-tarjan-bridge.c
index 270b091e0efdca8a45345d0a9d48f738c64647d9..54e3f01200a8d6373c60251d5e16a49d4c23b7ee 100644 (file)
--- 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 = (GCVTable)SGEN_LOAD_VTABLE (obj);
        return vt->klass->name;
 }
 

diff --git a/mono/sgen/sgen-alloc.c b/mono/sgen/sgen-alloc.c
index ac017ddf3143152ac07bf4b86fbcc17e80e88b69..d7234830fbe38f35504f5545878706ecbda1fe9b 100644 (file)
--- a/mono/sgen/sgen-alloc.c
+++ b/mono/sgen/sgen-alloc.c
@@ -94,7 +94,7 @@ static __thread char **tlab_next_addr MONO_ATTR_USED;
 #endif
 
 static void*
-alloc_degraded (GCVTable *vtable, size_t size, gboolean for_mature)
+alloc_degraded (GCVTable vtable, size_t size, gboolean for_mature)
 {
        void *p;
 
@@ -146,7 +146,7 @@ zero_tlab_if_necessary (void *p, size_t size)
  * a search for the pinned object in SGEN_SCAN_START_SIZE chunks.
  */
 void*
-sgen_alloc_obj_nolock (GCVTable *vtable, size_t size)
+sgen_alloc_obj_nolock (GCVTable vtable, size_t size)
 {
        /* FIXME: handle OOM */
        void **p;
@@ -330,7 +330,7 @@ sgen_alloc_obj_nolock (GCVTable *vtable, size_t size)
 }
 
 void*
-sgen_try_alloc_obj_nolock (GCVTable *vtable, size_t size)
+sgen_try_alloc_obj_nolock (GCVTable vtable, size_t size)
 {
        void **p;
        char *new_next;
@@ -418,7 +418,7 @@ sgen_try_alloc_obj_nolock (GCVTable *vtable, size_t size)
 }
 
 void*
-sgen_alloc_obj (GCVTable *vtable, size_t size)
+sgen_alloc_obj (GCVTable vtable, size_t size)
 {
        void *res;
        TLAB_ACCESS_INIT;
@@ -446,7 +446,7 @@ sgen_alloc_obj (GCVTable *vtable, size_t size)
        }
 
        ENTER_CRITICAL_REGION;
-       res = sgen_try_alloc_obj_nolock ((GCVTable*)vtable, size);
+       res = sgen_try_alloc_obj_nolock (vtable, size);
        if (res) {
                EXIT_CRITICAL_REGION;
                return res;
@@ -454,7 +454,7 @@ sgen_alloc_obj (GCVTable *vtable, size_t size)
        EXIT_CRITICAL_REGION;
 #endif
        LOCK_GC;
-       res = sgen_alloc_obj_nolock ((GCVTable*)vtable, size);
+       res = sgen_alloc_obj_nolock (vtable, size);
        UNLOCK_GC;
        if (G_UNLIKELY (!res))
                sgen_client_out_of_memory (size);
@@ -466,7 +466,7 @@ sgen_alloc_obj (GCVTable *vtable, size_t size)
  * We may want to explicitly free these objects.
  */
 void*
-sgen_alloc_obj_pinned (GCVTable *vtable, size_t size)
+sgen_alloc_obj_pinned (GCVTable vtable, size_t size)
 {
        void **p;
 
@@ -478,10 +478,10 @@ sgen_alloc_obj_pinned (GCVTable *vtable, size_t size)
 
        if (size > SGEN_MAX_SMALL_OBJ_SIZE) {
                /* large objects are always pinned anyway */
-               p = sgen_los_alloc_large_inner ((GCVTable*)vtable, size);
+               p = sgen_los_alloc_large_inner (vtable, size);
        } else {
                SGEN_ASSERT (9, sgen_client_vtable_is_inited (vtable), "class %s:%s is not initialized", sgen_client_vtable_get_namespace (vtable), sgen_client_vtable_get_name (vtable));
-               p = major_collector.alloc_small_pinned_obj ((GCVTable*)vtable, size, SGEN_VTABLE_HAS_REFERENCES ((GCVTable*)vtable));
+               p = major_collector.alloc_small_pinned_obj (vtable, size, SGEN_VTABLE_HAS_REFERENCES (vtable));
        }
        if (G_LIKELY (p)) {
                SGEN_LOG (6, "Allocated pinned object %p, vtable: %p (%s), size: %zd", p, vtable, sgen_client_vtable_get_name (vtable), size);
@@ -492,7 +492,7 @@ sgen_alloc_obj_pinned (GCVTable *vtable, size_t size)
 }
 
 void*
-sgen_alloc_obj_mature (GCVTable *vtable, size_t size)
+sgen_alloc_obj_mature (GCVTable vtable, size_t size)
 {
        void *res;
 
@@ -501,7 +501,7 @@ sgen_alloc_obj_mature (GCVTable *vtable, size_t size)
        size = ALIGN_UP (size);
 
        LOCK_GC;
-       res = alloc_degraded ((GCVTable*)vtable, size, TRUE);
+       res = alloc_degraded (vtable, size, TRUE);
        UNLOCK_GC;
 
        return res;

diff --git a/mono/sgen/sgen-client.h b/mono/sgen/sgen-client.h
index 505edbdc3fb940b9660e905f332f0024d7447382..87ec690602681b940b0c6172b6c9c70f55fc7f2c 100644 (file)
--- a/mono/sgen/sgen-client.h
+++ b/mono/sgen/sgen-client.h
@@ -29,7 +29,7 @@ void sgen_client_init (void);
  * The slow path for getting an object's size.  We're passing in the vtable because we've
  * already fetched it.
  */
-mword sgen_client_slow_object_get_size (GCVTable *vtable, GCObject* o);
+mword sgen_client_slow_object_get_size (GCVTable vtable, GCObject* o);
 
 /*
  * Fill the given range with a dummy object.  If the range is too short to be filled with an
@@ -144,9 +144,9 @@ const char* sgen_client_description_for_internal_mem_type (int type);
 /*
  * Only used for debugging.  `sgen_client_vtable_get_namespace()` may return NULL.
  */
-gboolean sgen_client_vtable_is_inited (GCVTable *vtable);
-const char* sgen_client_vtable_get_namespace (GCVTable *vtable);
-const char* sgen_client_vtable_get_name (GCVTable *vtable);
+gboolean sgen_client_vtable_is_inited (GCVTable vtable);
+const char* sgen_client_vtable_get_namespace (GCVTable vtable);
+const char* sgen_client_vtable_get_name (GCVTable vtable);
 
 /*
  * Called before starting collections.  The world is already stopped.  No action is

diff --git a/mono/sgen/sgen-copy-object.h b/mono/sgen/sgen-copy-object.h
index 99fd0cc37ca36d3c4325b5925620c3d164e9b6be..dd6c002a2a122dbf16ac4d9ace370cd8b8a99626 100644 (file)
--- a/mono/sgen/sgen-copy-object.h
+++ b/mono/sgen/sgen-copy-object.h
@@ -35,7 +35,7 @@ extern guint64 stat_slots_allocated_in_vain;
  * anymore, which is the case in the parallel collector.
  */
 static MONO_ALWAYS_INLINE void
-par_copy_object_no_checks (char *destination, GCVTable *vt, void *obj, mword objsize, SgenGrayQueue *queue)
+par_copy_object_no_checks (char *destination, GCVTable vt, void *obj, mword objsize, SgenGrayQueue *queue)
 {
        sgen_client_pre_copy_checks (destination, vt, obj, objsize);
        binary_protocol_copy (obj, destination, vt, objsize);
@@ -60,7 +60,7 @@ par_copy_object_no_checks (char *destination, GCVTable *vt, void *obj, mword obj
 static MONO_NEVER_INLINE void*
 copy_object_no_checks (void *obj, SgenGrayQueue *queue)
 {
-       GCVTable *vt = SGEN_LOAD_VTABLE_UNCHECKED (obj);
+       GCVTable vt = SGEN_LOAD_VTABLE_UNCHECKED (obj);
        gboolean has_references = SGEN_VTABLE_HAS_REFERENCES (vt);
        mword objsize = SGEN_ALIGN_UP (sgen_client_par_object_get_size (vt, obj));
        /* FIXME: Does this not mark the newly allocated object? */

diff --git a/mono/sgen/sgen-debug.c b/mono/sgen/sgen-debug.c
index be53b493fdd8fa35ae4faaa69e7905f00f1a7559..6011bcc35a7c154f8d5afc1814a9f2ad31a515a7 100644 (file)
--- a/mono/sgen/sgen-debug.c
+++ b/mono/sgen/sgen-debug.c
@@ -67,7 +67,7 @@ static char* describe_nursery_ptr (char *ptr, gboolean need_setup);
 static void
 describe_pointer (char *ptr, gboolean need_setup)
 {
-       GCVTable *vtable;
+       GCVTable vtable;
        mword desc;
        int type;
        char *start;
@@ -80,7 +80,7 @@ describe_pointer (char *ptr, gboolean need_setup)
                if (!start)
                        return;
                ptr = start;
-               vtable = (GCVTable*)LOAD_VTABLE (ptr);
+               vtable = (GCVTable)LOAD_VTABLE (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 = (GCVTable)LOAD_VTABLE (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);
@@ -99,11 +99,11 @@ describe_pointer (char *ptr, gboolean need_setup)
                                printf ("Pointer inside oldspace.\n");
                        if (start)
                                ptr = start;
-                       vtable = (GCVTable*)major_collector.describe_pointer (ptr);
+                       vtable = (GCVTable)major_collector.describe_pointer (ptr);
                } else if (major_collector.obj_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 = (GCVTable)LOAD_VTABLE (ptr);
                } else {
                        printf ("Pointer unknown.\n");
                        return;
@@ -130,7 +130,7 @@ describe_pointer (char *ptr, gboolean need_setup)
        }
        printf ("Class: %s.%s\n", sgen_client_vtable_get_namespace (vtable), sgen_client_vtable_get_name (vtable));
 
-       desc = sgen_vtable_get_descriptor ((GCVTable*)vtable);
+       desc = sgen_vtable_get_descriptor (vtable);
        printf ("Descriptor: %lx\n", (long)desc);
 
        type = desc & DESC_TYPE_MASK;
@@ -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)))                                                         \
@@ -178,8 +178,8 @@ static gboolean missing_remsets;
 static void
 check_consistency_callback (char *start, size_t size, void *dummy)
 {
-       GCVTable *vt = (GCVTable*)LOAD_VTABLE (start);
-       mword desc = sgen_vtable_get_descriptor ((GCVTable*)vt);
+       GCVTable vt = (GCVTable)LOAD_VTABLE (start);
+       mword desc = sgen_vtable_get_descriptor (vt);
        SGEN_LOG (8, "Scanning object %p, vtable: %p (%s)", start, vt, sgen_client_vtable_get_name (vt));
 
 #include "sgen-scan-object.h"
@@ -224,7 +224,7 @@ is_major_or_los_object_marked (char *obj)
 #define HANDLE_PTR(ptr,obj)    do {    \
        if (*(ptr) && !sgen_ptr_in_nursery ((char*)*(ptr)) && !is_major_or_los_object_marked ((char*)*(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;                         \
@@ -236,8 +236,8 @@ static void
 check_mod_union_callback (char *start, size_t size, void *dummy)
 {
        gboolean in_los = (gboolean) (size_t) dummy;
-       GCVTable *vt = (GCVTable*)LOAD_VTABLE (start);
-       mword desc = sgen_vtable_get_descriptor ((GCVTable*)vt);
+       GCVTable vt = (GCVTable)LOAD_VTABLE (start);
+       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));
 
@@ -407,7 +407,7 @@ static void
 bad_pointer_spew (char *obj, char **slot)
 {
        char *ptr = *slot;
-       GCVTable *vtable = (GCVTable*)LOAD_VTABLE (obj);
+       GCVTable vtable = (GCVTable)LOAD_VTABLE (obj);
 
        SGEN_LOG (0, "Invalid object pointer %p at offset %zd in object %p (%s.%s):", ptr,
                        (char*)slot - obj,
@@ -420,7 +420,7 @@ static void
 missing_remset_spew (char *obj, char **slot)
 {
        char *ptr = *slot;
-       GCVTable *vtable = (GCVTable*)LOAD_VTABLE (obj);
+       GCVTable vtable = (GCVTable)LOAD_VTABLE (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, 
@@ -665,7 +665,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 (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,
@@ -718,7 +718,7 @@ static gboolean scan_object_for_specific_ref_precise = TRUE;
 #undef HANDLE_PTR
 #define HANDLE_PTR(ptr,obj) do {                                       \
                if ((GCObject*)*(ptr) == key) {                         \
-                       GCVTable *vtable = SGEN_LOAD_VTABLE (*(ptr));   \
+                       GCVTable vtable = SGEN_LOAD_VTABLE (*(ptr));    \
                        g_print ("found ref to %p in object %p (%s.%s) at offset %zd\n", \
                                        key, (obj), sgen_client_vtable_get_namespace (vtable), sgen_client_vtable_get_name (vtable), ((char*)(ptr) - (char*)(obj))); \
                }                                                       \
@@ -741,7 +741,7 @@ scan_object_for_specific_ref (char *start, GCObject *key)
                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 (start);
                                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));
                        }
@@ -1023,7 +1023,7 @@ scan_object_for_xdomain_refs (char *start, mword size, void *data)
 {
        MonoVTable *vt = (MonoVTable*)SGEN_LOAD_VTABLE (start);
        MonoDomain *domain = vt->domain;
-       mword desc = sgen_vtable_get_descriptor ((GCVTable*)vt);
+       mword desc = sgen_vtable_get_descriptor (vt);
 
        #include "sgen-scan-object.h"
 }
@@ -1064,7 +1064,7 @@ sgen_dump_section (GCMemSection *section, const char *type)
 
        while (start < end) {
                guint size;
-               //GCVTable *vt;
+               //GCVTable vt;
                //MonoClass *class;
 
                if (!*(void**)start) {
@@ -1080,7 +1080,7 @@ sgen_dump_section (GCMemSection *section, const char *type)
                if (!occ_start)
                        occ_start = start;
 
-               //vt = (GCVTable*)SGEN_LOAD_VTABLE (start);
+               //vt = (GCVTable)SGEN_LOAD_VTABLE (start);
                //class = vt->klass;
 
                size = SGEN_ALIGN_UP (safe_object_get_size ((GCObject*) start));

diff --git a/mono/sgen/sgen-descriptor.h b/mono/sgen/sgen-descriptor.h
index 1a9d8cc37fe08dab75b868e63d67dd6e19c68486..335ba1a8054807c4b2fe1947dc188e5fff741022 100644 (file)
--- a/mono/sgen/sgen-descriptor.h
+++ b/mono/sgen/sgen-descriptor.h
@@ -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 = (GCVTable)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);    \

diff --git a/mono/sgen/sgen-fin-weak-hash.c b/mono/sgen/sgen-fin-weak-hash.c
index 047d9a41169ca2a30675e6e9f947c1498f912daf..84e3a20e6248624f272b5feb8b34dca4b99a6097 100644 (file)
--- a/mono/sgen/sgen-fin-weak-hash.c
+++ b/mono/sgen/sgen-fin-weak-hash.c
@@ -251,12 +251,12 @@ register_for_finalization (GCObject *obj, void *user_data, int generation)
 
        if (user_data) {
                if (sgen_hash_table_replace (hash_table, obj, NULL, NULL)) {
-                       GCVTable *vt = SGEN_LOAD_VTABLE_UNCHECKED (obj);
+                       GCVTable vt = SGEN_LOAD_VTABLE_UNCHECKED (obj);
                        SGEN_LOG (5, "Added finalizer for object: %p (%s) (%d) to %s table", obj, sgen_client_vtable_get_name (vt), hash_table->num_entries, sgen_generation_name (generation));
                }
        } else {
                if (sgen_hash_table_remove (hash_table, obj, NULL)) {
-                       GCVTable *vt = SGEN_LOAD_VTABLE_UNCHECKED (obj);
+                       GCVTable vt = SGEN_LOAD_VTABLE_UNCHECKED (obj);
                        SGEN_LOG (5, "Removed finalizer for object: %p (%s) (%d)", obj, sgen_client_vtable_get_name (vt), hash_table->num_entries);
                }
        }

diff --git a/mono/sgen/sgen-gc.h b/mono/sgen/sgen-gc.h
index 0fb1b3a1065f4296227dc0d5e567f65c785135fa..eba51c1da9c807b857e405c15e938dd0f5ea93af 100644 (file)
--- a/mono/sgen/sgen-gc.h
+++ b/mono/sgen/sgen-gc.h
@@ -533,7 +533,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, char *obj, size_t objsize, gboolean has_references);
 
        SgenObjectOperations serial_ops;
 
@@ -611,15 +611,15 @@ struct _SgenMajorCollector {
 
        void* (*alloc_heap) (mword nursery_size, mword nursery_align, int nursery_bits);
        gboolean (*is_object_live) (char *obj);
-       void* (*alloc_small_pinned_obj) (GCVTable *vtable, size_t size, gboolean has_references);
-       void* (*alloc_degraded) (GCVTable *vtable, size_t size);
+       void* (*alloc_small_pinned_obj) (GCVTable vtable, size_t size, gboolean has_references);
+       void* (*alloc_degraded) (GCVTable vtable, size_t size);
 
        SgenObjectOperations major_ops_serial;
        SgenObjectOperations major_ops_concurrent_start;
        SgenObjectOperations major_ops_concurrent;
        SgenObjectOperations major_ops_concurrent_finish;
 
-       void* (*alloc_object) (GCVTable *vtable, size_t size, gboolean has_references);
+       void* (*alloc_object) (GCVTable vtable, size_t size, gboolean has_references);
        void (*free_pinned_object) (char *obj, size_t size);
 
        /*
@@ -656,7 +656,7 @@ struct _SgenMajorCollector {
        void (*print_gc_param_usage) (void);
        void (*post_param_init) (SgenMajorCollector *collector);
        gboolean (*is_valid_object) (char *object);
-       GCVTable* (*describe_pointer) (char *pointer);
+       GCVTable (*describe_pointer) (char *pointer);
        guint8* (*get_cardtable_mod_union_for_object) (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);
@@ -705,7 +705,7 @@ void sgen_wbarrier_value_copy_bitmap (gpointer _dest, gpointer _src, int size, u
 static inline mword
 sgen_obj_get_descriptor (char *obj)
 {
-       GCVTable *vtable = SGEN_LOAD_VTABLE_UNCHECKED (obj);
+       GCVTable vtable = SGEN_LOAD_VTABLE_UNCHECKED (obj);
        SGEN_ASSERT (9, !SGEN_POINTER_IS_TAGGED_ANY (vtable), "Object can't be tagged");
        return sgen_vtable_get_descriptor (vtable);
 }
@@ -713,7 +713,7 @@ sgen_obj_get_descriptor (char *obj)
 static inline mword
 sgen_obj_get_descriptor_safe (char *obj)
 {
-       GCVTable *vtable = (GCVTable*)SGEN_LOAD_VTABLE (obj);
+       GCVTable vtable = (GCVTable)SGEN_LOAD_VTABLE (obj);
        return sgen_vtable_get_descriptor (vtable);
 }
 
@@ -725,7 +725,7 @@ sgen_safe_object_get_size (GCObject *obj)
        if ((forwarded = SGEN_OBJECT_IS_FORWARDED (obj)))
                obj = (GCObject*)forwarded;
 
-       return sgen_client_par_object_get_size ((GCVTable*)SGEN_LOAD_VTABLE (obj), obj);
+       return sgen_client_par_object_get_size ((GCVTable)SGEN_LOAD_VTABLE (obj), obj);
 }
 
 static inline gboolean
@@ -749,7 +749,7 @@ sgen_safe_object_get_size_unaligned (GCObject *obj)
                obj = (GCObject*)forwarded;
        }
 
-       return sgen_client_slow_object_get_size ((GCVTable*)SGEN_LOAD_VTABLE (obj), obj);
+       return sgen_client_slow_object_get_size ((GCVTable)SGEN_LOAD_VTABLE (obj), obj);
 }
 
 #ifdef SGEN_CLIENT_HEADER
@@ -851,7 +851,7 @@ extern LOSObject *los_object_list;
 extern mword los_memory_usage;
 
 void sgen_los_free_object (LOSObject *obj);
-void* sgen_los_alloc_large_inner (GCVTable *vtable, size_t size);
+void* sgen_los_alloc_large_inner (GCVTable vtable, size_t size);
 void sgen_los_sweep (void);
 gboolean sgen_ptr_is_in_los (char *ptr, char **start);
 void sgen_los_iterate_objects (IterateObjectCallbackFunc cb, void *user_data);
@@ -888,8 +888,8 @@ void sgen_nursery_alloc_prepare_for_major (void);
 
 char* sgen_alloc_for_promotion (char *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);
+void* sgen_alloc_obj_nolock (GCVTable vtable, size_t size);
+void* sgen_try_alloc_obj_nolock (GCVTable vtable, size_t size);
 
 /* Threads */
 
@@ -975,9 +975,9 @@ typedef enum {
 void sgen_init_tlab_info (SgenThreadInfo* info);
 void sgen_clear_tlabs (void);
 
-void* sgen_alloc_obj (GCVTable *vtable, size_t size);
-void* sgen_alloc_obj_pinned (GCVTable *vtable, size_t size);
-void* sgen_alloc_obj_mature (GCVTable *vtable, size_t size);
+void* sgen_alloc_obj (GCVTable vtable, size_t size);
+void* sgen_alloc_obj_pinned (GCVTable vtable, size_t size);
+void* sgen_alloc_obj_mature (GCVTable vtable, size_t size);
 
 /* Debug support */
 

diff --git a/mono/sgen/sgen-los.c b/mono/sgen/sgen-los.c
index dcc742aceda2bd28c781fc89f89eba809670c801..b2dacab99aafc454017d2cb78b8541c118f6e438 100644 (file)
--- a/mono/sgen/sgen-los.c
+++ b/mono/sgen/sgen-los.c
@@ -331,7 +331,7 @@ sgen_los_free_object (LOSObject *obj)
  * and we avoid the memcpy overhead.
  */
 void*
-sgen_los_alloc_large_inner (GCVTable *vtable, size_t size)
+sgen_los_alloc_large_inner (GCVTable vtable, size_t size)
 {
        LOSObject *obj = NULL;
        void **vtslot;
@@ -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 = (GCVTable)SGEN_LOAD_VTABLE (obj->data);
                if (SGEN_VTABLE_HAS_REFERENCES (vt))
                        callback ((mword)obj->data, (mword)obj->size);
        }

diff --git a/mono/sgen/sgen-marksweep-drain-gray-stack.h b/mono/sgen/sgen-marksweep-drain-gray-stack.h
index ebfb2507cb831d2ea523e1b7a83873791fb11707..01398a05918fb04ec195bfe8ecf3e9ea1c65dbe6 100644 (file)
--- a/mono/sgen/sgen-marksweep-drain-gray-stack.h
+++ b/mono/sgen/sgen-marksweep-drain-gray-stack.h
@@ -149,7 +149,7 @@ COPY_OR_MARK_FUNCTION_NAME (void **ptr, void *obj, SgenGrayQueue *queue)
 
                SGEN_ASSERT (9, !SGEN_VTABLE_IS_PINNED (vtable_word), "Pinned object in non-pinned block?");
 
-               desc = sgen_vtable_get_descriptor ((GCVTable*)vtable_word);
+               desc = sgen_vtable_get_descriptor ((GCVTable)vtable_word);
                type = desc & DESC_TYPE_MASK;
 
                if (sgen_safe_object_is_small ((GCObject*)obj, type)) {

diff --git a/mono/sgen/sgen-marksweep.c b/mono/sgen/sgen-marksweep.c
index 8ad7c5a147d6c02448ebfe617ea2a6e98492d999..369a6d4178431acb7fda4fa1da9aec16ff2cc746 100644 (file)
--- a/mono/sgen/sgen-marksweep.c
+++ b/mono/sgen/sgen-marksweep.c
@@ -643,7 +643,7 @@ unlink_slot_from_free_list_uncontested (MSBlockInfo * volatile *free_blocks, int
 }
 
 static void*
-alloc_obj (GCVTable *vtable, size_t size, gboolean pinned, gboolean has_references)
+alloc_obj (GCVTable vtable, size_t size, gboolean pinned, gboolean has_references)
 {
        int size_index = MS_BLOCK_OBJ_SIZE_INDEX (size);
        MSBlockInfo * volatile * free_blocks = FREE_BLOCKS (pinned, has_references);
@@ -656,13 +656,14 @@ alloc_obj (GCVTable *vtable, size_t size, gboolean pinned, gboolean has_referenc
 
        obj = unlink_slot_from_free_list_uncontested (free_blocks, size_index);
 
-       *(GCVTable**)obj = vtable;
+       /* FIXME: assumes object layout */
+       *(GCVTable*)obj = vtable;
 
        return obj;
 }
 
 static void*
-major_alloc_object (GCVTable *vtable, size_t size, gboolean has_references)
+major_alloc_object (GCVTable vtable, size_t size, gboolean has_references)
 {
        return alloc_obj (vtable, size, FALSE, has_references);
 }
@@ -711,7 +712,7 @@ major_free_non_pinned_object (char *obj, size_t size)
 
 /* size is a multiple of SGEN_ALLOC_ALIGN */
 static void*
-major_alloc_small_pinned_obj (GCVTable *vtable, size_t size, gboolean has_references)
+major_alloc_small_pinned_obj (GCVTable vtable, size_t size, gboolean has_references)
 {
        void *res;
 
@@ -736,7 +737,7 @@ free_pinned_object (char *obj, size_t size)
  * size is already rounded up and we hold the GC lock.
  */
 static void*
-major_alloc_degraded (GCVTable *vtable, size_t size)
+major_alloc_degraded (GCVTable vtable, size_t size)
 {
        void *obj = alloc_obj (vtable, size, FALSE, SGEN_VTABLE_HAS_REFERENCES (vtable));
        if (G_LIKELY (obj)) {
@@ -924,7 +925,7 @@ major_is_valid_object (char *object)
 }
 
 
-static GCVTable*
+static GCVTable
 major_describe_pointer (char *ptr)
 {
        MSBlockInfo *block;
@@ -933,7 +934,7 @@ major_describe_pointer (char *ptr)
                int idx;
                char *obj;
                gboolean live;
-               GCVTable *vtable;
+               GCVTable vtable;
                int w, b;
                gboolean marked;
 
@@ -946,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 ? (GCVTable)SGEN_LOAD_VTABLE (obj) : NULL;
 
                MS_CALC_MARK_BIT (w, b, obj);
                marked = MS_MARK_BIT (block, w, b);
@@ -1690,7 +1691,7 @@ static int count_nonpinned_nonref;
 static void
 count_nonpinned_callback (char *obj, size_t size, void *data)
 {
-       GCVTable *vtable = (GCVTable*)LOAD_VTABLE (obj);
+       GCVTable vtable = (GCVTable)LOAD_VTABLE (obj);
 
        if (SGEN_VTABLE_HAS_REFERENCES (vtable))
                ++count_nonpinned_ref;
@@ -1701,7 +1702,7 @@ count_nonpinned_callback (char *obj, size_t size, void *data)
 static void
 count_pinned_callback (char *obj, size_t size, void *data)
 {
-       GCVTable *vtable = (GCVTable*)LOAD_VTABLE (obj);
+       GCVTable vtable = (GCVTable)LOAD_VTABLE (obj);
 
        if (SGEN_VTABLE_HAS_REFERENCES (vtable))
                ++count_pinned_ref;

diff --git a/mono/sgen/sgen-minor-copy-object.h b/mono/sgen/sgen-minor-copy-object.h
index e32321885d5095bdfe47a7967e4ab0aac5199856..28c7629448a2ce464a6a303867b21f58f44e2e2b 100644 (file)
--- a/mono/sgen/sgen-minor-copy-object.h
+++ b/mono/sgen/sgen-minor-copy-object.h
@@ -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 ((GCVTable)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 ((GCVTable)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;
@@ -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 ((GCVTable)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 ((GCVTable)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-pinning-stats.c b/mono/sgen/sgen-pinning-stats.c
index df25033acb88c785a67d92623bbe709de21093a3..f245c5fb2c4ff47b476e4d84985de3dea2dec179 100644 (file)
--- a/mono/sgen/sgen-pinning-stats.c
+++ b/mono/sgen/sgen-pinning-stats.c
@@ -137,7 +137,7 @@ pin_stats_count_object_from_tree (char *obj, size_t size, PinStatAddress *node,
 }
 
 static gpointer
-lookup_vtable_entry (SgenHashTable *hash_table, GCVTable *vtable, gpointer empty_entry)
+lookup_vtable_entry (SgenHashTable *hash_table, GCVTable vtable, gpointer empty_entry)
 {
        char *name = g_strdup_printf ("%s.%s", sgen_client_vtable_get_namespace (vtable), sgen_client_vtable_get_name (vtable));
        gpointer entry = sgen_hash_table_lookup (hash_table, name);
@@ -153,7 +153,7 @@ lookup_vtable_entry (SgenHashTable *hash_table, GCVTable *vtable, gpointer empty
 }
 
 static void
-register_vtable (GCVTable *vtable, int pin_types)
+register_vtable (GCVTable vtable, int pin_types)
 {
        PinnedClassEntry empty_entry;
        PinnedClassEntry *entry;
@@ -180,7 +180,7 @@ 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 ((GCVTable)SGEN_LOAD_VTABLE (obj), pin_types);
 }
 
 void
@@ -193,7 +193,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, (GCVTable)SGEN_LOAD_VTABLE (obj), &empty_entry);
 
        ++entry->num_remsets;
 }

diff --git a/mono/sgen/sgen-simple-nursery.c b/mono/sgen/sgen-simple-nursery.c
index 5488775d4f673b8cdafc252a33d5453a1b61e9ac..f0827a95069471fa9692091b5d1b1519bd606a32 100644 (file)
--- 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, char *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 96d765fb8555fc910f2bfa51f16b1aeaa0d5a990..7ef988e368f01b231f4fb0415ade0607f08a8965 100644 (file)
--- a/mono/sgen/sgen-split-nursery.c
+++ b/mono/sgen/sgen-split-nursery.c
@@ -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, char *obj, size_t objsize, gboolean has_references)
 {
        char *p = NULL;
        int age;
@@ -281,13 +281,13 @@ alloc_for_promotion (GCVTable *vtable, char *obj, size_t objsize, gboolean has_r
        }
 
        /* FIXME: assumes object layout */
-       *(GCVTable**)p = vtable;
+       *(GCVTable*)p = vtable;
 
        return p;
 }
 
 static char*
-minor_alloc_for_promotion (GCVTable *vtable, char *obj, size_t objsize, gboolean has_references)
+minor_alloc_for_promotion (GCVTable vtable, char *obj, size_t objsize, gboolean has_references)
 {
        /*
        We only need to check for a non-nursery object if we're doing a major collection.