stdlib: implement a crappy allocator

pointbazaar · pointbazaar · commit e261ca3f2b85 · 2025-03-23T00:02:58.000+01:00
It allocates in multiples of systems page size.
It does not do any internal bookkeeping at all.

To summarize, it is very inefficient. But it should suffice for creating
simple programs which need a heap.
diff --git a/compiler/main/typeinference/typeinfer_expr.c b/compiler/main/typeinference/typeinfer_expr.c
@@ -91,6 +91,12 @@ static struct Type* infer_type_expr_ptr_arithmetic(struct ST* st, struct Type* t
 		return NULL;
 	}
 
+	if (t2->pointer_type) {
+		if (op == OP_EQ || op == OP_NEQ || op == OP_GE || op == OP_GT || op == OP_LE || op == OP_LT) {
+			return typeFromStrPrimitive(st, "bool");
+		}
+	}
+
 	if (t2->basic_type && t2->basic_type->simple_type) {
 		struct SimpleType* stype = t2->basic_type->simple_type;
 
diff --git a/examples/stdlib/base/allocator/alloc_0_bytes/alloc_0_bytes.dg b/examples/stdlib/base/allocator/alloc_0_bytes/alloc_0_bytes.dg
@@ -0,0 +1,13 @@
+
+fn main () -> int {
+
+	local *uint8 ptr;
+
+	ptr  = malloc(0);
+
+	if ptr != 0 {
+		return 1;
+	}
+
+	return 0;
+}
diff --git a/examples/stdlib/base/allocator/alloc_0_bytes/alloc_0_bytes.exitcode b/examples/stdlib/base/allocator/alloc_0_bytes/alloc_0_bytes.exitcode
@@ -0,0 +1 @@
+0
diff --git a/examples/stdlib/base/allocator/alloc_0_bytes/alloc_0_bytes.stdlib b/examples/stdlib/base/allocator/alloc_0_bytes/alloc_0_bytes.stdlib
diff --git a/examples/stdlib/base/allocator/loop_test/loop_test.dg b/examples/stdlib/base/allocator/loop_test/loop_test.dg
@@ -0,0 +1,20 @@
+
+fn main () -> int {
+
+	// test that the allocations do not exhaus memory
+
+	for i in 0 .. 10000 {
+
+		*uint64 p = malloc(3000);
+
+		if p == 0 {
+			return 1;
+		}
+
+		if free(p) != 0 {
+			return 1;
+		}
+	}
+
+	return 0;
+}
diff --git a/examples/stdlib/base/allocator/loop_test/loop_test.exitcode b/examples/stdlib/base/allocator/loop_test/loop_test.exitcode
@@ -0,0 +1 @@
+0
diff --git a/examples/stdlib/base/allocator/loop_test/loop_test.stdlib b/examples/stdlib/base/allocator/loop_test/loop_test.stdlib
diff --git a/examples/stdlib/base/allocator/no_overlap/no_overlap.dg b/examples/stdlib/base/allocator/no_overlap/no_overlap.dg
@@ -0,0 +1,19 @@
+
+fn main () -> int {
+
+	*uint64 ptr1 = malloc(30);
+	*uint64 ptr2 = malloc(30);
+
+	if ((ptr1 + 30) > ptr2 && (ptr1 <= ptr2)){
+		return 1;
+	}
+
+	if ((ptr2 + 30) > ptr1 && (ptr2 <= ptr1)){
+		return 1;
+	}
+
+	free(ptr1);
+	free(ptr2);
+
+	return 0;
+}
diff --git a/examples/stdlib/base/allocator/no_overlap/no_overlap.exitcode b/examples/stdlib/base/allocator/no_overlap/no_overlap.exitcode
@@ -0,0 +1 @@
+0
diff --git a/examples/stdlib/base/allocator/no_overlap/no_overlap.stdlib b/examples/stdlib/base/allocator/no_overlap/no_overlap.stdlib
diff --git a/examples/stdlib/base/allocator/realloc_test/realloc_test.dg b/examples/stdlib/base/allocator/realloc_test/realloc_test.dg
@@ -0,0 +1,35 @@
+
+fn main () -> int {
+
+	*uint8 p1 = malloc(4096);
+
+	if p1 == 0 {
+		return 1;
+	}
+
+	*p1 = 9;
+
+	*uint8 p2 = realloc(p1, 8192);
+
+	if p2 == 0 {
+		return 2;
+	}
+
+	if *p2 != 9 {
+		return 3;
+	}
+
+	if p1 == p2 {
+		// it should not re-use that block, it is too small
+		return 4;
+	}
+
+	*uint8 p3 = realloc(p2, 4096);
+
+	if p3 != p2 {
+		// it should re-use the block, it is big enough
+		return 5;
+	}
+
+	return 0;
+}
diff --git a/examples/stdlib/base/allocator/realloc_test/realloc_test.exitcode b/examples/stdlib/base/allocator/realloc_test/realloc_test.exitcode
@@ -0,0 +1 @@
+0
diff --git a/examples/stdlib/base/allocator/realloc_test/realloc_test.stdlib b/examples/stdlib/base/allocator/realloc_test/realloc_test.stdlib
diff --git a/examples/stdlib/base/allocator/use_allocator/use_allocator.dg b/examples/stdlib/base/allocator/use_allocator/use_allocator.dg
@@ -0,0 +1,34 @@
+
+fn main () -> int {
+
+	local *uint8 ptr;
+
+	ptr = malloc(329);
+
+	if ptr == 0 {
+		return 2;
+	}
+
+	free(ptr);
+
+	ptr = malloc(8349);
+
+	if ptr == 0 {
+		return 3;
+	}
+
+	local *uint8 p;
+	p = ptr;
+
+	p += 100;
+	*p = 84;
+	p += 10;
+	*p = 92;
+	p -= 10;
+
+	uint8 res = *p;
+
+	free(ptr);
+
+	return res;
+}
diff --git a/examples/stdlib/base/allocator/use_allocator/use_allocator.exitcode b/examples/stdlib/base/allocator/use_allocator/use_allocator.exitcode
@@ -0,0 +1 @@
+84
diff --git a/examples/stdlib/base/allocator/use_allocator/use_allocator.stdlib b/examples/stdlib/base/allocator/use_allocator/use_allocator.stdlib
diff --git a/stdlib/base/allocator.dg b/stdlib/base/allocator.dg
@@ -0,0 +1,108 @@
+
+// This is a really bad allocator.
+// It allocates in multiples of page size.
+
+fn malloc(uint64 nbytes) -> *# {
+
+	// PROT_READ = 0x1
+	// PROT_WRITE = 0x2
+
+	// MAP_SHARED = 0x1
+	// MAP_ANONYMOUS = 0x20
+
+	if nbytes == 0 {
+		return 0;
+	}
+
+	uint64 n = 4096;
+	uint64 npages = 1;
+
+	while n < nbytes {
+		n += 4096;
+		npages++;
+	}
+
+	local *uint64 ptr;
+	ptr = mmap(0, n, 0x3, 0x21, -1, 0);
+
+	// preserve number of bytes for calling munmap later
+	*ptr = n;
+
+	return ptr + 16;
+}
+
+// @returns 0 on success
+fn free(*# ptr) -> int {
+
+	*uint64 p = ptr;
+
+	if p == 0 {
+		return -1;
+	}
+
+	// obtain the real address
+	p -= 16;
+
+	uint64 nbytes = *p;
+
+	return munmap(p, nbytes);
+}
+
+fn realloc(*# ptr, uint64 nbytes) -> *# {
+
+	if ptr == 0 {
+		return malloc(nbytes);
+	}
+
+	if nbytes == 0 {
+		free(ptr);
+		return 0;
+	}
+
+	*uint64 p = ptr;
+	p -= 16;
+	uint64 old_size = *p;
+
+	uint64 n = 4096;
+	uint64 npages = 1;
+	while n < nbytes {
+		n += 4096;
+		npages++;
+	}
+
+	if (n <= old_size) {
+		return ptr;
+	}
+
+	local *uint64 new_ptr;
+	new_ptr = malloc(nbytes);
+
+	if new_ptr == 0 {
+		return 0;
+	}
+
+	uint64 copy_size = old_size - 16;
+	if (copy_size > nbytes) {
+		copy_size = nbytes;
+	}
+
+	local *# dst;
+	dst = new_ptr;
+	local *uint8 src;
+	src = ptr;
+
+	*uint8 d = dst;
+
+	uint64 i = 0;
+	while i < copy_size {
+		*d = *src;
+		d++;
+		src++;
+		i++;
+	}
+
+	free(ptr);
+
+	return dst;
+}
+
