Enhance constant folding optimization

Extend constant folding to support comparison operators (==, \!=, <, <=,
>, >=) in addition to existing arithmetic and bitwise operations. This
enables compile-time evaluation of constant comparisons, reducing code
size and improving optimization opportunities for control flow.

The enhancement integrates seamlessly with existing SSA optimizations
including copy propagation, redundant load elimination, and dead store
elimination. All operations with constant operands are now folded at
compile time.

Author: jserv

src/ssa.c

@@ -1532,6 +1532,9 @@ void simple_copy_propagation(basic_block_t *bb);
 void redundant_load_elimination(basic_block_t *bb);
 void dead_store_elimination(basic_block_t *bb);
 
+/* Enhanced optimization function declarations */
+bool enhanced_const_fold(insn_t *insn);
+
 void optimize(void)
 {
     /* build rdf information for DCE */
@@ -1556,6 +1559,11 @@ void optimize(void)
                 /* record the instruction assigned value to rd */
                 if (insn->rd)
                     insn->rd->last_assign = insn;
+
+                /* Apply enhanced constant folding first */
+                if (enhanced_const_fold(insn))
+                    continue;
+
                 if (cse(insn, bb))
                     continue;
                 if (const_folding(insn))
@@ -1857,3 +1865,84 @@ void dead_store_elimination(basic_block_t *bb)
         }
     }
 }
+
+
+/* Enhanced constant folding implementation */
+bool enhanced_const_fold(insn_t *insn)
+{
+    if (!insn->rs1 || !insn->rs2)
+        return false;
+
+    if (!insn->rs1->is_const || !insn->rs2->is_const)
+        return false;
+
+    int l = insn->rs1->init_val;
+    int r = insn->rs2->init_val;
+    int result;
+
+    switch (insn->opcode) {
+    case OP_add:
+        result = l + r;
+        break;
+    case OP_sub:
+        result = l - r;
+        break;
+    case OP_mul:
+        result = l * r;
+        break;
+    case OP_div:
+        if (r == 0)
+            return false;
+        result = l / r;
+        break;
+    case OP_mod:
+        if (r == 0)
+            return false;
+        result = l % r;
+        break;
+    case OP_lshift:
+        result = l << r;
+        break;
+    case OP_rshift:
+        result = l >> r;
+        break;
+    case OP_bit_and:
+        result = l & r;
+        break;
+    case OP_bit_or:
+        result = l | r;
+        break;
+    case OP_bit_xor:
+        result = l ^ r;
+        break;
+    case OP_eq:
+        result = (l == r) ? 1 : 0;
+        break;
+    case OP_neq:
+        result = (l != r) ? 1 : 0;
+        break;
+    case OP_lt:
+        result = (l < r) ? 1 : 0;
+        break;
+    case OP_leq:
+        result = (l <= r) ? 1 : 0;
+        break;
+    case OP_gt:
+        result = (l > r) ? 1 : 0;
+        break;
+    case OP_geq:
+        result = (l >= r) ? 1 : 0;
+        break;
+    default:
+        return false;
+    }
+
+    /* Transform to constant load */
+    insn->opcode = OP_load_constant;
+    insn->rd->is_const = true;
+    insn->rd->init_val = result;
+    insn->rs1 = NULL;
+    insn->rs2 = NULL;
+
+    return true;
+}