Optimize arena allocator, add helper functions

Refactor `arena_alloc` to insert newly allocated blocks at the head of
the block list, improving allocation efficiency.
This reduces pointer chasing during allocation and enables recently
freed memory to be reused more quickly.

Introduce `arena_calloc`, `arena_memdup`, `arena_strdup`, and
`arena_realloc` to extend the arena allocator’s API:

- `arena_calloc`: Allocate zero-initialized memory blocks.
- `arena_memdup`: Duplicate arbitrary data into arena-managed memory.
- `arena_strdup`: Copy null-terminated strings into the arena.
- `arena_realloc`: Resize existing arena-managed allocations.

These improvements lay the foundation for replacing standard `malloc`,
`calloc`, `realloc`, and `free` with the arena allocator, providing
better performance, consistent memory handling, and simpler batch
deallocation throughout the project.

Author: AW-AlanWu

src/globals.c

@@ -89,7 +89,6 @@ int elf_data_start;
 
 /**
  * arena_block_create() - Creates a new arena block with given capacity.
- * The created arena block is guaranteed to be zero-initialized.
  * @capacity: The capacity of the arena block. Must be positive.
  *
  * Return: The pointer of created arena block. NULL if failed to allocate.
@@ -99,14 +98,14 @@ arena_block_t *arena_block_create(int capacity)
     arena_block_t *block = malloc(sizeof(arena_block_t));
 
     if (!block) {
-        printf("Failed to allocate memory for arena block\n");
+        printf("Failed to allocate memory for arena block structure\n");
         exit(1);
     }
 
-    block->memory = calloc(capacity, sizeof(char));
+    block->memory = malloc(capacity * sizeof(char));
 
     if (!block->memory) {
-        printf("Failed to allocate memory for arena block\n");
+        printf("Failed to allocate memory for arena block buffer\n");
         free(block);
         exit(1);
     }
@@ -117,6 +116,16 @@ arena_block_t *arena_block_create(int capacity)
     return block;
 }
 
+/**
+ * arena_block_free() - Free a single arena block and its memory buffer.
+ * @block: Pointer to the arena_block_t to free. Must not be NULL.
+ */
+void arena_block_free(arena_block_t *block)
+{
+    free(block->memory);
+    free(block);
+}
+
 /**
  * arena_init() - Initializes the given arena with initial capacity.
  * @initial_capacity: The initial capacity of the arena. Must be positive.
@@ -126,6 +135,10 @@ arena_block_t *arena_block_create(int capacity)
 arena_t *arena_init(int initial_capacity)
 {
     arena_t *arena = malloc(sizeof(arena_t));
+    if (!arena) {
+        printf("Failed to allocate memory for arena structure\n");
+        exit(1);
+    }
     arena->head = arena_block_create(initial_capacity);
     return arena;
 }
@@ -141,47 +154,123 @@ arena_t *arena_init(int initial_capacity)
  */
 void *arena_alloc(arena_t *arena, int size)
 {
-    char *ptr;
-    arena_block_t *block = arena->head;
-
-    while (block) {
-        if (block->offset + size <= block->capacity) {
-            ptr = block->memory + block->offset;
-            block->offset += size;
-            return ptr;
-        }
-        if (!block->next)
-            break;
-        block = block->next;
+    if (size <= 0) {
+        printf("arena_alloc: size must be positive");
+        exit(1);
     }
 
-    /* If no space is available, create a new block
-     * Allocate at least 256 KiB or the requested size
-     */
-    int new_capacity = size > DEFAULT_ARENA_SIZE ? size : DEFAULT_ARENA_SIZE;
-    arena_block_t *new_block = arena_block_create(new_capacity);
+    /* Align to PTR_SIZE bytes */
+    size = (size + PTR_SIZE - 1) & ~(PTR_SIZE - 1);
 
-    if (!new_block)
-        return NULL;
+    if (!arena->head || arena->head->offset + size > arena->head->capacity) {
+        /* Need a new block: choose capacity = max(DEFAULT_ARENA_SIZE, size) */
+        int new_capacity =
+            (size > DEFAULT_ARENA_SIZE ? size : DEFAULT_ARENA_SIZE);
+        arena_block_t *new_block = arena_block_create(new_capacity);
+        new_block->next = arena->head;
+        arena->head = new_block;
+    }
 
-    block->next = new_block;
-    ptr = new_block->memory + new_block->offset;
-    new_block->offset += size;
+    void *ptr = arena->head->memory + arena->head->offset;
+    arena->head->offset += size;
     return ptr;
 }
 
 /**
- * arena_reset() - Resets the given arena by resetting all blocks' offset to 0.
- * @arena: The arena to reset. Must not be NULL.
+ * arena_calloc() - arena_alloc() plus explicit zero‑initialization.
+ * @arena: The arena to allocate memory from. Must not be NULL.
+ * @n:     Number of elements.
+ * @size:  Size of each element in bytes.
+ *
+ * Internally calls arena_alloc(n * size) and then fills the entire region
+ * with zero bytes.
+ *
+ * Return: Pointer to zero-initialized memory.
  */
-void arena_reset(arena_t *arena)
+void *arena_calloc(arena_t *arena, int n, int size)
 {
-    arena_block_t *block = arena->head;
+    int total = n * size;
+    void *ptr = arena_alloc(arena, total);
 
-    while (block) {
-        block->offset = 0;
-        block = block->next;
+    int *w_ptr = ptr;
+    int w_count = total >> 2;
+    int b_index = w_count << 2;
+
+    for (int i = 0; i < w_count; ++i)
+        w_ptr[i] = 0;
+
+    char *b_ptr = ptr;
+    while (b_index < total)
+        b_ptr[b_index++] = 0;
+
+    return ptr;
+}
+
+/**
+ * arena_realloc() - Reallocate a previously allocated region within the arena
+ * to a different size.
+ *
+ * If existing region is the most recent allocation in the current block
+ * and there is enough space to expand in place, simply extend the offset.
+ * Otherwise, allocate a new region of the requested size and copy the old data.
+ *
+ * @arena: Pointer to the arena. Must not be NULL.
+ * @oldptr: Pointer to the previously allocated memory in the arena.
+ * @oldsz: Original size (in bytes) of that allocation.
+ * @newsz: New desired size (in bytes).
+ *
+ * Return: Pointer to the reallocated (resized) memory region.
+ */
+void *arena_realloc(arena_t *arena, char *oldptr, int oldsz, int newsz)
+{
+    /* No need to grow; existing pointer is sufficient. */
+    if (newsz <= oldsz)
+        return oldptr;
+
+    /* Check if oldptr is at the end of the current block's allocations */
+    if (oldptr + oldsz == arena->head->memory + arena->head->offset &&
+        arena->head->offset + (newsz - oldsz) <= arena->head->capacity) {
+        /* Grow in place */
+        arena->head->offset += (newsz - oldsz);
+        return oldptr;
     }
+
+    /* Otherwise, allocate new region and copy */
+    void *newptr = arena_alloc(arena, newsz);
+    memcpy(newptr, oldptr, oldsz);
+    return newptr;
+}
+
+/**
+ * arena_strdup() - Duplicate a NULL-terminated string into the arena.
+ *
+ * @arena: a Pointer to the arena. Must not be NULL.
+ * @str: NULL-terminated input string to duplicate. Must not be NULL.
+ *
+ * Return: Pointer to the duplicated string stored in the arena.
+ */
+char *arena_strdup(arena_t *arena, char *str)
+{
+    int n = strlen(str);
+    char *dup = arena_alloc(arena, n + 1);
+    memcpy(dup, str, n);
+    dup[n] = '\0';
+    return dup;
+}
+
+/**
+ * arena_memdup() - Duplicate a block of memory into the arena.
+ * Allocates size bytes within the arena and copies data from the input pointer.
+ *
+ * @arena: a Pointer to the arena. Must not be NULL.
+ * @data: data Pointer to the source memory. Must not be NULL.
+ * @size: size Number of bytes to copy. Must be non-negative.
+ *
+ * Return: The pointer to the duplicated memory stored in the arena.
+ */
+void *arena_memdup(arena_t *arena, void *data, int size)
+{
+    return memcpy(arena_alloc(arena, size), data, size);
 }
 
 /**
@@ -194,8 +283,7 @@ void arena_free(arena_t *arena)
 
     while (block) {
         next = block->next;
-        free(block->memory);
-        free(block);
+        arena_block_free(block);
         block = next;
     }