Enhance constant propagation and folding

Extended the constant folding optimizer to support a wider range of
operations beyond basic arithmetic. Added support for:
- Bitwise operations: AND, OR, XOR, left shift, right shift
- Comparison operations: ==, \!=, <, <=, >, >=
- Logical operations: &&, ||
- Unary operations: negation, bitwise NOT, logical NOT

Author: jserv

src/ssa.c

@@ -1412,6 +1412,7 @@ bool eval_const_arithmetic(insn_t *insn)
     int l = insn->rs1->init_val, r = insn->rs2->init_val;
 
     switch (insn->opcode) {
+    /* Arithmetic operations */
     case OP_add:
         res = l + r;
         break;
@@ -1422,11 +1423,65 @@ bool eval_const_arithmetic(insn_t *insn)
         res = l * r;
         break;
     case OP_div:
+        if (r == 0)
+            return false; /* Division by zero protection */
         res = l / r;
         break;
     case OP_mod:
+        if (r == 0)
+            return false; /* Modulo by zero protection */
         res = l % r;
         break;
+
+    /* Bitwise operations */
+    case OP_bit_and:
+        res = l & r;
+        break;
+    case OP_bit_or:
+        res = l | r;
+        break;
+    case OP_bit_xor:
+        res = l ^ r;
+        break;
+    case OP_lshift:
+        if (r < 0 || r >= 32)
+            return false; /* Safe shift range */
+        res = l << r;
+        break;
+    case OP_rshift:
+        if (r < 0 || r >= 32)
+            return false; /* Safe shift range */
+        res = l >> r;
+        break;
+
+    /* Comparison operations */
+    case OP_eq:
+        res = (l == r);
+        break;
+    case OP_neq:
+        res = (l != r);
+        break;
+    case OP_lt:
+        res = (l < r);
+        break;
+    case OP_leq:
+        res = (l <= r);
+        break;
+    case OP_gt:
+        res = (l > r);
+        break;
+    case OP_geq:
+        res = (l >= r);
+        break;
+
+    /* Logical operations */
+    case OP_log_and:
+        res = (l && r);
+        break;
+    case OP_log_or:
+        res = (l || r);
+        break;
+
     default:
         return false;
     }
@@ -1439,12 +1494,47 @@ bool eval_const_arithmetic(insn_t *insn)
     return true;
 }
 
+bool eval_const_unary(insn_t *insn)
+{
+    if (!insn->rs1)
+        return false;
+    if (!insn->rs1->is_const)
+        return false;
+    if (insn->rs2) /* Should be unary operation */
+        return false;
+
+    int res;
+    int operand = insn->rs1->init_val;
+
+    switch (insn->opcode) {
+    case OP_negate:
+        res = -operand;
+        break;
+    case OP_bit_not:
+        res = ~operand;
+        break;
+    case OP_log_not:
+        res = !operand;
+        break;
+    default:
+        return false;
+    }
+
+    insn->rs1 = NULL;
+    insn->rd->is_const = 1;
+    insn->rd->init_val = res;
+    insn->opcode = OP_load_constant;
+    return true;
+}
+
 bool const_folding(insn_t *insn)
 {
     if (mark_const(insn))
         return true;
     if (eval_const_arithmetic(insn))
         return true;
+    if (eval_const_unary(insn))
+        return true;
     return false;
 }
 
@@ -1984,22 +2074,22 @@ bool enhanced_const_fold(insn_t *insn)
         result = l ^ r;
         break;
     case OP_eq:
-        result = (l == r) ? 1 : 0;
+        result = (l == r);
         break;
     case OP_neq:
-        result = (l != r) ? 1 : 0;
+        result = (l != r);
         break;
     case OP_lt:
-        result = (l < r) ? 1 : 0;
+        result = (l < r);
         break;
     case OP_leq:
-        result = (l <= r) ? 1 : 0;
+        result = (l <= r);
         break;
     case OP_gt:
-        result = (l > r) ? 1 : 0;
+        result = (l > r);
         break;
     case OP_geq:
-        result = (l >= r) ? 1 : 0;
+        result = (l >= r);
         break;
     default:
         return false;