fix: memory allocator align heap to eight bytes

Author: v420v

lib/std/header.ibu

@@ -11,15 +11,7 @@ struct Vec {
     cap i32,
 }
 
-struct BlockHeader {
-    size i32,
-    is_free bool,
-    next *BlockHeader,
-}
-
-func sbrk(increment i32) *u8;
 func alloc(size i32) *u8;
-func free(ptr *u8) u0;
 func strcmp(a *u8, b *u8) bool;
 func new_vec(cap i32) *Vec;
 func vec_realloc(vec *Vec) u0;

lib/std/std.ibu

@@ -4,96 +4,42 @@
 
 #define CHUNK_SIZE 16384 // 16KB
 
-let free_list *u8;
+#define HEAP_SIZE 2147483647
 
-func memset(ptr *u8, val u8, n i32) u0 {
-    for let i i32 = 0; i < n; i++ {
-        ptr[i] = val;
-    }
-}
-
-func sbrk(increment i32) *u8 {
-    let old_break *u8 = brk(0);
-    if old_break < 1 {
-        return nil;
-    }
-
-    let new_break *u8 = old_break + increment;
+let heap_head *u8;
+let heap_current *u8;
+let heap_tail *u8;
 
-    let result *u8 = brk(new_break);
-    if result < 1 {
-        return nil;
-    }
-
-    return old_break;
-}
-
-func find_free_block(size i32) *BlockHeader {
-    let current *BlockHeader = free_list;
-    while current != nil {
-        if current.is_free && current.size >= size + typesize(BlockHeader) {
-            return current;
-        }
-        current = current.next;
+func heap_init() u0 {
+    heap_head = brk(0);
+    heap_tail = brk(heap_head + HEAP_SIZE * 2);
+    if (heap_head % 8) == 0 {
+        heap_current = heap_head;
+    } else {
+        heap_current = heap_head + (8 - (heap_head % 8));
     }
-    return nil;
 }
 
-func request_space(size i32) *BlockHeader {
-    let request_size i32 = size + typesize(BlockHeader);
-
-    let new_heap_head *BlockHeader = sbrk(request_size);
-    if new_heap_head < 1 {
-        return nil;
+func memset(ptr *u8, val u8, n i32) u0 {
+    for let i i32 = 0; i < n; i++ {
+        ptr[i] = val;
     }
-
-    memset(new_heap_head, 0, request_size);
-
-    new_heap_head.size = request_size;
-    new_heap_head.is_free = false;
-    new_heap_head.next = nil;
-
-    return new_heap_head;
 }
 
 func alloc(size i32) *u8 {
-    if size <= 0 {
-        return nil;
-    }
-
-    let aligned_size i32 = size;
-    let block *BlockHeader = find_free_block(aligned_size);
-    if block == nil {
-        block = request_space(aligned_size);
-        if block == nil {
-            return nil;
-        }
-    } else {
-        if block == free_list {
-            free_list = block.next;
-        } else {
-            let prev *BlockHeader = free_list;
-            while prev.next != block {
-                prev = prev.next;
-            }
-            prev.next = block.next;
-        }
-        block.is_free = false;
-        block.next = nil;
+    if heap_current == nil {
+        heap_init();
     }
 
-    return block + typesize(BlockHeader);
-}
-
-func free(ptr *u8) u0 {
-    if ptr == nil {
-        return;
+    if heap_current + size > heap_tail {
+        eprintf("heap overflow\n");
+        exit(1);
     }
-    let block *BlockHeader = ptr - typesize(BlockHeader);
-    block.is_free = true;
 
-    block.next = free_list;
-    free_list = block;
+    let result *u8 = heap_current;
+    heap_current = heap_current + size;
+    memset(result, 0, size);
+    return result;
 }
 
 func strcmp(a *u8, b *u8) bool {
@@ -186,8 +132,6 @@ func memmove(dest *u8, src *u8, n u32) u0 {
             *(p_dest + i) = *(tmp + i);
         }
     }
-
-    free(tmp);
 }
 
 func byte_to_lower(c u8) u8 {