Add copy propagation optimization

This commit implements copy propagation to eliminate redundant variable
assignments by tracking copy relationships, reducing unnecessary data
movement in the generated code.
1. Local (intra-block) copy propagation:
   - Backward search within basic blocks to find copy sources
   - Configurable search limit (COPY_PROP_SEARCH_LIMIT) for performance
   - Transitive copy chain following (a=b, b=c => use a for c)
2. Cross-block copy propagation:
   - Uses dominator tree information for safe inter-block optimization
   - Conservative search depth to maintain compilation performance
   - SSA-aware to prevent incorrect propagation across versions
3. PHI node optimization:
   - Propagates copies into PHI operands
   - Enables optimization across control flow merges

Author: jserv

src/defs.h

@@ -39,6 +39,9 @@
 #define MAX_OPERAND_STACK_SIZE 32
 #define MAX_ANALYSIS_STACK_SIZE 800
 
+/* Max instructions to search backward for copy sources */
+#define COPY_PROP_SEARCH_LIMIT 10
+
 /* Default capacities for common data structures */
 /* Arena sizes optimized based on typical usage patterns */
 #define DEFAULT_ARENA_SIZE 262144 /* 256 KiB - standard default */

src/ssa.c

@@ -1366,6 +1366,289 @@ bool cse(insn_t *insn, basic_block_t *bb)
     return false;
 }
 
+/* Copy propagation: track and propagate variable copies
+ * This optimization eliminates redundant assignments by tracking
+ * copy relationships and replacing uses with original sources.
+ *
+ * Features:
+ * - Intra-block copy propagation with configurable search limits
+ * - Cross-block copy propagation using dominator information
+ * - Transitive copy chain following (a=b, b=c => a=c)
+ *
+ * TODO: Handle copy propagation through memory operations (loads/stores)
+ * TODO: Integrate with value numbering for more aggressive optimization
+ */
+
+/* Find if a variable is a simple copy from another variable */
+var_t *find_simple_copy_source(var_t *var, insn_t *use_insn, basic_block_t *bb)
+{
+    if (!var || !use_insn || !bb)
+        return var;
+
+    /* Don't propagate globals, functions, or constants */
+    if (var->is_global || var->is_func || var->is_const)
+        return var;
+
+    /* NOTE: Cross-block propagation is now handled separately using
+     * dominance information in find_cross_block_copy_source() */
+
+    /* Use configurable search limit from defs.h */
+    int search_limit = COPY_PROP_SEARCH_LIMIT;
+    insn_t *insn = use_insn->prev;
+
+    while (insn && search_limit > 0) {
+        if (!insn->rd) {
+            insn = insn->prev;
+            search_limit--;
+            continue;
+        }
+
+        /* Found the definition of our variable */
+        if (insn->rd == var) {
+            /* If it's a simple copy, return the source */
+            if (insn->opcode == OP_assign && insn->rs1) {
+                /* Don't propagate if source is global or function */
+                if (insn->rs1->is_global || insn->rs1->is_func)
+                    return var;
+                /* Check SSA safety - don't propagate across SSA versions */
+                if (var->base && insn->rs1->base &&
+                    var->base != insn->rs1->base)
+                    return var;
+                /* Don't create cycles */
+                if (insn->rs1 == var)
+                    return var;
+
+                /* Follow copy chains iteratively for transitive propagation */
+                /* Limit chain length to prevent infinite loops */
+                var_t *source = insn->rs1;
+                int chain_limit = 3;
+
+                while (chain_limit > 0 && source) {
+                    /* Look for another copy of this source */
+                    insn_t *prev = insn->prev;
+                    int inner_limit = COPY_PROP_SEARCH_LIMIT;
+                    bool found_copy = false;
+
+                    while (prev && inner_limit > 0) {
+                        if (prev->rd == source && prev->opcode == OP_assign &&
+                            prev->rs1) {
+                            /* Found another copy, continue chain */
+                            if (prev->rs1->is_global || prev->rs1->is_func)
+                                return source;
+                            if (source->base && prev->rs1->base &&
+                                source->base != prev->rs1->base)
+                                return source;
+                            if (prev->rs1 == var) /* Avoid cycles */
+                                return source;
+                            source = prev->rs1;
+                            found_copy = true;
+                            break;
+                        }
+                        prev = prev->prev;
+                        inner_limit--;
+                    }
+
+                    if (!found_copy)
+                        break;
+                    chain_limit--;
+                }
+
+                return source;
+            }
+            /* Not a copy assignment, stop here */
+            return var;
+        }
+
+        /* Stop at control flow instructions for local search.
+         * Cross-block propagation is handled separately using dominance */
+        if (insn->opcode == OP_branch || insn->opcode == OP_call ||
+            insn->opcode == OP_func_ret || insn->opcode == OP_phi) {
+            return var;
+        }
+
+        insn = insn->prev;
+        search_limit--;
+    }
+
+    return var;
+}
+
+/* Apply copy propagation to a single instruction */
+bool propagate_copies_insn(insn_t *insn, basic_block_t *bb)
+{
+    if (!insn || !bb)
+        return false;
+
+    bool changed = false;
+
+    /* Handle PHI nodes specially */
+    if (insn->opcode == OP_phi) {
+        /* Propagate copies into PHI operands */
+        bool phi_changed = false;
+        for (phi_operand_t *phi_op = insn->phi_ops; phi_op;
+             phi_op = phi_op->next) {
+            if (phi_op->var && !phi_op->var->is_global &&
+                !phi_op->var->is_func) {
+                var_t *source = find_simple_copy_source(phi_op->var, insn, bb);
+                if (source != phi_op->var) {
+                    phi_op->var = source;
+                    phi_changed = true;
+                }
+            }
+        }
+        return phi_changed;
+    }
+
+    /* Propagate copies in source operands */
+    if (insn->rs1 && !insn->rs1->is_global && !insn->rs1->is_func) {
+        var_t *source = find_simple_copy_source(insn->rs1, insn, bb);
+        if (source != insn->rs1) {
+            insn->rs1 = source;
+            changed = true;
+        }
+    }
+
+    if (insn->rs2 && !insn->rs2->is_func && !insn->rs2->is_global) {
+        var_t *source = find_simple_copy_source(insn->rs2, insn, bb);
+        if (source != insn->rs2) {
+            insn->rs2 = source;
+            changed = true;
+        }
+    }
+
+    /* Eliminate self-assignments after propagation */
+    if (insn->opcode == OP_assign && insn->rd && insn->rs1) {
+        if (insn->rd == insn->rs1) {
+            /* Self-assignment - convert to no-op for DCE to remove */
+            insn->opcode = OP_assign;
+            insn->rd = NULL;
+            insn->rs1 = NULL;
+            insn->rs2 = NULL;
+            /* Mark as not useful so DCE will remove it */
+            insn->useful = false;
+            changed = true;
+        }
+    }
+
+    return changed;
+}
+
+/* Apply copy propagation to an entire basic block */
+void copy_propagation_bb(basic_block_t *bb)
+{
+    if (!bb)
+        return;
+
+    /* Single pass: propagate copies and eliminate redundant assignments */
+    for (insn_t *insn = bb->insn_list.head; insn; insn = insn->next) {
+        /* First propagate copies in this instruction */
+        propagate_copies_insn(insn, bb);
+
+        /* Then check if this instruction itself is a redundant copy */
+        if (insn->opcode == OP_assign && insn->rd && insn->rs1) {
+            /* Check if this is now a self-copy after propagation */
+            if (insn->rs1 == insn->rd) {
+                /* Self-copy, mark for DCE removal */
+                insn->rd = NULL;
+                insn->rs1 = NULL;
+                insn->rs2 = NULL;
+                insn->useful = false;
+            }
+        }
+    }
+}
+
+/* Find copy source across basic blocks using dominance */
+var_t *find_cross_block_copy_source(var_t *var,
+                                    basic_block_t *use_bb,
+                                    func_t *func)
+{
+    if (!var || !use_bb || !func || var->is_global || var->is_func)
+        return var;
+
+    /* Search for copy definitions in dominating blocks */
+    basic_block_t *dom_bb = use_bb;
+    int search_depth = 3; /* Limit search depth */
+
+    while (dom_bb && search_depth > 0) {
+        /* Search within the dominating block */
+        for (insn_t *insn = dom_bb->insn_list.tail; insn; insn = insn->prev) {
+            if (insn->rd == var && insn->opcode == OP_assign && insn->rs1) {
+                /* Found a copy definition */
+                if (!insn->rs1->is_global && !insn->rs1->is_func) {
+                    /* Check SSA safety */
+                    if (var->base && insn->rs1->base &&
+                        var->base != insn->rs1->base)
+                        return var;
+                    return insn->rs1;
+                }
+            }
+            /* Stop if we find any other definition of var */
+            if (insn->rd == var && insn->opcode != OP_assign)
+                return var;
+        }
+
+        /* Move to immediate dominator */
+        if (dom_bb->idom && dom_bb->idom != dom_bb) {
+            dom_bb = dom_bb->idom;
+            search_depth--;
+        } else {
+            break;
+        }
+    }
+
+    return var;
+}
+
+/* Apply copy propagation to an entire function */
+void copy_propagation_pass(func_t *func)
+{
+    if (!func)
+        return;
+
+    /* Process all basic blocks - local propagation first */
+    for (basic_block_t *bb = func->bbs; bb; bb = bb->rpo_next) {
+        /* Apply copy propagation multiple times for better results */
+        bool changed = true;
+        int iterations = 0;
+        while (changed && iterations < 3) {
+            changed = false;
+            for (insn_t *insn = bb->insn_list.head; insn; insn = insn->next) {
+                if (propagate_copies_insn(insn, bb))
+                    changed = true;
+            }
+            iterations++;
+        }
+
+        /* Final cleanup pass */
+        copy_propagation_bb(bb);
+    }
+
+    /* Second pass: cross-block copy propagation using dominance */
+    /* Only do this if dominator information is available */
+    if (func->bbs && func->bbs->idom) {
+        for (basic_block_t *bb = func->bbs; bb; bb = bb->rpo_next) {
+            for (insn_t *insn = bb->insn_list.head; insn; insn = insn->next) {
+                /* Try cross-block propagation for operands */
+                if (insn->rs1 && !insn->rs1->is_global && !insn->rs1->is_func) {
+                    var_t *source =
+                        find_cross_block_copy_source(insn->rs1, bb, func);
+                    if (source != insn->rs1) {
+                        insn->rs1 = source;
+                    }
+                }
+                if (insn->rs2 && !insn->rs2->is_global && !insn->rs2->is_func) {
+                    var_t *source =
+                        find_cross_block_copy_source(insn->rs2, bb, func);
+                    if (source != insn->rs2) {
+                        insn->rs2 = source;
+                    }
+                }
+            }
+        }
+    }
+}
+
 bool mark_const(insn_t *insn)
 {
     if (insn->opcode == OP_load_constant) {
@@ -1811,6 +2094,10 @@ void optimize(void)
     for (func_t *func = FUNC_LIST.head; func; func = func->next)
         optimize_constant_casts(func);
 
+    /* Run copy propagation pass to eliminate redundant copies */
+    for (func_t *func = FUNC_LIST.head; func; func = func->next)
+        copy_propagation_pass(func);
+
     for (func_t *func = FUNC_LIST.head; func; func = func->next) {
         /* basic block level (control flow) optimizations */
 
@@ -1859,14 +2146,13 @@ void optimize(void)
                 }
 
                 /* TODO: Dead load elimination */
+                /* TODO: Phi node optimization */
 
                 /* more optimizations */
             }
         }
     }
 
-    /* TODO: Phi node optimization */
-
     /* Mark useful instructions */
     for (func_t *func = FUNC_LIST.head; func; func = func->next) {
         for (basic_block_t *bb = func->bbs; bb; bb = bb->rpo_next) {