Use new mono_gc_(memmove|bzero) in places messing with managed memory.

diff --git a/mono/metadata/appdomain.c b/mono/metadata/appdomain.c
index 0654fa6f2bc0809021fa5d129a02ef8e538a714f..398706d29281b0b7fbd369d70872f797cc3a8bbc 100644 (file)
--- a/mono/metadata/appdomain.c
+++ b/mono/metadata/appdomain.c
@@ -2183,7 +2183,7 @@ zero_static_data (MonoVTable *vtable)
        MonoClass *klass = vtable->klass;
 
        if (vtable->data && klass->has_static_refs)
-               memset (vtable->data, 0, mono_class_data_size (klass));
+               mono_gc_bzero (vtable->data, mono_class_data_size (klass));
 }
 
 typedef struct unload_data {

diff --git a/mono/metadata/boehm-gc.c b/mono/metadata/boehm-gc.c
index 2055a64e0b7e6e12369b2847d2e97bfc4f45bb3c..23c73d0cd67a088bdc6f483275d07ead9077b38e 100644 (file)
--- a/mono/metadata/boehm-gc.c
+++ b/mono/metadata/boehm-gc.c
@@ -696,7 +696,7 @@ mono_gc_wbarrier_set_arrayref (MonoArray *arr, gpointer slot_ptr, MonoObject* va
 void
 mono_gc_wbarrier_arrayref_copy (gpointer dest_ptr, gpointer src_ptr, int count)
 {
-       memmove (dest_ptr, src_ptr, count * sizeof (gpointer));
+       mono_gc_memmove (dest_ptr, src_ptr, count * sizeof (gpointer));
 }
 
 void
@@ -713,14 +713,14 @@ mono_gc_wbarrier_generic_nostore (gpointer ptr)
 void
 mono_gc_wbarrier_value_copy (gpointer dest, gpointer src, int count, MonoClass *klass)
 {
-       memmove (dest, src, count * mono_class_value_size (klass, NULL));
+       mono_gc_memmove (dest, src, count * mono_class_value_size (klass, NULL));
 }
 
 void
 mono_gc_wbarrier_object_copy (MonoObject* obj, MonoObject *src)
 {
        /* do not copy the sync state */
-       memcpy ((char*)obj + sizeof (MonoObject), (char*)src + sizeof (MonoObject),
+       mono_gc_memmove ((char*)obj + sizeof (MonoObject), (char*)src + sizeof (MonoObject),
                        mono_object_class (obj)->instance_size - sizeof (MonoObject));
 }
 

diff --git a/mono/metadata/domain.c b/mono/metadata/domain.c
index 653e4f167dff490fdee290402b42fea72d21fe3d..5fbd6fb8b5364f4036d46f1570de15e9238d1ae5 100644 (file)
--- a/mono/metadata/domain.c
+++ b/mono/metadata/domain.c
@@ -2276,7 +2276,7 @@ mono_domain_add_class_static_data (MonoDomain *domain, MonoClass *klass, gpointe
                if (next >= size) {
                        /* 'data' is allocated by alloc_fixed */
                        gpointer *new_array = mono_gc_alloc_fixed (sizeof (gpointer) * (size * 2), MONO_GC_ROOT_DESCR_FOR_FIXED (size * 2));
-                       memcpy (new_array, domain->static_data_array, sizeof (gpointer) * size);
+                       mono_gc_memmove (new_array, domain->static_data_array, sizeof (gpointer) * size);
                        size *= 2;
                        new_array [1] = GINT_TO_POINTER (size);
                        mono_gc_free_fixed (domain->static_data_array);

diff --git a/mono/metadata/icall.c b/mono/metadata/icall.c
index ca649adcf0509edd510afb5eb0008d3eccaf72af..17b2ca83c743b5affb981434b5bb84870e737331 100644 (file)
--- a/mono/metadata/icall.c
+++ b/mono/metadata/icall.c
@@ -234,7 +234,7 @@ ves_icall_System_Array_SetValueImpl (MonoArray *this, MonoObject *value, guint32
        }
 
        if (!value) {
-               memset (ea, 0,  esize);
+               mono_gc_bzero (ea, esize);
                return;
        }
 
@@ -297,7 +297,7 @@ ves_icall_System_Array_SetValueImpl (MonoArray *this, MonoObject *value, guint32
                if (ec->has_references)
                        mono_value_copy (ea, (char*)value + sizeof (MonoObject), ec);
                else
-                       memcpy (ea, (char *)value + sizeof (MonoObject), esize);
+                       mono_gc_memmove (ea, (char *)value + sizeof (MonoObject), esize);
                return;
        }
 
@@ -681,7 +681,7 @@ static void
 ves_icall_System_Array_ClearInternal (MonoArray *arr, int idx, int length)
 {
        int sz = mono_array_element_size (mono_object_class (arr));
-       memset (mono_array_addr_with_size (arr, sz, idx), 0, length * sz);
+       mono_gc_bzero (mono_array_addr_with_size (arr, sz, idx), length * sz);
 }
 
 static gboolean
@@ -772,7 +772,7 @@ ves_icall_System_Array_FastCopy (MonoArray *source, int source_idx, MonoArray* d
                        mono_value_copy_array (dest, dest_idx, source_addr, length);
                } else {
                        dest_addr = mono_array_addr_with_size (dest, element_size, dest_idx);
-                       memmove (dest_addr, source_addr, element_size * length);
+                       mono_gc_memmove (dest_addr, source_addr, element_size * length);
                }
        } else {
                mono_array_memcpy_refs (dest, dest_idx, source, source_idx, length);
@@ -797,7 +797,7 @@ ves_icall_System_Array_GetGenericValueImpl (MonoObject *this, guint32 pos, gpoin
        esize = mono_array_element_size (ac);
        ea = (gpointer*)((char*)ao->vector + (pos * esize));
 
-       memcpy (value, ea, esize);
+       mono_gc_memmove (value, ea, esize);
 }
 
 static void
@@ -826,7 +826,7 @@ ves_icall_System_Array_SetGenericValueImpl (MonoObject *this, guint32 pos, gpoin
                if (ec->has_references)
                        mono_gc_wbarrier_value_copy (ea, value, 1, ec);
                else
-                       memcpy (ea, value, esize);
+                       mono_gc_memmove (ea, value, esize);
        }
 }
 
@@ -6228,7 +6228,7 @@ ves_icall_System_Buffer_BlockCopyInternal (MonoArray *src, gint32 src_offset, Mo
        if (src != dest)
                memcpy (dest_buf, src_buf, count);
        else
-               memmove (dest_buf, src_buf, count); /* Source and dest are the same array */
+               mono_gc_memmove (dest_buf, src_buf, count); /* Source and dest are the same array */
 
        return TRUE;
 }

diff --git a/mono/metadata/mono-ptr-array.h b/mono/metadata/mono-ptr-array.h
index 94b1f625d0b9aa58555077e426c606569b5b8c7d..8ff1aea3a6c3f2209d9454e8875f3ac888804e7e 100644 (file)
--- a/mono/metadata/mono-ptr-array.h
+++ b/mono/metadata/mono-ptr-array.h
@@ -41,7 +41,7 @@ typedef struct {
 #define mono_ptr_array_append(ARRAY, VALUE) do { \
        if ((ARRAY).size >= (ARRAY).capacity) {\
        void *__tmp = mono_gc_alloc_fixed (sizeof (void*) * (ARRAY).capacity * 2, mono_gc_make_root_descr_all_refs ((ARRAY).capacity * 2)); \
-               memcpy (__tmp, (ARRAY).data, (ARRAY).capacity * sizeof (void*)); \
+               mono_gc_memmove (__tmp, (ARRAY).data, (ARRAY).capacity * sizeof (void*)); \
                if ((ARRAY).capacity > MONO_PTR_ARRAY_MAX_ON_STACK)     \
                        mono_gc_free_fixed ((ARRAY).data);      \
                (ARRAY).data = __tmp;   \

diff --git a/mono/metadata/mono-wsq.c b/mono/metadata/mono-wsq.c
index 3c36dcee88da733f0dd0ba63276290a55127ed1d..4b13fde7b0a6740a515758ca913254cca4e98bd7 100644 (file)
--- a/mono/metadata/mono-wsq.c
+++ b/mono/metadata/mono-wsq.c
@@ -125,7 +125,7 @@ mono_wsq_local_push (void *obj)
                for (i = 0; i < length; i++)
                        mono_array_setref (new_array, i, mono_array_get (wsq->queue, MonoObject*, (i + head) & wsq->mask));
 
-               memset (mono_array_addr (wsq->queue, MonoObject *, 0), 0, sizeof (MonoObject*) * length);
+               mono_gc_bzero (mono_array_addr (wsq->queue, MonoObject *, 0), sizeof (MonoObject*) * length);
                wsq->queue = new_array;
                wsq->head = 0;
                wsq->tail = tail = count;

diff --git a/mono/metadata/null-gc.c b/mono/metadata/null-gc.c
index cc26743e29ff42f72006b98e9e6667a4fe8673a5..d323b9b54b0578aae654a2c85798c737e8d8b11a 100644 (file)
--- a/mono/metadata/null-gc.c
+++ b/mono/metadata/null-gc.c
@@ -183,7 +183,7 @@ mono_gc_wbarrier_set_arrayref (MonoArray *arr, gpointer slot_ptr, MonoObject* va
 void
 mono_gc_wbarrier_arrayref_copy (gpointer dest_ptr, gpointer src_ptr, int count)
 {
-       memmove (dest_ptr, src_ptr, count * sizeof (gpointer));
+       mono_gc_memmove (dest_ptr, src_ptr, count * sizeof (gpointer));
 }
 
 void
@@ -200,14 +200,14 @@ mono_gc_wbarrier_generic_nostore (gpointer ptr)
 void
 mono_gc_wbarrier_value_copy (gpointer dest, gpointer src, int count, MonoClass *klass)
 {
-       memmove (dest, src, count * mono_class_value_size (klass, NULL));
+       mono_gc_memmove (dest, src, count * mono_class_value_size (klass, NULL));
 }
 
 void
 mono_gc_wbarrier_object_copy (MonoObject* obj, MonoObject *src)
 {
        /* do not copy the sync state */
-       memcpy ((char*)obj + sizeof (MonoObject), (char*)src + sizeof (MonoObject),
+       mono_gc_memmove ((char*)obj + sizeof (MonoObject), (char*)src + sizeof (MonoObject),
                        mono_object_class (obj)->instance_size - sizeof (MonoObject));
 }
 

diff --git a/mono/metadata/object.c b/mono/metadata/object.c
index 96c9f8a8b7703584621ad11f12dd7839924972f7..91c8dd289d7133e002353651e10a84a709e0c3ed 100644 (file)
--- a/mono/metadata/object.c
+++ b/mono/metadata/object.c
@@ -2912,7 +2912,7 @@ handle_enum:
                        MonoClass *class = mono_class_from_mono_type (type);
                        int size = mono_class_value_size (class, NULL);
                        if (value == NULL)
-                               memset (dest, 0, size);
+                               mono_gc_bzero (dest, size);
                        else
                                mono_gc_wbarrier_value_copy (dest, value, 1, class);
                }
@@ -3358,9 +3358,9 @@ mono_nullable_init (guint8 *buf, MonoObject *value, MonoClass *klass)
                if (param_class->has_references)
                        mono_gc_wbarrier_value_copy (buf + klass->fields [0].offset - sizeof (MonoObject), mono_object_unbox (value), 1, param_class);
                else
-                       memcpy (buf + klass->fields [0].offset - sizeof (MonoObject), mono_object_unbox (value), mono_class_value_size (param_class, NULL));
+                       mono_gc_memmove (buf + klass->fields [0].offset - sizeof (MonoObject), mono_object_unbox (value), mono_class_value_size (param_class, NULL));
        } else {
-               memset (buf + klass->fields [0].offset - sizeof (MonoObject), 0, mono_class_value_size (param_class, NULL));
+               mono_gc_bzero (buf + klass->fields [0].offset - sizeof (MonoObject), mono_class_value_size (param_class, NULL));
        }
 }
 
@@ -3385,7 +3385,7 @@ mono_nullable_box (guint8 *buf, MonoClass *klass)
                if (param_class->has_references)
                        mono_gc_wbarrier_value_copy (mono_object_unbox (o), buf + klass->fields [0].offset - sizeof (MonoObject), 1, param_class);
                else
-                       memcpy (mono_object_unbox (o), buf + klass->fields [0].offset - sizeof (MonoObject), mono_class_value_size (param_class, NULL));
+                       mono_gc_memmove (mono_object_unbox (o), buf + klass->fields [0].offset - sizeof (MonoObject), mono_class_value_size (param_class, NULL));
                return o;
        }
        else
@@ -4483,7 +4483,7 @@ mono_object_clone (MonoObject *obj)
        } else {
                int size = obj->vtable->klass->instance_size;
                /* do not copy the sync state */
-               memcpy ((char*)o + sizeof (MonoObject), (char*)obj + sizeof (MonoObject), size - sizeof (MonoObject));
+               mono_gc_memmove ((char*)o + sizeof (MonoObject), (char*)obj + sizeof (MonoObject), size - sizeof (MonoObject));
        }
        if (G_UNLIKELY (profile_allocs))
                mono_profiler_allocation (o, obj->vtable->klass);
@@ -4518,12 +4518,12 @@ mono_array_full_copy (MonoArray *src, MonoArray *dest)
                if (klass->element_class->has_references)
                        mono_value_copy_array (dest, 0, mono_array_addr_with_size (src, 0, 0), mono_array_length (src));
                else
-                       memcpy (&dest->vector, &src->vector, size);
+                       mono_gc_memmove (&dest->vector, &src->vector, size);
        } else {
                mono_array_memcpy_refs (dest, 0, src, 0, mono_array_length (src));
        }
 #else
-       memcpy (&dest->vector, &src->vector, size);
+       mono_gc_memmove (&dest->vector, &src->vector, size);
 #endif
 }
 
@@ -4555,12 +4555,12 @@ mono_array_clone_in_domain (MonoDomain *domain, MonoArray *array)
                        if (klass->element_class->has_references)
                                mono_value_copy_array (o, 0, mono_array_addr_with_size (array, 0, 0), mono_array_length (array));
                        else
-                               memcpy (&o->vector, &array->vector, size);
+                               mono_gc_memmove (&o->vector, &array->vector, size);
                } else {
                        mono_array_memcpy_refs (o, 0, array, 0, mono_array_length (array));
                }
 #else
-               memcpy (&o->vector, &array->vector, size);
+               mono_gc_memmove (&o->vector, &array->vector, size);
 #endif
                return o;
        }
@@ -4578,12 +4578,12 @@ mono_array_clone_in_domain (MonoDomain *domain, MonoArray *array)
                if (klass->element_class->has_references)
                        mono_value_copy_array (o, 0, mono_array_addr_with_size (array, 0, 0), mono_array_length (array));
                else
-                       memcpy (&o->vector, &array->vector, size);
+                       mono_gc_memmove (&o->vector, &array->vector, size);
        } else {
                mono_array_memcpy_refs (o, 0, array, 0, mono_array_length (array));
        }
 #else
-       memcpy (&o->vector, &array->vector, size);
+       mono_gc_memmove (&o->vector, &array->vector, size);
 #endif
 
        return o;
@@ -5000,7 +5000,7 @@ mono_value_box (MonoDomain *domain, MonoClass *class, gpointer value)
        mono_gc_wbarrier_value_copy ((char *)res + sizeof (MonoObject), value, 1, class);
 #else
 #if NO_UNALIGNED_ACCESS
-       memcpy ((char *)res + sizeof (MonoObject), value, size);
+       mono_gc_memmove ((char *)res + sizeof (MonoObject), value, size);
 #else
        switch (size) {
        case 1:
@@ -5016,7 +5016,7 @@ mono_value_box (MonoDomain *domain, MonoClass *class, gpointer value)
                *(guint64 *)((guint8 *) res + sizeof (MonoObject)) = *(guint64 *) value;
                break;
        default:
-               memcpy ((char *)res + sizeof (MonoObject), value, size);
+               mono_gc_memmove ((char *)res + sizeof (MonoObject), value, size);
        }
 #endif
 #endif
@@ -6170,10 +6170,10 @@ mono_method_return_message_restore (MonoMethod *method, gpointer *params, MonoAr
                                        if (class->has_references)
                                                mono_gc_wbarrier_value_copy (*((gpointer *)params [i]), arg + sizeof (MonoObject), 1, class);
                                        else
-                                               memcpy (*((gpointer *)params [i]), arg + sizeof (MonoObject), size);
+                                               mono_gc_memmove (*((gpointer *)params [i]), arg + sizeof (MonoObject), size);
                                } else {
                                        size = mono_class_value_size (mono_class_from_mono_type (pt), NULL);
-                                       memset (*((gpointer *)params [i]), 0, size);
+                                       mono_gc_bzero (*((gpointer *)params [i]), size);
                                }
                        }
 

diff --git a/mono/metadata/reflection.c b/mono/metadata/reflection.c
index 46ce7a02d4c01ebef08e37eb16d01a095d512f5f..184bef4c458c783d86f5c2391455ea9f32ba4b72 100644 (file)
--- a/mono/metadata/reflection.c
+++ b/mono/metadata/reflection.c
@@ -7897,7 +7897,7 @@ handle_type:
                val = load_cattr_value (image, &subc->byval_arg, p, end);
                obj = mono_object_new (mono_domain_get (), subc);
                g_assert (!subc->has_references);
-               memcpy ((char*)obj + sizeof (MonoObject), val, mono_class_value_size (subc, NULL));
+               mono_gc_memmove ((char*)obj + sizeof (MonoObject), val, mono_class_value_size (subc, NULL));
                g_free (val);
                return obj;
        }

diff --git a/mono/metadata/sgen-gc.c b/mono/metadata/sgen-gc.c
index 43230d1373089afdbaf3bd349f101d44322be545..c0fcd99cc5990f71904b6e9603ef39c4b071914d 100644 (file)
--- a/mono/metadata/sgen-gc.c
+++ b/mono/metadata/sgen-gc.c
@@ -5807,7 +5807,7 @@ mono_gc_wbarrier_arrayref_copy (gpointer dest_ptr, gpointer src_ptr, int count)
        HEAVY_STAT (++stat_wbarrier_arrayref_copy);
        /*This check can be done without taking a lock since dest_ptr array is pinned*/
        if (ptr_in_nursery (dest_ptr) || count <= 0) {
-               memmove (dest_ptr, src_ptr, count * sizeof (gpointer));
+               mono_gc_memmove (dest_ptr, src_ptr, count * sizeof (gpointer));
                return;
        }
 
@@ -5842,7 +5842,7 @@ mono_gc_wbarrier_arrayref_copy (gpointer dest_ptr, gpointer src_ptr, int count)
                RememberedSet *rs;
                TLAB_ACCESS_INIT;
                LOCK_GC;
-               memmove (dest_ptr, src_ptr, count * sizeof (gpointer));
+               mono_gc_memmove (dest_ptr, src_ptr, count * sizeof (gpointer));
 
                rs = REMEMBERED_SET;
                DEBUG (8, fprintf (gc_debug_file, "Adding remset at %p, %d\n", dest_ptr, count));
@@ -6028,7 +6028,7 @@ mono_gc_wbarrier_value_copy (gpointer dest, gpointer src, int count, MonoClass *
 #else
                ENTER_CRITICAL_REGION;
 #endif
-               memmove (dest, src, size);
+               mono_gc_memmove (dest, src, size);
                sgen_card_table_mark_range ((mword)dest, size);
 #ifdef DISABLE_CRITICAL_REGION
                UNLOCK_GC;
@@ -6037,7 +6037,7 @@ mono_gc_wbarrier_value_copy (gpointer dest, gpointer src, int count, MonoClass *
 #endif
        } else {
                LOCK_GC;
-               memmove (dest, src, size);
+               mono_gc_memmove (dest, src, size);
                rs = REMEMBERED_SET;
                if (ptr_in_nursery (dest) || ptr_on_stack (dest) || !SGEN_CLASS_HAS_REFERENCES (klass)) {
                        UNLOCK_GC;
@@ -6084,7 +6084,7 @@ mono_gc_wbarrier_object_copy (MonoObject* obj, MonoObject *src)
        size = mono_object_class (obj)->instance_size;
        LOCK_GC;
        /* do not copy the sync state */
-       memcpy ((char*)obj + sizeof (MonoObject), (char*)src + sizeof (MonoObject),
+       mono_gc_memmove ((char*)obj + sizeof (MonoObject), (char*)src + sizeof (MonoObject),
                        size - sizeof (MonoObject));
        if (ptr_in_nursery (obj) || ptr_on_stack (obj)) {
                UNLOCK_GC;

diff --git a/mono/metadata/sgen-major-copy-object.h b/mono/metadata/sgen-major-copy-object.h
index 8922cc99e99470676c891a81b80b6fc1b9e29d19..06446b63efc97043bc33bd5439d1c2c94f761209 100644 (file)
--- a/mono/metadata/sgen-major-copy-object.h
+++ b/mono/metadata/sgen-major-copy-object.h
@@ -63,7 +63,8 @@ par_copy_object_no_checks (char *destination, MonoVTable *vt, void *obj, mword o
        LAB_0:
                ;
        } else {
-               memcpy (destination + sizeof (mword), (char*)obj + sizeof (mword), objsize - sizeof (mword));
+               /*can't trust memcpy doing word copies */
+               mono_gc_memmove (destination + sizeof (mword), (char*)obj + sizeof (mword), objsize - sizeof (mword));
        }
        /* adjust array->bounds */
        DEBUG (9, g_assert (vt->gc_descr));

diff --git a/mono/metadata/threads.c b/mono/metadata/threads.c
index 38f0cdf8c895b0f416784a7b59d6579635ccc145..120bedc008d6c4c470b03e66c0b6bceb93c10d79 100644 (file)
--- a/mono/metadata/threads.c
+++ b/mono/metadata/threads.c
@@ -1241,7 +1241,7 @@ byte_array_to_domain (MonoArray *arr, MonoDomain *domain)
                return arr;
 
        copy = mono_array_new (domain, mono_defaults.byte_class, arr->max_length);
-       memcpy (mono_array_addr (copy, guint8, 0), mono_array_addr (arr, guint8, 0), arr->max_length);
+       mono_gc_memmove (mono_array_addr (copy, guint8, 0), mono_array_addr (arr, guint8, 0), arr->max_length);
        return copy;
 }
 
@@ -3761,7 +3761,7 @@ free_thread_static_data_helper (gpointer key, gpointer value, gpointer user)
        if (!thread->static_data || !thread->static_data [idx])
                return;
        ptr = ((char*) thread->static_data [idx]) + (data->offset & 0xffffff);
-       memset (ptr, 0, data->size);
+       mono_gc_bzero (ptr, data->size);
 }
 
 static void

diff --git a/mono/metadata/tpool-epoll.c b/mono/metadata/tpool-epoll.c
index 18c6a204bfb30cdc093f78cde1ca1de5f67110bd..7c94652629b796e82e3b0fdfe4ffd63e9f719c0f 100644 (file)
--- a/mono/metadata/tpool-epoll.c
+++ b/mono/metadata/tpool-epoll.c
@@ -159,7 +159,7 @@ tp_epoll_wait (gpointer p)
                }
                LeaveCriticalSection (&socket_io_data->io_lock);
                threadpool_append_jobs (&async_io_tp, (MonoObject **) async_results, nresults);
-               memset (async_results, 0, sizeof (gpointer) * nresults);
+               mono_gc_bzero (async_results, sizeof (gpointer) * nresults);
        }
 }
 #undef EPOLL_NEVENTS

diff --git a/mono/metadata/tpool-kqueue.c b/mono/metadata/tpool-kqueue.c
index b043791987ca23652a43119937ef0b45456ca6da..6a2ecdfdb830e8315ed74900bcecb363bceec52c 100644 (file)
--- a/mono/metadata/tpool-kqueue.c
+++ b/mono/metadata/tpool-kqueue.c
@@ -151,7 +151,7 @@ tp_kqueue_wait (gpointer p)
                }
                LeaveCriticalSection (&socket_io_data->io_lock);
                threadpool_append_jobs (&async_io_tp, (MonoObject **) async_results, nresults);
-               memset (async_results, 0, sizeof (gpointer) * nresults);
+               mono_gc_bzero (async_results, sizeof (gpointer) * nresults);
        }
 }
 #undef KQUEUE_NEVENTS