Add safe peephole optimizations

- Add comparison optimization for self-comparisons (x==x, x!=x, etc.)
- Add strength reduction for multiplication by power-of-2
- Both optimizations are conservative and maintain bootstrap stability
- Removed problematic dead instruction elimination that broke bootstrap

Author: jserv

src/peephole.c

@@ -242,6 +242,108 @@ bool insn_fusion(ph2_ir_t *ph2_ir)
     return false;
 }
 
+/* Comparison optimization for self-comparisons
+ * Returns true if optimization was applied
+ */
+bool comparison_optimization(ph2_ir_t *ph2_ir)
+{
+    if (!ph2_ir)
+        return false;
+
+    /* Self-comparisons that can be evaluated at compile time */
+    
+    /* x != x → 0 (always false) */
+    if (ph2_ir->op == OP_neq && ph2_ir->src0 == ph2_ir->src1) {
+        ph2_ir->op = OP_load_constant;
+        ph2_ir->src0 = 0;
+        ph2_ir->src1 = 0;
+        return true;
+    }
+
+    /* x == x → 1 (always true) */
+    if (ph2_ir->op == OP_eq && ph2_ir->src0 == ph2_ir->src1) {
+        ph2_ir->op = OP_load_constant;
+        ph2_ir->src0 = 1;
+        ph2_ir->src1 = 0;
+        return true;
+    }
+
+    /* x < x → 0 (always false) */
+    if (ph2_ir->op == OP_lt && ph2_ir->src0 == ph2_ir->src1) {
+        ph2_ir->op = OP_load_constant;
+        ph2_ir->src0 = 0;
+        ph2_ir->src1 = 0;
+        return true;
+    }
+
+    /* x > x → 0 (always false) */
+    if (ph2_ir->op == OP_gt && ph2_ir->src0 == ph2_ir->src1) {
+        ph2_ir->op = OP_load_constant;
+        ph2_ir->src0 = 0;
+        ph2_ir->src1 = 0;
+        return true;
+    }
+
+    /* x <= x → 1 (always true) */
+    if (ph2_ir->op == OP_leq && ph2_ir->src0 == ph2_ir->src1) {
+        ph2_ir->op = OP_load_constant;
+        ph2_ir->src0 = 1;
+        ph2_ir->src1 = 0;
+        return true;
+    }
+
+    /* x >= x → 1 (always true) */
+    if (ph2_ir->op == OP_geq && ph2_ir->src0 == ph2_ir->src1) {
+        ph2_ir->op = OP_load_constant;
+        ph2_ir->src0 = 1;
+        ph2_ir->src1 = 0;
+        return true;
+    }
+
+    return false;
+}
+
+/* Strength reduction optimization for power-of-2 operations
+ * Returns true if optimization was applied
+ */
+bool strength_reduction(ph2_ir_t *ph2_ir)
+{
+    if (!ph2_ir || !ph2_ir->next)
+        return false;
+
+    ph2_ir_t *next = ph2_ir->next;
+
+    /* Check for constant load followed by mul/div/mod */
+    if (ph2_ir->op != OP_load_constant)
+        return false;
+
+    int value = ph2_ir->src0;
+    
+    /* Check if value is a power of 2 (must be positive) */
+    if (value <= 0 || (value & (value - 1)) != 0)
+        return false;
+
+    /* Calculate shift amount for power of 2 */
+    int shift = 0;
+    int tmp = value;
+    while (tmp > 1) {
+        shift++;
+        tmp >>= 1;
+    }
+
+    /* Pattern: Multiplication by power of 2 → left shift */
+    if (next->op == OP_mul && next->src1 == ph2_ir->dest) {
+        ph2_ir->src0 = shift;
+        next->op = OP_lshift;
+        return true;
+    }
+
+    /* Note: Division and modulo optimizations require handling signed values
+     * which is more complex, so we skip them for safety */
+
+    return false;
+}
+
 /* Main peephole optimization driver.
  * It iterates through all functions, basic blocks, and IR instructions to apply
  * local optimizations on adjacent instruction pairs.
@@ -265,6 +367,15 @@ void peephole(void)
                     continue;
                 }
 
+                /* Try comparison optimization for single instructions */
+                if (comparison_optimization(ir))
+                    continue;
+
+                /* Try strength reduction for constant+op patterns */
+                if (strength_reduction(ir))
+                    continue;
+
+                /* Try instruction fusion last */
                 insn_fusion(ir);
             }
         }