Add support for custom allocators to DeeDeepCopyContext

Author: GrieferAtWork

include/deemon/deepcopy.h

@@ -60,6 +60,27 @@ struct Dee_deepcopy_mapitem {
 	__BYTE_TYPE__       *dcmi_new;         /* [1..1] New pointer */
 };
 
+struct Dee_deepcopy_uheap {
+	struct Dee_deepcopy_uheap       *ddcuh_next; /* [0..1][owned] Next user-heap chunk */
+	DeeObject                       *ddcuh_base; /* [1..1][owned(ddcuh_free)] Heap item base address */
+	NONNULL_T((1)) void      (DCALL *ddcuh_free)(void *__restrict ob); /* [1..1][const] Free function for `ddcuh_base' */
+};
+#ifdef __INTELLISENSE__
+#define Dee_deepcopy_uheap_alloc()    ((struct Dee_deepcopy_uheap *)sizeof(struct Dee_deepcopy_uheap))
+#define Dee_deepcopy_uheap_free(self) (void)Dee_REQUIRES_TYPE(struct Dee_deepcopy_uheap *, self)
+#define Dee_deepcopy_uheap_destroy(self)        \
+	((*(self)->ddcuh_free)((self)->ddcuh_base), \
+	 Dee_deepcopy_uheap_free(self))
+#else /* __INTELLISENSE__ */
+#define Dee_deepcopy_uheap_alloc()    DeeObject_MALLOC(struct Dee_deepcopy_uheap)
+#define Dee_deepcopy_uheap_free(self) DeeObject_FREE(Dee_REQUIRES_TYPE(struct Dee_deepcopy_uheap *, self))
+#define Dee_deepcopy_uheap_destroy(self)               \
+	(Dee_Decref_unlikely((self)->ddcuh_base->ob_type), \
+	 (*(self)->ddcuh_free)((self)->ddcuh_base),        \
+	 Dee_deepcopy_uheap_free(self))
+#endif /* !__INTELLISENSE__ */
+
+
 #ifdef CONFIG_EXPERIMENTAL_CUSTOM_HEAP
 typedef void Dee_deepcopy_heap_t;
 #define Dee_deepcopy_heap_getbase(self)    (self)
@@ -129,6 +150,7 @@ typedef struct {
 	Dee_deepcopy_heap_t         *dcc_heap;       /* [0..N][owned] Deepcopy heap */
 	Dee_deepcopy_heap_t         *dcc_obheap;     /* [0..N][owned] Deepcopy heap for objects */
 	Dee_deepcopy_heap_t         *dcc_gcheap;     /* [0..N][owned] Deepcopy heap for gc objects */
+	struct Dee_deepcopy_uheap   *dcc_uheap;      /* [0..N][owned] Deepcopy heap for objects with custom allocators */
 	struct Dee_deepcopy_mapitem *dcc_ptrmapv;    /* [0..dcc_ptrmapc][owned][SORT(dcmi_old_minaddr ASC)] mapping of source range to target ranges. */
 	size_t                       dcc_ptrmapc;    /* # of used elements in `dcc_ptrmapv' */
 	size_t                       dcc_ptrmapa;    /* # of allocated elements in `dcc_ptrmapv' */

include/deemon/object.h

@@ -1804,8 +1804,8 @@ struct Dee_type_constructor {
 			 *          were created using regular heap allocations (`DeeObject_Malloc'). */
 			NONNULL_T((1)) void (DCALL *tp_free)(void *__restrict ob);
 			union {
-				size_t tp_instance_size;       /* [valid_if(tp_free == NULL)] */
-				void *(DCALL *tp_alloc)(void); /* [valid_if(tp_free != NULL)] */
+				size_t tp_instance_size;       /*       [valid_if(tp_free == NULL)] */
+				void *(DCALL *tp_alloc)(void); /* [1..1][valid_if(tp_free != NULL)] */
 			}
 #ifndef __COMPILER_HAVE_TRANSPARENT_UNION
 			_dee_aunion

src/deemon/objects/object.c

@@ -4950,8 +4950,7 @@ PUBLIC ATTR_PURE WUNUSED NONNULL((1)) size_t
 		return self->tp_init.tp_alloc.tp_instance_size;
 	/* FIXME: This right here doesn't work in DEX modules when PLT symbols are used.
 	 *
-	 * This currently breaks "deepcopy" for stuff like "collections.UniqueSet" when
-	 * deemon was built with "CONFIG_EXPERIMENTAL_SERIALIZED_DEEPCOPY".
+	 * This currently breaks serialization for stuff like "collections.UniqueSet".
 	 *
 	 * The only solution I can see here is to just always disable slab-based alloc
 	 * functions in DEX modules, but then the deemon core should be able to lazily

src/deemon/runtime/deepcopy.c

@@ -32,6 +32,7 @@
 #include <deemon/types.h>           /* DREF, DeeObject, DeeTypeObject, Dee_TYPE, Dee_funptr_t, Dee_unlockinfo, OBJECT_HEAD */
 
 #include <hybrid/typecore.h> /* __BYTE_TYPE__ */
+#include <hybrid/overflow.h> /* __BYTE_TYPE__ */
 
 #include <stdbool.h> /* bool, false, true */
 #include <stddef.h>  /* NULL, offsetof, ptrdiff_t, size_t */
@@ -317,7 +318,8 @@ deepcopy_gcobject_malloc_impl(DeeDeepCopyContext *__restrict self,
 	struct Dee_gc_head *result_head, *next;
 	ASSERT_OBJECT(ref);
 	ASSERTF(DeeType_IsGC(Dee_TYPE(ref)), "Use deepcopy_object_malloc_impl()");
-	num_bytes += Dee_GC_HEAD_SIZE;
+	if (OVERFLOW_UADD(num_bytes, Dee_GC_HEAD_SIZE, &num_bytes))
+		num_bytes = (size_t)-1;
 	result_head = (struct Dee_gc_head *)deepcopy_heap_malloc(&self->dcc_gcheap, num_bytes, do_try, do_bzero);
 	if unlikely(!result_head)
 		goto err;
@@ -466,6 +468,8 @@ deepcopy_putpointer(DeeDeepCopyContext *__restrict self,
 		}
 	}
 
+	/* TODO: Only allow this part for static pointers! */
+
 	/* Assign pointer... */
 	*deepcopy_ser2ptr(self, addrof_pointer, void const *) = pointer;
 	return 0;
@@ -519,6 +523,7 @@ DeeDeepCopy_Init(DeeDeepCopyContext *__restrict self) {
 	self->dcc_heap       = NULL;
 	self->dcc_obheap     = NULL;
 	self->dcc_gcheap     = NULL;
+	self->dcc_uheap      = NULL;
 	self->dcc_ptrmapv    = NULL;
 	self->dcc_ptrmapc    = 0;
 	self->dcc_ptrmapa    = 0;
@@ -552,6 +557,16 @@ destroy_obheap(Dee_deepcopy_heap_t *heap, ptrdiff_t offsetof_object) {
 	}
 }
 
+PRIVATE void DCALL
+destroy_uheap(struct Dee_deepcopy_uheap *heap) {
+	while (heap) {
+		struct Dee_deepcopy_uheap *next;
+		next = heap->ddcuh_next;
+		Dee_deepcopy_uheap_destroy(heap);
+		heap = next;
+	}
+}
+
 PUBLIC NONNULL((1)) void DCALL
 DeeDeepCopy_Fini(DeeDeepCopyContext *__restrict self) {
 	size_t i;
@@ -574,7 +589,9 @@ DeeDeepCopy_Fini(DeeDeepCopyContext *__restrict self) {
 	destroy_heap(self->dcc_heap);
 	destroy_obheap(self->dcc_obheap, 0);
 	destroy_obheap(self->dcc_gcheap, offsetof(struct Dee_gc_head, gc_object));
+	destroy_uheap(self->dcc_uheap);
 
+	/* For safety... */
 	DBG_memset(self, 0xcc, sizeof(*self));
 }
 
@@ -676,15 +693,66 @@ DeeDeepCopy_CopyObject(DeeDeepCopyContext *__restrict self,
 	} else {
 		int status;
 		size_t instance_size = DeeType_GetInstanceSize(tp);
-		if unlikely(!instance_size)
-			goto cannot_serialize;
-
-		/* Allocate buffer for object. */
-		out_addr = DeeType_IsGC(tp)
-		           ? deepcopy_gcobject_malloc(self, instance_size, ob)
-		           : deepcopy_object_malloc(self, instance_size, ob);
-		if unlikely(!out_addr)
-			goto err;
+		if unlikely(!instance_size) {
+			GenericObject *object_buffer;
+			struct Dee_deepcopy_uheap *uheap;
+			if (!tp->tp_init.tp_alloc.tp_free) {
+				/* tp_instance_size == 0 + tp_free == NULL
+				 * -> probably a singleton
+				 * -> cannot serialize */
+				goto cannot_serialize;
+			}
+			uheap = Dee_deepcopy_uheap_alloc();
+			if unlikely(!uheap)
+				goto err;
+
+			/* Support custom allocators... */
+			ASSERT(tp->tp_init.tp_alloc.tp_alloc);
+			object_buffer = (GenericObject *)((*tp->tp_init.tp_alloc.tp_alloc)());
+			if unlikely(!object_buffer) {
+				Dee_deepcopy_uheap_free(uheap);
+				goto err;
+			}
+			uheap->ddcuh_base = Dee_AsObject(object_buffer);
+			uheap->ddcuh_free = tp->tp_init.tp_alloc.tp_free;
+			uheap->ddcuh_next = self->dcc_uheap;
+			self->dcc_uheap   = uheap;
+			DeeObject_Init(object_buffer, tp);
+
+			if (DeeType_IsGC(tp)) {
+				/* Insert GC head */
+				struct Dee_gc_head *result_head, *next;
+				result_head = DeeGC_Head(object_buffer);
+				result_head->gc_pself = NULL;
+				if ((next = self->dcc_gc_head) != NULL) {
+					ASSERT(self->dcc_gc_tail != NULL);
+					next->gc_pself = &result_head->gc_next;
+				} else {
+					ASSERT(self->dcc_gc_tail == NULL);
+					self->dcc_gc_tail = result_head;
+				}
+				result_head->gc_next = next;
+				self->dcc_gc_head = result_head;
+				/* Only able to map the object's basic header */
+				instance_size = Dee_GC_OBJECT_OFFSET + sizeof(DeeObject);
+				if unlikely(deepcopy_mappointer(self, DeeGC_Head(ob),
+				                                result_head, instance_size, false))
+					goto err;
+			} else {
+				/* Only able to map the object's basic header */
+				instance_size = sizeof(DeeObject);
+				if unlikely(deepcopy_mappointer(self, ob, object_buffer, instance_size, false))
+					goto err;
+			}
+			out_addr = deepcopy_ptr2ser(self, object_buffer);
+		} else {
+			/* Allocate buffer for object. */
+			out_addr = DeeType_IsGC(tp)
+			           ? deepcopy_gcobject_malloc(self, instance_size, ob)
+			           : deepcopy_object_malloc(self, instance_size, ob);
+			if unlikely(!Dee_SERADDR_ISOK(out_addr))
+				goto err;
+		}
 
 		/* NOTE: Standard fields have already been initialized by "deepcopy_[gc]object_malloc" */
 		status = (*(Dee_tp_serialize_obj_t)tp_serialize)(ob, (DeeSerial *)self, out_addr);
@@ -719,6 +787,16 @@ cleanup_heap(Dee_deepcopy_heap_t *heap) {
 }
 #endif /* !CONFIG_EXPERIMENTAL_CUSTOM_HEAP */
 
+PRIVATE void DCALL
+cleanup_uheap(struct Dee_deepcopy_uheap *heap) {
+	while (heap) {
+		struct Dee_deepcopy_uheap *next;
+		next = heap->ddcuh_next;
+		Dee_deepcopy_uheap_free(heap);
+		heap = next;
+	}
+}
+
 /* Finalize "self" in the sense of doing a COMMIT.
  *
  * This function behaves similar to `DeeDeepCopy_Fini()', but will also
@@ -737,6 +815,7 @@ DeeDeepCopy_Pack(/*inherit(always)*/DeeDeepCopyContext *__restrict self) {
 	cleanup_heap(self->dcc_obheap);
 	cleanup_heap(self->dcc_gcheap);
 #endif /* !CONFIG_EXPERIMENTAL_CUSTOM_HEAP */
+	cleanup_uheap(self->dcc_uheap);
 
 	/* Free map tables. */
 	Dee_Free(self->dcc_ptrmapv);