Enhance register allocation with usage-based spill

Building on the VReg abstraction, this commit adds intelligent spill
decisions based on variable usage patterns and context.
- Track variable lifetime with first_use, last_use, and use_count
- Add loop_depth field for identifying loop-resident variables
- Transform spill cost from simple distance to multi-factor heuristic:
  * Loop variables: +200 cost per nesting level
  * Usage frequency: +5 cost per use
  * Live range length: +20 for long ranges
  * Constants: -50 (prefer spilling for rematerialization)

Author: jserv

src/defs.h

@@ -374,6 +374,10 @@ struct var {
     int vreg_id;    /* Virtual register ID */
     int phys_reg;   /* Physical register assignment (-1 if unassigned) */
     int vreg_flags; /* VReg flags */
+    int first_use;  /* First instruction index where variable is used */
+    int last_use;   /* Last instruction index where variable is used */
+    int loop_depth; /* Nesting depth if variable is in a loop */
+    int use_count;  /* Number of times variable is used */
 };
 
 typedef struct {

src/parser.c

@@ -64,6 +64,10 @@ var_t *require_var(block_t *blk)
     var_list->elements[var_list->size++] = var;
     var->consumed = -1;
     var->phys_reg = -1;
+    var->first_use = -1;
+    var->last_use = -1;
+    var->loop_depth = 0;
+    var->use_count = 0;
     var->base = var;
     var->type = TY_int;
     return var;

src/reg-alloc.c

@@ -54,6 +54,19 @@ bool check_live_out(basic_block_t *bb, var_t *var)
     return false;
 }
 
+void track_var_use(var_t *var, int insn_idx)
+{
+    if (!var)
+        return;
+
+    var->use_count++;
+
+    if (var->first_use < 0)
+        var->first_use = insn_idx;
+
+    var->last_use = insn_idx;
+}
+
 void refresh(basic_block_t *bb, insn_t *insn)
 {
     for (int i = 0; i < REG_CNT; i++) {
@@ -95,16 +108,33 @@ ph2_ir_t *bb_add_ph2_ir(basic_block_t *bb, opcode_t op)
 
 int calculate_spill_cost(var_t *var, basic_block_t *bb, int current_idx)
 {
+    int cost = 0;
+
     if (check_live_out(bb, var))
-        return 1000;
+        cost += 1000;
 
     if (var->consumed > current_idx) {
         int distance = var->consumed - current_idx;
         if (distance < 10)
-            return 100 - distance * 10;
+            cost += 100 - distance * 10;
+    }
+
+    if (var->use_count > 0)
+        cost += var->use_count * 5;
+
+    if (var->loop_depth > 0)
+        cost += var->loop_depth * 200;
+
+    if (var->is_const)
+        cost -= 50;
+
+    if (var->first_use >= 0 && var->last_use >= 0) {
+        int range_length = var->last_use - var->first_use;
+        if (range_length > 100)
+            cost += 20;
     }
 
-    return 0;
+    return cost;
 }
 
 int find_best_spill(basic_block_t *bb,
@@ -490,6 +520,7 @@ void reg_alloc(void)
 
                 switch (insn->opcode) {
                 case OP_unwound_phi:
+                    track_var_use(insn->rs1, insn->idx);
                     src0 = prepare_operand(bb, insn->rs1, -1);
 
                     if (!insn->rd->offset) {
@@ -583,6 +614,7 @@ void reg_alloc(void)
                     if (insn->rd->consumed == -1)
                         break;
 
+                    track_var_use(insn->rs1, insn->idx);
                     src0 = find_in_regs(insn->rs1);
 
                     /* If operand is loaded from stack, clear the original slot
@@ -727,6 +759,8 @@ void reg_alloc(void)
                 case OP_bit_and:
                 case OP_bit_or:
                 case OP_bit_xor:
+                    track_var_use(insn->rs1, insn->idx);
+                    track_var_use(insn->rs2, insn->idx);
                     src0 = prepare_operand(bb, insn->rs1, -1);
                     src1 = prepare_operand(bb, insn->rs2, src0);
                     dest = prepare_dest(bb, insn->rd, src0, src1);