Improve dead code elimination

Enhanced the dead code elimination (DCE) optimizer with more aggressive
and comprehensive dead code detection and removal capabilities.
- Added side-effect analysis to identify safe-to-remove instructions
- Enhanced dead variable detection within basic blocks
- Improved dead store elimination for overwritten values
- Better handling of unused computation chains
- Added explicit handling of branches and jumps in DCE

Author: jserv

src/ssa.c

@@ -1538,6 +1538,75 @@ bool const_folding(insn_t *insn)
     return false;
 }
 
+/* Dead code detection helper */
+bool is_side_effect_free(insn_t *insn)
+{
+    /* Instructions that have no side effects and can be eliminated if unused */
+    switch (insn->opcode) {
+    case OP_load_constant:
+    case OP_add:
+    case OP_sub:
+    case OP_mul:
+    case OP_div:
+    case OP_mod:
+    case OP_lshift:
+    case OP_rshift:
+    case OP_bit_and:
+    case OP_bit_or:
+    case OP_bit_xor:
+    case OP_bit_not:
+    case OP_negate:
+    case OP_log_and:
+    case OP_log_or:
+    case OP_log_not:
+    case OP_eq:
+    case OP_neq:
+    case OP_lt:
+    case OP_leq:
+    case OP_gt:
+    case OP_geq:
+    case OP_read:
+    case OP_assign:
+    case OP_load_data_address:
+        return true;
+    default:
+        return false;
+    }
+}
+
+/* Check if instruction result is never used */
+bool is_result_dead(insn_t *insn)
+{
+    if (!insn->rd)
+        return false;
+
+    /* Check if the result variable is never used after this instruction */
+    var_t *var = insn->rd;
+    insn_t *next = insn->next;
+    bool found_use = false;
+
+    /* Scan forward in the basic block */
+    while (next && next->belong_to == insn->belong_to) {
+        if ((next->rs1 && next->rs1 == var) ||
+            (next->rs2 && next->rs2 == var)) {
+            found_use = true;
+            break;
+        }
+        /* Check if variable is redefined without being used */
+        if (next->rd && next->rd == var) {
+            /* Variable redefined before use - original is dead */
+            return true;
+        }
+        next = next->next;
+    }
+
+    /* If not used in current block and not global, it's likely dead */
+    if (!found_use && !var->is_global)
+        return true;
+
+    return false;
+}
+
 /* initial mark useful instruction */
 int dce_init_mark(insn_t *insn, insn_t *work_list[], int work_list_idx)
 {
@@ -1576,6 +1645,15 @@ int dce_init_mark(insn_t *insn, insn_t *work_list[], int work_list_idx)
             mark_num++;
         }
         break;
+    /* Mark branches and jumps as initially useful */
+    case OP_branch:
+    case OP_jump:
+        /* Will be re-evaluated later for dead branch elimination */
+        insn->useful = true;
+        insn->belong_to->useful = true;
+        work_list[work_list_idx + mark_num] = insn;
+        mark_num++;
+        break;
     default:
         if (!insn->rd)
             break;
@@ -1586,6 +1664,13 @@ int dce_init_mark(insn_t *insn, insn_t *work_list[], int work_list_idx)
             work_list[work_list_idx + mark_num] = insn;
             mark_num++;
         }
+        /* Skip marking if result is provably dead */
+        else if (!is_result_dead(insn) && !is_side_effect_free(insn)) {
+            insn->useful = true;
+            insn->belong_to->useful = true;
+            work_list[work_list_idx + mark_num] = insn;
+            mark_num++;
+        }
         break;
     }
     return mark_num;
@@ -1644,13 +1729,22 @@ void dce_insn(basic_block_t *bb)
     }
 }
 
+
 void dce_sweep(void)
 {
     for (func_t *func = FUNC_LIST.head; func; func = func->next) {
         for (basic_block_t *bb = func->bbs; bb; bb = bb->rpo_next) {
-            for (insn_t *insn = bb->insn_list.head; insn; insn = insn->next) {
-                if (insn->useful)
+            insn_t *insn = bb->insn_list.head;
+            insn_t *next;
+
+            while (insn) {
+                next = insn->next;
+
+                if (insn->useful) {
+                    insn = next;
                     continue;
+                }
+
                 /* If a branch instruction is useless, redirect to the
                  * reverse immediate dominator of this basic block and
                  * remove the branch instruction. Later, register allocation
@@ -1669,15 +1763,42 @@ void dce_sweep(void)
                     }
                 }
 
+                /* Additional check for dead stores */
+                if (insn->opcode == OP_write && insn->rd && !insn->useful) {
+                    /* Check if this store is immediately overwritten */
+                    insn_t *check = insn->next;
+                    bool is_dead_store = false;
+                    while (check && check->belong_to == bb) {
+                        if (check->opcode == OP_write &&
+                            check->rd == insn->rd) {
+                            /* Found overwriting store - original is dead */
+                            is_dead_store = true;
+                            break;
+                        }
+                        /* Stop if the value is read */
+                        if ((check->rs1 && check->rs1 == insn->rd) ||
+                            (check->rs2 && check->rs2 == insn->rd)) {
+                            break;
+                        }
+                        check = check->next;
+                    }
+                    if (is_dead_store)
+                        insn->useful = false;
+                }
+
                 /* remove useless instructions */
-                if (insn->next)
-                    insn->next->prev = insn->prev;
-                else
-                    bb->insn_list.tail = insn->prev;
-                if (insn->prev)
-                    insn->prev->next = insn->next;
-                else
-                    bb->insn_list.head = insn->next;
+                if (!insn->useful) {
+                    if (insn->next)
+                        insn->next->prev = insn->prev;
+                    else
+                        bb->insn_list.tail = insn->prev;
+                    if (insn->prev)
+                        insn->prev->next = insn->next;
+                    else
+                        bb->insn_list.head = insn->next;
+                }
+
+                insn = next;
             }
         }
     }
@@ -1689,8 +1810,6 @@ void build_reversed_rpo();
 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)