Implement SSA optimizations for phi nodes

This eliminates trivial phi nodes with identical operands, converts
division by power-of-2 to right shift, and converts modulo by
power-of-2 to bitwise AND.

Author: jserv

src/ssa.c

@@ -2397,7 +2397,56 @@ void optimize(void)
                     }
                 }
 
-                /* TODO: Phi node optimization */
+                /* Phi node optimization - eliminate trivial phi nodes */
+                if (insn->opcode == OP_phi && insn->phi_ops) {
+                    /* Count unique operands */
+                    var_t *first_var = insn->phi_ops->var;
+                    bool all_same = true;
+
+                    for (phi_operand_t *op = insn->phi_ops->next; op;
+                         op = op->next) {
+                        if (op->var != first_var) {
+                            all_same = false;
+                            break;
+                        }
+                    }
+
+                    /* Replace trivial phi with simple assignment */
+                    if (all_same && first_var) {
+                        insn->opcode = OP_assign;
+                        insn->rs1 = first_var;
+                        insn->rs2 = NULL;
+                    }
+                }
+
+                /* Simple strength reduction for division by power of 2 */
+                if (insn->opcode == OP_div && insn->rs2 &&
+                    insn->rs2->is_const) {
+                    int val = insn->rs2->init_val;
+                    /* Check if power of 2 */
+                    if (val > 0 && (val & (val - 1)) == 0) {
+                        /* Convert to right shift */
+                        int shift = 0;
+                        while (val > 1) {
+                            val >>= 1;
+                            shift++;
+                        }
+                        insn->opcode = OP_rshift;
+                        insn->rs2->init_val = shift;
+                    }
+                }
+
+                /* Simple strength reduction for modulo by power of 2 */
+                if (insn->opcode == OP_mod && insn->rs2 &&
+                    insn->rs2->is_const) {
+                    int val = insn->rs2->init_val;
+                    /* Check if power of 2 */
+                    if (val > 0 && (val & (val - 1)) == 0) {
+                        /* Convert to bitwise AND */
+                        insn->opcode = OP_bit_and;
+                        insn->rs2->init_val = val - 1;
+                    }
+                }
 
                 /* more optimizations */
             }