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

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 {

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));
 }
 

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);

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;
 }

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;	\

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;

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));
 }
 

mono/metadata/object.c

@@ -2912,7 +2912,7 @@ set_value (MonoType *type, void *dest, void *value, int deref_pointer)
 			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);
 				}
 			}
 

mono/metadata/reflection.c

@@ -7897,7 +7897,7 @@ load_cattr_value (MonoImage *image, MonoType *t, const char *p, const char **end
 		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;
 	}

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;

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));

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

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

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