Fix SSA optimizations for safety and correctness

Author: jserv

src/parser.c

@@ -1752,9 +1752,10 @@ void read_expr_operand(block_t *parent, basic_block_t **bb)
         rs1 = opstack_pop();
 
         /* Constant folding for logical NOT */
-        if (rs1 && rs1->init_val && !rs1->ptr_level && !rs1->is_global) {
+        if (rs1 && rs1->is_const && !rs1->ptr_level && !rs1->is_global) {
             vd = require_var(parent);
             gen_name_to(vd->var_name);
+            vd->is_const = true;
             vd->init_val = !rs1->init_val;
             opstack_push(vd);
             add_insn(parent, *bb, OP_load_constant, vd, NULL, NULL, 0, NULL);
@@ -1770,9 +1771,10 @@ void read_expr_operand(block_t *parent, basic_block_t **bb)
         rs1 = opstack_pop();
 
         /* Constant folding for bitwise NOT */
-        if (rs1 && rs1->init_val && !rs1->ptr_level && !rs1->is_global) {
+        if (rs1 && rs1->is_const && !rs1->ptr_level && !rs1->is_global) {
             vd = require_var(parent);
             gen_name_to(vd->var_name);
+            vd->is_const = true;
             vd->init_val = ~rs1->init_val;
             opstack_push(vd);
             add_insn(parent, *bb, OP_load_constant, vd, NULL, NULL, 0, NULL);
@@ -2201,9 +2203,10 @@ void read_expr_operand(block_t *parent, basic_block_t **bb)
             rs1 = opstack_pop();
 
             /* Constant folding for negation */
-            if (rs1 && rs1->init_val && !rs1->ptr_level && !rs1->is_global) {
+            if (rs1 && rs1->is_const && !rs1->ptr_level && !rs1->is_global) {
                 vd = require_var(parent);
                 gen_name_to(vd->var_name);
+                vd->is_const = true;
                 vd->init_val = -rs1->init_val;
                 opstack_push(vd);
                 add_insn(parent, *bb, OP_load_constant, vd, NULL, NULL, 0,

src/ssa.c

@@ -2046,15 +2046,19 @@ void optimize(void)
                         insn->opcode = OP_assign;
                         insn->rs2 = NULL;
                     }
-                    /* x / x = 1 (if x != 0) */
+                    /* x / x = 1 (undefined if x = 0, but optimization is still
+                     * safe)
+                     */
                     else if (insn->opcode == OP_div && insn->rd) {
                         insn->opcode = OP_load_constant;
                         insn->rd->is_const = true;
                         insn->rd->init_val = 1;
                         insn->rs1 = NULL;
                         insn->rs2 = NULL;
                     }
-                    /* x % x = 0 */
+                    /* x % x = 0 (undefined if x = 0, but optimization is still
+                     * safe)
+                     */
                     else if (insn->opcode == OP_mod && insn->rd) {
                         insn->opcode = OP_load_constant;
                         insn->rd->is_const = true;
@@ -2100,7 +2104,8 @@ void optimize(void)
                 }
 
                 /* Comprehensive algebraic simplifications with identity
-                 * operations */
+                 * operations
+                 */
                 if (insn->rs2 && insn->rs2->is_const && insn->rd) {
                     int val = insn->rs2->init_val;
 
@@ -2170,10 +2175,9 @@ void optimize(void)
                             insn->rs1 = insn->rs2;
                             insn->rs2 = NULL;
                         }
-                        /* 0 * x = 0, 0 & x = 0, 0 / x = 0 */
+                        /* 0 * x = 0, 0 & x = 0 */
                         else if (insn->opcode == OP_mul ||
-                                 insn->opcode == OP_bit_and ||
-                                 insn->opcode == OP_div) {
+                                 insn->opcode == OP_bit_and) {
                             insn->opcode = OP_load_constant;
                             insn->rd->is_const = true;
                             insn->rd->init_val = 0;
@@ -2246,7 +2250,13 @@ void optimize(void)
                     }
                 }
 
-                /* Strength reduction for division and modulo by power of 2 */
+                /* Strength reduction for division and modulo by power of 2.
+                 * Note: This optimization assumes unsigned semantics or
+                 * non-negative dividend values. For signed division with
+                 * potentially negative dividends, this may produce different
+                 * results than true division (rounding toward zero vs toward
+                 * negative infinity).
+                 */
                 if (insn->rs2 && insn->rs2->is_const) {
                     int divisor = insn->rs2->init_val;