More stuff

.gitignore

@@ -0,0 +1,6 @@
+a.out
+*.~*
+.gdb_history
+*.o
+*.a
+.clang-format

.vscode/launch.json

@@ -0,0 +1,16 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Launch",
+            "type": "lldb",
+            "request": "launch",
+            "program": "${workspaceRoot}/a.out",
+            "args": [],
+            "cwd": "${workspaceRoot}"
+        }
+    ]
+}

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "C_Cpp.default.cStandard": "gnu23"
+}

.vscode/tasks.json

@@ -0,0 +1,16 @@
+{
+    // See https://go.microsoft.com/fwlink/?LinkId=733558
+    // for the documentation about the tasks.json format
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "build",
+            "type": "shell",
+            "command": "${workspaceFolder}/build.sh && ./a.out",
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            }
+        }
+    ]
+}

build.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+set -x
+gcc  -ggdb -Wall -Wextra -Wno-unused-parameter -Wno-unused-variable -std=gnu23 src/*c

src/arena.c

@@ -15,12 +15,15 @@ static void memory_release(void *mem)
 
 Arena *arena_alloc_(const ArenaParams *params)
 {
+    Assert(params->size > ARENA_HEADER_SZ);
+    Assert(params->size < (U32_Max -  ARENA_HEADER_SZ - 1));
+
     // Note: only backend now is malloc
-    Assert(params.size > ARENA_HEADER_SZ);
     void *base = memory_allocate(params->size);
     Assert(base != NULL);
 
     Arena *arena = (Arena *)base;
+    arena->base     = base;
     arena->current  = arena;
     arena->size     = params->size;
     arena->pos      = ARENA_HEADER_SZ;
@@ -29,7 +32,6 @@ Arena *arena_alloc_(const ArenaParams *params)
     return arena;
 }
 
-
 void arena_free(Arena *arena)
 {
     Arena *it = arena->current;
@@ -42,35 +44,36 @@ void arena_free(Arena *arena)
     }
 }
 
-
-
 void *arena_push(Arena *arena, U32 size, U32 align)
 {
+    Assert(size < (U32_Max - align - ARENA_HEADER_SZ - 1));
+    Assert(IsPow2(align));
     Arena *current = arena->current;
     U32 start_pos = AlignUpPow2(arena->pos, align);
-    U32 available = current->size - start_pos;
+    U32 available = arena_available(current);
 
-    if (available > size) {
-
-        U8 *mem = &current->base[start_pos];
-        arena->pos = start_pos + size;
-        return mem;
-
-    } else {
-        // Note: We could hunt for a previous arena that still have room
+    if (available < size) {
         U32 new_size = current->size;
         if (new_size < size) {
-            new_size = size;
+            new_size = AlignUpPow2(size + ARENA_HEADER_SZ,align);
         }
 
         ArenaParams new_params  = {};
-        new_params.flags = current->flags;
-        new_params.size = size + ARENA_HEADER_SZ;
+        new_params.flags        = current->flags;
+        new_params.size         = new_size;
+
         Arena *new_arena = arena_alloc_(&new_params);
-
-        new_arena->prev = current;
+        new_arena->prev  = current;
         current->current = new_arena;
-        current = new_arena;
-
+        current          = new_arena;
+        start_pos        = AlignUpPow2(current->pos, align);
     }
+
+    U32 end_pos = start_pos + size;
+    Assert(end_pos <= current->size);
+
+    U8 *mem     = &current->base[start_pos];
+    arena->pos  = start_pos + size;
+
+    return mem;
 }

src/arena.h

@@ -32,3 +32,6 @@ INLINE U32 arena_available(const Arena *arena)
 }
 
 
+Arena *arena_alloc_(const ArenaParams *params);
+void arena_free(Arena *arena);
+void *arena_push(Arena *arena, U32 size, U32 align);

src/base_core.h

@@ -4,6 +4,7 @@
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
+#include <string.h>
 
 // Types
 typedef int8_t      S8;
@@ -16,8 +17,10 @@ typedef uint32_t    U32;
 typedef uint64_t    U64;
 typedef float       F32;
 typedef double      F64;
-#if defined(__FLT128_MANT_DIG__) || defined(__FLOAT128__)
-typedef __float128 F128;
+#if defined(__FLT128_MANT_DIG__)
+    typedef _Float128 F128;
+#elif defined(__SIZEOF_FLOAT128__)
+    typedef __float128 F128;
 #endif
 #ifdef __SIZEOF_INT128__
 typedef __int128          S128;
@@ -179,12 +182,12 @@ typedef unsigned __int128 U128;
 #define TB(n)    (((U64)(n)) << 40)
 
 #define Thousand(n) (((U64)(n) * 1000))
-#define Million(n)  (((U64)(n) * 1000_000))
-#define Billion(n)  (((U64)(n) * 1000_000_000))
+#define Million(n)  (((U64)(n) * 1000000))
+#define Billion(n)  (((U64)(n) * 1000000000))
 
 // memory
 #define MemSet(ptr, val, len)       memset(ptr, val, len)
-#define MemoryZero(ptr, len)        memset_explicit(ptr, 0, len)
+#define MemoryZero(ptr, len)        explicit_bzero(ptr,len)
 #define MemMove(dst, src, len)      memmove(dst, src, len)
 #define MemCpy(dst, src, len)       memcpy(dst, src, len)
 #define MemAppend(dst, src, len)    mempcpy(dst, src, len)

src/main.c

@@ -0,0 +1,41 @@
+#include "base_core.h"
+#include "arena.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+void arena_dump(const Arena *arena)
+{
+    arena = arena->current;
+    puts("@@@@@@@@@@");
+    while (arena) {
+        puts("-----Arena-----");
+        printf("base: %p\n", arena->base);
+        printf("size: %u\n", arena->size);
+        printf("pos:  %u\n", arena->pos);
+        printf("prev: %p\n", arena->prev);
+        puts("-----Arena  end-");
+        arena = arena->prev;
+    }
+}
+
+int main(int argc, char *argv[])
+{
+    ArenaParams arena_params = {};
+    arena_params.size = 1024+ARENA_HEADER_SZ;
+    Arena *arena = arena_alloc_(&arena_params);
+    arena_dump(arena);
+    char *ptr = arena_push(arena, 1024, 1);
+    MemoryZero(ptr, 1024);
+    printf("Allocated ptr %p\n", ptr);
+    arena_dump(arena);
+    ptr = arena_push(arena, 512, 1);
+    MemoryZero(ptr, 512);
+    printf("Allocated ptr %p\n", ptr);
+    arena_dump(arena);
+
+    ptr = arena_push(arena, 1, 1);
+    MemoryZero(ptr, 1);
+    printf("Allocated ptr %p\n", ptr);
+    arena_dump(arena);
+    arena_free(arena);
+}