Add dead code elimination for unreachable blocks

This commit implements dead code elimination that works in conjunction
with SCCP to remove unreachable code after constant propagation and
branch folding.

These optimizations target code that becomes dead after constant
propagation, such as:
- Branches with constant conditions (if(1), if(0))
- Instructions that are immediately overwritten
- Unreachable code blocks after branch folding

Author: jserv

src/peephole.c

@@ -320,13 +320,129 @@ bool redundant_move_elim(ph2_ir_t *ph2_ir)
     return false;
 }
 
+/* Simple dead instruction elimination within basic blocks.
+ * Removes instructions whose results are never used (dead stores).
+ * Works in conjunction with existing SSA-based DCE.
+ */
+bool eliminate_dead_instructions(func_t *func)
+{
+    if (!func || !func->bbs)
+        return false;
+
+    bool changed = false;
+
+    for (basic_block_t *bb = func->bbs; bb; bb = bb->rpo_next) {
+        ph2_ir_t *ir = bb->ph2_ir_list.head;
+        while (ir && ir->next) {
+            ph2_ir_t *next = ir->next;
+
+            /* Check if next instruction immediately overwrites this one's
+             * result */
+            if (ir->op == OP_load_constant && next->op == OP_load_constant &&
+                ir->dest == next->dest) {
+                /* Consecutive constant loads to same register - first is dead
+                 */
+                ir->next = next->next;
+                if (next == bb->ph2_ir_list.tail) {
+                    bb->ph2_ir_list.tail = ir;
+                }
+                changed = true;
+                continue;
+            }
+
+            /* Check for dead arithmetic results */
+            if ((ir->op == OP_add || ir->op == OP_sub || ir->op == OP_mul) &&
+                next->op == OP_assign && ir->dest == next->dest) {
+                /* Arithmetic result immediately overwritten by assignment */
+                ir->next = next->next;
+                if (next == bb->ph2_ir_list.tail) {
+                    bb->ph2_ir_list.tail = ir;
+                }
+                changed = true;
+                continue;
+            }
+
+            ir = ir->next;
+        }
+    }
+
+    return changed;
+}
+
+/* Simple constant folding for branches after SCCP.
+ * Converts branches with obvious constant conditions to jumps.
+ * Very conservative to maintain bootstrap stability.
+ */
+bool fold_constant_branches(func_t *func)
+{
+    if (!func || !func->bbs)
+        return false;
+
+    bool changed = false;
+
+    for (basic_block_t *bb = func->bbs; bb; bb = bb->rpo_next) {
+        if (!bb->ph2_ir_list.tail)
+            continue;
+
+        ph2_ir_t *last = bb->ph2_ir_list.tail;
+
+        /* Only handle branches */
+        if (last->op != OP_branch || last->src0 < 0)
+            continue;
+
+        /* Look for immediately preceding constant load to the same register */
+        ph2_ir_t *prev = bb->ph2_ir_list.head;
+        ph2_ir_t *found = NULL;
+
+        /* Find the most recent constant load to the branch condition register
+         */
+        while (prev && prev != last) {
+            if (prev->op == OP_load_constant && prev->dest == last->src0) {
+                found = prev;
+                /* Keep looking - want the most recent load */
+            }
+            /* Stop if we see any other write to this register */
+            else if (prev->dest == last->src0) {
+                found = NULL; /* Register was modified, can't fold */
+            }
+            prev = prev->next;
+        }
+
+        if (found) {
+            /* Found constant condition - convert branch to jump */
+            int const_val = found->src0;
+
+            /* Just change the opcode, don't modify CFG edges directly */
+            last->op = OP_jump;
+
+            if (const_val != 0) {
+                /* Always take then branch */
+                last->next_bb = bb->then_;
+            } else {
+                /* Always take else branch */
+                last->next_bb = bb->else_;
+            }
+
+            /* Don't modify src0 or CFG edges - let later passes handle it */
+            changed = true;
+        }
+    }
+
+    return changed;
+}
+
 /* Main peephole optimization driver.
  * It iterates through all functions, basic blocks, and IR instructions to apply
  * local optimizations on adjacent instruction pairs.
  */
 void peephole(void)
 {
     for (func_t *func = FUNC_LIST.head; func; func = func->next) {
+        /* Phase 1: Dead code elimination working with SCCP results */
+        eliminate_dead_instructions(func);
+        fold_constant_branches(func);
+
+        /* Phase 2: Local peephole optimizations */
         for (basic_block_t *bb = func->bbs; bb; bb = bb->rpo_next) {
             for (ph2_ir_t *ir = bb->ph2_ir_list.head; ir; ir = ir->next) {
                 ph2_ir_t *next = ir->next;