Reduced memory usage in live sets

Live sets in shecc are implemented using arrays of pointers, which
preallocate hundreds of unused slots, leading to significant
memory waste.

This patch replaces arrays of pointers with arena-backed vectors,
reducing memory usage substantially.

Although this change introduces additional memcpy during
dynamic resize in "var_list_ensure_capacity", which may add
overhead. The working set is much smaller and the better cache
locality with fewer minor page faults outweigh the amortized
memcpy cost.

Measured (compiling src/main.c):
- RSS: ~1.24GB -> ~305MB (≈ 75.4% reduction)
- Elapsed time: 0.50s -> 0.17s (≈ 66% faster)
- Minor page faults: ~309k -> ~76k

Changes include:
- Replace live sets with "var_list_t" for dynamic resizing.
- Added helper routine in "ssa.c" for managing "var_list_t"
instances.
- Updated related logic in "reg-alloc.c" and "ssa.c".

Author: icgmilk

src/defs.h

@@ -535,14 +535,10 @@ struct basic_block {
     struct basic_block *r_idom;
     struct basic_block *rpo_next;
     struct basic_block *rpo_r_next;
-    var_t *live_gen[MAX_ANALYSIS_STACK_SIZE];
-    int live_gen_idx;
-    var_t *live_kill[MAX_ANALYSIS_STACK_SIZE];
-    int live_kill_idx;
-    var_t *live_in[MAX_ANALYSIS_STACK_SIZE];
-    int live_in_idx;
-    var_t *live_out[MAX_ANALYSIS_STACK_SIZE];
-    int live_out_idx;
+    var_list_t live_gen;
+    var_list_t live_kill;
+    var_list_t live_in;
+    var_list_t live_out;
     int rpo;
     int rpo_r;
     struct basic_block *DF[64];

src/reg-alloc.c

@@ -47,8 +47,8 @@ int align_size(int i)
 
 bool check_live_out(basic_block_t *bb, var_t *var)
 {
-    for (int i = 0; i < bb->live_out_idx; i++) {
-        if (bb->live_out[i] == var)
+    for (int i = 0; i < bb->live_out.size; i++) {
+        if (bb->live_out.elements[i] == var)
             return true;
     }
     return false;

src/ssa.c

@@ -21,6 +21,43 @@
 /* Dead store elimination window size */
 #define OVERWRITE_WINDOW 3
 
+void var_list_ensure_capacity(var_list_t *list, int min_capacity)
+{
+    if (list->capacity >= min_capacity)
+        return;
+
+    int new_capacity = list->capacity ? list->capacity : HOST_PTR_SIZE;
+
+    while (new_capacity < min_capacity)
+        new_capacity <<= 1;
+
+    var_t **new_elements = arena_alloc(BB_ARENA, new_capacity * HOST_PTR_SIZE);
+
+    if (list->elements)
+        memcpy(new_elements, list->elements, list->size * HOST_PTR_SIZE);
+
+    list->elements = new_elements;
+    list->capacity = new_capacity;
+}
+
+void var_list_add_var(var_list_t *list, var_t *var)
+{
+    for (int i = 0; i < list->size; i++) {
+        if (list->elements[i] == var)
+            return;
+    }
+
+    var_list_ensure_capacity(list, list->size + 1);
+    list->elements[list->size++] = var;
+}
+
+void var_list_assign_array(var_list_t *list, var_t **data, int count)
+{
+    var_list_ensure_capacity(list, count);
+    memcpy(list->elements, data, count * HOST_PTR_SIZE);
+    list->size = count;
+}
+
 /* cfront does not accept structure as an argument, pass pointer */
 void bb_forward_traversal(bb_traversal_args_t *args)
 {
@@ -484,26 +521,16 @@ void use_chain_build(void)
 
 bool var_check_killed(var_t *var, basic_block_t *bb)
 {
-    for (int i = 0; i < bb->live_kill_idx; i++) {
-        if (bb->live_kill[i] == var)
+    for (int i = 0; i < bb->live_kill.size; i++) {
+        if (bb->live_kill.elements[i] == var)
             return true;
     }
     return false;
 }
 
 void bb_add_killed_var(basic_block_t *bb, var_t *var)
 {
-    bool found = false;
-    for (int i = 0; i < bb->live_kill_idx; i++) {
-        if (bb->live_kill[i] == var) {
-            found = true;
-            break;
-        }
-    }
-    if (found)
-        return;
-
-    bb->live_kill[bb->live_kill_idx++] = var;
+    var_list_add_var(&bb->live_kill, var);
 }
 
 void var_add_killed_bb(var_t *var, basic_block_t *bb)
@@ -2475,7 +2502,7 @@ void build_reversed_rpo(void)
 void bb_reset_live_kill_idx(func_t *func, basic_block_t *bb)
 {
     UNUSED(func);
-    bb->live_kill_idx = 0;
+    bb->live_kill.size = 0;
 }
 
 void add_live_gen(basic_block_t *bb, var_t *var);
@@ -2486,8 +2513,8 @@ void bb_reset_and_solve_locals(func_t *func, basic_block_t *bb)
 {
     UNUSED(func);
 
-    /* Reset live_kill index */
-    bb->live_kill_idx = 0;
+    /* Reset live_kill list */
+    bb->live_kill.size = 0;
 
     /* Solve locals */
     int i = 0;
@@ -2514,11 +2541,7 @@ void add_live_gen(basic_block_t *bb, var_t *var)
     if (var->is_global)
         return;
 
-    for (int i = 0; i < bb->live_gen_idx; i++) {
-        if (bb->live_gen[i] == var)
-            return;
-    }
-    bb->live_gen[bb->live_gen_idx++] = var;
+    var_list_add_var(&bb->live_gen, var);
 }
 
 void update_consumed(insn_t *insn, var_t *var)
@@ -2553,51 +2576,49 @@ void bb_solve_locals(func_t *func, basic_block_t *bb)
 
 void add_live_in(basic_block_t *bb, var_t *var)
 {
-    for (int i = 0; i < bb->live_in_idx; i++) {
-        if (bb->live_in[i] == var)
-            return;
-    }
-    bb->live_in[bb->live_in_idx++] = var;
+    var_list_add_var(&bb->live_in, var);
 }
 
 void compute_live_in(basic_block_t *bb)
 {
-    bb->live_in_idx = 0;
+    bb->live_in.size = 0;
 
-    for (int i = 0; i < bb->live_out_idx; i++) {
-        if (var_check_killed(bb->live_out[i], bb))
+    for (int i = 0; i < bb->live_out.size; i++) {
+        var_t *var = bb->live_out.elements[i];
+        if (var_check_killed(var, bb))
             continue;
-        add_live_in(bb, bb->live_out[i]);
+        add_live_in(bb, var);
     }
-    for (int i = 0; i < bb->live_gen_idx; i++)
-        add_live_in(bb, bb->live_gen[i]);
+    for (int i = 0; i < bb->live_gen.size; i++)
+        add_live_in(bb, bb->live_gen.elements[i]);
 }
 
 int merge_live_in(var_t *live_out[], int live_out_idx, basic_block_t *bb)
 {
     /* Early exit for empty live_in */
-    if (bb->live_in_idx == 0)
+    if (bb->live_in.size == 0)
         return live_out_idx;
 
     /* Optimize for common case of small sets */
     if (live_out_idx < 16) {
         /* For small sets, simple linear search is fast enough */
-        for (int i = 0; i < bb->live_in_idx; i++) {
+        for (int i = 0; i < bb->live_in.size; i++) {
             bool found = false;
+            var_t *var = bb->live_in.elements[i];
             for (int j = 0; j < live_out_idx; j++) {
-                if (live_out[j] == bb->live_in[i]) {
+                if (live_out[j] == var) {
                     found = true;
                     break;
                 }
             }
             if (!found && live_out_idx < MAX_ANALYSIS_STACK_SIZE)
-                live_out[live_out_idx++] = bb->live_in[i];
+                live_out[live_out_idx++] = var;
         }
     } else {
         /* For larger sets, check bounds and use optimized loop */
-        for (int i = 0; i < bb->live_in_idx; i++) {
+        for (int i = 0; i < bb->live_in.size; i++) {
             bool found = false;
-            var_t *var = bb->live_in[i];
+            var_t *var = bb->live_in.elements[i];
             /* Unroll inner loop for better performance */
             int j;
             for (j = 0; j + 3 < live_out_idx; j += 4) {
@@ -2643,9 +2664,8 @@ bool recompute_live_out(basic_block_t *bb)
     }
 
     /* Quick check: if sizes differ, sets must be different */
-    if (bb->live_out_idx != live_out_idx) {
-        memcpy(bb->live_out, live_out, HOST_PTR_SIZE * live_out_idx);
-        bb->live_out_idx = live_out_idx;
+    if (bb->live_out.size != live_out_idx) {
+        var_list_assign_array(&bb->live_out, live_out, live_out_idx);
         return true;
     }
 
@@ -2654,31 +2674,29 @@ bool recompute_live_out(basic_block_t *bb)
     if (live_out_idx > 0) {
         /* Quick check first element */
         bool first_found = false;
-        for (int j = 0; j < bb->live_out_idx; j++) {
-            if (live_out[0] == bb->live_out[j]) {
+        for (int j = 0; j < bb->live_out.size; j++) {
+            if (live_out[0] == bb->live_out.elements[j]) {
                 first_found = true;
                 break;
             }
         }
         if (!first_found) {
-            memcpy(bb->live_out, live_out, HOST_PTR_SIZE * live_out_idx);
-            bb->live_out_idx = live_out_idx;
+            var_list_assign_array(&bb->live_out, live_out, live_out_idx);
             return true;
         }
     }
 
     /* Full comparison */
     for (int i = 0; i < live_out_idx; i++) {
         int same = 0;
-        for (int j = 0; j < bb->live_out_idx; j++) {
-            if (live_out[i] == bb->live_out[j]) {
+        for (int j = 0; j < bb->live_out.size; j++) {
+            if (live_out[i] == bb->live_out.elements[j]) {
                 same = 1;
                 break;
             }
         }
         if (!same) {
-            memcpy(bb->live_out, live_out, HOST_PTR_SIZE * live_out_idx);
-            bb->live_out_idx = live_out_idx;
+            var_list_assign_array(&bb->live_out, live_out, live_out_idx);
             return true;
         }
     }