[dtrace] Make pointers into user space uintptr_t instead of void*.

diff --git a/data/mono.d b/data/mono.d
index 6d5ba78d07970af42f27ce6e68b5b42e8200a89f..566508e26883ed824097d42286173fc63ad51e7e 100644 (file)
--- a/data/mono.d
+++ b/data/mono.d
@@ -19,27 +19,27 @@ provider mono {
        probe gc__begin (int generation);
        probe gc__end (int generation);
 
-       probe gc__heap__alloc (void *addr, uintptr_t len);
-       probe gc__heap__free (void *addr, uintptr_t len);
+       probe gc__heap__alloc (uintptr_t addr, uintptr_t len);
+       probe gc__heap__free (uintptr_t addr, uintptr_t len);
 
        probe gc__locked ();
        probe gc__unlocked ();
 
-       probe gc__nursery__tlab__alloc (void *addr, uintptr_t len);
-       probe gc__nursery__obj__alloc (void *addr, uintptr_t size, char *ns_name, char *class_name);
+       probe gc__nursery__tlab__alloc (uintptr_t addr, uintptr_t len);
+       probe gc__nursery__obj__alloc (uintptr_t addr, uintptr_t size, char *ns_name, char *class_name);
 
-       probe gc__major__obj__alloc__large (void *addr, uintptr_t size, char *ns_name, char *class_name);
-       probe gc__major__obj__alloc__pinned (void *addr, uintptr_t size, char *ns_name, char *class_name);
-       probe gc__major__obj__alloc__degraded (void *addr, uintptr_t size, char *ns_name, char *class_name);
-       probe gc__major__obj__alloc__mature (void *addr, uintptr_t size, char *ns_name, char *class_name);
+       probe gc__major__obj__alloc__large (uintptr_t addr, uintptr_t size, char *ns_name, char *class_name);
+       probe gc__major__obj__alloc__pinned (uintptr_t addr, uintptr_t size, char *ns_name, char *class_name);
+       probe gc__major__obj__alloc__degraded (uintptr_t addr, uintptr_t size, char *ns_name, char *class_name);
+       probe gc__major__obj__alloc__mature (uintptr_t addr, uintptr_t size, char *ns_name, char *class_name);
 
        /* Can be nursery->nursery, nursery->major or major->major */
-       probe gc__obj__moved (void *dest, void *src, int dest_gen, int src_gen, uintptr_t size, char *ns_name, char *class_name);
+       probe gc__obj__moved (uintptr_t dest, uintptr_t src, int dest_gen, int src_gen, uintptr_t size, char *ns_name, char *class_name);
 
-       probe gc__nursery__sweeped (void *addr, uintptr_t len);
-       probe gc__major__sweeped (void *addr, uintptr_t len);
+       probe gc__nursery__sweeped (uintptr_t addr, uintptr_t len);
+       probe gc__major__sweeped (uintptr_t addr, uintptr_t len);
 
-       probe gc__obj__pinned (void *addr, uintptr_t size, char *ns_name, char *class_name, int generation);
+       probe gc__obj__pinned (uintptr_t addr, uintptr_t size, char *ns_name, char *class_name, int generation);
 };
 
 #pragma D attributes Evolving/Evolving/Common provider mono provider

diff --git a/mono/metadata/sgen-alloc.c b/mono/metadata/sgen-alloc.c
index af41d84e6bdc7024b0116ea8338f9748584202b3..12d865bf54ad0adefc7ff1a60e0d4c1db4c526d4 100644 (file)
--- a/mono/metadata/sgen-alloc.c
+++ b/mono/metadata/sgen-alloc.c
@@ -136,10 +136,10 @@ alloc_degraded (MonoVTable *vtable, size_t size, gboolean for_mature)
        p = major_collector.alloc_degraded (vtable, size);
 
        if (for_mature) {
-               MONO_GC_MAJOR_OBJ_ALLOC_MATURE (p, size, vtable->klass->name_space, vtable->klass->name);
+               MONO_GC_MAJOR_OBJ_ALLOC_MATURE ((mword)p, size, vtable->klass->name_space, vtable->klass->name);
        } else {
                binary_protocol_alloc_degraded (p, vtable, size);
-               MONO_GC_MAJOR_OBJ_ALLOC_DEGRADED (p, size, vtable->klass->name_space, vtable->klass->name);
+               MONO_GC_MAJOR_OBJ_ALLOC_DEGRADED ((mword)p, size, vtable->klass->name_space, vtable->klass->name);
        }
 
        return p;
@@ -221,7 +221,7 @@ mono_gc_alloc_obj_nolock (MonoVTable *vtable, size_t size)
                        DEBUG (6, fprintf (gc_debug_file, "Allocated object %p, vtable: %p (%s), size: %zd\n", p, vtable, vtable->klass->name, size));
                        binary_protocol_alloc (p , vtable, size);
                        if (G_UNLIKELY (MONO_GC_NURSERY_OBJ_ALLOC_ENABLED ()))
-                               MONO_GC_NURSERY_OBJ_ALLOC (p, size, vtable->klass->name_space, vtable->klass->name);
+                               MONO_GC_NURSERY_OBJ_ALLOC ((mword)p, size, vtable->klass->name_space, vtable->klass->name);
                        g_assert (*p == NULL);
                        mono_atomic_store_seq (p, vtable);
 
@@ -329,9 +329,9 @@ mono_gc_alloc_obj_nolock (MonoVTable *vtable, size_t size)
                binary_protocol_alloc (p, vtable, size);
                if (G_UNLIKELY (MONO_GC_MAJOR_OBJ_ALLOC_LARGE_ENABLED ()|| MONO_GC_NURSERY_OBJ_ALLOC_ENABLED ())) {
                        if (size > SGEN_MAX_SMALL_OBJ_SIZE)
-                               MONO_GC_MAJOR_OBJ_ALLOC_LARGE (p, size, vtable->klass->name_space, vtable->klass->name);
+                               MONO_GC_MAJOR_OBJ_ALLOC_LARGE ((mword)p, size, vtable->klass->name_space, vtable->klass->name);
                        else
-                               MONO_GC_NURSERY_OBJ_ALLOC (p, size, vtable->klass->name_space, vtable->klass->name);
+                               MONO_GC_NURSERY_OBJ_ALLOC ((mword)p, size, vtable->klass->name_space, vtable->klass->name);
                }
                mono_atomic_store_seq (p, vtable);
        }
@@ -410,7 +410,7 @@ mono_gc_try_alloc_obj_nolock (MonoVTable *vtable, size_t size)
                        if (nursery_clear_policy == CLEAR_AT_TLAB_CREATION)
                                memset (new_next, 0, alloc_size);
 
-                       MONO_GC_NURSERY_TLAB_ALLOC (new_next, alloc_size);
+                       MONO_GC_NURSERY_TLAB_ALLOC ((mword)new_next, alloc_size);
                }
        }
 
@@ -420,7 +420,7 @@ mono_gc_try_alloc_obj_nolock (MonoVTable *vtable, size_t size)
        DEBUG (6, fprintf (gc_debug_file, "Allocated object %p, vtable: %p (%s), size: %zd\n", p, vtable, vtable->klass->name, size));
        binary_protocol_alloc (p, vtable, size);
        if (G_UNLIKELY (MONO_GC_NURSERY_OBJ_ALLOC_ENABLED ()))
-               MONO_GC_NURSERY_OBJ_ALLOC (p, size, vtable->klass->name_space, vtable->klass->name);
+               MONO_GC_NURSERY_OBJ_ALLOC ((mword)p, size, vtable->klass->name_space, vtable->klass->name);
        g_assert (*p == NULL); /* FIXME disable this in non debug builds */
 
        mono_atomic_store_seq (p, vtable);
@@ -575,9 +575,9 @@ mono_gc_alloc_pinned_obj (MonoVTable *vtable, size_t size)
        if (G_LIKELY (p)) {
                DEBUG (6, fprintf (gc_debug_file, "Allocated pinned object %p, vtable: %p (%s), size: %zd\n", p, vtable, vtable->klass->name, size));
                if (size > SGEN_MAX_SMALL_OBJ_SIZE)
-                       MONO_GC_MAJOR_OBJ_ALLOC_LARGE (p, size, vtable->klass->name_space, vtable->klass->name);
+                       MONO_GC_MAJOR_OBJ_ALLOC_LARGE ((mword)p, size, vtable->klass->name_space, vtable->klass->name);
                else
-                       MONO_GC_MAJOR_OBJ_ALLOC_PINNED (p, size, vtable->klass->name_space, vtable->klass->name);
+                       MONO_GC_MAJOR_OBJ_ALLOC_PINNED ((mword)p, size, vtable->klass->name_space, vtable->klass->name);
                binary_protocol_alloc_pinned (p, vtable, size);
                mono_atomic_store_seq (p, vtable);
        }

diff --git a/mono/metadata/sgen-copy-object.h b/mono/metadata/sgen-copy-object.h
index 1b183952cd4614bf8a5d8e67c3e53d398508fd27..a1eccaee0f00418cabacddbcc1b4cc412d16b0ed 100644 (file)
--- a/mono/metadata/sgen-copy-object.h
+++ b/mono/metadata/sgen-copy-object.h
@@ -46,7 +46,7 @@ par_copy_object_no_checks (char *destination, MonoVTable *vt, void *obj, mword o
        if (G_UNLIKELY (MONO_GC_OBJ_MOVED_ENABLED ())) {
                int dest_gen = sgen_ptr_in_nursery (destination) ? GENERATION_NURSERY : GENERATION_OLD;
                int src_gen = sgen_ptr_in_nursery (obj) ? GENERATION_NURSERY : GENERATION_OLD;
-               MONO_GC_OBJ_MOVED (destination, obj, dest_gen, src_gen, objsize, vt->klass->name_space, vt->klass->name);
+               MONO_GC_OBJ_MOVED ((mword)destination, (mword)obj, dest_gen, src_gen, objsize, vt->klass->name_space, vt->klass->name);
        }
 
        if (objsize <= sizeof (gpointer) * 8) {

diff --git a/mono/metadata/sgen-gc.c b/mono/metadata/sgen-gc.c
index 692a2e9bbe7174a984bf5dfa3556c7503de7beba..491844a1893fc5843280fe02c088e3d52639b56e 100644 (file)
--- a/mono/metadata/sgen-gc.c
+++ b/mono/metadata/sgen-gc.c
@@ -1248,7 +1248,7 @@ pin_objects_from_addresses (GCMemSection *section, void **start, void **end, voi
                                                if (G_UNLIKELY (MONO_GC_OBJ_PINNED_ENABLED ())) {
                                                        int gen = sgen_ptr_in_nursery (search_start) ? GENERATION_NURSERY : GENERATION_OLD;
                                                        MonoVTable *vt = (MonoVTable*)LOAD_VTABLE (search_start);
-                                                       MONO_GC_OBJ_PINNED (search_start, sgen_safe_object_get_size (search_start), vt->klass->name_space, vt->klass->name, gen);
+                                                       MONO_GC_OBJ_PINNED ((mword)search_start, sgen_safe_object_get_size (search_start), vt->klass->name_space, vt->klass->name, gen);
                                                }
                                                pin_object (search_start);
                                                GRAY_OBJECT_ENQUEUE (queue, search_start);
@@ -1318,7 +1318,7 @@ sgen_pin_object (void *object, GrayQueue *queue)
        if (G_UNLIKELY (MONO_GC_OBJ_PINNED_ENABLED ())) {
                int gen = sgen_ptr_in_nursery (object) ? GENERATION_NURSERY : GENERATION_OLD;
                MonoVTable *vt = (MonoVTable*)LOAD_VTABLE (object);
-               MONO_GC_OBJ_PINNED (object, sgen_safe_object_get_size (object), vt->klass->name_space, vt->klass->name, gen);
+               MONO_GC_OBJ_PINNED ((mword)object, sgen_safe_object_get_size (object), vt->klass->name_space, vt->klass->name, gen);
        }
 }
 
@@ -2701,7 +2701,7 @@ major_do_collection (const char *reason)
                        binary_protocol_pin (bigobj->data, (gpointer)LOAD_VTABLE (bigobj->data), safe_object_get_size (bigobj->data));
                        if (G_UNLIKELY (MONO_GC_OBJ_PINNED_ENABLED ())) {
                                MonoVTable *vt = (MonoVTable*)LOAD_VTABLE (bigobj->data);
-                               MONO_GC_OBJ_PINNED (bigobj->data, sgen_safe_object_get_size ((MonoObject*)bigobj->data), vt->klass->name_space, vt->klass->name, GENERATION_OLD);
+                               MONO_GC_OBJ_PINNED ((mword)bigobj->data, sgen_safe_object_get_size ((MonoObject*)bigobj->data), vt->klass->name_space, vt->klass->name, GENERATION_OLD);
                        }
                        pin_object (bigobj->data);
                        /* FIXME: only enqueue if object has references */

diff --git a/mono/metadata/sgen-marksweep.c b/mono/metadata/sgen-marksweep.c
index ba29647c143564bd4d5ee64c29bd150f3728ab4a..dd9a2983faae0a8bd04b45e42fc86a032edce7b6 100644 (file)
--- a/mono/metadata/sgen-marksweep.c
+++ b/mono/metadata/sgen-marksweep.c
@@ -1372,7 +1372,7 @@ major_copy_or_mark_object (void **ptr, SgenGrayQueue *queue)
                        binary_protocol_pin (obj, (gpointer)SGEN_LOAD_VTABLE (obj), sgen_safe_object_get_size ((MonoObject*)obj));
                        if (G_UNLIKELY (MONO_GC_OBJ_PINNED_ENABLED ())) {
                                MonoVTable *vt = (MonoVTable*)SGEN_LOAD_VTABLE (obj);
-                               MONO_GC_OBJ_PINNED (obj, sgen_safe_object_get_size (obj), vt->klass->name_space, vt->klass->name, GENERATION_OLD);
+                               MONO_GC_OBJ_PINNED ((mword)obj, sgen_safe_object_get_size (obj), vt->klass->name_space, vt->klass->name, GENERATION_OLD);
                        }
                        SGEN_PIN_OBJECT (obj);
                        /* FIXME: only enqueue if object has references */
@@ -1467,7 +1467,7 @@ ms_sweep (void)
                                         * will also benefit?
                                         */
                                        binary_protocol_empty (obj, block->obj_size);
-                                       MONO_GC_MAJOR_SWEEPED (obj, block->obj_size);
+                                       MONO_GC_MAJOR_SWEEPED ((mword)obj, block->obj_size);
                                        memset (obj, 0, block->obj_size);
                                }
                                *(void**)obj = block->free_list;

diff --git a/mono/metadata/sgen-memory-governor.c b/mono/metadata/sgen-memory-governor.c
index 2ae0ab2e045381aec52616e04ca841a6fe75b914..d237de8d3c86885efd9452550e7ab45ffab13543 100644 (file)
--- a/mono/metadata/sgen-memory-governor.c
+++ b/mono/metadata/sgen-memory-governor.c
@@ -309,7 +309,7 @@ sgen_alloc_os_memory (size_t size, int activate, gboolean is_heap_memory, const
        if (ptr) {
                SGEN_ATOMIC_ADD_P (total_alloc, size);
                if (is_heap_memory)
-                       MONO_GC_HEAP_ALLOC (ptr, size);
+                       MONO_GC_HEAP_ALLOC ((mword)ptr, size);
        }
        return ptr;
 }
@@ -323,7 +323,7 @@ sgen_alloc_os_memory_aligned (size_t size, mword alignment, gboolean activate, g
        if (ptr) {
                SGEN_ATOMIC_ADD_P (total_alloc, size);
                if (is_heap_memory)
-                       MONO_GC_HEAP_ALLOC (ptr, size);
+                       MONO_GC_HEAP_ALLOC ((mword)ptr, size);
        }
        return ptr;
 }
@@ -337,7 +337,7 @@ sgen_free_os_memory (void *addr, size_t size, gboolean is_heap_memory)
        mono_vfree (addr, size);
        SGEN_ATOMIC_ADD_P (total_alloc, -size);
        if (is_heap_memory)
-               MONO_GC_HEAP_FREE (addr, size);
+               MONO_GC_HEAP_FREE ((mword)addr, size);
 }
 
 int64_t

diff --git a/mono/metadata/sgen-nursery-allocator.c b/mono/metadata/sgen-nursery-allocator.c
index fef74c4826aadd8450bd0e2a683480964c2fe7f6..b165f12dd614d123ebaeccaa98292e23575c1fdb 100644 (file)
--- a/mono/metadata/sgen-nursery-allocator.c
+++ b/mono/metadata/sgen-nursery-allocator.c
@@ -712,7 +712,7 @@ add_nursery_frag (SgenFragmentAllocator *allocator, size_t frag_size, char* frag
 {
        DEBUG (4, fprintf (gc_debug_file, "Found empty fragment: %p-%p, size: %zd\n", frag_start, frag_end, frag_size));
        binary_protocol_empty (frag_start, frag_size);
-       MONO_GC_NURSERY_SWEEPED (frag_start, frag_end - frag_start);
+       MONO_GC_NURSERY_SWEEPED ((mword)frag_start, frag_end - frag_start);
        /* Not worth dealing with smaller fragments: need to tune */
        if (frag_size >= SGEN_MAX_NURSERY_WASTE) {
                /* memsetting just the first chunk start is bound to provide better cache locality */