Add generic dynamic array (dynarr_t)

Introduce a reusable, arena-allocated dynamic array implementation.
The new 'dynarr_t' type encapsulates element size, current size,
capacity, and a pointer to the arena allocator.

Core operations include:
  - 'dynarr_init': initialize array with specified capacity.
  - 'dynarr_reserve': reserve given capacity.
  - 'dynarr_resize': adjust array size, growing if needed.
  - 'dynarr_push_raw/byte/word': append elements of arbitrary types.
  - 'dynarr_extend': bulk append buffer of elements.
  - 'dynarr_get_raw/byte/word': retrieve elements by index with checks.
  - 'dynarr_set_raw': overwrite an element at a given index.

Relying on the existing arena allocator ensures proper byte alignment
and eliminates failure checks.

This implementation can replace the current 'strbuf_t' and most
fixed-size arrays.
In addition to improving consistency in memory management, the built-in
boundary checks enhance safety, while the impact on performance remains
within an acceptable margin.

Co-authored-by: Jim Hsu <[email protected]>

Author: AW-AlanWu

src/defs.h

@@ -351,6 +351,23 @@ typedef struct {
     char *elements;
 } strbuf_t;
 
+/* Definition of a generic dynamic array.
+ *
+ * size:      Number of elements currently in use.
+ * capacity:  Number of elements the buffer can hold before reallocation.
+ * elem_size: Size of each element in bytes.
+ * elements:  Pointer to the data buffer.
+ * arena:     Arena allocator used for allocations.
+ */
+typedef struct {
+    int size;
+    int capacity;
+    int elem_size;
+    void *elements;
+
+    arena_t *arena;
+} dynarr_t;
+
 /* phase-2 IR definition */
 struct ph2_ir {
     opcode_t op;

src/globals.c

@@ -1009,6 +1009,220 @@ void add_insn(block_t *block,
     bb->insn_list.tail = n;
 }
 
+/**
+ * dynarr_reserve() - Ensure the array can hold at least new_cap elements.
+ * @arr:     Dynamic array (must not be NULL).
+ * @new_cap: Desired capacity (in elements).
+ *
+ * If new_cap <= current capacity, do nothing. Otherwise, reallocate
+ * via arena_realloc(), preserving existing elements.
+ */
+void dynarr_reserve(dynarr_t *arr, int new_cap)
+{
+    if (new_cap <= arr->capacity)
+        return;
+    int oldsz = arr->capacity * arr->elem_size;
+    int newsz = new_cap * arr->elem_size;
+    arr->elements = arena_realloc(arr->arena, arr->elements, oldsz, newsz);
+    arr->capacity = new_cap;
+}
+
+/**
+ * dynarr_init() - Initialize a new dynamic array in the given arena.
+ * @arena:     Arena allocator (must not be NULL).
+ * @init_cap:  Initial capacity (0 for none).
+ * @elem_size: Size of each element in bytes (> 0).
+ *
+ * Returns a pointer to the new dynarr_t.
+ */
+dynarr_t *dynarr_init(arena_t *arena, int init_cap, int elem_size)
+{
+    if (elem_size <= 0) {
+        printf("dynarr_init: elem_size must be > 0\n");
+        abort();
+    }
+    dynarr_t *arr = arena_alloc(arena, sizeof(dynarr_t));
+    arr->size = 0;
+    arr->capacity = 0;
+    arr->elem_size = elem_size;
+    arr->elements = NULL;
+    arr->arena = arena;
+    dynarr_reserve(arr, init_cap);
+    return arr;
+}
+
+void _dynarr_grow(dynarr_t *arr, int need)
+{
+    if (need <= arr->capacity)
+        return;
+    int new_cap = arr->capacity ? arr->capacity << 1 : 4;
+    while (need > new_cap)
+        new_cap <<= 1;
+    dynarr_reserve(arr, new_cap);
+}
+
+/**
+ * dynarr_resize() - Set array size, growing capacity if needed.
+ * @arr:      Target array.
+ * @new_size: New size (>= 0).
+ */
+void dynarr_resize(dynarr_t *arr, int new_size)
+{
+    if (new_size < 0) {
+        printf("dynarr_resize: new_size must be >= 0\n");
+        abort();
+    }
+    _dynarr_grow(arr, new_size);
+    arr->size = new_size;
+}
+
+/**
+ * dynarr_push_raw() - Append an element by copying bytes.
+ * @arr:  Target array.
+ * @elem: Pointer to element (elem_size bytes).
+ */
+void dynarr_push_raw(dynarr_t *arr, void *elem)
+{
+    _dynarr_grow(arr, arr->size + 1);
+    char *dst = arr->elements;
+    char *src = elem;
+    dst += arr->size * arr->elem_size;
+    memcpy(dst, src, arr->elem_size);
+    ++arr->size;
+}
+
+/**
+ * dynarr_push_byte() - Append a single byte.
+ * @arr:  Target array (elem_size must be 1).
+ * @elem: Byte value to append.
+ */
+void dynarr_push_byte(dynarr_t *arr, char elem)
+{
+    if (arr->elem_size != sizeof(char)) {
+        printf("dynarr_push_byte: elem_size must be 1\n");
+        abort();
+    }
+    _dynarr_grow(arr, arr->size + 1);
+    char *ptr = arr->elements;
+    ptr[arr->size] = elem;
+    ++arr->size;
+}
+
+/**
+ * dynarr_push_word() - Append an int value.
+ * @arr:  Target array (elem_size must equal sizeof(int)).
+ * @elem: Int value to append.
+ */
+void dynarr_push_word(dynarr_t *arr, int elem)
+{
+    if (arr->elem_size != sizeof(int)) {
+        printf("dynarr_push_word: elem_size must be sizeof(int)\n");
+        abort();
+    }
+    _dynarr_grow(arr, arr->size + 1);
+    int *ptr = arr->elements;
+    ptr[arr->size] = elem;
+    ++arr->size;
+}
+
+/**
+ * dynarr_extend() - Append multiple elements from a buffer.
+ * @arr:   Target array.
+ * @elems: Buffer of elements to copy.
+ * @size:  Size of buffer in bytes (multiple of elem_size).
+ */
+void dynarr_extend(dynarr_t *arr, void *elems, int size)
+{
+    if (size % arr->elem_size != 0) {
+        printf("dynarr_extend: size must be a multiple of elem_size\n");
+        abort();
+    }
+    int added = (size / arr->elem_size);
+    _dynarr_grow(arr, arr->size + added);
+    char *dst = arr->elements;
+    int offset = arr->size * arr->elem_size;
+    char *ptr = elems;
+    memcpy(dst + offset, ptr, size);
+    arr->size += added;
+}
+
+/**
+ * dynarr_get_raw() - Get pointer to element at index.
+ * @arr:   Target array.
+ * @index: Element index (0-based).
+ *
+ * Returns pointer to element in internal buffer.
+ */
+void *dynarr_get_raw(dynarr_t *arr, int index)
+{
+    if (index < 0 || index >= arr->size) {
+        printf("index %d out of bounds (size=%d)\n", index, arr->size);
+        return NULL;
+    }
+    char *ptr = arr->elements;
+    ptr += index * arr->elem_size;
+    return ptr;
+}
+
+/**
+ * dynarr_get_byte() - Fetch byte at index.
+ * @arr:   Target array (elem_size must be 1).
+ * @index: Element index.
+ *
+ * Returns the byte value.
+ */
+char dynarr_get_byte(dynarr_t *arr, int index)
+{
+    if (arr->elem_size != sizeof(char)) {
+        printf("dynarr_get_byte: elem_size must be 1\n");
+        abort();
+    }
+    if (index < 0 || index >= arr->size) {
+        printf("index %d out of bounds (size=%d)\n", index, arr->size);
+        return 0;
+    }
+    char *ptr = arr->elements;
+    return ptr[index];
+}
+
+/**
+ * dynarr_get_word() - Fetch int at index.
+ * @arr:   Target array (elem_size must be sizeof(int)).
+ * @index: Element index.
+ *
+ * Returns the int value.
+ */
+int dynarr_get_word(dynarr_t *arr, int index)
+{
+    if (arr->elem_size != sizeof(int)) {
+        printf("dynarr_get_word: elem_size must be sizeof(int)\n");
+        abort();
+    }
+    if (index < 0 || index >= arr->size) {
+        printf("index %d out of bounds (size=%d)\n", index, arr->size);
+        return 0;
+    }
+    int *ptr = arr->elements;
+    return ptr[index];
+}
+
+/**
+ * dynarr_set_raw() - Overwrite element at index with given bytes.
+ * @arr:   Target array.
+ * @index: Element index to overwrite.
+ * @elem:  Pointer to source bytes (elem_size bytes).
+ */
+void dynarr_set_raw(dynarr_t *arr, int index, void *elem)
+{
+    if (index < 0 || index >= arr->size) {
+        printf("index %d out of bounds (size=%d)\n", index, arr->size);
+        return;
+    }
+    char *dst = arr->elements;
+    dst += index * arr->elem_size;
+    memcpy(dst, elem, arr->elem_size);
+}
+
 strbuf_t *strbuf_create(int init_capacity)
 {
     strbuf_t *array = malloc(sizeof(strbuf_t));