Integrate all optimizer functions

This adds optimizer division of labor documentation:
- SSA: handles constant folding, CSE, self-assignments, DCE
- Peephole: handles register patterns, bitwise ops, strength reduction

Integrate all optimization functions into peephole driver:
- Triple pattern optimization (3-instruction sequences)
- Instruction fusion (2-instruction sequences)
- Comparison optimization (self-comparisons)
- Strength reduction (power-of-2 optimizations)
- Algebraic simplification (register self-operations)
- Bitwise optimization (identity/absorption patterns)
- Move elimination and load/store patterns

Author: jserv

src/peephole.c

@@ -937,37 +937,75 @@ bool triple_pattern_optimization(ph2_ir_t *ph2_ir)
 }
 
 /* Main peephole optimization driver.
- * It iterates through all functions, basic blocks, and IR instructions to apply
- * local optimizations on adjacent instruction pairs.
+ *
+ * SSA Optimizer (insn_t, before register allocation):
+ * - Constant folding with known values (5+3 → 8, x+0 → x)
+ * - Common subexpression elimination
+ * - Self-assignment elimination (x = x)
+ * - Dead code elimination
+ * - Constant comparison folding (5 < 3 → 0)
+ *
+ * Peephole Optimizer (ph2_ir_t, after register allocation):
+ * - Register-based self-operations (r1-r1 → 0, r1^r1 → 0)
+ * - Bitwise operation optimization (SSA doesn't handle these)
+ * - Strength reduction for power-of-2 (needs actual constants loaded)
+ * - Load/store pattern elimination
+ * - Triple instruction sequence optimization
+ * - Architecture-specific instruction fusion
+ *
+ * This refined separation eliminates redundant optimizations while
+ * maintaining comprehensive coverage of optimization opportunities.
  */
 void peephole(void)
 {
     for (func_t *func = FUNC_LIST.head; func; func = func->next) {
-        /* Phase 1: Dead code elimination working with SCCP results */
+        /* Phase 1: Dead code elimination complementing SCCP results */
         eliminate_dead_instructions(func);
         fold_constant_branches(func);
 
-        /* Phase 2: Local peephole optimizations */
+        /* Phase 2: Local peephole optimizations on post-register-allocation IR
+         */
         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;
                 if (!next)
                     continue;
 
                 /* Self-assignment elimination
-                 * Removes trivial assignments where destination equals source
-                 * Pattern: {mov x, x} → eliminated
-                 * Common in compiler-generated intermediate code
+                 * Keep this as a safety net: SSA handles most cases, but
+                 * register allocation might create new self-assignments
                  */
                 if (next->op == OP_assign && next->dest == next->src0) {
                     ir->next = next->next;
                     continue;
                 }
 
-                /* Try instruction fusion first */
+                /* Try triple pattern optimization first (3-instruction
+                 * sequences)
+                 */
+                if (triple_pattern_optimization(ir))
+                    continue;
+
+                /* Try instruction fusion (2-instruction sequences) */
                 if (insn_fusion(ir))
                     continue;
 
+                /* Apply comparison optimization */
+                if (comparison_optimization(ir))
+                    continue;
+
+                /* Apply strength reduction for power-of-2 operations */
+                if (strength_reduction(ir))
+                    continue;
+
+                /* Apply algebraic simplification */
+                if (algebraic_simplification(ir))
+                    continue;
+
+                /* Apply bitwise operation optimizations */
+                if (bitwise_optimization(ir))
+                    continue;
+
                 /* Apply redundant move elimination */
                 if (redundant_move_elim(ir))
                     continue;