Fix potential overflow when we're nearing 4G blocks..

src/arena.c

@@ -2,29 +2,22 @@
 #include "base_core.h"
 #include "platform.h"
 
-typedef struct MemoryBlockOptions MemoryBlockOptions;
-struct MemoryBlockOptions {
-    U32 size;
-    U32 commit_size;
-    U32 commit_now_size;
-    U32 page_size;
-};
-static MemoryBlock *memoryblock_allocate(const MemoryBlockOptions *opts)
-{
-    U32 aligned_size            = AlignUpPow2(opts->size, opts->page_size);
-    U32 aligned_commit_size     = AlignUpPow2(opts->commit_size, opts->page_size);
-    U32 aligned_commit_now_size = AlignUpPow2(opts->commit_now_size, opts->page_size);
 
-    MemoryBlock *block = memory_reserve(aligned_size);
+static MemoryBlock *memoryblock_allocate(U32 size, U32 commit_size, U32 page_size)
+{
+    Assert(IsAlignedTo(size, page_size));
+    Assert(IsAlignedTo(commit_size, page_size));
+
+    MemoryBlock *block = memory_reserve(size);
     Assert(block != NULL);
-    memory_commit(block, aligned_commit_now_size);
+    memory_commit(block, commit_size);
 
     block->base          = (U8 *)block;
-    block->size          = aligned_size;
+    block->size          = size;
     block->first_free    = MemoryBlock_Header_Size;
     block->arena_offset  = 0;
     block->prev          = NULL;
-    block->committed_end = aligned_commit_now_size;
+    block->committed_end = commit_size;
 
     ASAN_POISON_MEMORY_REGION(block->base, block->size);
     ASAN_UNPOISON_MEMORY_REGION(block, MemoryBlock_Header_Size);
@@ -37,22 +30,19 @@ void arena_init(Arena *arena, const ArenaOptions *opts)
     Assert(opts->size > MemoryBlock_Header_Size);
     Assert(opts->size < (U32_Max -  page_size)); // Reserving last piece so our math doesn't overflow
     Assert(opts->commit_size > 0);
-    Assert(opts->commit_size <= opts->size);
 
-    MemoryBlockOptions mb_opts;
-    mb_opts.page_size       = page_size;
-    mb_opts.commit_size     = opts->commit_size;
-    mb_opts.size            = opts->size;
-    mb_opts.commit_now_size = opts->commit_size;
-    MemoryBlock *block = memoryblock_allocate(&mb_opts);
+    U32 aligned_commit_size = AlignUp(opts->commit_size, page_size);
+    U32 aligned_size        = AlignUp(opts->size, page_size);
+    Assert(aligned_commit_size <= aligned_size);
+
+    MemoryBlock *block  = memoryblock_allocate(aligned_size, aligned_commit_size, page_size);
 
     arena->flags            = opts->flags;
     arena->checkpoint_level = 0;
     arena->current          = block;
-    arena->block_size       = opts->size;
-    arena->commit_size      = opts->commit_size;
+    arena->block_size       = aligned_size;
+    arena->commit_size      = aligned_commit_size;
     arena->page_size        = page_size;
-
 }
 
 void arena_free(Arena *arena)
@@ -69,35 +59,32 @@ void arena_free(Arena *arena)
 
 void *arena_push(Arena *arena, U32 size, U32 align)
 {
-    Assert(size < (U32_Max - platform_page_size()));
     Assert(IsPow2(align));
 
+
     MemoryBlock *block = arena->current;
-    U32 start_pos = AlignUpPow2(block->first_free, align);  // might align past block->size, handled in below check
+    U32 start_pos = AlignUp(block->first_free, align);  // might align past block->size, handled in below check
     U32 available = block->size - start_pos;
 
     if (start_pos > block->size || available < size) {
-        U32 block_size = arena->block_size; // original user requested size
+        U32 pad = AlignUp(MemoryBlock_Header_Size, align);
+        Assert(size <= (U32_Max - arena->page_size) - pad);
+        U32 needed = pad + size;
+        U32 new_block_size = arena->block_size;
         U32 new_commit_size = arena->commit_size;
-        if (size > block_size - MemoryBlock_Header_Size) {
-            block_size = AlignUpPow2(size + MemoryBlock_Header_Size,align);
-            new_commit_size = block_size;
+        if (needed > new_block_size) {
+            new_block_size = AlignUp(needed, arena->page_size);
+            new_commit_size = new_block_size;
         }
-        U32 commit_now_size = Max(new_commit_size, size);
 
-        MemoryBlockOptions mb_opts;
-        mb_opts.page_size   = arena->page_size;
-        mb_opts.commit_size = new_commit_size;
-        mb_opts.size        = block_size;
-        mb_opts.commit_now_size = commit_now_size;
-        MemoryBlock *new_block = memoryblock_allocate(&mb_opts);
+        MemoryBlock *new_block = memoryblock_allocate(new_block_size, new_commit_size, arena->page_size);
         // arena_offset tracks the virtual absolute position within an arena
         // This is not a contiguous space, we use it to free blocks when popping the arena
         new_block->arena_offset = block->arena_offset + block->size;
         new_block->prev         = block;
         arena->current          = new_block;
         block                   = new_block;
-        start_pos               = AlignUpPow2(block->first_free, align);
+        start_pos               = AlignUp(block->first_free, align);
     }
 
     U32 end_pos = start_pos + size;
@@ -106,7 +93,7 @@ void *arena_push(Arena *arena, U32 size, U32 align)
     U8 *mem = &block->base[start_pos];
     if (block->committed_end < end_pos) {
         // Commit more memory
-        U32 aligned_end_pos   = AlignUpPow2(start_pos + size, arena->page_size);
+        U32 aligned_end_pos   = AlignUp(start_pos + size, arena->page_size);
         U32 aligned_size      = RoundUpToMultiple(aligned_end_pos - block->committed_end, arena->commit_size);
         aligned_size = Min(aligned_size, block->size - block->committed_end);